C# ਵਿੱਚ strings ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

C# ਵਿੱਚ, **`string`** ਇੱਕ immutable reference type ਹੈ ਜੋ ਪਾਠ ਦੀ ਨੁਮਾਇੰਦਗੀ ਕਰਦਾ ਹੈ। Strings interpolation, ਇੱਕ ਅਮੀਰ method library, ਅਤੇ — performance ਲਈ ਮਹੱਤਵਪੂਰਨ — `StringBuilder` ਨੂੰ efficient repeated modification ਲਈ ਸਮਰਥਨ ਕਰਦੇ ਹਨ।

## 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 ਨੂੰ 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
```

ਹਰ ਓਪਰੇਸ਼ਨ ਜੋ ਇੱਕ 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 ਨੂੰ process ਕਰਨਾ, data ਨੂੰ format ਕਰਨਾ), ਇਸ ਲਈ C# strings ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਰੋਜ਼ਮਰਾਹ ਦਾ ਗਿਆਨ ਹੈ।

ਆਧੁਨਿਕ features productivity ਲਈ ਮਹੱਤਵਪੂਰਨ ਹਨ: **string interpolation** (`$"..."`) embedded values ਅਤੇ formatting ਦੇ ਨਾਲ strings ਬਣਾਉਣ ਦਾ clean, ਪੜ੍ਹਨਯੋਗ ਤਰੀਕਾ ਹੈ, ਅਤੇ verbatim/raw string literals paths ਅਤੇ multi-line text ਨੂੰ elegantly handle ਕਰਦੇ ਹਨ।

ਗੰਭੀਰ ਤੌਰ ਤੇ, ਇਹ ਸਮਝਣਾ ਕਿ **strings immutable ਹਨ** (ਹਰ "modification" ਇੱਕ ਨਵੀਂ string ਬਣਾਉਂਦਾ ਹੈ) ਇੱਕ ਮੁੱਖ performance consideration ਨੂੰ ਸਮਝਾਉਂਦਾ ਹੈ: naive **string concatenation in loops** wasteful ਹੈ (O(n²), ਬਹੁਤ ਸਾਰੀਆਂ intermediate strings ਬਣਾਉਂਦਾ ਹੈ), ਅਤੇ repeated modification ਲਈ **`StringBuilder`** ਵਰਤਣਾ ਜਾਣਨਾ (ਜੋ efficiently ਇੱਕ internal buffer ਨੂੰ mutate ਕਰਦਾ ਹੈ) ਇੱਕ ਮਹੱਤਵਪੂਰਨ practical optimization ਹੈ ਜੋ immutability ਨੂੰ ਸਮਝਣ ਤੋਂ directly ਆਉਂਦਾ ਹੈ।

Rich string method library (search, replace, split/join, formatting) ਨੂੰ ਜਾਣਨਾ, ਆਧੁਨਿਕ interpolation syntax, ਅਤੇ immutability-driven StringBuilder practice constant string work ਲਈ ਕੋਰ ਗਿਆਨ ਹਨ ਜੋ programming ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ — ਇਥੇ fluency, ਖਾਸ ਤੌਰ ਤੇ interpolation convenience ਅਤੇ StringBuilder performance fix, clean, efficient C# ਲਿਖਣ ਲਈ fundamental ਹੈ।