Stringhe

Una stringa è un pezzo di testo. Di solito è formata da due o più caratteri, dal momento che se fosse di uno solo, si dovrebbe invece valutare di usare un char. Tuttavia, le stringhe possono anche essere vuote o addirittura null, visto che è un tipo di dato di riferimento. Una stringa può essere dichiarata proprio come gli altri tipi con cui abbiamo già lavorato:

string s;

Oppure se si vuole assegnarne un valore immediatamente:

string name = "John Doe";

Tutto ciò che è all'interno di virgolette, in C# viene considerato una stringa, come nell'esempio sopra - racchiudere uno o più caratteri tra virgolette è semplicemente il modo in cui si dice al compilatore che quanto è all'interno deve essere interpretato come stringa anziché, per esempio, parole chiave e comandi.

Le stringhe sono immutabili

In C#, le stringhe sono immutabili, il che significa solamente che una volta create, non possono essere modificate. Questo non è ovviamente molto pratico nell'uso quotidiano, così il framework ci viene in aiuto: invece di continuare a dichiarare nuove stringhe per fare modifiche, ne viene semplicemente creata una nuova ogni volta che viene modificata quella esistente. Questo procedura avviene in modo trasparente, ma può anche rendere il codice meno efficiente senza accorgercene. Ecco un esempio che lo dimostra:

string numbers = "";
for (int i = 0; i < 10000; i++)
    numbers += i.ToString();

In questo caso, viene eseguito un ciclo 10.000 volte, ogni volta accodando l'indice corrente alla stringa. Con ciò che abbiamo appena appreso, ora sappiamo che invece di modificare la stringa esistente per includere l'ultimo numero, una nuova stringa viene creata e poi assegnata alla vecchia variabile, lasciando al framework il compito di ripulire il precedente valore. E questo avviene 10.000 volte! Piuttosto, viene generalmente consigliato di usare un cosiddetto StringBuilder, se si deve costruire una stringa con diverse operazioni:

StringBuilder numbers = new StringBuilder();
for (int i = 0; i < 10000; i++)
    numbers.Append(i);
Console.WriteLine(numbers.ToString());

Operazioni di base sulle stringhe

Posto quanto detto sull'immutabilità delle stringhe, ci si troverà spesso a manipolare e lavorare con semplici stringhe, ma non c'è da preoccuparsi: a meno che non si stia lavorando all'interno di un ciclo gigantesco, è improbabile che ci siano problemi. Ecco alcune delle operazioni basilari che si possono fare con le stringhe:

Si possono concatenare due o più stringhe semplicemente "addizionandole" (usando l'operatore più):

string name = "John" + " " + "Doe";

Naturalmente si può fare lo stesso con le variabili, dove si mescolano stringhe tra virgolette e variabili che possono essere stringhe o che possono essere convertite in stringa (usando il metodo ToString() presente in tutti gli oggetti). Tuttavia, un modo più "pulito" di farlo è con il metodo Format presente nella classe String:

string name = "John Doe";
int age = 42;
string userString = String.Format("{0} is {1} years old and lives in {2}", name, age, "New York");

Notare come sono stati usati dei segnaposto ({0}, {1} ecc.) e poi passati i relativi valori come parametri del metodo. Basta ricordare che gli indici e il numero di segnaposto devono combaciare con i parametri passati.

La proprietà Length permette di verificare la lunghezza attuale di una stringa, per esempio a scopo di validazione. La proprietà Length è anche molto utile in combinazione con altre proprietà e metodi, ad esempio i metodi Substring() e IndexOf(). Il metodo Substring permette di ottenere una parte della stringa, mentre il metodo IndexOf permette di trovare il primo indice in base a un carattere o a una stringa passati. Vediamolo con un esempio:

string name = "John Doe";
int indexOfSpace = name.IndexOf(' ') + 1;
string lastName = name.Substring(indexOfSpace, name.Length - indexOfSpace);
Console.WriteLine(lastName);

Spiegazione rapida: definiamo un nome, poi usiamo il metodo IndexOf() per trovare la prima posizione di un carattere spazio. Quindi usiamo il metodo Substring() per ottenere tutto dopo il carattere spazio, fornendo una posizione di partenza e una lunghezza.

Un altro stupendo metodo di utilità nella classe String è il metodo Replace(). Permette di prendere una stringa e poi eseguire una ricerca/sostituzione sulla stessa, come in questo caso:

string name = "John Doe";
Console.WriteLine(name.Replace("John", "Jane"));

Il metodo Replace() non è affatto rigido: se la stringa che si sta cercando (il primo parametro) non è presente, allora non succede niente (non vengono sollevate eccezioni o altro del genere). Se è presente, viene sostituita con il secondo parametro. Tuttavia, se si vuole fare una verifica prima della sostituzione, si può usare il metodo Contains():

string name = "John Doe";
if (name.Contains("John"))
    Console.WriteLine(name.Replace("John", "Jane"));
else
    Console.WriteLine("John was not found!");

Talvolta si vuole sapere se una stringa inizia o termina con uno specifico carattere o stringa. Per questo, la classe String può essere d'aiuto con i metodi StartsWith() e EndsWith(), che lavorano proprio come il nome suggerisce:

string name = "John Doe";
if ((name.StartsWith("John")) && (name.EndsWith("Doe")))
    Console.WriteLine("Hello, Mr. Doe!");

Ci sono ancora altri interessanti metodi in String, e ci sono certamente più modi di usarli di quelli mostrati con questi brevi esempi. Se si vuole saperne di più, si può vedere la documentazione MSDN per la classe String.

Stringhe letterali & Escape dei caratteri

Mentre definiamo una stringa, noteremo presto che certi caratteri hanno una funzione speciale. L'esempio più importante di questo sono le virgolette stesse, poiché, dal momento che sono usate per indicare al compilatore l'inizio e la fine di una stringa, come possono essere usate all'interno della stringa? La risposta più semplice è il "carattere di escape", dove si segnala al compilatore che un carattere con una funzione speciale deve essere interpretato letteralmente invece della sua funzione normale. Ecco un esempio:

Console.WriteLine("What do you mean by \"Hello, world\" ??");

Una volta eseguito, il risultato assomiglierà a questo:

What do you mean by "Hello, world" ??

In altre parole, si usa semplicemente la barra retroversa davanti alla virgoletta, per indicare che questa NON è la fine della stringa, ma che, invece, vogliamo effettivamente una virgoletta. Quindi... e se si volesse effettivamente mostrare una barra retroversa invece di usarla come carattere di escape per un'altro carattere? Ebbene, si dovrà anteporre un carattere di escape, ovvero un'altra barra retroversa:

Console.WriteLine("Right here \\ Right now");

Il risultato sarà:

Right here \ Right now

La ragione è che la barra retroversa non viene usata solo con le virgolette, è anche usata come prefisso per una serie di caratteri per dargli un significato speciale. Per esempio, \n è una nuova linea, \t è un carattere di tabulazione e così via. Si può vedere una lista di caratteri di escape qui.

Stringhe letterali

Come alternativa a tutto questo escape, si può usare una stringa letterale. La dichiarazione è come quella di una stringa normale, ma con davanti il carattere @ e all'interno tutti i caratteri sono trattati letteralmente:

Console.WriteLine(@"In a verbatim string \ everything is literal: \n & \t");

L'output verrà reso proprio come l'input:

In a verbatim string \ everything is literal: \n & \t

C'è solo una eccezione a questa regola: davanti a una virgoletta si dovrà comunque inserire il carattere di escape. Questo ha perfettamente senso, perchè altrimenti come farebbe il compilatore a sapere se si sta cercando di terminare una stringa oppure no? In una stringa letterale, tuttavia, il carattere di escape della virgoletta non è la barra retroversa bensì un'altra virgoletta, così:

Console.WriteLine(@"What do you mean by ""Hello, world"" ??");

Il risultato appare così:

What do you mean by "Hello, world" ??

Riepilogo

Le stringhe sono un un argomento di ENORME importanza per tutti i programmatori. Ci sarà sempre da fare qualche tipo di operazione su stringhe per buona parte del tempo speso a scrivere codice. Fortunatamente, C# ha tutti gli strumenti di cui si ha bisogno per farlo, come abbiamo provato a illustrare in questo articolo.