C# मा string कसरी काम गर्छ?

Question

Accepted Answer

C# मा, **`string`** एक अपरिवर्तनीय reference type हो जसले पाठ प्रतिनिधित्व गर्छ। Strings ले interpolation, एक समृद्ध method library, र — performance को लागि महत्त्वपूर्ण — `StringBuilder` लाई repeated modification को लागि efficient तरिकाले समर्थन गर्छ।

## 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 बनाउँछ। Verbatim (`@`) strings ले escaping लाई अक्षम गर्छ (paths/regex को लागि उत्तम), र raw string literals (`"""") ले multi-line text लाई हेरचाह गर्छ।

## Strings अपरिवर्तनीय छन्

```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
```

प्रत्येक अपरेशन जसले string लाई "modify" गर्छ वास्तवमा एक **नयाँ** string बनाउँछ (immutability)। यो सुरक्षित छ तर repeated modification को लागि performance cost छ।

## 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 practice।

## Common 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 प्रक्रिया गर्दै, data को लागि format गर्दै), त्यसैले C# strings बुझ्न अत्यावश्यक दैनिक ज्ञान हो।

आधुनिक features उत्पादकता को लागि महत्त्वपूर्ण छन्: **string interpolation** (`$"..."`) embedded values र formatting को साथ strings बनाउने स्वच्छ, पठनीय तरिका हो, र verbatim/raw string literals ले paths र multi-line text लाई सुंदर तरिकाले हेरचाह गर्छन्।

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

समृद्ध string method library (search, replace, split/join, formatting) जान्न, आधुनिक interpolation syntax, र immutability-driven StringBuilder practice core knowledge हो constant string work को लागि जो programming मा समावेश हुन्छ — यहाँ fluency, विशेष गरी interpolation सुविधा र StringBuilder performance fix, clean, efficient C# लेखन को लागि आधारभूत छ।