Stringhe in C#: Length, confronto, escape, stringhe verbatim e multiriga

In C# una string è una sequenza di caratteri UTF-16 (valori char). È un tipo riferimento, ma si comporta come un valore negli aspetti che contano: è immutabile, e == confronta il testo invece dell'identità dell'oggetto. string è la parola chiave di C# per il tipo .NET System.String; i due sono intercambiabili.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

Output:

Porto
5
0
*****
hi
Porto has 5 letters

Le stringhe sono immutabili

Nessun metodo modifica una stringa sul posto. ToUpper, Replace, Trim e ogni altro metodo restituiscono una nuova stringa e lasciano intatta quella originale. Dimenticarsi di usare il valore restituito è un bug molto comune con le stringhe:

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

Output:

[  maya  ]
[MAYA]
tea
tea and cake

L'immutabilità rende le stringhe sicure da condividere tra thread e da usare come chiavi di dizionario. Il prezzo è che costruire una stringa pezzo per pezzo in un ciclo crea una nuova stringa a ogni passo; in quel caso usa StringBuilder.

Length e indicizzazione

Length è una proprietà (niente parentesi). L'indicizzatore s[i] restituisce il char alla posizione i, contando da 0, ed è di sola lettura:

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

Output:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 e successivi accettano anche un indice dalla fine: code[^1] è l'ultimo carattere, come code[code.Length - 1]. Per prendere più caratteri insieme, vedi substring.

Length conta le unità di codice UTF-16, non quello che un lettore vede come caratteri. La maggior parte delle lettere nella maggior parte delle lingue è una sola unità, ma le emoji e alcune scritture rare ne usano due (una coppia surrogata), quindi "👍".Length vale 2.

Confrontare le stringhe

== e != confrontano i caratteri, distinguendo maiuscole e minuscole. Per tutto il resto, passa un valore StringComparison che dice come confrontare:

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

Output:

False
False
True
True
apple first
True
False
False
True

Quale confronto usare:

• Ordinal confronta i codici numerici dei caratteri. È veloce, prevedibile e uguale su ogni macchina. Usalo per identificatori, nomi di file, chiavi, valori di protocollo e tutto ciò che non viene mostrato a una persona.
• OrdinalIgnoreCase è lo stesso, ma ignora maiuscole e minuscole. È la scelta giusta per i controlli che non distinguono maiuscole e minuscole, come le estensioni dei file o gli header HTTP.
• CurrentCulture (e CurrentCultureIgnoreCase) segue le regole della lingua dell'utente, quindi ordina le parole come farebbe un dizionario in quella lingua. Usalo per ordinare elenchi mostrati agli utenti.
• InvariantCulture usa regole basate sulla cultura che non dipendono dalle impostazioni della lingua dell'utente. Dipende comunque dalla libreria di globalizzazione: il .NET moderno usa ICU, .NET Framework usa NLS di Windows, e i due possono ordinare alcune stringhe in modo diverso.

string.Compare(a, b) e a.CompareTo(b) senza uno StringComparison usano la cultura corrente, per cui i loro risultati cambiano da una macchina all'altra. Evita di confrontare con a.ToLower() == b.ToLower(): alloca due nuove stringhe e dà risposte sbagliate in alcune culture (la i turca con e senza punto è il caso classico).

Chiamare a.Equals(b) quando a è null lancia una NullReferenceException, mentre a == b e il metodo statico string.Equals(a, b) gestiscono il null in modo sicuro.

Caratteri di escape

Dentro un normale letterale stringa, un backslash inizia una sequenza di escape:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

Output:

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

Una sequenza non riconosciuta come "\d" è un errore di compilazione (CS1009, sequenza di escape non riconosciuta), ed è quello che succede quando un percorso Windows o un'espressione regolare viene scritto come stringa normale.

Stringhe verbatim e stringhe multiriga

Mettere @ davanti a un letterale lo rende verbatim: i backslash sono caratteri letterali e la stringa può occupare più righe. L'unico escape rimasto è "", che produce una virgoletta doppia.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

Output:

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

Una stringa verbatim multiriga include tutto ciò che sta tra le virgolette, compresa l'indentazione delle righe successive, ed è per questo che di solito si scrivono attaccate al margine come sopra. Gli a capo che contiene sono quelli del file sorgente, quindi un file salvato con i fine riga di Windows produce \r\n.

C# 11 ha aggiunto i raw string literal, che risolvono entrambi i problemi. Iniziano e finiscono con tre o più virgolette doppie, non richiedono alcun escape e rimuovono l'indentazione pari a quella delle virgolette di chiusura:

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

Se il contenuto stesso contiene """, inizia e termina con quattro virgolette. I raw literal si combinano anche con l'interpolazione ($"""..."""); vedi interpolazione di stringhe.

Null, stringa vuota e spazi bianchi

Una variabile stringa può essere null (nessuna stringa), vuota ("", lunghezza 0) oppure contenere solo spazi bianchi. Due metodi statici controllano questi casi senza rischiare una NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

Output:

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

Per validare l'input dell'utente, string.IsNullOrWhiteSpace è quasi sempre quello che ti serve. string.Empty e "" sono lo stesso valore; quale scrivere è questione di stile.

Ciclare sui caratteri

Una stringa è enumerabile, quindi foreach visita ogni char. Il tipo char ha metodi statici per classificare i caratteri:

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

Output:

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

Unire stringhe

+ concatena, e funziona con qualsiasi tipo dall'altra parte (chiama ToString()). Per combinare molti valori, preferisci l'interpolazione o string.Join:

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

Output:

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

Le ultime due righe mostrano una trappola di precedenza: + viene valutato da sinistra a destra, quindi appena il lato sinistro è una stringa, ogni + successivo è una concatenazione. Metti tra parentesi l'aritmetica dentro una concatenazione.