C# में strings कैसे काम करती हैं?

Question

Accepted Answer

C# में, **`string`** एक immutable reference type है जो text को represent करता है। Strings interpolation, एक समृद्ध method library, और — performance के लिए महत्वपूर्ण — बार-बार modification के लिए efficient तरीके से `StringBuilder` का समर्थन करती हैं।

## String interpolation और creation

```csharp
string name = "Ann";
int age = 30;

// string interpolation ($) — embed expressions directly
string msg = $"Hello {name}, you are {age} years old";
string formatted = $"Price: {price:C2}";    // {value:format} — C2 = currency, 2 decimals

// verbatim strings (@) — no escaping, multi-line
string path = @"C:\Users\Ann";               // backslashes literal, no \ needed
string multi = """
    Raw string literal
    preserves formatting (C# 11)
    """;
```

**String interpolation** (`$"..."`) embedded values और format specifiers के साथ strings बनाने का modern, readable तरीका है। Verbatim (`@`) strings escaping को disable करती हैं (paths/regex के लिए बेहतरीन), और raw string literals (`"""`) multi-line text को handle करती हैं।

## Strings immutable होती हैं

```csharp
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 को "modify" करता है वास्तव में एक **नई** string बनाता है (immutability)। यह सुरक्षित है लेकिन बार-बार modification के लिए performance की कीमत है।

## efficient building के लिए StringBuilder

```csharp
// ❌ 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 प्रथा।

## सामान्य string methods

```csharp
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 processing करना, data formatting करना), इसलिए C# strings को समझना आवश्यक रोजमर्रा का ज्ञान है।

Modern features productivity के लिए मायने रखते हैं: **string interpolation** (`$"..."`) embedded values और formatting के साथ strings बनाने का स्वच्छ, readable तरीका है, और verbatim/raw string literals paths व multi-line text को elegantly handle करती हैं।

महत्वपूर्ण रूप से, यह समझना कि **strings immutable हैं** (हर "modification" एक नई string बनाती है) एक प्रमुख performance विचार की व्याख्या करता है: naive **loops में string concatenation** बेकार है (O(n²), कई intermediate strings बनाते हुए), और बार-बार modification के लिए **`StringBuilder`** का उपयोग करना जानना (जो एक internal buffer को efficiently mutate करता है) एक महत्वपूर्ण व्यावहारिक optimization है जो सीधे immutability को समझने से आता है।

समृद्ध string method library (search, replace, split/join, formatting), modern interpolation syntax, और immutability-संचालित StringBuilder प्रथा को जानना programming में शामिल निरंतर string कार्य के लिए मूल ज्ञान है — यहाँ fluency, विशेष रूप से interpolation सुविधा और StringBuilder performance fix, स्वच्छ, efficient C# लिखने के लिए मूलभूत है।