C# માં, string એ અપરિવર્તનશીલ reference type છે જે text રજૂ કરે છે. Strings interpolation, સમૃદ્ધ method library, અને — performance માટે મહત્વપૂર્ણ — efficient બનાવવા માટે StringBuilder સમર્થન આપે છે.
name = ;
age = ;
msg = ;
formatted = ;
path = ;
multi = ;
String interpolation ($"..."), પ્રમાણભૂત અને સુવાચ્ય રીત છે strings બનાવવાની embedded values અને format specifiers સાથે. Verbatim (@) strings escaping અક્ષમ કરે છે (paths/regex માટે શ્રેષ્ઠ), અને raw string literals ("""), multi-line text સંભાળે છે.
string s = "Hello";
s.ToUpper(); // returns a NEW string "HELLO"; s is unchanged
s = s + " World"; // creates a NEW string; the old "Hello" is discarded
હરેક operation જે string ને "સંશોધિત" કરે છે તે વાસ્તવમાં એક નવો string બનાવે છે (immutability). આ સુરક્ષિત છે પરંતુ repeated modification માટે performance cost છે.
// ❌ string concatenation in a loop — creates a new string each iteration (slow, O(n²))
string result = "";
for (int i = 0; i < 10000; i++) result += i;
// ✅ StringBuilder mutates a buffer — efficient (O(n))
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++) sb.Append(i);
string final = sb.ToString();
Loops માં strings બનાવવા માટે, StringBuilder અনેક intermediate strings બનાવવાથી બચે છે — આ એક મુખ્ય performance practice છે.
s.Length; s.ToUpper(); s.Trim(); s.Substring(0, 5);
s.Contains("x"); s.IndexOf("x"); s.Replace("a", "b");
s.Split(','); string.Join(",", items);
string.IsNullOrEmpty(s); string.IsNullOrWhiteSpace(s);
String manipulation programming માં સર્વવ્યાપી છે (output બનાવવું, input process કરવું, data ફોર્મેટ કરવું), તેથી C# strings સમજવું એ આવશ્યક રોજિંદાન જ્ઞાન છે.
આધુનિક features productivity માટે મહત્વપૂર્ણ છે: string interpolation ($"..."), embedded values અને formatting સાથે strings બનાવવાની સ્વચ્છ, સુવાચ્ય રીત છે, અને verbatim/raw string literals paths અને multi-line text સુંદર રીતે હેન્ડલ કરે છે.
onestly, strings અપરિવર્તનશીલ છે તે સમજવું (હરેક "modification" નવો string બનાવે છે) એક મુખ્ય performance consideration સમજાવે છે: naive string concatenation in loops બર્બાદ છે (O(n²), અનેક intermediate strings બનાવે છે), અને repeated modification માટે StringBuilder વાપરવાનું જાણવું (જે efficiently એક internal buffer mutate કરે છે) એક મહત્વપૂર્ણ વ્યવહારુ optimization છે જે સીધું immutability સમજણમાંથી આવે છે.
સમૃદ્ધ string method library (search, replace, split/join, formatting), આધુનિક interpolation syntax, અને immutability-દ્વારા-driven StringBuilder practice જાણવું એ મુખ્ય જ્ઞાન છે constant string work માટે જે programming માં સમાવે છે — fluency અહીં, ખાસ કરીને interpolation સુવિધા અને StringBuilder performance fix, fundamental છે clean, efficient C# લખવા માટે.