1. Introduzione
Ricorda, le stringhe in C# sono immutabili (immutable). Questo significa che dopo la creazione non puoi modificarle: qualsiasi operazione che sembra "modificare" una stringa in realtà crea una nuova stringa in memoria.
Per esempio, quando scrivi:
string hello = "Ciao";
hello += " mondo!"; // Sembra che hello sia cambiata, ma in realtà è stato creato un nuovo oggetto!
La variabile hello punta a un nuovo oggetto, e quello vecchio (se non viene più usato) verrà prima o poi eliminato dal garbage collector. Se fai queste operazioni tante volte in un ciclo, rischi di "intasare" la RAM e vedere un calo improvviso delle prestazioni. Questo si sente soprattutto se unisci migliaia o milioni di stringhe: a ogni passo viene creata una nuova stringa, vengono copiati tutti i suoi caratteri, i vecchi oggetti restano in memoria fino al garbage collector, e il tuo programma inizia a rallentare di brutto.
Ed è qui che entra in scena l’eroe di questa lezione — StringBuilder.
using System.Text; // ← obbligatorio!
StringBuilder sb = new StringBuilder("Ciao");
sb.Append(" mondo!"); // Ora la stringa cambia veloce ed efficiente
Conosciamo StringBuilder
StringBuilder è una classe dello spazio dei nomi System.Text. Il suo scopo è creare e assemblare stringhe grandi in modo efficiente, modificandone il contenuto senza creare sempre nuovi oggetti.
Un’analogia:
Se una stringa (string) è come un pezzo di mosaico che puoi solo sostituire tutto intero, StringBuilder è come una lavagna magnetica dove puoi attaccare e staccare i pezzi all’infinito, senza dover prendere una nuova lavagna ogni volta che vuoi aggiungere o togliere qualcosa.
Quando conviene usare StringBuilder?
- Se modifichi la stringa tante volte (soprattutto in un ciclo).
- Se stai assemblando testo da tanti pezzettini piccoli.
- Se ti interessa la velocità e l’uso della memoria.
Quando NON conviene usarlo?
- Se hai solo 1-2 operazioni semplici con la stringa ― una string normale è più semplice e leggibile.
- Se vuoi davvero (per qualche motivo) salvare ogni stato intermedio della stringa.
2. Creazione e operazioni base con StringBuilder
Importare lo spazio dei nomi
Iniziare è facile: ricordati di importare lo spazio dei nomi.
using System.Text;// ← obbligatorio!
Modi per creare una nuova stringa
StringBuilder sb1 = new StringBuilder(); // Vuoto
StringBuilder sb2 = new StringBuilder("Start"); // Con testo iniziale
StringBuilder sb3 = new StringBuilder(100); // Con spazio per 100 caratteri
Metodi principali
var sb = new StringBuilder("Inizio");
sb.Append(" + aggiunto nuovo testo"); // Aggiungi alla fine
sb.AppendLine(" (e questo con a capo)"); // Aggiungi con \n
sb.Insert(0, "Start: "); // Inserisci dalla posizione 0
sb.Remove(0, 7); // Rimuovi 7 caratteri dalla posizione 0
sb.Replace("testo", "STRING"); // Sostituisci tutti "testo" con "STRING"
string result = sb.ToString(); // Ottieni la stringa finale
3. Efficienza di StringBuilder
Esempio: confronto delle prestazioni
Supponiamo di dover assemblare una stringa con 10 000 numeri di fila (magari ti chiedono di stampare tutti i numeri dei tuoi compagni di corso):
Approccio ingenuo (string)
string text = "";
for (int i = 0; i < 10000; i++)
{
text += i + " "; // Ad ogni passo viene creata una nuova stringa!
}
Console.WriteLine(text.Substring(0, 100) + "..."); // Per accorciare l’output
Approccio ottimale (StringBuilder)
var sb = new StringBuilder();
for (int i = 0; i < 10000; i++)
{
sb.Append(i).Append(' '); // Puoi concatenare!
}
Console.WriteLine(sb.ToString().Substring(0, 100) + "...");
Qual è la differenza?
Il primo metodo sarà molto più lento e potrebbe “mangiarsi” molta più RAM. Il secondo è veloce e leggero.
4. I metodi più usati di StringBuilder
Append — aggiunge una stringa o altro tipo (automaticamente converte in stringa):
sb.Append("testo");
sb.Append(123); // 123 diventa "123"
sb.Append('!'); // Carattere
AppendLine — aggiunge una stringa + carattere di nuova riga:
sb.AppendLine("stringa"); // Aggiunge "stringa\n"
Insert — inserisce una stringa in una posizione specifica:
sb.Insert(0, "Hello, "); // Inserisci all’inizio
Remove — rimuove alcuni caratteri:
sb.Remove(3, 4); // Rimuove 4 caratteri a partire dalla posizione 3
Replace — sostituisce tutte le occorrenze di una sottostringa o carattere:
sb.Replace("old", "new");
sb.Replace('a', 'A');
ToString — restituisce la stringa pronta.
Tagliare la stringa
A differenza di string, a un oggetto StringBuilder puoi assegnare una nuova lunghezza. Così la stringa viene tagliata a quella lunghezza.
sb.Length = 10; // Tutto quello dopo il decimo carattere — sparisce!
5. Caratteristiche e errori tipici
Perché ToString() è importante
Finché lavori con StringBuilder, hai in mano non una stringa ma un oggetto speciale. Molti metodi (tipo Console.WriteLine) lo accettano senza problemi, perché sa convertirsi in stringa da solo, ma a volte potresti avere sorprese — tipo se confronti per sbaglio con una stringa normale o fai qualcosa tipo:
if (sb == "Ciao") { ... } // Ops! Non funziona, anche se sb contiene "Ciao"
Il risultato sarà false: stai confrontando oggetti di tipi diversi, non stringhe.
Corretto:
if (sb.ToString() == "Ciao") { ... }
Mutabilità
A differenza di string, StringBuilder è mutabile (mutable)! Un oggetto può cambiare il suo contenuto quante volte vuoi, ed è questo che lo rende veloce.
Non dimenticare ToString() alla fine del lavoro con l’oggetto, altrimenti otterrai non una stringa ma un testo strano tipo System.Text.StringBuilder.
Dimensione del buffer e ridimensionamento
Dentro di sé StringBuilder tiene un array di caratteri. Se già sai che vuoi “costruire” una stringa molto lunga, puoi passare la lunghezza prevista al costruttore — così lavori ancora più veloce.
var bigBuilder = new StringBuilder(50000); // Ci aspettiamo 50 mila caratteri
Ma se sbagli — nessun problema! StringBuilder allargherà il buffer da solo se serve, solo che sarà un po’ più lento.
Out of memory?
Teoricamente, se proprio esageri e aggiungi miliardi di caratteri, puoi arrivare a un OutOfMemoryException, ma per i casi reali non succede quasi mai.
GO TO FULL VERSION