Come funzionano le stringhe in C#?

Question

Accepted Answer

In C#, **`string`** è un tipo reference immutabile che rappresenta testo. Le stringhe supportano interpolazione, una ricca libreria di metodi, e — importante per le prestazioni — `StringBuilder` per modifiche ripetute efficienti.

## Interpolazione di stringhe e creazione

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

**L'interpolazione di stringhe** (`$"..."`） è il modo moderno e leggibile per costruire stringhe con valori incorporati e specificatori di formato. Le stringhe verbatim (`@`) disabilitano l'escape (ottimo per percorsi/regex), e i raw string literal (`"""`) gestiscono il testo multi-linea.

## Le stringhe sono immutabili

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

Ogni operazione che "modifica" una stringa in realtà crea una **nuova** stringa (immutabilità). Questo è sicuro ma ha un costo prestazionale per modifiche ripetute.

## StringBuilder per costruzione efficiente

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

Per costruire stringhe in loop, **`StringBuilder`** evita di creare molte stringhe intermedie — una pratica prestazionale fondamentale.

## Metodi comuni delle stringhe

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

## Perché è importante

La manipolazione di stringhe è pervasiva nella programmazione (costruzione di output, elaborazione di input, formattazione dei dati), quindi comprendere le stringhe C# è una conoscenza essenziale del giorno per giorno.

Le caratteristiche moderne contano per la produttività: **l'interpolazione di stringhe** (`$"..."`） è il modo pulito e leggibile per costruire stringhe con valori incorporati e formattazione, e i literal verbatim/raw gestiscono percorsi e testo multi-linea elegantemente.

Criticamente, comprendere che **le stringhe sono immutabili** (ogni "modifica" crea una nuova stringa) spiega una considerazione prestazionale fondamentale: la concatenazione di stringhe ingenua in loop è dispendiosa (O(n²), creando molte stringhe intermedie), e sapere di usare **`StringBuilder`** per modifiche ripetute (che muta un buffer interno efficientemente) è un'importante ottimizzazione pratica che emerge direttamente da una comprensione dell'immutabilità.

Conosce la ricca libreria di metodi delle stringhe (ricerca, sostituzione, split/join, formattazione), la moderna sintassi di interpolazione, e la pratica StringBuilder guidata dall'immutabilità è conoscenza fondamentale per il lavoro costante con le stringhe che la programmazione comporta — la fluenza qui, soprattutto la convenienza dell'interpolazione e la correzione prestazionale di StringBuilder, è fondamentale per scrivere C# pulito ed efficiente.