C# मध्ये strings कसे काम करतात?

Question

Accepted Answer

C# मध्ये, **`string`** हे immutable reference type आहे जे text प्रतिनिधित्व करते. Strings interpolation, एक समृद्ध method library, आणि — performance साठी महत्वाचे — `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 तयार करण्याचा आधुनिक, वाचनीय मार्ग आहे. Verbatim (`@`) strings escaping अक्षम करते (paths/regex साठी उत्तम), आणि raw string literals (`"""`) multi-line text हाताळतात.

## 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). हे सुरक्षित आहे परंतु पुनरावृत्त संशोधनासाठी 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 process करणे, data format करणे), म्हणून C# strings समजून घेणे आवश्यक दैनंदिन ज्ञान आहे.

आधुनिक features productivity साठी महत्वाचे आहेत: **string interpolation** (`$"..."`) हे embedded values आणि formatting सह strings तयार करण्याचा स्वच्छ, वाचनीय मार्ग आहे, आणि verbatim/raw string literals paths आणि multi-line text मार्जितपणे हाताळतात.

काटेकोरपणे, हे समजून घेणे की **strings immutable आहेत** (प्रत्येक "modification" एक नई string तयार करते) हे एक मुख्य performance विचार स्पष्ट करते: naive **string concatenation loops मध्ये** हानिकारक आहे (O(n²), अनेक intermediate strings तयार करते), आणि पुनरावृत्त संशोधनासाठी **`StringBuilder`** वापरण्याचे ज्ञान असणे (जो internal buffer कार्यक्षमतेने mutate करते) हे immutability समजून घेण्यापासून थेट येणारे महत्वाचे practical optimization आहे.

String method library (search, replace, split/join, formatting), आधुनिक interpolation syntax, आणि immutability-driven StringBuilder practice हे core knowledge आहे constant string work साठी जे programming मध्ये समाविष्ट आहे — विशेषत: interpolation convenience आणि StringBuilder performance fix साठी fluency हे clean, efficient C# लिहिण्याचे fundamental आहे.