Kif jaħdmu l-strings f'C#?

Question

Accepted Answer

F'C#, **`string`** huwa tip ta' referenza immutable li jirrappreżenta test. L-strings jappoġġaw l-interpolazzjoni, librerija ta' metodi għanja, u — importanti għall-prestazzjoni — `StringBuilder` għal modifika effiċjenti ripetuta.

## Interpolazzjoni tal-string u kreazzjoni

```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** (`$"..."`) hija l-mod modern u leġġibbli biex tinbena strings b'valuri integrati u specificaturi tal-format. Strings verbatim (`@`) jiddisabbilitaw l-escaping (tajba għal paths/regex), u raw string literals (`"""`) jmaniġġjaw test multi-line.

## L-strings huma 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
```

Kull operazzjoni li "tmodifika" string tħoloq fil-fatt string **ġdid** (immutability). Dan huwa sigur iżda għandu spiża tal-prestazzjoni għal modifika ripetuta.

## StringBuilder għall-bina effiċjenti

```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();
```

Għall-bina tal-strings f'loops, **`StringBuilder`** jevita l-ħolqien ta' ħafna strings intermediji — prattika ewlenija tal-prestazzjoni.

## Metodi komuni tal-string

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

## Għaliex dan huwa importanti

L-manipulazzjoni tal-strings hija pervasiva fil-programmazzjoni (bina tal-output, ipproċessar tal-input, formattazzjoni tad-data), għalhekk il-fehim tal-strings f'C# huwa għarifa essenzjali ta' kuljum.

L-features moderni huma importanti għall-produttività: **string interpolation** (`$"..."`) hija l-mod nadif u leġġibbli biex tinbena strings b'valuri integrati u formattazzjoni, u string literals verbatim/raw jmaniġġjaw paths u test multi-line b'eleganza.

B'mod kritiku, il-fehim li **strings huma immutable** (kull "modifika" tinħoloq string ġdid) jispjega konsiderazzjoni ewlenija tal-prestazzjoni: naive **string concatenation f'loops** huwa miswieq (O(n²), jinħolqu ħafna strings intermediji), u l-għarifa li tuża **`StringBuilder`** għal modifika ripetuta (li tmodifika buffer intern b'mod effiċjenti) hija ottimizzazzjoni prattika importanti li ġejja direttament mill-fehim tal-immutability.

Il-għarifa tal-librerija għanja ta' metodi tal-string (search, replace, split/join, formattazzjoni), is-sintassi modern tal-interpolazzjoni, u l-prattika driven-immutability ta' StringBuilder hija għarifa ewlenija għall-iskart kostanti tal-string li l-programmazzjoni tinvolvi — fluidità hawnhekk, speċjalment il-convenienza tal-interpolazzjoni u l-fix tal-prestazzjoni ta' StringBuilder, hija fundamentali għall-kitba tal-C# nadif u effiċjenti.