Cum funcționează șirurile de caractere în C#?

Question

Accepted Answer

În C#, **`string`** este un tip de referință imutabil care reprezintă text. Șirurile suportă interpolarea, o bibliotecă bogată de metode și — important pentru performanță — `StringBuilder` pentru modificare repetată eficientă.

## Interpolarea și crearea șirurilor

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

**Interpolarea șirurilor** (`$"..."`) este modul modern și ușor de citit pentru a construi șiruri cu valori încorporate și specificatori de format. Șirurile verbatim (`@`) dezactivează escapingul (excelent pentru căi/regex), iar literalii bruti de șiruri (`"""`) gestionează textul multi-linie.

## Șirurile sunt imutabile

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

Fiecare operație care "modifică" un șir creează de fapt un **nou** șir (imutabilitate). Acest lucru este sigur, dar are un cost de performanță pentru modificare repetată.

## StringBuilder pentru construire eficientă

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

La construirea șirurilor în bucle, **`StringBuilder`** evită crearea multor șiruri intermediare — o practică de performanță esențială.

## Metode comune de șir

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

## De ce este important

Manipularea șirurilor este omniprezentă în programare (construirea output-ului, procesarea input-ului, formatarea datelor), deci înțelegerea șirurilor din C# este o cunoaștere esențială zilnică.

Funcționalitățile moderne contează pentru productivitate: **interpolarea șirurilor** (`$"..."`) este modul curat și ușor de citit pentru a construi șiruri cu valori încorporate și formatare, iar șirurile verbatim/literalii bruti gestionează elegant căile și textul multi-linie.

În mod critic, înțelegerea că **șirurile sunt imutabile** (fiecare "modificare" creează un nou șir) explică o considerație importantă de performanță: **concatenarea naivă a șirurilor în bucle** este risipă (O(n²), creează multe șiruri intermediare), și știind să folosiți **`StringBuilder`** pentru modificare repetată (care mută eficient un buffer intern) este o optimizare practică importantă care decurge direct din înțelegerea imutabilității.

Cunoașterea bibliotecii bogate de metode de șir (căutare, înlocuire, împărțire/unire, formatare), sintaxa modernă de interpolare și practica StringBuilder condusă de imutabilitate este cunoașterea esențială pentru munca constantă cu șiruri pe care o implică programarea — fluență aici, în special conveniența interpolării și corectarea performanței StringBuilder, este fundamentală pentru a scrie C# curat și eficient.