Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese
Questa documentazione è stata archiviata e non viene gestita.

Stringhe (Guida per programmatori C#)

Una stringa è un oggetto di tipo String il cui valore è testo. Internamente, il testo viene archiviato come insieme 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.

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.

È 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.

Gli oggetti stringa sono immutabili: non possono essere modificati dopo essere stati 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#).

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."


Sequenza di escape

Nome carattere

Codifica Unicode

\'

Virgoletta singola

0x0027

\"

Virgoletta doppia

0x0022

\\

Barra rovesciata

0x005C

\0

Null

0x0000

\a

Avviso

0x0007

\b

Backspace

0x0008

\f

Avanzamento carta

0x000C

\n

Nuova riga

0x000A

\r

Ritorno a capo

0x000D

\t

Tabulazione orizzontale

0x0009

\U

Sequenza di escape Unicode per le coppie di surrogati.

\Unnnnnnnn

\u

Sequenza di escape Unicode

\u0041 = "A"

\v

Tabulazione verticale

0x000B

\x

Sequenza di escape Unicode simile a "\u", eccetto con lunghezza variabile.

\x0041 = "A"

NotaNota

In fase di compilazione, le stringhe verbatim vengono convertite in stringhe normali con tutte le stesse sequenze di escape. Pertanto, se si visualizza una stringa verbatim nella finestra Espressioni di controllo del debugger, si vedranno i caratteri di escape aggiunti dal compilatore, non la versione verbatim del codice sorgente. Ad esempio, la stringa verbatim @"C:\files.txt" verrà visualizzata nella finestra Espressioni di controllo come "C:\\files.txt".

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 il testo di debug nella finestra Output di Visual Studio, è necessario utilizzare in modo esplicito il metodo Format, poiché WriteLine accetta solo una stringa, e non una stringa di formato. Per ulteriori informazioni sulla stringhe di formato, vedere Formattazione dei tipi di dati.

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


È possibile utilizzare la notazione di matrice con un valore di indice per ottenere l'accesso in sola lettura a singoli caratteri, 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 del tipo 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", e quindi creare una nuova stringa per archiviare i risultati usando i metodi di 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?            


Una stringa vuota è un'istanza di un oggetto System.String che contiene zero caratteri. Le stringhe vuote sono 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 sono inizializzate nel modo seguente:

string s = String.Empty;

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:


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

    string tempStr = str + nullStr;
    // The following line displays "hello."
    Console.WriteLine(tempStr);

    bool b = (emptyStr == nullStr);
    // The following line displays 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";
    // The following line displays "* abc*".
    Console.WriteLine("*" + s1 + "*");
    // The following line displays "abc *".
    Console.WriteLine("*" + s2 + "*");
    // The following line displays 4.
    Console.WriteLine(s2.Length);
}


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


Poiché il tipo String implementa IEnumerable<T>, è 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.

Argomento

Descrizione

Procedura: modificare il contenuto delle stringhe (Guida per programmatori C#)

Viene fornito un esempio di codice che illustra come modificare il contenuto delle stringhe.

Procedura: concatenare più stringhe (Guida per programmatori C#)

Viene illustrato l'utilizzo dell'operatore + e della classe Stringbuilder per unire le stringhe in fase di compilazione e in fase di esecuzione.

Procedura: confrontare stringhe (Guida per programmatori C#)

Viene mostrato come eseguire confronti ordinali di stringhe.

Procedura: dividere stringhe (Guida per programmatori C#)

È contenuto un esempio di codice che illustra come utilizzare il metodo String.Split per analizzare le stringhe.

Procedura: eseguire la ricerca di stringhe tramite metodi stringa (Guida per programmatori C#)

Viene spiegato come utilizzare metodi specifici per cercare le stringhe.

Procedura: eseguire la ricerca di stringhe tramite espressioni regolari (Guida per programmatori C#)

Viene spiegato come utilizzare le espressioni regolari per cercare le stringhe.

Procedura: determinare se una stringa rappresenta un valore numerico (Guida per programmatori C#)

Viene mostrato come analizzare in modo sicuro una stringa per verificare se abbia un valore numerico valido.

Procedura: convertire una stringa in un oggetto DateTime (Guida per programmatori C#)

Viene mostrato come convertire una stringa come "01/24/2008" in un oggetto System.DateTime.

Operazioni di base sulle stringhe

Vengono forniti i collegamenti agli argomenti in cui sono utilizzati i metodi System.String e System.Text.StringBuilder per eseguire operazioni di base relative alle stringhe.

Analisi delle stringhe

Viene illustrato come inserire caratteri o spazi vuoti in una stringa.

Confronto di stringhe

Sono incluse informazioni sul confronto di stringhe e vengono forniti esempi in C# e Visual Basic.

Utilizzo della classe StringBuilder

Viene illustrato come creare e modificare oggetti stringa dinamici utilizzando la classe StringBuilder.

LINQ e stringhe

Vengono fornite informazioni sull'esecuzione di svariate operazioni di stringa utilizzando query LINQ.

Guida per programmatori C#

Vengono forniti collegamenti ad argomenti in cui sono descritti i costrutti di programmazione in C#.

date

Cronologia

Motivo

Giugno 2010

Chiarimento relativo alla descrizione della proprietà Lenght.

Commenti e suggerimenti dei clienti.

Mostra: