Stringhe (Guida per programmatori C#)

Una stringa è un oggetto di tipo String il cui valore è testo. Internamente, il testo viene archiviato come raccolta di sola lettura sequenziale di oggetti Char. Le stringhe C# non presentano un carattere di terminazione null alla fine, pertanto una stringa C# può contenere qualsiasi numero di caratteri null incorporati ('\0'). La proprietà Length di una stringa rappresenta il numero di oggetti Char in essa contenuti e non il numero di caratteri Unicode. Per accedere ai singoli punti di codice Unicode in una stringa, utilizzare l'oggetto StringInfo.

string eSystem.String

In C#, la parola chiave string è un alias per String. String e string sono pertanto equivalenti ed è possibile utilizzare la convenzione di denominazione che si preferisce. La classe String fornisce molti metodi per creare, modificare e confrontare stringhe in modo sicuro. Inoltre, il linguaggio C# esegue l'overload di alcuni operatori per semplificare le operazioni comuni sulle stringhe. Per ulteriori informazioni sulla parola chiave, vedere string (Riferimenti per C#). Per ulteriori informazioni sul tipo e i relativi metodi, vedere String.

Dichiarazione e inizializzazione di stringhe

È possibile dichiarare e inizializzare stringhe in vari modi, come mostrato nell'esempio seguente:

// Declare without initializing. 
string message1;

// Initialize to null. 
string message2 = null;

// Initialize as an empty string. 
// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

//Initialize with a regular string literal. 
string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal. 
string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.
System.String greeting = "Hello World!";

// In local variables (i.e. within a method body) 
// you can use implicit typing. 
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from 
// being used to store another string value. 
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating 
// a string from a char*, char[], or sbyte*. See 
// System.String documentation for details. 
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

Si noti che l'operatore new non viene utilizzato per creare un oggetto stringa tranne nel caso in cui la stringa venga inizializzaziata con una matriche di caratteri.

Inizializzare una stringa con il valore costante Empty per creare un nuovo oggetto String la cui stringa è di lunghezza zero. La rappresentazione del valore letterale stringa di una stringa di lunghezza zero è"". Inizializzando le stringhe con il valore Empty anziché null, è possibile ridurre le possibilità di NullReferenceException. Utilizzare il metodo IsNullOrEmpty(String) statico per verificare il valore di una stringa prima di tentare di accedervi.

Immutabilità degli oggetti stringa

Gli oggetti stringa sono non modificabili, ovvero non possono essere modificati una volta creati. Tutti i metodi String e gli operatori C# che sembrano modificare una stringa, in realtà restituiscono i risultati in un nuovo oggetto stringa. Nell'esempio seguente, quando il contenuto di s1 e s2 viene concatenato per formare un'unica stringa, le due stringhe originali restano immutate. L'operatore += crea una nuova stringa che contiene il contenuto delle due stringhe combinato. Il nuovo oggetto viene assegnato alla variabile s1e l'oggetto originale assegnato a s1 viene rilasciato per l'operazione di Garbage Collection perché nessun'altra variabile contiene un riferimento a tale oggetto.

string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new 
// string object and stores it in s1, releasing the 
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.

Poiché una "modifica" della stringa è in effetti la creazione di una nuova stringa, è necessario prestare attenzione quando si creano riferimenti alle stringhe. Se si crea un riferimento a una stringa e quindi si "modifica" la stringa originale, il riferimento continuerà a puntare all'oggetto originale anziché al nuovo oggetto creato quando la stringa è stata modificata. Nel seguente codice viene illustrato questo comportamento:

string s1 = "Hello ";
string s2 = s1;
s1 += "World";

System.Console.WriteLine(s2);
//Output: Hello

Per ulteriori informazioni su come creare nuove stringhe basate su modifiche quali operazioni di ricerca e sostituzione sulla stringa originale, vedere Procedura: modificare il contenuto delle stringhe (Guida per programmatori C#).

Valori letterali stringa normali e verbatim

Utilizzare valori letterali stringa normali quando è necessario incorporare caratteri di escape forniti da C#, come mostrato nell'esempio seguente:

string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1        Column 2        Column 3 

string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
  Row 1
  Row 2
  Row 3
*/ 

string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Utilizzare stringhe verbatim per praticità e migliore leggibilità quando il testo della stringa contiene barre rovesciate, ad esempio nei percorsi di file. Poiché le stringhe verbatim mantengono i caratteri di nuova riga come parte del testo della stringa, possono essere utilizzate per inizializzare stringhe su più righe. Utilizzare virgolette doppie per incorporare una virgoletta in una stringa verbatim. Nell'esempio seguente sono mostrati alcuni utilizzi comuni delle stringhe verbatim:

string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\ 

string text = @"My pensive SARA ! thy soft cheek reclined
    Thus on mine arm, most soothing sweet it is
    To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
   Thus on mine arm, most soothing sweet it is
   To sit beside our Cot,... 
*/ 

string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Sequenze di escape delle stringhe

Stringhe di formato

Una stringa di formato è una stringa il cui contenuto può essere determinato dinamicamente in fase di esecuzione. Si crea una stringa di formato tramite il metodo Format statico e incorporando in parentesi graffe i segnaposto che verranno sostituiti da altri valori in fase di esecuzione. Nell'esempio seguente viene utilizzata una stringa di formato per restituire il risultato di ogni iterazione di un ciclo:

class FormatString
{
    static void Main()
    {
        // Get user input.
        System.Console.WriteLine("Enter a number");
        string input = System.Console.ReadLine();

        // Convert the input string to an int. 
        int j;
        System.Int32.TryParse(input, out j);

        // Write a different string each iteration. 
        string s;
        for (int i = 0; i < 10; i++)
        {
            // A simple format string with no alignment formatting.
            s = System.String.Format("{0} times {1} = {2}", i, j, (i * j));
            System.Console.WriteLine(s);
        }

        //Keep the console window open in debug mode.
        System.Console.ReadKey();
    }
}

Un overload del metodo WriteLine accetta una stringa di formato come parametro. Pertanto, è possibile incorporare solo un valore letterale stringa di formato senza una chiamata esplicita al metodo. Tuttavia, se si utilizza il metodo WriteLine per visualizzare l'output di debug nella finestra Output di Visual Studio, si deve chiamare in modo esplicito il metodo Format perché WriteLine accetta solo una stringa, non una stringa di formato. Per ulteriori informazioni sulla stringhe di formato, vedere Formattazione di tipi in .NET Framework.

Sottostringhe

Una sottostringa è qualsiasi sequenza di caratteri contenuta in una stringa. Utilizzare il metodo Substring per creare una nuova stringa da una parte della stringa originale. È possibile cercare una o più occorrenze di una sottostringa tramite il metodo IndexOf. Utilizzare il metodo Replace per sostituire tutte le occorrenze di una sottostringa specificata con una nuova stringa. Come il metodo Substring, Replace restituisce in realtà una nuova stringa e non modifica la stringa originale. Per ulteriori informazioni, vedere°Procedura: eseguire la ricerca di stringhe tramite metodi stringa (Guida per programmatori C#) e Procedura: modificare il contenuto delle stringhe (Guida per programmatori C#).

string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express" 

// Index values are zero-based 
int index = s3.IndexOf("C");
// index = 7

Accesso a caratteri singoli

È possibile utilizzare la notazione di matrice con un valore di indice per acquisire accesso in sola lettura a caratteri singoli, come nell'esempio seguente:

string s5 = "Printing backwards";

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

Se i metodi String non forniscono la funzionalità richiesta per modificare singoli caratteri in una stringa, è possibile utilizzare un oggetto StringBuilder per modificare i singoli caratteri "sul posto", quindi creare una nuova stringa per archiviare i risultati tramite i metodi StringBuilder. Nell'esempio seguente, presupporre che sia necessario modificare la stringa originale in un modo specifico e archiviare quindi i risultati per uso futuro:

string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)
{
    if (System.Char.IsLower(sb[j]) == true)
        sb[j] = System.Char.ToUpper(sb[j]);
    else if (System.Char.IsUpper(sb[j]) == true)
        sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string. 
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?            

Stringhe null e stringhe vuote

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

string s = String.Empty;

Al contrario, una stringa null non fa riferimento a un'istanza di un oggetto 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:

static void Main()
{
    string str = "hello";
    string nullStr = null;
    string emptyStr = String.Empty;

    string tempStr = str + nullStr;
    // Output of the following line: hello
    Console.WriteLine(tempStr);

    bool b = (emptyStr == nullStr);
    // Output of the following line: False
    Console.WriteLine(b);

    // The following line creates a new empty string. 
    string newStr = emptyStr + nullStr;

    // Null strings and empty strings behave differently. The following 
    // two lines display 0.
    Console.WriteLine(emptyStr.Length);
    Console.WriteLine(newStr.Length);
    // The following line raises a NullReferenceException. 
    //Console.WriteLine(nullStr.Length); 

    // The null character can be displayed and counted, like other chars. 
    string s1 = "\x0" + "abc";
    string s2 = "abc" + "\x0";
    // Output of the following line: * abc*
    Console.WriteLine("*" + s1 + "*");
    // Output of the following line: *abc *
    Console.WriteLine("*" + s2 + "*");
    // Output of the following line: 4
    Console.WriteLine(s2.Length);
}

Utilizzo di StringBuilder per la creazione veloce di stringhe

Le operazioni sulle stringhe in .NET sono altamente ottimizzate e nella maggior parte dei casi non influiscono sulle prestazioni in modo significativo. Tuttavia, in alcuni scenari, ad esempio cicli rigidi eseguiti molte centinaia o migliaia di volte, le operazioni sulle stringhe possono incidere sulle prestazioni. 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, un'operazione non supportata dal tipo di dati string 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();

//Outputs Cat: the ideal pet

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

Stringhe, metodi di estensione e LINQ

Poiché il tipo String implementa IEnumerable, è possibile utilizzare i metodi di estensione definiti nella classe Enumerable sulle stringhe. Per evitare confusioni a livello visivo, questi metodi sono esclusi da IntelliSense per il tipo String, ma sono comunque disponibili. È possibile utilizzare anche le espressioni di query LINQ sulle stringhe. Per ulteriori informazioni, vedere LINQ e stringhe.

Argomenti correlati

Capitoli del libro rappresentati

Ulteriori informazioni sulle variabili in Visual c# 2010 iniziale