Questa documentazione è stata archiviata e non viene gestita.

Utilizzo di stringhe (Guida per programmatori C#)

Una stringa C# è una matrice di caratteri dichiarata tramite la parola chiave string. Una stringa letterale viene dichiarata utilizzando le virgolette, come illustrato nell'esempio riportato di seguito:

string s = "Hello, World!";

È possibile estrarre sottostringhe e concatenare stringhe nel modo seguente:

string s1 = "orange";
string s2 = "red";

s1 += s2;
System.Console.WriteLine(s1);  // outputs "orangered"

s1 = s1.Substring(2, 5);
System.Console.WriteLine(s1);  // outputs "anger"

Gli oggetti stringa sono non modificabili, ovvero non possono essere modificati una volta creati. I metodi che intervengono sulle stringhe in realtà restituiscono oggetti stringa nuovi. Nell'esempio riportato in precedenza, quando il contenuto di s1 e s2 è concatenato per formare un'unica stringa, le due stringhe contenenti "orange" e "red" sono entrambe non modificabili. L'operatore += crea una nuova stringa che contiene il contenuto delle due stringhe combinato. A questo punto, s1 fa riferimento a una stringa completamente diversa. Esiste ancora una stringa che contiene soltanto "orange" , ma non viene più fatto riferimento ad essa quando viene concatenata s1.

NoteNota

Fare attenzione quando si creano riferimenti a stringhe. Se si crea un riferimento a una stringa e quindi si "modifica" la stringa, il riferimento continuerà a puntare all'oggetto originale e non all'oggetto nuovo creato quando la stringa è stata modificata. Il codice seguente illustra questo problema:

string s1 = "Hello";
string s2 = s1;
s1 += " and goodbye.";
Console.WriteLine(s2); //outputs "Hello"

Poiché le modifiche alle stringhe comportano la creazione di oggetti di tipo stringa nuovi, per evitare di compromettere le prestazioni in caso di numerose operazioni di concatenazione o di modifica delle stringhe, è consigliabile utilizzare la classe StringBuilder, come illustrato di seguito:

System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append("one ");
sb.Append("two ");
sb.Append("three");
string str = sb.ToString();

La classe StringBuilder viene illustrata in dettaglio nella sezione "Utilizzo di Stringbuilder".

Utilizzo delle stringhe

Caratteri di escape

È possibile includere nelle stringhe caratteri di escape come "\n" (nuova riga) e "\t" (tabulazione). La riga:

string hello = "Hello\nWorld!";

corrisponde a:

Hello

World!

Se si desidera includere una barra rovesciata, quest'ultima deve essere preceduta da un'altra barra rovesciata. La stringa riportata di seguito:

string filePath = "\\\\My Documents\\";

corrisponde effettivamente a:

\\My Documents\

Simbolo @

Il simbolo @ indica al costruttore della stringa di ignorare i caratteri di escape e le interruzioni di riga. Di conseguenza le due stringhe riportate di seguito sono identiche:

string p1 = "\\\\My Documents\\My Files\\";
string p2 = @"\\My Documents\My Files\";

ToString()

Analogamente a tutti gli oggetti derivati da Object, le stringhe forniscono il metodo ToString, tramite il quale un valore viene convertito in una stringa. Questo metodo può essere utilizzato per convertire valori numerici in stringhe:

int year = 1999;
string msg = "Eve was born in " + year.ToString();
System.Console.WriteLine(msg);  // outputs "Eve was born in 1999"

Accesso a caratteri singoli

È possibile accedere a caratteri singoli contenuti in una stringa tramite metodi quali SubString(), Replace(), Split() e Trim().

string s3 = "Visual C# Express";

System.Console.WriteLine(s3.Substring(7, 2));         // outputs "C#"
System.Console.WriteLine(s3.Replace("C#", "Basic"));  // outputs "Visual Basic Express"

È anche possibile copiare i caratteri in una matrice di caratteri:

string s4 = "Hello, World";
char[] arr = s4.ToCharArray(0, s4.Length);

foreach (char c in arr)
{
    System.Console.Write(c);  // outputs "Hello, World"
}

È possibile accedere a caratteri singoli derivati da una stringa con un indice:

string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)
{
    System.Console.Write(s5[s5.Length - i - 1]);  // outputs "sdrawkcab gnitnirP"
}

Modifica della combinazione di maiuscole e minuscole

Per modificare le lettere in una stringa in maiuscole o minuscole, utilizzare ToUpper() o ToLower():

string s6 = "Battle of Hastings, 1066";

System.Console.WriteLine(s6.ToUpper());  // outputs "BATTLE OF HASTINGS 1066"
System.Console.WriteLine(s6.ToLower());  // outputs "battle of hastings 1066"

Confronti

Il modo più semplice per confrontare due stringhe consiste nell'utilizzare gli operatori == e !=, che eseguono un confronto con distinzione tra maiuscole e minuscole.

string color1 = "red";
string color2 = "green";
string color3 = "red";

if (color1 == color3)
{
    System.Console.WriteLine("Equal");
}
if (color1 != color2)
{
    System.Console.WriteLine("Not equal");
}

Gli oggetti stringa dispongono anche di un metodo CompareTo() che restituisce un valore integer basato sul fatto che una stringa sia minore (<) o maggiore (>) di un'altra. Durante il confronto delle stringhe, viene utilizzato il valore Unicode e le lettere minuscole hanno un valore inferiore alle lettere maiuscole.

string s7 = "ABC";
string s8 = "abc";

if (s7.CompareTo(s8) > 0)
{
    System.Console.WriteLine("Greater-than");
}
else
{
    System.Console.WriteLine("Less-than");
}

Per cercare una stringa all'interno di un'altra stringa, utilizzare il metodo IndexOf(), il quale restituisce -1 se la stringa di ricerca non viene trovata; in caso contrario, restituisce l'indice in base zero della prima posizione in cui è presente.

string s9 = "Battle of Hastings, 1066";

System.Console.WriteLine(s9.IndexOf("Hastings"));  // outputs 10
System.Console.WriteLine(s9.IndexOf("1967"));      // outputs -1

Suddivisione di una stringa in sottostringhe

La suddivisione di una stringa in sottostringhe, analoga alla suddivisione di una frase in singole parole, è una comune attività di programmazione. Il metodo Split() accetta una matrice char di delimitatori, ad esempio uno spazio e restituisce una matrice di sottostringhe. È possibile accedere a questa matrice con foreach:

char[] delimit = new char[] { ' ' };
string s10 = "The cat sat on the mat.";
foreach (string substr in s10.Split(delimit))
{
    System.Console.WriteLine(substr);
}

Questo codice visualizza ogni parola su una riga separata:

The

cat

sat

on

the

mat.

Stringhe null e stringhe vuote

Una stringa vuota è un'istanza di un oggetto System.String che contiene zero caratteri. Le stringhe vuote vengono utilizzate di frequente in diversi scenari di programmazione per rappresentare un campo di testo vuoto. È possibile chiamare metodi in stringhe vuote perché sono oggetti System.String validi. Le stringhe vuote vengono inizializzate nel seguente modo:

string s = "";

Al contrario, una stringa null non fa riferimento a un'istanza di un oggetto System.String ed eventuali tentativi di chiamata di un metodo in una stringa null restituiscono un'eccezione NullReferenceException. È tuttavia possibile utilizzare stringhe null nelle operazioni di concatenazione e confronto con altre stringhe. Negli esempi seguenti vengono illustrati casi in cui un riferimento a una stringa null causa o meno la generazione di un'eccezione:

string str = "hello";
string nullStr = null;
string emptyStr = "";

string tempStr  = str + nullStr; // tempStr = "hello"
bool b = (emptyStr == nullStr);// b = false;
emptyStr + nullStr = ""; // creates a new empty string
int I  = nullStr.Length; // throws NullReferenceException

Utilizzo di StringBuilder

La classe StringBuilder crea un buffer di stringhe che offre prestazioni migliori se il programma esegue numerose modifiche di stringhe. La stringa StringBuilder consente inoltre di riassegnare singoli caratteri, operazione non supportata dal tipo di dati di stringa incorporato. Tramite il codice riportato di seguito, ad esempio, è possibile modificare il contenuto di una stringa senza crearne una nuova:

System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
System.Console.ReadLine();

Nell'esempio riportato di seguito, viene utilizzato un oggetto StringBuilder per creare una stringa da un insieme di tipi numerici:

class TestStringBuilder
{
    static void Main()
    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();

        // Create a string composed of numbers 0 - 9
        for (int i = 0; i < 10; i++)
        {
            sb.Append(i.ToString());
        }
        System.Console.WriteLine(sb);  // displays 0123456789

        // Copy one character of the string (not possible with a System.String)
        sb[0] = sb[9];

        System.Console.WriteLine(sb);  // displays 9123456789
    }
}

Ulteriori informazioni

Da Riferimenti per programmatori C#:

Vedere anche

Mostra: