String Classe

Definizione

Rappresenta il testo come sequenza di unità di codice UTF-16.

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public ref class System::String sealed : ICloneable, IComparable, IConvertible, System::Collections::IEnumerable
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::IEnumerable
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public sealed class String : IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
[System.Serializable]
public sealed class String : ICloneable, IComparable, IConvertible, System.Collections.IEnumerable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.IEnumerable
public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface ICloneable
[<System.Serializable>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IComparable<string>
    interface seq<char>
    interface IEnumerable
    interface IEquatable<string>
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
type string = class
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
type string = class
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
    interface seq<char>
    interface IEnumerable
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Public NotInheritable Class String
Implements ICloneable, IComparable, IConvertible, IEnumerable
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable, IEquatable(Of String)
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable(Of Char), IEquatable(Of String)
Ereditarietà
String
Attributi
Implementazioni

Commenti

Una stringa è una raccolta sequenziale di caratteri usata per rappresentare il testo. Un oggetto è una raccolta sequenziale di oggetti che rappresentano una stringa. Un String oggetto corrisponde a System.Char un'unità di codice System.Char UTF-16. Il valore dell'oggetto è il contenuto della raccolta sequenziale di oggetti e tale valore non è modificabile, ovvero è String System.Char di sola lettura. Per altre informazioni sull'immutabilità delle stringhe, vedere la sezione Immutabilità e classe StringBuilder. Le dimensioni massime di String un oggetto in memoria sono di 2 GB o circa 1 miliardo di caratteri.

Per altre informazioni su Unicode, UTF-16, unità di codice, punti di codice e tipi e , vedere Introduzione alla codifica dei caratteri Char Rune in .NET.

Contenuto della sezione:

Creare un'istanza di un oggetto String
Oggetti Char e caratteri Unicode
Stringhe e standard Unicode
Stringhe e caratteri Null incorporati
Stringhe e indici
Stringhe Null e stringhe vuote
Immutabilità e classe StringBuilder
Operazioni ordinali e con distinzione delle impostazioni cultura
Normalizzazione
Operazioni sulle stringhe per categoria

Creare un'istanza di un oggetto String

È possibile creare String un'istanza di un oggetto nei modi seguenti:

  • Assegnando un valore letterale stringa a una String variabile. Si tratta del metodo più comunemente usato per la creazione di una stringa. Nell'esempio seguente viene utilizzata l'assegnazione per creare diverse stringhe. Si noti che in C#, poiché la barra rovesciata ( ) è un carattere di escape, le barre rovesciate letterali in una stringa devono essere precedute da un carattere di escape o l'intera \ stringa deve essere @-quoted .

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc
    
  • Chiamando un costruttore String di classe. Nell'esempio seguente viene creata un'istanza delle stringhe chiamando diversi costruttori di classe. Si noti che alcuni costruttori includono puntatori a matrici di caratteri o matrici di byte con segno come parametri. Visual Basic non supporta le chiamate a questi costruttori. Per informazioni dettagliate sui String costruttori, vedere il riepilogo String dei costruttori.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc
    
  • Usando l'operatore di concatenazione di stringhe (+ in C# e & o + in Visual Basic) per creare una singola stringa da qualsiasi combinazione di istanze e valori letterali String stringa. Nell'esempio seguente viene illustrato l'utilizzo dell'operatore di concatenazione di stringhe.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • Recuperando una proprietà o chiamando un metodo che restituisce una stringa. Nell'esempio seguente vengono utilizzati i metodi della String classe per estrarre una sottostringa da una stringa più grande.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • Chiamando un metodo di formattazione per convertire un valore o un oggetto nella relativa rappresentazione di stringa. Nell'esempio seguente viene utilizzata la funzionalità di formattazione composita per incorporare la rappresentazione di stringa di due oggetti in una stringa.

    DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
    Double temperature = 68.3;
    String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                   dateAndTime, temperature);
    Console::WriteLine(result);
    // The example displays the following output: 
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    

Oggetti Char e caratteri Unicode

Ogni carattere in una stringa è definito da un valore scalare Unicode, detto anche punto di codice Unicode o valore ordinale (numerico) del carattere Unicode. Ogni punto di codice viene codificato usando la codifica UTF-16 e il valore numerico di ogni elemento della codifica è rappresentato da un Char oggetto .

Nota

Si noti che, poiché un'istanza è costituita da una raccolta sequenziale di unità di codice UTF-16, è possibile creare un oggetto che non sia una stringa String String Unicode ben formata. Ad esempio, è possibile creare una stringa con un surrogato basso senza un surrogato alto corrispondente. Anche se alcuni metodi, ad esempio i metodi di codifica e decodifica degli oggetti nello spazio dei nomi , possono eseguire controlli per verificare che le stringhe siano ben formate, i membri della classe non garantiscono che una stringa sia ben System.Text String formata.

Un singolo Char oggetto rappresenta in genere un singolo punto di codice, ad esempio il valore numerico di è uguale al punto di Char codice. Ad esempio, il punto di codice per il carattere "a" è U+0061. Tuttavia, un punto di codice potrebbe richiedere più di un elemento codificato (più di un Char oggetto). Lo standard Unicode definisce due tipi di caratteri che corrispondono a più oggetti: grafiemi e punti di codice supplementari Unicode che corrispondono ai caratteri nei piani Char supplementari Unicode.

  • Un grafo è rappresentato da un carattere di base seguito da uno o più caratteri di combinazione. Ad esempio, il carattere â è rappresentato da un oggetto il cui punto di codice è U+0061 seguito da un oggetto il cui punto di codice Char Char è U+0308. Questo carattere può essere definito anche da un singolo oggetto con un punto Char di codice U+00E4. Come illustrato nell'esempio seguente, un confronto di uguaglianza con distinzione delle impostazioni cultura indica che queste due rappresentazioni sono uguali, a meno che non sia stato eseguito un confronto ordinale comune. Tuttavia, se le due stringhe sono normalizzate, un confronto ordinale indica anche che sono uguali. Per altre informazioni sulla normalizzazione delle stringhe, vedere la sezione Normalizzazione.

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Un punto di codice supplementare Unicode (una coppia di surrogati) è rappresentato da un oggetto il cui punto di codice è un surrogato elevato seguito da un oggetto il cui punto di codice è Char Char un surrogato basso. Le unità di codice dei surrogati alti variano da U+D800 a U+DBFF. Le unità di codice dei surrogati bassi sono diverse da U+DC00 a U+DFFF. Le coppie di surrogati vengono usate per rappresentare i caratteri nei 16 piani supplementari Unicode. Nell'esempio seguente viene creato un carattere surrogato che viene passato al metodo Char.IsSurrogatePair(Char, Char) per determinare se si tratta di una coppia di surrogati.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");
    
    Console.WriteLine();
    Console.WriteLine("   Is Surrogate Pair: {0}", 
                      Char.IsSurrogatePair(surrogate[0], surrogate[1]));
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    Module Example
       Public Sub Main()
          Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
          For ctr As Integer = 0 To surrogate.Length - 1
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
          Next   
          Console.WriteLine()
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate(0), surrogate(1)))
       End Sub
    End Module
    
    ' The example displays the following output:
    '       U+D800 U+DC03
    '          Is Surrogate Pair: True
    

Stringhe e standard Unicode

I caratteri in una stringa sono rappresentati da unità di codice con codifica UTF-16, che corrispondono ai Char valori.

A ogni carattere in una stringa è associata una categoria di caratteri Unicode, rappresentata in .NET UnicodeCategory dall'enumerazione . La categoria di un carattere o di una coppia di surrogati può essere determinata chiamando il CharUnicodeInfo.GetUnicodeCategory metodo .

.NET gestisce una propria tabella di caratteri e le relative categorie, per assicurare che una versione specifica di un'implementazione .NET in esecuzione su piattaforme diverse restituisca informazioni identiche sulle categorie di caratteri. In tutte le versioni di .NET e in tutte le piattaforme del sistema operativo, le informazioni sulle categorie di caratteri vengono fornite dal database di caratteri Unicode.

Nella tabella seguente sono elencate le versioni di .NET e le versioni dello standard Unicode su cui si basano le categorie di caratteri.

Versione di .NET Versione dello standard Unicode
.NET Framework 1.1 Standard Unicode, versione 4.0.0
.NET Framework 2.0 Standard Unicode, versione 5.0.0
.NET Framework 3.5 Standard Unicode, versione 5.0.0
.NET Framework 4 Standard Unicode, versione 5.0.0
.NET Framework 4.5 Standard Unicode, versione 6.3.0
.NET Framework 4.5.1 Standard Unicode, versione 6.3.0
.NET Framework 4.5.2 Standard Unicode, versione 6.3.0
.NET framework 4.6 Standard Unicode, versione 6.3.0
.NET Framework 4.6.1 Standard Unicode, versione 6.3.0
.NET Framework 4.6.2 e versioni successive Standard Unicode, versione 8.0.0
.NET Core 2.1 Standard Unicode, versione 8.0.0
.NET Core 3.1 Standard Unicode, versione 11.0.0
.NET 5 Standard Unicode, versione 13.0.0

.NET supporta inoltre il confronto e l'ordinamento delle stringhe in base allo standard Unicode. .NET Framework 4 e versioni precedenti mantengono la propria tabella di dati stringa. Questo vale anche per le versioni di .NET Framework a partire da .NET Framework 4.5 in esecuzione Windows 7. A partire da .NET Framework 4.5 in esecuzione in Windows 8 e versioni successive del sistema operativo Windows, il runtime delega le operazioni di confronto e ordinamento delle stringhe al sistema operativo. In .NET Core e .NET 5+, le informazioni sul confronto e sull'ordinamento delle stringhe vengono fornite da International Components for Unicode libraries (tranne che nelle versioni Windows precedenti a Aggiornamento di Windows 10 (maggio 2019)). Nella tabella seguente sono elencate le versioni di .NET e le versioni dello standard Unicode su cui si basano il confronto e l'ordinamento dei caratteri.

Versione di .NET Versione dello standard Unicode
.NET Framework 1.1 Standard Unicode, versione 4.0.0
.NET Framework 2.0 Standard Unicode, versione 5.0.0
.NET Framework 3.5 Standard Unicode, versione 5.0.0
.NET Framework 4 Standard Unicode, versione 5.0.0
.NET Framework 4.5 e versioni successive in Windows 7 Standard Unicode, versione 5.0.0
.NET Framework 4.5 e versioni successive in Windows 8 e versioni successive Windows sistemi operativi Standard Unicode, versione 6.3.0
.NET Core e .NET 5+ Dipende dalla versione dello standard Unicode supportato dal sistema operativo sottostante.

Stringhe e caratteri Null incorporati

In .NET un oggetto può includere caratteri Null incorporati, che vengono conteggiati String come parte della lunghezza della stringa. Tuttavia, in alcuni linguaggi, ad esempio C e C++, un carattere Null indica la fine di una stringa; non viene considerato una parte della stringa e non viene conteggiato come parte della lunghezza della stringa. Ciò significa che i presupposti comuni seguenti che i programmatori o le librerie C e C++ scritte in C o C++ potrebbero fare sulle stringhe non sono necessariamente validi se applicati agli String oggetti:

  • Il valore restituito dalle strlen funzioni o non è necessariamente uguale a wcslen String.Length .

  • La stringa creata dalle strcpy_s funzioni o non è necessariamente identica alla stringa creata dal metodo wcscpy_s String.Copy .

È necessario assicurarsi che il codice C nativo e C++ che crea un'istanza degli oggetti e il codice passato agli oggetti tramite platform invoke non presuppongono che un carattere Null incorporato contrassegni la fine della String String stringa.

I caratteri Null incorporati in una stringa vengono trattati in modo diverso anche quando una stringa viene ordinata (o confrontata) e quando viene cercata una stringa. I caratteri Null vengono ignorati quando si eseguono confronti con distinzione delle impostazioni cultura tra due stringhe, inclusi i confronti che usano le impostazioni cultura invarianti. Vengono considerati solo per confronti ordinali o senza distinzione tra maiuscole e minuscole. D'altra parte, i caratteri Null incorporati vengono sempre considerati quando si esegue una ricerca in una stringa con metodi come Contains StartsWith , e IndexOf .

Stringhe e indici

Un indice è la posizione di un Char oggetto (non un carattere Unicode) in un String oggetto . Un indice è un numero non negativo in base zero che inizia dalla prima posizione nella stringa, ovvero la posizione di indice zero. Diversi metodi di ricerca, ad esempio e IndexOf LastIndexOf , restituiscono l'indice di un carattere o di una sottostringa nell'istanza di stringa.

La Chars[] proprietà consente di accedere ai singoli oggetti in base alla relativa posizione di indice nella Char stringa. Poiché la proprietà è la proprietà predefinita (in Visual Basic) o l'indicizzatore (in C#), è possibile accedere ai singoli oggetti in una stringa usando codice simile al Chars[] Char seguente. Questo codice cerca spazi vuoti o caratteri di punteggiatura in una stringa per determinare il numero di parole contenute nella stringa.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for (int ctr = 0; ctr < s1->Length; ctr++) {
         if (Char::IsPunctuation(s1[ctr]) | Char::IsWhiteSpace(s1[ctr]))
            nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                     s1, nWords);           
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
for (int ctr = 0; ctr < s1.Length; ctr++) {
   if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For ctr As Integer = 0 To s1.Length - 1
         If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr)) 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Poiché la classe implementa l'interfaccia , è anche possibile scorrere gli oggetti in una stringa usando un costrutto , come illustrato String IEnumerable Char foreach nell'esempio seguente.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for each (Char ch in s1)
   {
      if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
         nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                      s1, nWords);  
   Console::ReadLine();
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.
string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
foreach (var ch in s1) {
   if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For Each ch In s1
         If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

I valori di indice consecutivi potrebbero non corrispondere a caratteri Unicode consecutivi, perché un carattere Unicode potrebbe essere codificato come più di un Char oggetto. In particolare, una stringa può contenere unità di testo di più caratteri formate da un carattere di base seguito da uno o più caratteri di combinazione o da coppie di surrogati. Per usare caratteri Unicode anziché Char oggetti , usare le classi e oppure il metodo e lo System.Globalization.StringInfo TextElementEnumerator String.EnumerateRunes Rune struct . Nell'esempio seguente viene illustrata la differenza tra il codice che funziona con Char gli oggetti e il codice che funziona con i caratteri Unicode. Confronta il numero di caratteri o elementi di testo in ogni parola di una frase. La stringa include due sequenze di un carattere di base seguite da un carattere di combinazione.

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;

void main()
{
   // First sentence of The Mystery of the Yellow Room, by Leroux. 
   String^ opening = L"Ce n'est pas sans une certaine émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

   for each (Char ch in opening) {
      // Skip the ' character. 
      if (ch == '\x0027') continue;

      if (Char::IsWhiteSpace(ch) | (Char::IsPunctuation(ch))) {
         chars->Add(nChars);
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   TextElementEnumerator^ te = StringInfo::GetTextElementEnumerator(opening);
   while (te->MoveNext()) {
      String^ s = te->GetTextElement();   
      // Skip the ' character. 
      if (s == "\x0027") continue;
      if ( String::IsNullOrEmpty(s->Trim()) | (s->Length == 1 && Char::IsPunctuation(Convert::ToChar(s)))) {
         elements->Add(nChars);         
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12
// First sentence of The Mystery of the Yellow Room, by Leroux.
string opening = "Ce n'est pas sans une certaine émotion que "+
                 "je commence à raconter ici les aventures " +
                 "extraordinaires de Joseph Rouletabille."; 
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int> chars = new List<int>();
List<int> elements = new List<int>();

foreach (var ch in opening) {
   // Skip the ' character.
   if (ch == '\u0027') continue;
        
   if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
      chars.Add(nChars);
      nChars = 0;
   }
   else {
      nChars++;
   }
}

System.Globalization.TextElementEnumerator te = 
   System.Globalization.StringInfo.GetTextElementEnumerator(opening);
while (te.MoveNext()) {
   string s = te.GetTextElement();   
   // Skip the ' character.
   if (s == "\u0027") continue;
   if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
      elements.Add(nChars);         
      nChars = 0;
   }
   else {
      nChars++;
   }
}

// Display character counts.
Console.WriteLine("{0,6} {1,20} {2,20}",
                  "Word #", "Char Objects", "Characters"); 
for (int ctr = 0; ctr < chars.Count; ctr++) 
   Console.WriteLine("{0,6} {1,20} {2,20}",
                     ctr, chars[ctr], elements[ctr]); 
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      ' First sentence of The Mystery of the Yellow Room, by Leroux.
      Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille." 
      ' Character counters.
      Dim nChars As Integer = 0
      ' Objects to store word count.
      Dim chars As New List(Of Integer)()
      Dim elements As New List(Of Integer)()
      
      For Each ch In opening
         ' Skip the ' character.
         If ch = ChrW(&h0027) Then Continue For
              
         If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
            chars.Add(nChars)
            nChars = 0
         Else 
            nChars += 1
         End If
      Next

      Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
      Do While te.MoveNext()
         Dim s As String = te.GetTextElement()   
         ' Skip the ' character.
         If s = ChrW(&h0027) Then Continue Do
         If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) 
            elements.Add(nChars)         
            nChars = 0
         Else 
            nChars += 1
         End If
      Loop

      ' Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters") 
      For ctr As Integer = 0 To chars.Count - 1 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars(ctr), elements(ctr)) 
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Word #         Char Objects           Characters
'         0                    2                    2
'         1                    4                    4
'         2                    3                    3
'         3                    4                    4
'         4                    3                    3
'         5                    8                    8
'         6                    8                    7
'         7                    3                    3
'         8                    2                    2
'         9                    8                    8
'        10                    2                    1
'        11                    8                    8
'        12                    3                    3
'        13                    3                    3
'        14                    9                    9
'        15                   15                   15
'        16                    2                    2
'        17                    6                    6
'        18                   12                   12

Questo esempio funziona con gli elementi di testo usando il StringInfo.GetTextElementEnumerator metodo e la classe per TextElementEnumerator enumerare tutti gli elementi di testo in una stringa. È anche possibile recuperare una matrice che contiene l'indice iniziale di ogni elemento di testo chiamando il StringInfo.ParseCombiningCharacters metodo .

Per altre informazioni sull'uso di unità di testo anziché di singoli Char valori, vedere Introduzione alla codifica dei caratteri in .NET.

Stringhe Null e stringhe vuote

Una stringa che è stata dichiarata ma a cui non è stato assegnato un valore è null . Il tentativo di chiamare metodi su tale stringa genera un'eccezione NullReferenceException . Una stringa Null è diversa da una stringa vuota, ovvero una stringa il cui valore è "" o String.Empty . In alcuni casi, il passaggio di una stringa Null o di una stringa vuota come argomento in una chiamata al metodo genera un'eccezione. Ad esempio, il passaggio di una stringa Null al metodo genera Int32.Parse un'eccezione e il passaggio di una stringa vuota genera ArgumentNullException un'eccezione FormatException . In altri casi, un argomento del metodo può essere una stringa Null o una stringa vuota. Se, ad esempio, si fornisce un'implementazione per una classe, si vuole equivalure sia una stringa Null che una stringa vuota con l'identificatore IFormattable di formato generale ("G").

La String classe include i due metodi pratici seguenti che consentono di verificare se una stringa è o null vuota:

  • IsNullOrEmpty, che indica se una stringa è null o è uguale a String.Empty . Questo metodo elimina la necessità di usare codice simile al seguente:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, che indica se una stringa null è , è uguale a o è costituita esclusivamente da spazi String.Empty vuoti. Questo metodo elimina la necessità di usare codice simile al seguente:

    if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

Nell'esempio seguente viene IsNullOrEmpty utilizzato il metodo IFormattable.ToString nell'implementazione di una classe Temperature personalizzata. Il metodo supporta le stringhe di formato "G", "C", "F" e "K". Se una stringa di formato vuota o una stringa di formato il cui valore viene passato al metodo , il relativo valore viene modificato null nella stringa di formato "G".

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }
public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}
Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
                Implements IFormattable.ToString
   If String.IsNullOrEmpty(fmt) Then fmt = "G"  
   If provider Is Nothing Then provider = CultureInfo.CurrentCulture
   
   Select Case fmt.ToUpperInvariant()
      ' Return degrees in Celsius.    
      Case "G", "C"
         Return temp.ToString("F2", provider) + "°C"
      ' Return degrees in Fahrenheit.
      Case "F" 
         Return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F"
      ' Return degrees in Kelvin.
      Case "K"   
         Return (temp + 273.15).ToString()
      Case Else
         Throw New FormatException(
               String.Format("The {0} format string is not supported.", 
                             fmt))
    End Select                                   
End Function

Immutabilità e classe StringBuilder

Un String oggetto è denominato non modificabile (sola lettura), perché il relativo valore non può essere modificato dopo che è stato creato. I metodi che sembrano modificare un String oggetto restituiscono effettivamente un nuovo String oggetto che contiene la modifica.

Poiché le stringhe non sono modificabili, le routine di modifica delle stringhe che eseguono aggiunte o eliminazioni ripetute a quella che sembra essere una singola stringa possono esatti una riduzione significativa delle prestazioni. Ad esempio, il codice seguente usa un generatore di numeri casuali per creare una stringa con 1000 caratteri nell'intervallo 0x0001 da 0x052F. Anche se il codice sembra usare la concatenazione di stringhe per aggiungere un nuovo carattere alla stringa esistente denominata , crea effettivamente un nuovo oggetto str per ogni operazione di String concatenazione.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   String^ str = String::Empty;
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      str += Convert::ToChar(rnd->Next(1, 0x0530)); 
      if (str->Length % 60 == 0)
         str += Environment::NewLine;          
   }                    
   sw->Write(str);
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += (char)rnd.Next(1, 0x0530);
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      Dim str As String = String.Empty
      Dim sw As New StreamWriter(".\StringFile.txt", 
                           False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         str += ChrW(rnd.Next(1, &h0530)) 
         If str.Length Mod 60 = 0 Then str += vbCrLf          
      Next                    
      sw.Write(str)
      sw.Close()
   End Sub
End Module

È possibile usare la StringBuilder classe anziché la classe per le operazioni che apportano più modifiche al valore di una String stringa. A differenza delle istanze della classe , gli oggetti sono modificabili. Quando si concatenano, accodono o eliminano sottostringhe da una stringa, le operazioni vengono eseguite su String StringBuilder una singola stringa. Dopo aver modificato il valore di un oggetto , è possibile chiamare il relativo StringBuilder StringBuilder.ToString metodo per convertirlo in una stringa. Nell'esempio seguente viene sostituito l'oggetto usato nell'esempio precedente per String concatenare 1000 caratteri casuali nell'intervallo 0x0001 da 0x052F con un StringBuilder oggetto .

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   StringBuilder^ sb = gcnew StringBuilder();
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      sb->Append(Convert::ToChar(rnd->Next(1, 0x0530))); 
      if (sb->Length % 60 == 0)
         sb->AppendLine();          
   }                    
   sw->Write(sb->ToString());
   sw->Close();
}
using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append((char)rnd.Next(1, 0x0530));
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      Dim sw As New StreamWriter(".\StringFile.txt", 
                                 False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         sb.Append(ChrW(rnd.Next(1, &h0530))) 
         If sb.Length Mod 60 = 0 Then sb.AppendLine()          
      Next                    
      sw.Write(sb.ToString())
      sw.Close()
   End Sub
End Module

Operazioni ordinali e con distinzione delle impostazioni cultura

I membri della classe eseguono operazioni ordinali o con distinzione delle String impostazioni cultura (linguistiche) su un oggetto String . Un'operazione ordinale agisce sul valore numerico di ogni Char oggetto. Un'operazione con distinzione delle impostazioni cultura agisce sul valore dell'oggetto e prende in considerazione le regole di distinzione tra maiuscole e minuscole, ordinamento, formattazione e analisi specifiche String delle impostazioni cultura. Le operazioni con distinzione delle impostazioni cultura vengono eseguite nel contesto delle impostazioni cultura dichiarate in modo esplicito o delle impostazioni cultura correnti implicite. I due tipi di operazioni possono produrre risultati molto diversi quando vengono eseguiti sulla stessa stringa.

.NET supporta anche operazioni sulle stringhe linguistiche indipendenti dalle impostazioni cultura usando le impostazioni cultura invarianti ( ), che si basano in modo libero sulle impostazioni cultura della lingua inglese indipendentemente CultureInfo.InvariantCulture dall'area. A differenza di altre impostazioni, è garantito che le impostazioni delle impostazioni cultura invarianti rimangano coerenti in un singolo computer, da sistema a sistema e tra versioni System.Globalization.CultureInfo diverse di .NET. Le impostazioni cultura invarianti possono essere viste come una black box che garantisce la stabilità dei confronti di stringhe e dell'ordinamento in tutte le impostazioni cultura.

Importante

Se l'applicazione prende una decisione di sicurezza su un identificatore simbolico, ad esempio un nome file o un named pipe, o sui dati persistenti, ad esempio i dati basati su testo in un file XML, l'operazione deve utilizzare un confronto ordinale anziché un confronto con distinzione delle impostazioni cultura. Ciò è dovuto al fatto che un confronto dipendente dalle impostazioni cultura può produrre risultati diversi a seconda delle impostazioni cultura in vigore, mentre un confronto ordinale dipende esclusivamente dal valore binario dei caratteri confrontati.

Importante

La maggior parte dei metodi che eseguono operazioni su stringhe include un overload con un parametro di tipo , che consente di specificare se il metodo esegue un'operazione ordinale o con distinzione StringComparison delle impostazioni cultura. In generale, è necessario chiamare questo overload per rendere chiara la finalità della chiamata al metodo. Per le procedure consigliate e le linee guida per l'uso di operazioni ordinali e con distinzione delle impostazioni cultura sulle stringhe, vedere Procedure consigliate per l'uso di stringhe.

Le operazioni per l'applicazione dimaiuscole eminuscole, l'analisi e la formattazione, il confronto e l'ordinamento e il test dell'uguaglianza possono essere ordinali o con distinzione delle impostazioni cultura. Le sezioni seguenti illustrano ogni categoria di operazioni.

Suggerimento

È sempre consigliabile chiamare un overload del metodo che rende chiara la finalità della chiamata al metodo. Ad esempio, anziché chiamare il metodo per eseguire un confronto con distinzione delle impostazioni cultura di due stringhe usando le convenzioni delle impostazioni cultura correnti, è necessario chiamare il metodo con un valore per Compare(String, String) Compare(String, String, StringComparison) StringComparison.CurrentCulture comparisonType l'argomento . Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).

È possibile scaricare le tabelle dello spessore di ordinamento, un set di file di testo che contengono informazioni sugli spessori dei caratteri usati nelle operazioni di ordinamento e confronto, dai collegamenti seguenti:

  • Windows (.NET Framework e .NET Core): Ordinamento delle tabelle di spessore
  • Aggiornamento di Windows 10 (maggio 2019) o versione successiva (.NET 5+) e Linux e macOS (.NET Core e .NET 5+): tabella predefinita degli elementi delle regole di confronto Unicode

Maiuscole/minuscole

Le regole relative all'utilizzo di maiuscole e minuscole determinano come modificare le maiuscole/minuscole di un carattere Unicode. ad esempio da minuscolo a maiuscolo. Spesso viene eseguita un'operazione di distinzione tra maiuscole e minuscole prima di un confronto tra stringhe. Ad esempio, una stringa potrebbe essere convertita in maiuscolo in modo che possa essere confrontata con un'altra stringa maiuscola. È possibile convertire i caratteri di una stringa in lettere minuscole chiamando il metodo o ed è possibile convertirli in lettere maiuscole chiamando ToLower ToLowerInvariant il metodo o ToUpper ToUpperInvariant . Inoltre, è possibile usare il metodo TextInfo.ToTitleCase per convertire una stringa in maiuscole/minuscole.

Nota

.NET Core in esecuzione solo in sistemi Linux e macOS: Il comportamento delle regole di confronto per le impostazioni cultura C e Posix fa sempre distinzione tra maiuscole e minuscole perché queste impostazioni cultura non usano l'ordine delle regole di confronto Unicode previsto. È consigliabile usare impostazioni cultura diverse da C o Posix per l'esecuzione di operazioni di ordinamento dipendenti dalle impostazioni cultura e senza distinzione tra maiuscole e minuscole.

Le operazioni di distinzione tra maiuscole e minuscole possono essere basate sulle regole delle impostazioni cultura correnti, delle impostazioni cultura specificate o delle impostazioni cultura invarianti. Poiché i mapping tra maiuscole e minuscole possono variare a seconda delle impostazioni cultura usate, il risultato delle operazioni di distinzione tra maiuscole e minuscole può variare in base alle impostazioni cultura. Le differenze effettive nell'utilizzo di maiuscole e minuscole sono di tre tipi:

  • Differenze nel mapping tra maiuscole e minuscole di LETTERA MAIUSCOLA LATINA I (U+0049), LETTERA MINUSCOLA LATINA I (U+0069), LETTERA MAIUSCOLA LATINA I CON PUNTO SOPRA (U+0130) e LETTERA PICCOLA LATINA DOTLESS I (U+0131). Nelle impostazioni cultura tr-TR (Turco (Repubblica)) e az-Latn-AZ (Alfabeto latino) e nelle impostazioni cultura non associate a tr, az e az-Latn, l'equivalente minuscolo della LETTERA MAIUSCOLA I LATINI è LATIN SMALL LETTER DOTLESS I e l'equivalente maiuscolo di LATIN SMALL LETTER I è LATIN CAPITAL LETTER I WITH DOT ABOVE. In tutte le altre impostazioni cultura, incluse le impostazioni cultura invarianti, LATIN SMALL LETTER I e LATIN CAPITAL LETTER I sono equivalenti in lettere minuscole e maiuscole.

    Nell'esempio seguente viene illustrato come un confronto tra stringhe progettato per impedire file system'accesso non riesca se si basa su un confronto tra maiuscole e minuscole con distinzione delle impostazioni cultura. Devono essere state usate le convenzioni di utilizzo delle maiuscole e minuscole delle impostazioni cultura invarianti.

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • Differenze nei mapping tra maiuscole e minuscole tra le impostazioni cultura invarianti e tutte le altre impostazioni cultura. In questi casi, l'uso delle regole relative all'uso di maiuscole e minuscole delle impostazioni cultura invarianti per modificare un carattere in maiuscolo o minuscolo restituisce lo stesso carattere. Per tutte le altre impostazioni cultura, restituisce un carattere diverso. Alcuni dei caratteri interessati sono elencati nella tabella seguente.

    Carattere Se è stato modificato in Restituisce
    MICRON SIGN (U+00B5) Maiuscole LETTERA MAIUSCOLA GRECO MU (U+-39C)
    LETTERA MAIUSCOLA I CON PUNTO SOPRA (U+0130) Minuscole LETTERA MINUSCOLA I (U+0069)
    LETTERA MINUSCOLA LATINO SENZA PUNTO I (U+0131) Maiuscole LETTERA MAIUSCOLA I (U+0049)
    LATIN SMALL LETTER LONG S (U+017F) Maiuscole LETTERA MAIUSCOLA LATINO S (U+0053)
    LETTERA MAIUSCOLA LATINO D CON LETTERA PICCOLA Z CON CARON (U+01C5) Minuscole LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    COMBINAZIONE DI YPOGEGRAMMENI GRECO (U+0345) Maiuscole LETTERA MAIUSCOLA GRECO IOTA (U+0399)
  • Differenze nei mapping tra maiuscole e minuscole delle coppie di maiuscole e minuscole di due lettere nell'intervallo di caratteri ASCII. Nella maggior parte delle impostazioni cultura, una coppia di due lettere maiuscole e minuscole è uguale alla coppia di due lettere maiuscole o minuscole equivalente. Questo non vale per le coppie di due lettere seguenti nelle impostazioni cultura seguenti, perché in ogni caso vengono confrontate con un digraph:

    • "lJ" e "nJ" nelle impostazioni cultura hr-HR (Bosnia)).

    • "cH" nelle impostazioni cultura cs-CZ (Ceco (Repubblica Ceca)) e sk-SK (Slovacco (Slovacco)).

    • "aA" nelle impostazioni cultura da-DK (Danesi (Danimarca)).

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" e "zS" nelle impostazioni cultura hu-HU (ungherese (Ungheria)).

    • "cH" e "lL" nelle impostazioni cultura es-ES_tradnl (spagnolo (Spagna, ordinamento tradizionale).)

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" e "tR" nelle impostazioni cultura vi-VN (Taiwan)).

    Tuttavia, è insolito riscontrare una situazione in cui un confronto con distinzione delle impostazioni cultura di queste coppie crea problemi, perché queste coppie non sono comuni nelle stringhe fisse o negli identificatori.

L'esempio seguente illustra alcune delle differenze nelle regole di combinazione di maiuscole e minuscole tra le impostazioni cultura durante la conversione di stringhe in lettere maiuscole.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

   for each (String^ word in words) {
      sw->WriteLine("{0}:", word);
      for each (CultureInfo^ culture in cultures) {
         String^ name = String::IsNullOrEmpty(culture->Name) ? 
                              "Invariant" : culture->Name;
         String^ upperWord = word->ToUpper(culture);
         sw->WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                        upperWord, ShowHexValue(upperWord));

      }
      sw->WriteLine();  
   }
   sw->Close();
}

String^ ShowHexValue(String^ s)
{
   String^ retval = nullptr;
   for each (Char ch in s) {
      array<Byte>^ bytes = BitConverter::GetBytes(ch);
      retval += String::Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
   }
   return retval;
} 
// The example displays the following output: 
//    file: 
//        Invariant:    FILE               00 46 00 49 00 4C 00 45  
//            en-US:    FILE               00 46 00 49 00 4C 00 45  
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45  
//     
//    sıfır: 
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52  
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//     
//    Dženana: 
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41
using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));
         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41
Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\case.txt")   
      Dim words As String() = { "file", "sıfır", "Dženana" }
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"),  
                                        New CultureInfo("tr-TR") }

      For Each word In words
         sw.WriteLine("{0}:", word)
         For Each culture In cultures
            Dim name As String = If(String.IsNullOrEmpty(culture.Name),  
                                 "Invariant", culture.Name)
            Dim upperWord As String = word.ToUpper(culture)
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord))
     
         Next
         sw.WriteLine()  
      Next
      sw.Close()
   End Sub

   Private Function ShowHexValue(s As String) As String
      Dim retval As String = Nothing
      For Each ch In s
         Dim bytes() As Byte = BitConverter.GetBytes(ch)
         retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))     
      Next
      Return retval
   End Function
End Module
' The example displays the following output:
'    file:
'        Invariant:    FILE               00 46 00 49 00 4C 00 45 
'            en-US:    FILE               00 46 00 49 00 4C 00 45 
'            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
'    
'    sıfır:
'        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
'            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'    
'    Dženana:
'        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41

Analisi e formattazione

La formattazione e l'analisi sono operazioni inverse. Le regole di formattazione determinano come convertire un valore, ad esempio una data e un'ora o un numero, nella relativa rappresentazione di stringa, mentre le regole di analisi determinano come convertire una rappresentazione di stringa in un valore, ad esempio una data e un'ora. Sia la formattazione che le regole di analisi dipendono dalle convenzioni culturali. Nell'esempio seguente viene illustrata l'ambiguità che può verificarsi quando si interpreta una stringa di data specifica delle impostazioni cultura. Senza conoscere le convenzioni delle impostazioni cultura usate per produrre una stringa di data, non è possibile sapere se 03/01/2011, 1/3/2011 e 03/01/2011 rappresentano il 3 gennaio 2011 o il 1° marzo 2011.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

   for each (CultureInfo^ culture in cultures)
      Console::WriteLine("{0,-12} {1}", String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date->ToString("d", culture));                                    
}
// The example displays the following output: 
//       Invariant    03/01/2011 
//       en-US        3/1/2011 
//       fr-FR        01/03/2011
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat As Date = #3/1/2011#
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }

      For Each culture In cultures
         Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.ToString("d", culture))
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Invariant    03/01/2011
'       en-US        3/1/2011
'       fr-FR        01/03/2011

Analogamente, come illustrato nell'esempio seguente, una singola stringa può produrre date diverse a seconda delle impostazioni cultura le cui convenzioni vengono usate nell'operazione di analisi.

using namespace System;
using namespace System::Globalization;

void main()
{
   String^ dateString = "07/10/2011";
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               CultureInfo::CreateSpecificCulture("en-GB"), 
                                                               CultureInfo::CreateSpecificCulture("en-US") };
   Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                "Month", "Day");
   for each (CultureInfo^ culture in cultures) {
      DateTime date = DateTime::Parse(dateString, culture);
      Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                        String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date.Month, date.Day);
   }                      
}
// The example displays the following output: 
//       Date String     Culture    Month      Day 
//        
//       07/10/2011    Invariant        7       10 
//       07/10/2011        en-GB       10        7 
//       07/10/2011        en-US        7       10
using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString As String = "07/10/2011"
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        CultureInfo.CreateSpecificCulture("en-GB"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture", 
                                                 "Month", "Day")
      Console.WriteLine()                                                 
      For Each culture In cultures
         Dim dat As Date = DateTime.Parse(dateString, culture)
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.Month, dat.Day)
      Next
   End Sub
End Module
' The example displays the following output:
'       Date String     Culture    Month      Day
'       
'       07/10/2011    Invariant        7       10
'       07/10/2011        en-GB       10        7
'       07/10/2011        en-US        7       10

Confronto e ordinamento delle stringhe

Le convenzioni per il confronto e l'ordinamento delle stringhe variano a seconda delle impostazioni cultura. Ad esempio, l'ordinamento può essere basato sulla fonetica o sulla rappresentazione visiva dei caratteri. Nelle lingue dell'Asia orientale i caratteri vengono ordinati in base al tratto e all'ideogramma radicale. L'ordinamento dipende anche dall'ordine in cui le lingue e le impostazioni cultura usano per l'alfabeto. Ad esempio, la lingua danesi ha un carattere "Æ" che ordina dopo "Z" nell'alfabeto. Inoltre, i confronti possono essere con distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole e le regole di distinzione tra maiuscole e minuscole possono differire in base alle impostazioni cultura. Il confronto ordinale, d'altra parte, usa i punti di codice Unicode dei singoli caratteri in una stringa durante il confronto e l'ordinamento delle stringhe.

Le regole di ordinamento determinano l'ordine alfabetico dei caratteri Unicode e il confronto tra due stringhe. Ad esempio, String.Compare(String, String, StringComparison) il metodo confronta due stringhe in base al parametro StringComparison . Se il valore del parametro è , il metodo esegue un confronto linguistico che usa le convenzioni delle impostazioni cultura correnti. Se il valore del parametro è , il metodo esegue un confronto StringComparison.CurrentCulture StringComparison.Ordinal ordinale. Di conseguenza, come illustrato nell'esempio seguente, se le impostazioni cultura correnti sono l'inglese degli Stati Uniti, la prima chiamata al metodo (usando il confronto con distinzione delle impostazioni cultura) considera "a" minore di "A", ma la seconda chiamata allo stesso metodo (usando il confronto ordinale) considera "a" maggiore di String.Compare(String, String, StringComparison) "A".

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       1                                                                                     
'       -32

.NET supporta le regole di ordinamento ordinale, stringa e parola:

  • Un ordinamento di parole esegue un confronto di stringhe con distinzione delle impostazioni cultura in cui a determinati caratteri Unicode non alfanumerici potrebbero essere assegnati pesi speciali. Ad esempio, il trattino (-) potrebbe avere un peso molto ridotto assegnato in modo che "coop" e "co-op" vengano visualizzati uno accanto all'altro in un elenco ordinato. Per un elenco dei metodi che confrontano due stringhe usando regole di ordinamento String delle parole, vedere la sezione Operazioni sulle stringhe per categoria.

  • Un ordinamento di stringhe esegue anche un confronto con distinzione delle impostazioni cultura. È simile a un ordinamento di parole, ad eccezione del fatto che non sono presenti casi speciali e tutti i simboli non alfanumerici vengono prima di tutti i caratteri Unicode alfanumerici. È possibile confrontare due stringhe usando regole di ordinamento delle stringhe chiamando gli overload del metodo con un parametro a cui viene fornito CompareInfo.Compare options il valore CompareOptions.StringSort . Si noti che questo è l'unico metodo fornito da .NET per confrontare due stringhe usando regole di ordinamento delle stringhe.

  • Un ordinamento ordinale confronta le stringhe in base al valore numerico di Char ogni oggetto nella stringa. Un confronto ordinale fa distinzione automatica tra maiuscole e minuscole perché le versioni minuscole e maiuscole di un carattere hanno punti di codice diversi. Tuttavia, se la distinzione tra maiuscole e minuscole non è importante, è possibile specificare un confronto ordinale che ignora la distinzione tra maiuscole e minuscole. Equivale a convertire la stringa in lettere maiuscole usando le impostazioni cultura invarianti e quindi eseguendo un confronto ordinale sul risultato. Per un elenco dei metodi che confrontano due stringhe usando regole String di ordinamento ordinali, vedere la sezione Operazioni sulle stringhe per categoria.

Un confronto con distinzione delle impostazioni cultura è qualsiasi confronto che usa in modo esplicito o implicito un oggetto , incluse le impostazioni cultura CultureInfo invarianti specificate dalla CultureInfo.InvariantCulture proprietà . Le impostazioni cultura implicite sono le impostazioni cultura correnti, specificate dalle Thread.CurrentCulture proprietà e CultureInfo.CurrentCulture . L'ordinamento dei caratteri alfabetici (ovvero i caratteri per i quali la proprietà restituisce ) è notevole nelle Char.IsLetter true impostazioni cultura. È possibile specificare un confronto con distinzione delle impostazioni cultura che usa le convenzioni di impostazioni cultura specifiche fornendo un oggetto a un metodo di confronto CultureInfo tra stringhe, ad esempio Compare(String, String, CultureInfo, CompareOptions) . È possibile specificare un confronto con distinzione delle impostazioni cultura che usa le convenzioni delle impostazioni cultura correnti fornendo , o qualsiasi membro dell'enumerazione diverso da o a un StringComparison.CurrentCulture overload appropriato del metodo StringComparison.CurrentCultureIgnoreCase CompareOptions CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase Compare . Un confronto con distinzione delle impostazioni cultura è in genere appropriato per l'ordinamento, mentre non è un confronto ordinale. Un confronto ordinale è in genere appropriato per determinare se due stringhe sono uguali ,ovvero per determinare l'identità, mentre un confronto con distinzione delle impostazioni cultura non lo è.

Nell'esempio seguente viene illustrata la differenza tra confronto ordinale e con distinzione delle impostazioni cultura. Nell'esempio vengono valutate tre stringhe, "Apple", "Æble" e "AEble", usando il confronto ordinale e le convenzioni delle impostazioni cultura da-DK e en-US (ognuna delle quali rappresenta le impostazioni cultura predefinite al momento della chiamata Compare al metodo ). Poiché la lingua danesi considera il carattere "Æ" come una singola lettera e lo ordina dopo "Z" nell'alfabeto, la stringa "Æble" è maggiore di "Apple". Tuttavia, "Æble" non è considerato equivalente a "AEble", quindi "Æble" è anche maggiore di "AEble". Le impostazioni cultura en-US non includono la lettera "Æ", ma la considera equivalente a "AE", che spiega perché "Æble" è minore di "Apple" ma uguale a "AEble". Il confronto ordinale, d'altra parte, considera "Apple" minore di "Æble" e "Æble" come maggiore di "AEble".

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133
Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      Dim str3 As String = "AEble"
      
      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison")
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Current culture: da-DK
'       Comparison of Apple with Æble: -1
'       Comparison of Æble with AEble: 1
'       
'       Current culture: en-US
'       Comparison of Apple with Æble: 1
'       Comparison of Æble with AEble: 0
'       
'       Ordinal comparison
'       Comparison of Apple with Æble: -133
'       Comparison of Æble with AEble: 133

Usare le linee guida generali seguenti per scegliere un metodo di ordinamento o confronto di stringhe appropriato:

  • Se si vuole ordinare le stringhe in base alle impostazioni cultura dell'utente, è necessario ordinarle in base alle convenzioni delle impostazioni cultura correnti. Se le impostazioni cultura dell'utente cambiano, anche l'ordine delle stringhe ordinate cambierà di conseguenza. Ad esempio, un'applicazione thesaurus deve ordinare sempre le parole in base alle impostazioni cultura dell'utente.

  • Se si desidera ordinare le stringhe in base alle convenzioni di impostazioni cultura specifiche, è necessario ordinarle fornendo un oggetto che rappresenta le impostazioni cultura a un CultureInfo metodo di confronto. Ad esempio, in un'applicazione progettata per insegnare agli studenti una determinata lingua, si vuole che le stringhe siano ordinate in base alle convenzioni di una delle impostazioni cultura che parla tale lingua.

  • Se si vuole che l'ordine delle stringhe rimanga invariato tra le impostazioni cultura, è necessario ordinarle in base alle convenzioni delle impostazioni cultura invarianti o usare un confronto ordinale. Ad esempio, si userebbe un ordinamento ordinale per organizzare i nomi di file, processi, mutex o named pipe.

  • Per un confronto che comporta una decisione di sicurezza (ad esempio se un nome utente è valido), è sempre necessario eseguire un test ordinale per l'uguaglianza chiamando un overload del Equals metodo .

Nota

Le regole di ordinamento e di distinzione tra maiuscole e minuscole usate nel confronto tra stringhe dipendono dalla versione di .NET. In .NET Core il confronto tra stringhe dipende dalla versione dello standard Unicode supportata dal sistema operativo sottostante. In .NET Framework 4.5 e versioni successive in esecuzione su Windows 8 o versioni successive, le informazioni sull'ordinamento, l'uso di maiuscole e minuscole, la normalizzazione e i caratteri Unicode sono conformi allo standard Unicode 6.0. In altri Windows sistemi operativi, sono conformi allo standard Unicode 5.0.

Per altre informazioni sulle regole di ordinamento ordinale, stringa e parola, vedere System.Globalization.CompareOptions l'argomento . Per altre raccomandazioni su quando usare ogni regola, vedere Procedure consigliate per l'uso di stringhe.

In genere, non si chiamano metodi di confronto tra stringhe, ad esempio Compare direttamente per determinare l'ordinamento delle stringhe. I metodi di confronto vengono invece chiamati dai metodi di ordinamento, ad Array.Sort esempio o List<T>.Sort . L'esempio seguente esegue quattro diverse operazioni di ordinamento (ordinamento delle parole usando le impostazioni cultura correnti, ordinamento delle parole usando le impostazioni cultura invarianti, ordinamento ordinale e ordinamento di stringhe usando le impostazioni cultura invarianti) senza chiamare in modo esplicito un metodo di confronto tra stringhe, anche se specificano il tipo di confronto da usare. Si noti che ogni tipo di ordinamento produce un ordinamento univoco delle stringhe nella relativa matrice.

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;

// IComparer<String> implementation to perform string sort. 
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
   SCompare() {};

   virtual int Compare(String^ x, String^ y)
   {
      return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
   }
};

void main()
{
   array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative", 
                                                    L"co\x00ADoperative", L"c�ur", "coeur" };

   // Perform a word sort using the current (en-US) culture. 
   array<String^>^ current = gcnew array<String^>(strings->Length); 
   strings->CopyTo(current, 0); 
   Array::Sort(current, StringComparer::CurrentCulture);

   // Perform a word sort using the invariant culture. 
   array<String^>^ invariant = gcnew array<String^>(strings->Length);
   strings->CopyTo(invariant, 0); 
   Array::Sort(invariant, StringComparer::InvariantCulture);

   // Perform an ordinal sort. 
   array<String^>^ ordinal = gcnew array<String^>(strings->Length);
   strings->CopyTo(ordinal, 0); 
   Array::Sort(ordinal, StringComparer::Ordinal);

   // Perform a string sort using the current culture. 
   array<String^>^ stringSort = gcnew array<String^>(strings->Length);
   strings->CopyTo(stringSort, 0); 
   Array::Sort(stringSort, gcnew SCompare());

   // Display array values
   Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                     "Original", "Word Sort", "Invariant Word", 
                     "Ordinal Sort", "String Sort");
   for (int ctr = 0; ctr < strings->Length; ctr++)
      Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                         strings[ctr], current[ctr], invariant[ctr], 
                         ordinal[ctr], stringSort[ctr] );          
}
// The example displays the following output: 
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort 
//     
//             coop          c�ur            c�ur         co-op         co-op 
//            co-op         coeur           coeur         coeur          c�ur 
//      cooperative          coop            coop          coop         coeur 
//      co�operative         co-op           co-op   cooperative          coop 
//             c�ur   cooperative     cooperative   co�operative   cooperative 
//            coeur   co�operative     co�operative          c�ur   co�operative
using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative
Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim strings() As String = { "coop", "co-op", "cooperative", 
                                  "co" + ChrW(&h00AD) + "operative", 
                                  "cœur", "coeur" }

      ' Perform a word sort using the current (en-US) culture.
      Dim current(strings.Length - 1) As String  
      strings.CopyTo(current, 0) 
      Array.Sort(current, StringComparer.CurrentCulture)

      ' Perform a word sort using the invariant culture.
      Dim invariant(strings.Length - 1) As String
      strings.CopyTo(invariant, 0) 
      Array.Sort(invariant, StringComparer.InvariantCulture)

      ' Perform an ordinal sort.
      Dim ordinal(strings.Length - 1) As String
      strings.CopyTo(ordinal, 0) 
      Array.Sort(ordinal, StringComparer.Ordinal)

      ' Perform a string sort using the current culture.
      Dim stringSort(strings.Length - 1) As String
      strings.CopyTo(stringSort, 0) 
      Array.Sort(stringSort, new SCompare())

      ' Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort")
      Console.WriteLine()
                                                      
      For ctr As Integer = 0 To strings.Length - 1
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings(ctr), current(ctr), invariant(ctr), 
                           ordinal(ctr), stringSort(ctr))   
      Next                                  
   End Sub
End Module

' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
   Public Function Compare(x As String, y As String) As Integer _
                   Implements IComparer(Of String).Compare
      Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
   End Function
End Class
' The example displays the following output:
'         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
'    
'             coop          cœur            cœur         co-op         co-op
'            co-op         coeur           coeur         coeur          cœur
'      cooperative          coop            coop          coop         coeur
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

Suggerimento

Internamente, .NET usa chiavi di ordinamento per supportare il confronto di stringhe sensibili alle impostazioni cultura. A ogni carattere di una stringa vengono fornite diverse categorie di pesi di ordinamento, tra cui alfabetico, maiuscole e minuscole. Una chiave di ordinamento, rappresentata dalla classe , fornisce un repository di questi SortKey pesi per una determinata stringa. Se l'app esegue un numero elevato di operazioni di ricerca o ordinamento sullo stesso set di stringhe, è possibile migliorarne le prestazioni generando e archiviando chiavi di ordinamento per tutte le stringhe che usa. Quando è necessaria un'operazione di ordinamento o confronto, usare le chiavi di ordinamento anziché le stringhe. Per altre informazioni, vedere la classe SortKey.

Se non si specifica una convenzione di confronto tra stringhe, i metodi di ordinamento, ad esempio , eseguono un ordinamento basato sulle impostazioni cultura con distinzione tra maiuscole Array.Sort(Array) e minuscole per le stringhe. L'esempio seguente illustra come la modifica delle impostazioni cultura correnti influisce sull'ordine delle stringhe ordinate in una matrice. Crea una matrice di tre stringhe. In primo luogo, imposta System.Threading.Thread.CurrentThread.CurrentCulture la proprietà su en-US e chiama il Array.Sort(Array) metodo . L'ordinamento risultante si basa sulle convenzioni di ordinamento per le impostazioni cultura inglese (Stati Uniti). Successivamente, l'esempio imposta System.Threading.Thread.CurrentThread.CurrentCulture la proprietà su da-DK e chiama di Array.Sort nuovo il metodo . Si noti che l'ordinamento risultante differisce dai risultati en-US perché usa le convenzioni di ordinamento per il danese (Danimarca).

using System;
using System.Globalization;
using System.Threading;

public class ArraySort
{
   public static void Main(String[] args)
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray);
   }
   public static void PrintIndexAndValues(string[] myArray)
   {
      for (int i = myArray.GetLowerBound(0); i <=
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble
Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
      
      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

Avviso

Se lo scopo principale del confronto delle stringhe è determinare se sono uguali, è necessario chiamare il String.Equals metodo . In genere, è Equals consigliabile usare per eseguire un confronto ordinale. Il String.Compare metodo è destinato principalmente all'ordinamento delle stringhe.

I metodi di ricerca di stringhe, ad esempio e , possono anche eseguire confronti tra stringhe con distinzione delle impostazioni cultura String.StartsWith String.IndexOf o ordinali. Nell'esempio seguente vengono illustrate le differenze tra confronti ordinali e con distinzione delle impostazioni cultura usando il IndexOf metodo . Una ricerca con distinzione delle impostazioni cultura in cui le impostazioni cultura correnti sono inglese (Stati Uniti) considera la sottostringa "oe" in modo che corrisponda alla legatura "œ". Poiché un trattino soft (U+00AD) è un carattere di larghezza zero, la ricerca considera il trattino soft come equivalente a e trova una corrispondenza all'inizio Empty della stringa. Una ricerca ordinale, d'altra parte, non trova una corrispondenza in entrambi i casi.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2
using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2
Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

   Private Sub FindInString(s As String, substring As String, 
                            options As StringComparison)
      Dim result As Integer = s.IndexOf(substring, options)
      If result <> -1
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result)
      Else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s)
      End If                                                                          
   End Sub
End Module
' The example displays the following output:
'       'oe' found in œufs at position 0
'       'oe' not found in œufs
'       'œu' found in oeufs at position 0
'       'œu' not found in oeufs
'       
'       '­' found in co­operative at position 0
'       '­' found in co­operative at position 2

Cercare nelle stringhe

I metodi di ricerca di stringhe, ad esempio e , possono anche eseguire confronti tra stringhe con distinzione delle impostazioni cultura o ordinali per determinare se un carattere o una sottostringa viene trovato String.StartsWith String.IndexOf in una stringa specificata.

I metodi di ricerca nella classe che eseguono la ricerca di un singolo carattere, ad esempio il metodo o uno di un set di caratteri, ad esempio il metodo , eseguono tutti una ricerca String IndexOf IndexOfAny ordinale. Per eseguire una ricerca di un carattere con distinzione delle impostazioni cultura, è necessario chiamare un CompareInfo metodo, ad esempio CompareInfo.IndexOf(String, Char) o CompareInfo.LastIndexOf(String, Char) . Si noti che i risultati della ricerca di un carattere usando il confronto ordinale e con distinzione delle impostazioni cultura possono essere molto diversi. Ad esempio, una ricerca di un carattere Unicode precoposto, ad esempio la legatura "Æ" (U+00C6), potrebbe corrispondere a qualsiasi occorrenza dei relativi componenti nella sequenza corretta, ad esempio "AE" (U+041U+0045), a seconda delle impostazioni cultura. Nell'esempio seguente viene illustrata la differenza tra i String.IndexOf(Char) metodi e durante la ricerca di un singolo CompareInfo.IndexOf(String, Char) carattere. La legatura "æ" (U+00E6) si trova nella stringa "aerial" quando si usano le convenzioni delle impostazioni cultura en-US, ma non quando si usano le convenzioni delle impostazioni cultura da-DK o quando si esegue un confronto ordinale.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "da-DK", "en-US" }
      Dim ci As CompareInfo
      Dim str As String = "aerial"
      Dim ch As Char = "æ"c  ' U+00E6
      
      Console.Write("Ordinal comparison -- ")
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch))
      
      For Each cultureName In cultureNames
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
         Console.Write("{0} cultural comparison -- ", cultureName)
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch))
      Next
   End Sub
End Module
' The example displays the following output:
'       Ordinal comparison -- Position of 'æ' in aerial: -1
'       da-DK cultural comparison -- Position of 'æ' in aerial: -1
'       en-US cultural comparison -- Position of 'æ' in aerial: 0

D'altra parte, i metodi di classe che eseguono la ricerca di una stringa anziché di un carattere eseguono una ricerca con distinzione delle impostazioni cultura se le opzioni di ricerca non vengono specificate in modo esplicito da un parametro di String tipo StringComparison . L'unica eccezione è Contains , che esegue una ricerca ordinale.

Test dell'uguaglianza

Usare il String.Compare metodo per determinare la relazione tra due stringhe nell'ordinamento. In genere, si tratta di un'operazione sensibile alle impostazioni cultura. Chiamare invece il metodo String.Equals per verificare l'uguaglianza. Poiché il test per l'uguaglianza in genere confronta l'input dell'utente con una stringa nota, ad esempio un nome utente valido, una password o un percorso file system, si tratta in genere di un'operazione ordinale.

Avviso

È possibile verificare l'uguaglianza chiamando il metodo e String.Compare determinando se il valore restituito è zero. Tuttavia, questa procedura non è consigliata. Per determinare se due stringhe sono uguali, è necessario chiamare uno degli overload del String.Equals metodo . L'overload preferito da chiamare è il metodo di istanza o il metodo statico, perché entrambi i metodi includono un parametro che specifica in modo esplicito Equals(String, StringComparison) Equals(String, String, StringComparison) il tipo di System.StringComparison confronto.

Nell'esempio seguente viene illustrato il rischio di eseguire un confronto con distinzione delle impostazioni cultura per l'uguaglianza quando è invece necessario usare uno ordinale. In questo caso, lo scopo del codice è impedire l'accesso file system dagli URL che iniziano con "FILE://" o "file://" eseguendo un confronto senza distinzione tra maiuscole e minuscole dell'inizio di un URL con la stringa "FILE://". Tuttavia, se un confronto con distinzione delle impostazioni cultura viene eseguito usando le impostazioni cultura turche (Turco) su un URL che inizia con "file://", il confronto per l'uguaglianza ha esito negativo, perché l'equivalente in maiuscolo turco della "i" minuscola è " I" anziché "I". Di conseguenza, l file system'accesso remoto è inavvertitamente consentito. D'altra parte, se viene eseguito un confronto ordinale, il confronto per l'uguaglianza ha esito positivo file system viene negato l'accesso.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

      String^ substring = str->Substring(0, position);  
      return substring->Equals("FILE", cmp);
}
// The example displays the following output: 
//       Culture-sensitive test for equality: 
//       Access to file://c:/notes.txt is allowed. 
//        
//       Ordinal test for equality: 
//       Access to file://c:/notes.txt is not allowed.
using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")      

      Dim filePath As String = "file://c:/notes.txt"
      
      Console.WriteLine("Culture-sensitive test for equality:")
      If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
      Console.WriteLine()
      
      Console.WriteLine("Ordinal test for equality:")
      If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
   End Sub
   
   Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
      Dim position As Integer = str.IndexOf("://")
      If position < 0 Then Return False

      Dim substring As String = str.Substring(0, position)  
      Return substring.Equals("FILE", cmp)
   End Function
End Module
' The example displays the following output:
'       Culture-sensitive test for equality:
'       Access to file://c:/notes.txt is allowed.
'       
'       Ordinal test for equality:
'       Access to file://c:/notes.txt is not allowed.

Normalization

Alcuni caratteri Unicode hanno più rappresentazioni. Ad esempio, uno dei punti di codice seguenti può rappresentare la lettera "ắ":

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Più rappresentazioni per un singolo carattere complicano la ricerca, l'ordinamento, la corrispondenza e altre operazioni sulle stringhe.

Lo standard Unicode definisce un processo denominato normalizzazione che restituisce una rappresentazione binaria di un carattere Unicode per una delle rappresentazioni binarie equivalenti. La normalizzazione può usare diversi algoritmi, denominati moduli di normalizzazione, che seguono regole diverse. .NET supporta i moduli di normalizzazione Unicode C, D, KC e KD. Quando le stringhe sono state normalizzate allo stesso formato di normalizzazione, possono essere confrontate usando il confronto ordinale.

Un confronto ordinale è un confronto binario del valore scalare Unicode degli Char oggetti corrispondenti in ogni stringa. La String classe include diversi metodi che possono eseguire un confronto ordinale, inclusi i seguenti:

È possibile determinare se una stringa viene normalizzata nel formato di normalizzazione C chiamando il metodo oppure è possibile chiamare il metodo per determinare se una stringa viene String.IsNormalized() String.IsNormalized(NormalizationForm) normalizzata in un formato di normalizzazione specificato. È anche possibile chiamare il metodo per convertire una stringa nel formato di normalizzazione C oppure chiamare il metodo per convertire una stringa String.Normalize() in un formato di String.Normalize(NormalizationForm) normalizzazione specificato. Per informazioni dettagliate sulla normalizzazione e il confronto delle stringhe, vedere i Normalize() metodi e Normalize(NormalizationForm) .

Il semplice esempio seguente illustra la normalizzazione delle stringhe. Definisce la lettera "ố" in tre diversi modi in tre stringhe diverse e usa un confronto ordinale per l'uguaglianza per determinare che ogni stringa è diversa dalle altre due stringhe. Converte quindi ogni stringa nei formati di normalizzazione supportati ed esegue di nuovo un confronto ordinale di ogni stringa in un formato di normalizzazione specificato. In ogni caso, il secondo test per l'uguaglianza mostra che le stringhe sono uguali.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;

public ref class Example
{
private:
   StreamWriter^ sw;

   void TestForEquality(... array<String^>^  words)
   {
      for (int ctr = 0; ctr <= words->Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words->Length - 1; ctr2++) 
            sw->WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr]->Equals(words[ctr2], StringComparison::Ordinal));
   }

   String^ ShowBytes(String^ str)
   {
      String^ result = nullptr;
      for each (Char ch in str)
         result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4")); 
      return result->Trim();            
   } 

   array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
   {
      for (int ctr = 0; ctr < words->Length; ctr++)
         if (! words[ctr]->IsNormalized(nf))
            words[ctr] = words[ctr]->Normalize(nf); 
      return words;   
   }

public: 
   void Execute()
   {
      sw = gcnew StreamWriter(".\\TestNorm1.txt");

      // Define three versions of the same word.  
      String^ s1 = L"sống";        // create word with U+1ED1 
      String^ s2 = L"s\x00F4\x0301ng";
      String^ s3 = L"so\x0302\x0301ng";

      TestForEquality(s1, s2, s3);      
      sw->WriteLine();

      // Normalize and compare strings using each normalization form. 
      for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
      {
         sw->WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
         array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
         TestForEquality(sn);           
         sw->WriteLine("\n");                                        
      }

      sw->Close(); 
   }
};

void main()
{
   Example^ ex = gcnew Example();
   ex->Execute();
}
// The example produces the following output:
// The example displays the following output: 
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False 
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//        
//       Normalization FormC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//        
//        
//       Normalization FormKC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormKD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }
      
      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += $"{(ushort)ch:X4} ";
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
Imports System.Globalization
Imports System.IO
Imports System.Text

Module Example
   Private sw As StreamWriter
       
   Public Sub Main()
      sw = New StreamWriter(".\TestNorm1.txt")

      ' Define three versions of the same word. 
      Dim s1 As String = "sống"        ' create word with U+1ED1
      Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
      Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"

      TestForEquality(s1, s2, s3)      
      sw.WriteLine()

      ' Normalize and compare strings using each normalization form.
      For Each formName In [Enum].GetNames(GetType(NormalizationForm))
         sw.WriteLine("Normalization {0}:", formName) 
         Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),  
                                             NormalizationForm)
         Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
         TestForEquality(sn)           
         sw.WriteLine(vbCrLf)                                        
      Next
      
      sw.Close()   
   End Sub

   Private Sub TestForEquality(ParamArray words As String())
      For ctr As Integer = 0 To words.Length - 2
         For ctr2 As Integer = ctr + 1 To words.Length - 1 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words(ctr), ShowBytes(words(ctr)),
                         words(ctr2), ShowBytes(words(ctr2)),
                         words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
         Next                
      Next   
   End Sub

   Private Function ShowBytes(str As String) As String
      Dim result As String = Nothing
      For Each ch In str
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")) 
      Next
      Return result.Trim()            
   End Function  
   
   Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
      For ctr As Integer = 0 To words.Length - 1
         If Not words(ctr).IsNormalized(nf) Then
            words(ctr) = words(ctr).Normalize(nf)
         End If    
      Next
      Return words   
   End Function
End Module
' The example displays the following output:
'       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
'       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

Per altre informazioni sui moduli di normalizzazione e normalizzazione, vedere , nonché Unicode System.Text.NormalizationForm Standard Annex #15: Unicode Normalization Forms e Normalization FAQ (Domande frequenti sulla normalizzazione) nel sito Web unicode.org Unicode.

Operazioni sulle stringhe per categoria

La classe fornisce membri per il confronto di stringhe, il test dell'uguaglianza delle stringhe, la ricerca di caratteri o sottostringhe in una stringa, la modifica di una stringa, l'estrazione di sottostringhe da una stringa, la combinazione di stringhe, la formattazione dei valori, la copia di una stringa e String la normalizzazione di una stringa.

Confrontare le stringhe

È possibile confrontare le stringhe per determinarne la posizione relativa nell'ordinamento usando i metodi String seguenti:

  • Compare restituisce un numero intero che indica la relazione tra una stringa e una seconda stringa nell'ordinamento.

  • CompareOrdinal restituisce un intero che indica la relazione tra una stringa e una seconda stringa in base a un confronto dei relativi punti di codice.

  • CompareTo restituisce un intero che indica la relazione tra l'istanza di stringa corrente e una seconda stringa nell'ordinamento. Il CompareTo(String) metodo fornisce le IComparable IComparable<T> implementazioni e per la classe String .

Testare l'uguaglianza delle stringhe

Chiamare il Equals metodo per determinare se due stringhe sono uguali. L'istanza e gli overload statici consentono di specificare se il confronto è sensibile alle impostazioni cultura o ordinale e se la distinzione tra maiuscole e minuscole Equals(String, String, StringComparison) Equals(String, StringComparison) viene considerata o ignorata. La maggior parte dei test per l'uguaglianza è ordinale e i confronti per l'uguaglianza che determinano l'accesso a una risorsa di sistema (ad esempio un oggetto file system) devono essere sempre ordinali.

Trovare caratteri in una stringa

La String classe include due tipi di metodi di ricerca:

Avviso

Se si vuole cercare in una stringa un criterio specifico anziché una sottostringa specifica, è consigliabile usare espressioni regolari. Per altre informazioni, vedere Espressioni regolari .NET.

Modificare una stringa

La String classe include i metodi seguenti che sembrano modificare il valore di una stringa:

  • Insert inserisce una stringa nell'istanza String corrente.

  • PadLeft inserisce una o più occorrenze di un carattere specificato all'inizio di una stringa.

  • PadRight inserisce una o più occorrenze di un carattere specificato alla fine di una stringa.

  • Remove elimina una sottostringa dall'istanza String corrente.

  • Replace sostituisce una sottostringa con un'altra sottostringa nell'istanza String corrente.

  • ToLower e ToLowerInvariant convertono tutti i caratteri di una stringa in lettere minuscole.

  • ToUpper e ToUpperInvariant convertono tutti i caratteri di una stringa in lettere maiuscole.

  • Trim rimuove tutte le occorrenze di un carattere dall'inizio e dalla fine di una stringa.

  • TrimEnd rimuove tutte le occorrenze di un carattere dalla fine di una stringa.

  • TrimStart rimuove tutte le occorrenze di un carattere dall'inizio di una stringa.

Importante

Tutti i metodi di modifica delle stringhe restituiscono un nuovo String oggetto . Non modificano il valore dell'istanza corrente.

Estrarre sottostringhe da una stringa

Il String.Split metodo separa una singola stringa in più stringhe. Gli overload del metodo consentono di specificare più delimitatori, di limitare il numero di sottostringhe estratte dal metodo, di tagliare gli spazi vuoti dalle sottostringhe e di specificare se le stringhe vuote (che si verificano quando i delimitatori sono adiacenti) vengono incluse tra le stringhe restituite.

Combinare stringhe

Per la concatenazione di stringhe String è possibile usare i metodi seguenti:

  • Concat combina una o più sottostringhe in una singola stringa.

  • Join concatena una o più sottostringhe in un singolo elemento e aggiunge un separatore tra ogni sottostringa.

Formattare i valori

Il metodo usa la funzionalità di formattazione composita per sostituire uno o più segnaposto in una stringa con la rappresentazione di String.Format stringa di un oggetto o di un valore. Il Format metodo viene spesso usato per eseguire le operazioni seguenti:

  • Per incorporare la rappresentazione di stringa di un valore numerico in una stringa.

  • Per incorporare la rappresentazione di stringa di un valore di data e ora in una stringa.

  • Per incorporare la rappresentazione di stringa di un valore di enumerazione in una stringa.

  • Per incorporare la rappresentazione di stringa di un oggetto che supporta IFormattable l'interfaccia in una stringa.

  • Per giustificare a destra o a sinistra una sottostringa in un campo all'interno di una stringa più grande.

Per informazioni dettagliate sulle operazioni di formattazione e sugli esempi, vedere il riepilogo Format dell'overload.

Copia una stringa

È possibile chiamare i metodi String seguenti per creare una copia di una stringa:

  • Clone restituisce un riferimento a un oggetto String esistente.

  • Copy crea una copia di una stringa esistente.

  • CopyTo copia una parte di una stringa in una matrice di caratteri.

Normalizzare una stringa

In Unicode un singolo carattere può avere più punti di codice. La normalizzazione converte questi caratteri equivalenti nella stessa rappresentazione binaria. Il String.Normalize metodo esegue la normalizzazione e il metodo determina se una stringa è String.IsNormalized normalizzata.

Per altre informazioni e un esempio, vedere la sezione Normalization più indietro in questo argomento.

Costruttori

String(Char*)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode.

String(Char*, Int32, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.

String(Char, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico carattere Unicode ripetuto un numero precisato di volte.

String(Char[])

Inizializza una nuova istanza della classe String sui caratteri Unicode indicati nella matrice di caratteri specificata.

String(Char[], Int32, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode, da una posizione iniziale del carattere all'interno di tale matrice e da una lunghezza.

String(ReadOnlySpan<Char>)

Inizializza una nuova istanza della classe String sui caratteri Unicode indicati nell'intervallo di sola lettura specificato.

String(SByte*)

Inizializza una nuova istanza della classe String sul valore indicato da un puntatore a una matrice di interi con segno a 8 bit.

String(SByte*, Int32, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da una lunghezza.

String(SByte*, Int32, Int32, Encoding)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di interi con segno a 8 bit, da una posizione iniziale all'interno di tale matrice e da un oggetto Encoding.

Campi

Empty

Rappresenta la stringa vuota. Questo campo è di sola lettura.

Proprietà

Chars[Int32]

Ottiene l'oggetto Char in una posizione specificata dell'oggetto String corrente.

Length

Ottiene il numero di caratteri nell'oggetto String corrente.

Metodi

Clone()

Restituisce un riferimento a questa istanza della classe String.

Compare(String, Int32, String, Int32, Int32)

Confronta le sottostringhe di due oggetti String specificati e restituisce un intero che indica la relativa posizione nell'ordinamento.

Compare(String, Int32, String, Int32, Int32, Boolean)

Confronta le sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Confronta le sottostringhe di due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e usando le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Confronta le sottostringhe di due oggetti String specificati, usando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due sottostringhe nell'ordinamento.

Compare(String, Int32, String, Int32, Int32, StringComparison)

Confronta sottostringhe di due oggetti String specificati usando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento.

Compare(String, String)

Confronta due oggetti String specificati e restituisce un intero che ne indica la posizione relativa nell'ordinamento.

Compare(String, String, Boolean)

Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.

Compare(String, String, Boolean, CultureInfo)

Confronta due oggetti String specificati, ignorando o rispettando la distinzione tra maiuscole e minuscole e usando le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che ne indica la posizione relativa nell'ordinamento.

Compare(String, String, CultureInfo, CompareOptions)

Confronta due oggetti String specificati, usando le opzioni di confronto specificate e le informazioni specifiche delle impostazioni cultura per influenzare il confronto, e restituisce un intero che indica la relazione reciproca tra le due stringhe nell'ordinamento.

Compare(String, String, StringComparison)

Confronta due oggetti String specificati usando le regole specificate e restituisce un intero che ne indica la posizione relativa nell'ordinamento.

CompareOrdinal(String, Int32, String, Int32, Int32)

Effettua il confronto fra sottostringhe di due determinati oggetti String in base all'analisi dei valori numerici dei corrispondenti oggetti Char in ogni sottostringa.

CompareOrdinal(String, String)

Confronta due oggetti String specificati in base all'analisi dei valori numerici dei corrispondenti oggetti Char in ogni stringa.

CompareTo(Object)

Confronta questa istanza con un oggetto Object specificato e indica se questa istanza precede, segue o si trova nella stessa posizione dell'oggetto Object specificato all'interno dell'ordinamento.

CompareTo(String)

Confronta questa istanza con un oggetto String specificato e indica se questa istanza precede, segue o si trova nella stessa posizione della stringa specificata all'interno dei criteri di ordinamento.

Concat(IEnumerable<String>)

Concatena i membri di una raccolta IEnumerable<T> costruita di tipo String.

Concat(Object)

Crea la rappresentazione di stringa di un oggetto specificato.

Concat(Object, Object)

Concatena le rappresentazioni di stringa di due oggetti specificati.

Concat(Object, Object, Object)

Concatena le rappresentazioni di stringa di tre oggetti specificati.

Concat(Object, Object, Object, Object)

Concatena le rappresentazioni di stringa di quattro oggetti specificati e di qualsiasi oggetto specificato in un elenco di parametri di lunghezza variabile facoltativo.

Concat(Object[])

Concatena le rappresentazioni di stringa degli elementi in una matrice Object specificata.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena le rappresentazioni stringa di due intervalli di caratteri di sola lettura specificati.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena le rappresentazioni stringa di tre intervalli di caratteri di sola lettura specificati.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Concatena le rappresentazioni stringa di quattro intervalli di caratteri di sola lettura specificati.

Concat(String, String)

Concatena due istanze specificate della classe String.

Concat(String, String, String)

Concatena tre istanze specificate della classe String.

Concat(String, String, String, String)

Concatena quattro istanze specificate della classe String.

Concat(String[])

Concatena gli elementi di una matrice di oggetti String specificati.

Concat<T>(IEnumerable<T>)

Concatena i membri di un'implementazione di IEnumerable<T>.

Contains(Char)

Restituisce un valore che indica se un carattere specificato è presente all'interno della stringa.

Contains(Char, StringComparison)

Restituisce un valore che indica se un carattere specificato si trova all'interno di questa stringa, usando le regole di confronto specificate.

Contains(String)

Restituisce un valore che indica se una sottostringa specificata è presente all'interno della stringa.

Contains(String, StringComparison)

Restituisce un valore che indica se una stringa specificata si trova all'interno di questa stringa, usando le regole di confronto specificate.

Copy(String)
Obsoleta.

Crea una nuova istanza dell'oggetto String con lo stesso valore di un'istanza dell'oggetto String specificata.

CopyTo(Int32, Char[], Int32, Int32)

Copia un numero definito di caratteri da una posizione specificata in questa istanza in una posizione specificata in una matrice di caratteri Unicode.

CopyTo(Span<Char>)

Copia il contenuto di questa stringa nell'intervallo di destinazione.

Create(IFormatProvider, DefaultInterpolatedStringHandler)

Crea una nuova stringa usando il provider specificato per controllare la formattazione della stringa interpolata specificata.

Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

Crea una nuova stringa usando il provider specificato per controllare la formattazione della stringa interpolata specificata.

Create<TState>(Int32, TState, SpanAction<Char,TState>)

Crea una nuova stringa con una lunghezza specifica e la inizializza dopo la creazione usando il callback specificato.

EndsWith(Char)

Determina se la fine di questa istanza di stringa corrisponde al carattere specificato.

EndsWith(String)

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata.

EndsWith(String, Boolean, CultureInfo)

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante le impostazioni cultura specificate.

EndsWith(String, StringComparison)

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante l'opzione di confronto specificata.

EnumerateRunes()

Restituisce un'enumerazione di Rune da questa stringa.

Equals(Object)

Determina se questa istanza e un oggetto specificato, che deve essere anche un oggetto String, hanno lo stesso valore.

Equals(String)

Determina se questa istanza e un altro oggetto String specificato hanno lo stesso valore.

Equals(String, String)

Determina se due oggetti String specificati hanno lo stesso valore.

Equals(String, String, StringComparison)

Determina se due oggetti String specificati hanno lo stesso valore. Un parametro specifica le impostazioni cultura, l'eventuale distinzione fra maiuscole e minuscole e le regole di ordinamento usate per effettuare il confronto.

Equals(String, StringComparison)

Determina se questa stringa e un oggetto String specificato hanno lo stesso valore. Un parametro specifica le impostazioni cultura, l'eventuale distinzione fra maiuscole e minuscole e le regole di ordinamento usate per effettuare il confronto.

Format(IFormatProvider, String, Object)

Sostituisce uno o più elementi di formato presenti in una stringa specificata con la rappresentazione di stringa dell'oggetto corrispondente. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Format(IFormatProvider, String, Object, Object)

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Format(IFormatProvider, String, Object, Object, Object)

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Format(IFormatProvider, String, Object[])

Sostituisce gli elementi di formato presenti in una stringa con le rappresentazioni di stringa degli oggetti corrispondenti in una matrice specificata. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.

Format(String, Object)

Sostituisce uno o più elementi di formato in una stringa con la rappresentazione di stringa di un oggetto specificato.

Format(String, Object, Object)

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.

Format(String, Object, Object, Object)

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.

Format(String, Object[])

Sostituisce l'elemento di formato presente in una stringa specificata con la rappresentazione di stringa di un oggetto corrispondente in una matrice specificata.

GetEnumerator()

Recupera un oggetto che può eseguire l'iterazione fra i singoli caratteri di questa stringa.

GetHashCode()

Restituisce il codice hash di questa stringa.

GetHashCode(ReadOnlySpan<Char>)

Restituisce il codice hash per l'intervallo di caratteri di sola lettura specificato.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Restituisce il codice hash per l'intervallo di caratteri di sola lettura specificato usando le regole specificate.

GetHashCode(StringComparison)

Restituisce il codice hash per questa stringa usando le regole specificate.

GetPinnableReference()

Restituisce un riferimento all'elemento della stringa in corrispondenza dell'indice zero.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
GetTypeCode()

Restituisce l'oggetto TypeCode per la classe String.

IndexOf(Char)

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa.

IndexOf(Char, Int32)

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa. La ricerca ha inizio alla posizione del carattere specificata.

IndexOf(Char, Int32, Int32)

Restituisce l'indice in base zero della prima occorrenza del carattere specificato in questa istanza. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.

IndexOf(Char, StringComparison)

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa. Un parametro specifica il tipo di ricerca da usare per il carattere specificato.

IndexOf(String)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza.

IndexOf(String, Int32)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza. La ricerca ha inizio alla posizione del carattere specificata.

IndexOf(String, Int32, Int32)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.

IndexOf(String, Int32, Int32, StringComparison)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. I parametri specificano la posizione di ricerca iniziale nella stringa corrente, il numero di caratteri nella stringa corrente in cui eseguire la ricerca e il tipo di ricerca da usare per la stringa specificata.

IndexOf(String, Int32, StringComparison)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. I parametri specificano la posizione iniziale della ricerca nella stringa corrente e il tipo di ricerca da usare per la stringa specificata.

IndexOf(String, StringComparison)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente. Un parametro specifica il tipo di ricerca da usare per la stringa specificata.

IndexOfAny(Char[])

Restituisce l'indice in base zero della prima occorrenza in questa istanza di qualsiasi carattere presente in una matrice di caratteri Unicode specificata.

IndexOfAny(Char[], Int32)

Restituisce l'indice in base zero della prima occorrenza in questa istanza di qualsiasi carattere presente in una matrice di caratteri Unicode specificata. La ricerca ha inizio alla posizione del carattere specificata.

IndexOfAny(Char[], Int32, Int32)

Restituisce l'indice in base zero della prima occorrenza in questa istanza di qualsiasi carattere presente in una matrice di caratteri Unicode specificata. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.

Insert(Int32, String)

Restituisce una nuova stringa in cui una stringa specificata viene inserita in una posizione di indice specificata in questa istanza.

Intern(String)

Recupera il riferimento del sistema all'oggetto String specificato.

IsInterned(String)

Recupera un riferimento a un oggetto String specificato.

IsNormalized()

Specifica se la stringa è nel formato di normalizzazione Unicode C.

IsNormalized(NormalizationForm)

Specifica se la stringa è nel formato di normalizzazione Unicode indicato.

IsNullOrEmpty(String)

Indica se la stringa specificata è null o una stringa vuota ("").

IsNullOrWhiteSpace(String)

Indica se una stringa specificata è null, vuota o è composta solo da spazi vuoti.

Join(Char, Object[])

Concatena le rappresentazioni di stringa di una matrice di oggetti, usando il separatore specificato tra ogni membro.

Join(Char, String[])

Concatena una matrice di stringhe, usando il separatore specificato tra ogni membro.

Join(Char, String[], Int32, Int32)

Concatena una matrice di stringhe, usando il separatore specificato tra ogni membro, a partire dall'elemento in value presente nella posizione di startIndex e concatenando fino a count elementi.

Join(String, IEnumerable<String>)

Concatena i membri di una raccolta IEnumerable<T> costruita di tipo String, usando tra i membri il separatore specificato.

Join(String, Object[])

Concatena gli elementi di una matrice di oggetti, usando tra gli elementi il separatore specificato.

Join(String, String[])

Concatena tutti gli elementi di una matrice di stringhe, usando tra gli elementi il separatore specificato.

Join(String, String[], Int32, Int32)

Concatena gli elementi specificati di una matrice di stringhe, usando tra gli elementi il separatore specificato.

Join<T>(Char, IEnumerable<T>)

Concatena i membri di una raccolta, usando tra i membri il separatore specificato.

Join<T>(String, IEnumerable<T>)

Concatena i membri di una raccolta, usando tra i membri il separatore specificato.

LastIndexOf(Char)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di un carattere Unicode specificato all'interno di questa istanza.

LastIndexOf(Char, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di un carattere Unicode specificato all'interno di questa istanza. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.

LastIndexOf(Char, Int32, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza del carattere Unicode specificato in una sottostringa all'interno di questa istanza. La ricerca inizia in una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa per un determinato numero di posizioni dei caratteri.

LastIndexOf(String)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza.

LastIndexOf(String, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.

LastIndexOf(String, Int32, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza. La ricerca inizia in una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa per un determinato numero di posizioni dei caratteri.

LastIndexOf(String, Int32, Int32, StringComparison)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza. La ricerca inizia in una posizione del carattere specificata e continua all'indietro verso l'inizio della stringa per il numero di posizioni dei caratteri indicato. Un parametro specifica il tipo di confronto da effettuare durante la ricerca della stringa specificata.

LastIndexOf(String, Int32, StringComparison)

Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno dell'oggetto String corrente. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa. Un parametro specifica il tipo di confronto da effettuare durante la ricerca della stringa specificata.

LastIndexOf(String, StringComparison)

Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno dell'oggetto String corrente. Un parametro specifica il tipo di ricerca da usare per la stringa specificata.

LastIndexOfAny(Char[])

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza in questa istanza di uno o più caratteri specificati in una matrice di caratteri Unicode.

LastIndexOfAny(Char[], Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza in questa istanza di uno o più caratteri specificati in una matrice di caratteri Unicode. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.

LastIndexOfAny(Char[], Int32, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza in questa istanza di uno o più caratteri specificati in una matrice di caratteri Unicode. La ricerca inizia in una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa per un determinato numero di posizioni dei caratteri.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
Normalize()

Restituisce una nuova stringa il cui valore testuale è lo stesso di questa stringa ma la cui rappresentazione binaria è nel formato di normalizzazione Unicode C.

Normalize(NormalizationForm)

Restituisce una nuova stringa il cui valore testuale è lo stesso di questa stringa ma la cui rappresentazione binaria è nel formato di normalizzazione Unicode specificato.

PadLeft(Int32)

Restituisce una nuova stringa che allinea a destra i caratteri in questa istanza mediante l'aggiunta a sinistra di un numero di spazi tale da ottenere la lunghezza totale specificata.

PadLeft(Int32, Char)

Restituisce una nuova stringa che allinea a destra i caratteri in questa istanza mediante l'aggiunta a sinistra di una sequenza di elementi pari al carattere Unicode specificato, in modo da ottenere la lunghezza totale specificata.

PadRight(Int32)

Restituisce una nuova stringa che allinea a sinistra i caratteri in questa stringa mediante l'aggiunta a destra di un numero di spazi tale da ottenere la lunghezza totale specificata.

PadRight(Int32, Char)

Restituisce una nuova stringa che allinea a sinistra i caratteri in questa stringa mediante l'aggiunta a destra di un carattere Unicode specificato, in modo da ottenere la lunghezza totale specificata.

Remove(Int32)

Restituisce una nuova stringa in cui sono stati eliminati tutti i caratteri dell'istanza corrente a partire da una posizione specificata fino all'ultima posizione.

Remove(Int32, Int32)

Restituisce una nuova stringa in cui è stato eliminato un numero specificato di caratteri nell'istanza corrente a partire da una posizione specificata.

Replace(Char, Char)

Restituisce una nuova stringa in cui tutte le occorrenze di un carattere Unicode specificato presenti in questa istanza vengono sostituite con un altro carattere Unicode specificato.

Replace(String, String)

Restituisce una nuova stringa in cui tutte le occorrenze di una stringa specificata nell'istanza corrente vengono sostituite con un'altra stringa specificata.

Replace(String, String, Boolean, CultureInfo)

Restituisce una nuova stringa in cui tutte le occorrenze di una stringa specificata nell'istanza corrente vengono sostituite con un'altra stringa specificata, usando le impostazioni cultura e la distinzione fra maiuscole e minuscole specificate.

Replace(String, String, StringComparison)

Restituisce una nuova stringa in cui tutte le occorrenze di una stringa specificata nell'istanza corrente vengono sostituite con un'altra stringa specificata, usando il tipo di confronto specificato.

ReplaceLineEndings()

Sostituisce tutte le sequenze di nuova riga nella stringa corrente con NewLine .

ReplaceLineEndings(String)

Sostituisce tutte le sequenze di nuova riga nella stringa corrente con replacementText .

Split(Char, Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base al carattere di delimitazione specificato e, facoltativamente, ad altre opzioni. Divide una stringa in un numero massimo di sottostringhe in base al separatore di caratteri specificato, omettendo facoltativamente le sottostringhe vuote dal risultato.

Split(Char, StringSplitOptions)

Divide una stringa in sottostringhe in base al carattere di delimitazione specificato e, facoltativamente, ad altre opzioni.

Split(Char[])

Divide una stringa in sottostringhe in base ai caratteri di delimitazione specificati.

Split(Char[], Int32)

Divide una stringa in un numero massimo di sottostringhe in base ai caratteri di delimitazione specificati.

Split(Char[], Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base ai caratteri di delimitazione specificati e, facoltativamente, ad altre opzioni.

Split(Char[], StringSplitOptions)

Divide una stringa in sottostringhe in base ai caratteri di delimitazione specificati e ad altre opzioni.

Split(String, Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base a una stringa di delimitazione specificata e, facoltativamente, ad altre opzioni.

Split(String, StringSplitOptions)

Suddivide una stringa in sottostringhe in base al separatore di stringa specificato.

Split(String[], Int32, StringSplitOptions)

Divide una stringa in un numero massimo di sottostringhe in base alle stringhe di delimitazione specificate e, facoltativamente, ad altre opzioni.

Split(String[], StringSplitOptions)

Divide una stringa in sottostringhe in base a una stringa di delimitazione specificata e, facoltativamente, ad altre opzioni.

StartsWith(Char)

Determina se questa istanza di stringa inizia con il carattere specificato.

StartsWith(String)

Determina se l'inizio di questa istanza di stringa corrisponde alla stringa specificata.

StartsWith(String, Boolean, CultureInfo)

Determina se l'inizio di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante le impostazioni cultura specificate.

StartsWith(String, StringComparison)

Determina se l'inizio di questa istanza di stringa corrisponde alla stringa specificata se confrontata usando l'opzione di confronto specificata.

Substring(Int32)

Recupera una sottostringa da questa istanza. La sottostringa inizia in corrispondenza di un carattere specificato e continua fino alla fine della stringa.

Substring(Int32, Int32)

Recupera una sottostringa da questa istanza. La sottostringa inizia in corrispondenza della posizione del carattere specificata e ha la lunghezza specificata.

ToCharArray()

Copia i caratteri di questa istanza in una matrice di caratteri Unicode.

ToCharArray(Int32, Int32)

Copia i caratteri di una determinata sottostringa di questa istanza in una matrice di caratteri Unicode.

ToLower()

Restituisce una copia di questa stringa convertita in caratteri minuscoli.

ToLower(CultureInfo)

Restituisce una copia di questa stringa convertita in caratteri minuscoli, usando le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura specificate.

ToLowerInvariant()

Restituisce una copia dell'oggetto String convertito in caratteri minuscoli mediante le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura invariabili.

ToString()

Restituisce questa istanza di String. Non viene eseguita alcuna conversione effettiva.

ToString(IFormatProvider)

Restituisce questa istanza di String. Non viene eseguita alcuna conversione effettiva.

ToUpper()

Restituisce una copia di questa stringa convertita in caratteri maiuscoli.

ToUpper(CultureInfo)

Restituisce una copia di questa stringa convertita in caratteri maiuscoli, usando le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura specificate.

ToUpperInvariant()

Restituisce una copia dell'oggetto String convertito in caratteri maiuscoli mediante le regole relative all'utilizzo di maiuscole e minuscole proprie delle impostazioni cultura invariabili.

Trim()

Rimuove tutti gli spazi vuoti iniziali e finali dalla stringa corrente.

Trim(Char)

Rimuove tutte le istanze iniziali e finali di un carattere dalla stringa corrente.

Trim(Char[])

Rimuove dalla stringa corrente tutte le occorrenze iniziali e finali di un set di caratteri specificato in una matrice.

TrimEnd()

Rimuove tutti gli spazi vuoti finali dalla stringa corrente.

TrimEnd(Char)

Rimuove tutte le occorrenze finali di un carattere dalla stringa corrente.

TrimEnd(Char[])

Rimuove dalla stringa corrente tutte le occorrenze finali di un set di caratteri specificato in una matrice.

TrimStart()

Rimuove tutti gli spazi vuoti iniziali dalla stringa corrente.

TrimStart(Char)

Rimuove tutte le occorrenze iniziali di un carattere specificato dalla stringa corrente.

TrimStart(Char[])

Rimuove dalla stringa corrente tutte le occorrenze iniziali di un set di caratteri specificato in una matrice.

TryCopyTo(Span<Char>)

Copia il contenuto di questa stringa nell'intervallo di destinazione.

Operatori

Equality(String, String)

Determina se due stringhe specificate hanno lo stesso valore.

Implicit(String to ReadOnlySpan<Char>)

Definisce una conversione implicita di una determinata stringa in un intervallo di sola lettura di caratteri.

Inequality(String, String)

Determina se due stringhe specificate hanno valori diversi.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object)

Confronta questa istanza con un oggetto Object specificato e indica se questa istanza precede, segue o si trova nella stessa posizione dell'oggetto Object specificato all'interno dell'ordinamento.

IConvertible.GetTypeCode()

Restituisce l'oggetto TypeCode per la classe String.

IConvertible.ToBoolean(IFormatProvider)

Per una descrizione di questo membro, vedere ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Per una descrizione di questo membro, vedere ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Per una descrizione di questo membro, vedere ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Per una descrizione di questo membro, vedere ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider)

Per una descrizione di questo membro, vedere ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Per una descrizione di questo membro, vedere ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Per una descrizione di questo membro, vedere ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Per una descrizione di questo membro, vedere ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)

Per una descrizione di questo membro, vedere ToString(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Per una descrizione di questo membro, vedere ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione dell'oggetto String corrente.

IEnumerable<Char>.GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione dell'oggetto String corrente.

Metodi di estensione

ToImmutableArray<TSource>(IEnumerable<TSource>)

Crea una matrice non modificabile dalla raccolta specificata.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Costruisce un dizionario non modificabile da una raccolta di elementi esistente, applicando una funzione di trasformazione alle chiavi di origine.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Costruisce un dizionario non modificabile basato su una trasformazione di una sequenza.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera e trasforma una sequenza e produce un dizionario non modificabile del relativo contenuto.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

Enumera e trasforma una sequenza e produce un dizionario non modificabile del relativo contenuto usando l'operatore di confronto della chiave specificato.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

Enumera e trasforma una sequenza e produce un dizionario non modificabile del relativo contenuto usando gli operatori di confronto della chiave e del valore specificati.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Enumera una sequenza e produce un set di hash non modificabile del relativo contenuto.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Enumera una sequenza, produce un set di hash non modificabile del relativo contenuto e usa l'operatore di confronto di uguaglianza specificato per il tipo di set.

ToImmutableList<TSource>(IEnumerable<TSource>)

Enumera una sequenza e produce un elenco non modificabile del relativo contenuto.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Enumera e trasforma una sequenza e produce un dizionario ordinato non modificabile del relativo contenuto.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

Enumera e trasforma una sequenza e produce un dizionario ordinato non modificabile del relativo contenuto usando l'operatore di confronto della chiave specificato.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

Enumera e trasforma una sequenza e produce un dizionario ordinato non modificabile del relativo contenuto usando gli operatori di confronto della chiave e del valore specificati.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Enumera una sequenza e produce un set ordinato non modificabile del relativo contenuto.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Enumera una sequenza, produce un set ordinato non modificabile del relativo contenuto e usa l'operatore di confronto specificato.

CopyToDataTable<T>(IEnumerable<T>)

Restituisce un oggetto DataTable che contiene copie degli oggetti DataRow, dato un oggetto IEnumerable<T> di input dove il parametro generico DataRow è T.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copia gli oggetti DataRow nell'oggetto DataTable specificato, dato un oggetto IEnumerable<T> di input dove il parametro generico T è DataRow.

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Applica una funzione accumulatore a una sequenza.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Applica una funzione accumulatore a una sequenza. Il valore di inizializzazione specificato viene usato come valore iniziale dell'accumulatore.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Applica una funzione accumulatore a una sequenza. Il valore di inizializzazione specificato viene usato come valore iniziale dell'accumulatore e la funzione specificata viene usata per selezionare il valore risultante.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Determina se tutti gli elementi di una sequenza soddisfano una condizione.

Any<TSource>(IEnumerable<TSource>)

Determina se una sequenza contiene elementi.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Determina un qualsiasi elemento di una sequenza soddisfa una condizione.

Append<TSource>(IEnumerable<TSource>, TSource)

Accoda un valore alla fine della sequenza.

AsEnumerable<TSource>(IEnumerable<TSource>)

Restituisce l'input tipizzato come oggetto IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcola la media di una sequenza di valori Decimal ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcola la media di una sequenza di valori Double ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcola la media di una sequenza di valori Int32 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcola la media di una sequenza di valori Int64 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcola la media di una sequenza di valori Decimal nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcola la media di una sequenza di valori Double nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcola la media di una sequenza di valori Int32 nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcola la media di una sequenza di valori Int64 nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcola la media di una sequenza di valori Single nullable ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcola la media di una sequenza di valori Single ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.

Chunk<TSource>(IEnumerable<TSource>, Int32)

Suddividere gli elementi di una sequenza in blocchi di dimensioni al massimo size .

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Concatena due sequenze.

Contains<TSource>(IEnumerable<TSource>, TSource)

Determina se una sequenza contiene uno specifico elemento utilizzando l'operatore di confronto uguaglianze predefinito.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Determina se una sequenza contiene un elemento specificato utilizzando un oggetto IEqualityComparer<T> specificato.

Count<TSource>(IEnumerable<TSource>)

Restituisce il numero di elementi in una sequenza.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce un valore che rappresenta il numero di elementi nella sequenza specificata che soddisfano una condizione.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Restituisce gli elementi della sequenza specificata o il valore predefinito del parametro di tipo in una raccolta di singleton se la sequenza è vuota.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Restituisce gli elementi della sequenza specificata o il valore specificato in una raccolta di singleton se la sequenza è vuota.

Distinct<TSource>(IEnumerable<TSource>)

Restituisce elementi distinti da una sequenza utilizzando l'operatore di confronto uguaglianze predefinito per confrontare i valori.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Restituisce elementi distinti da una sequenza utilizzando uno specificato IEqualityComparer<T> per confrontare valori.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Restituisce elementi distinti da una sequenza in base a una funzione del selettore di chiave specificata.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Restituisce elementi distinti da una sequenza in base a una funzione del selettore di chiave specificata.

ElementAt<TSource>(IEnumerable<TSource>, Index)

Restituisce l'elemento in corrispondenza dell’indice specificato in una sequenza.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Restituisce l'elemento in corrispondenza dell’indice specificato in una sequenza.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)

Restituisce l'elemento in corrispondenza di un indice specificato in una sequenza o un valore predefinito se l'indice è esterno all'intervallo.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Restituisce l'elemento in corrispondenza di un indice specificato in una sequenza o un valore predefinito se l'indice è esterno all'intervallo.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Produce la differenza insiemistica di due sequenze utilizzando l'operatore di confronto eguaglianze predefinito per confrontare i valori.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produce la differenza insiemistica delle due sequenze utilizzando l’oggetto IEqualityComparer<T> specificato per confrontare i valori.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Produce la differenza di set di due sequenze in base a una funzione del selettore di chiave specificata.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Produce la differenza di set di due sequenze in base a una funzione del selettore di chiave specificata.

First<TSource>(IEnumerable<TSource>)

Restituisce il primo elemento di una sequenza.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce il primo elemento in una sequenza che soddisfa una condizione specificata.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Restituisce il primo elemento di una sequenza o un valore predefinito se la sequenza non contiene elementi.

FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)

Restituisce il primo elemento di una sequenza o un valore predefinito se la sequenza non contiene elementi.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce il primo elemento della sequenza che soddisfa una condizione specificata o un valore predefinito se tale elemento non viene trovato.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Restituisce il primo elemento della sequenza che soddisfa una condizione specificata o un valore predefinito se tale elemento non viene trovato.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Raggruppa gli elementi di una sequenza secondo una specificata funzione del selettore principale.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Raggruppa gli elementi di una sequenza secondo una specificata funzione del selettore principale e confronta le chiavi utilizzando un operatore di confronto specificato.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Raggruppa gli elementi di una sequenza in base a una funzione specificata del selettore principale e proietta gli elementi di ogni gruppo utilizzando una funzione specificata.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Raggruppa gli elementi di una sequenza secondo una specificata funzione del selettore principale. Le chiavi vengono confrontate usando un operatore di confronto e gli elementi di ogni gruppo vengono proiettati usando una funzione specificata.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave. Le chiavi vengono confrontati usando un operatore di confronto specificato.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave. Gli elementi di ogni gruppo vengono proiettati usando una funzione specificata.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>, IEqualityComparer<TKey>)

Raggruppa gli elementi di una sequenza in base a una funzione del selettore principale specificata e crea un valore risultante da ciascun gruppo e relativa chiave. I valori delle chiavi vengono confrontati usando un operatore di confronto specificato e gli elementi di ogni gruppo vengono proiettati usando una funzione specificata.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>)

Correla gli elementi di due sequenze in base all'uguaglianza delle chiavi e raggruppa i risultati. Per confrontare le chiavi viene usato l'operatore di confronto uguaglianze predefinito.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>,TResult>, IEqualityComparer<TKey>)

Correla gli elementi di due sequenze in base all'uguaglianza delle chiavi e raggruppa i risultati. Per confrontare le chiavi, viene usato un oggetto IEqualityComparer<T> specificato.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Produce l’intersezione insiemistica di due sequenze utilizzando l'operatore di confronto uguaglianze predefinito per confrontare i valori.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produce l’intersezione insiemistica delle due sequenze utilizzando l’oggetto IEqualityComparer<T> specificato per confrontare i valori.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Produce l'intersezione set di due sequenze in base a una funzione del selettore di chiave specificata.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Produce l'intersezione set di due sequenze in base a una funzione del selettore di chiave specificata.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Correla gli elementi di due sequenze in base alle chiavi corrispondenti. Per confrontare le chiavi viene usato l'operatore di confronto uguaglianze predefinito.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Correla gli elementi di due sequenze in base alle chiavi corrispondenti. Per confrontare le chiavi, viene usato un oggetto IEqualityComparer<T> specificato.

Last<TSource>(IEnumerable<TSource>)

Restituisce l'ultimo elemento di una sequenza.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce l'ultimo elemento di una sequenza che soddisfa una condizione specificata.

LastOrDefault<TSource>(IEnumerable<TSource>)

Restituisce l'ultimo elemento di una sequenza o un valore predefinito se la sequenza non contiene elementi.

LastOrDefault<TSource>(IEnumerable<TSource>, TSource)

Restituisce l'ultimo elemento di una sequenza o un valore predefinito se la sequenza non contiene elementi.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce l'ultimo elemento di una sequenza che soddisfa una condizione specificata o un valore predefinito se tale elemento non viene trovato.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Restituisce l'ultimo elemento di una sequenza che soddisfa una condizione specificata o un valore predefinito se tale elemento non viene trovato.

LongCount<TSource>(IEnumerable<TSource>)

Restituisce un oggetto Int64 che rappresenta il numero totale di elementi in una sequenza.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce un oggetto Int64 che rappresenta quanti elementi in una sequenza soddisfano una condizione.

Max<TSource>(IEnumerable<TSource>)

Restituisce il valore massimo in una sequenza generica.

Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Restituisce il valore massimo in una sequenza generica.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Decimal massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Double massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int32 massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int64 massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Decimal massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Double massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int32 massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int64 massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Single massimo.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Single massimo.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Richiama una funzione di trasformazione su ogni elemento di una generica sequenza e restituisce il valore massimo risultante.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Restituisce il valore massimo in una sequenza generica in base a una funzione del selettore di chiave specificata.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Restituisce il valore massimo in una sequenza generica in base a una funzione del selettore di chiave specificata.

Min<TSource>(IEnumerable<TSource>)

Restituisce il valore minimo in una sequenza generica.

Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Restituisce il valore minimo in una sequenza generica.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Decimal minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Double minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int32 minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Int64 minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Decimal minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Double minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int32 minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Int64 minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore nullable Single minimo.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Richiama una funzione di trasformazione su ogni elemento di una sequenza e restituisce il valore Single minimo.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Richiama una funzione di trasformazione su ogni elemento di una generica sequenza e restituisce il valore minimo risultante.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Restituisce il valore minimo in una sequenza generica in base a una funzione del selettore di chiave specificata.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Restituisce il valore minimo in una sequenza generica in base a una funzione del selettore di chiave specificata.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Ordina in senso crescente gli elementi di una sequenza secondo una chiave.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Ordina in ordine crescente gli elementi di una sequenza utilizzando un operatore di confronto specificato.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Ordina in senso decrescente gli elementi di una sequenza secondo una chiave.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Ordina in senso decrescente gli elementi di una sequenza usando un operatore di confronto specificato.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Aggiunge un valore all'inizio della sequenza.

Reverse<TSource>(IEnumerable<TSource>)

Inverte l'ordine degli elementi in una sequenza.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Proietta ogni elemento di una sequenza in un nuovo form.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Proietta ogni elemento di una sequenza in un nuovo modulo incorporando l'indice dell'elemento.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T> e semplifica le sequenze risultanti in un’unica sequenza. L'indice di ogni elemento di origine viene usato nella maschera proiettata di tale elemento.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T>, semplifica le sequenze risultanti in un'unica sequenza e richiama una funzione del selettore di risultato su ogni elemento al suo interno.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Proietta ogni elemento di una sequenza a un oggetto IEnumerable<T>, semplifica le sequenze risultanti in un'unica sequenza e richiama una funzione del selettore di risultato su ogni elemento al suo interno. L'indice di ogni elemento di origine viene usato nella maschera intermedia proiettata di tale elemento.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Determina se due sequenze sono uguali confrontando gli elementi tramite l’uso dell'operatore di confronto uguaglianze predefinito per il loro tipo.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Determina se due sequenze sono uguali confrontando i loro elementi mediante l’uso di un oggetto IEqualityComparer<T> specificato.

Single<TSource>(IEnumerable<TSource>)

Restituisce l'unico elemento di una sequenza e genera un'eccezione se nella sequenza non è presente esattamente un elemento.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce l'unico elemento di una sequenza che soddisfa una condizione specificata e genera un'eccezione se esistono più elementi di tale tipo.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Restituisce il singolo elemento di una sequenza o un valore predefinito se la sequenza è vuota. Questo metodo genera un'eccezione se esiste più di un elemento nella sequenza.

SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)

Restituisce il singolo elemento di una sequenza o un valore predefinito se la sequenza è vuota. Questo metodo genera un'eccezione se esiste più di un elemento nella sequenza.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce l'unico elemento di una sequenza che soddisfa una condizione specificata o un valore predefinito se tale elemento esiste. Questo metodo genera un'eccezione se più di un elemento soddisfa la condizione.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Restituisce l'unico elemento di una sequenza che soddisfa una condizione specificata o un valore predefinito se tale elemento esiste. Questo metodo genera un'eccezione se più di un elemento soddisfa la condizione.

Skip<TSource>(IEnumerable<TSource>, Int32)

Ignora un numero specificato di elementi in una sequenza e quindi restituisce gli elementi rimanenti.

SkipLast<TSource>(IEnumerable<TSource>, Int32)

Restituisce una nuova raccolta enumerabile che contiene gli elementi di source con gli ultimi count elementi della raccolta di origine omessi.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Ignora gli elementi in sequenza finché la condizione specificata è soddisfatta e quindi restituisce gli elementi rimanenti.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Ignora gli elementi in sequenza finché la condizione specificata è soddisfatta e quindi restituisce gli elementi rimanenti. L'indice dell'elemento viene usato nella logica della funzione predicativa.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Calcola la somma della sequenza di valori Decimal ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Calcola la somma della sequenza di valori Double ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Calcola la somma della sequenza di valori Int32 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Calcola la somma della sequenza di valori Int64 ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Calcola la somma della sequenza di valori Decimal nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Calcola la somma della sequenza di valori Double nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Calcola la somma della sequenza di valori Int32 nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Calcola la somma della sequenza di valori Int64 nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Calcola la somma della sequenza di valori Single nullable, ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Calcola la somma della sequenza di valori Single ottenuti chiamando una funzione di trasformazione su ogni elemento della sequenza di input.

Take<TSource>(IEnumerable<TSource>, Int32)

Restituisce un numero specificato di elementi contigui dall'inizio di una sequenza.

Take<TSource>(IEnumerable<TSource>, Range)

Restituisce un intervallo specificato di elementi contigui da una sequenza.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Restituisce una nuova raccolta enumerabile che contiene gli ultimi count elementi di source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Restituisce elementi di una sequenza finché una condizione specificata è soddisfatta.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Restituisce elementi di una sequenza finché una condizione specificata è soddisfatta. L'indice dell'elemento viene usato nella logica della funzione predicativa.

ToArray<TSource>(IEnumerable<TSource>)

Crea una matrice da un oggetto IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crea un oggetto Dictionary<TKey,TValue> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un oggetto Dictionary<TKey,TValue> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata e un operatore di confronto principale.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crea un oggetto Dictionary<TKey,TValue> da un oggetto IEnumerable<T> secondo le funzioni specificate del selettore principale e del selettore di elementi.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crea un oggetto Dictionary<TKey,TValue> da un oggetto IEnumerable<T> secondo una funzione specificata del selettore principale, un operatore di confronto principale e una funzione del selettore di elementi.

ToHashSet<TSource>(IEnumerable<TSource>)

Crea un oggetto HashSet<T> da un oggetto IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Crea un oggetto HashSet<T> da un oggetto IEnumerable<T> usando comparer per confrontare le chiavi.

ToList<TSource>(IEnumerable<TSource>)

Crea un oggetto List<T> da un oggetto IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Crea un oggetto Lookup<TKey,TElement> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Crea un oggetto Lookup<TKey,TElement> da un oggetto IEnumerable<T> secondo una funzione del selettore principale specificata e un operatore di confronto principale.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Crea un oggetto Lookup<TKey,TElement> da un oggetto IEnumerable<T> secondo le funzioni specificate del selettore principale e del selettore di elementi.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Crea un oggetto Lookup<TKey,TElement> da un oggetto IEnumerable<T> secondo una funzione specificata del selettore principale, un operatore di confronto principale e una funzione del selettore di elementi.

TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)

Tenta di determinare il numero di elementi in una sequenza senza forzare un'enumerazione.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Produce l'unione insiemistica delle due sequenze utilizzando l'operatore di confronto uguaglianze predefinito.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Produce l'unione insiemistica di due sequenze utilizzando un oggetto IEqualityComparer<T> specificato.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)

Produce l'unione di set di due sequenze in base a una funzione del selettore di chiave specificata.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Produce l'unione di set di due sequenze in base a una funzione del selettore di chiave specificata.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtra una sequenza di valori in base a un predicato.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtra una sequenza di valori in base a un predicato. L'indice di ogni elemento viene usato nella logica della funzione predicato.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Produce una sequenza di tuple con gli elementi dalle due sequenze specificate.

Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

Produce una sequenza di tuple con elementi delle tre sequenze specificate.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Applica una funzione specificata agli elementi corrispondenti di due sequenze, producendo una sequenza dei risultati.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.

AsParallel<TSource>(IEnumerable<TSource>)

Consente la parallelizzazione di una query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Converte un generico oggetto IEnumerable<T> in un generico oggetto IQueryable<T>.

AsMemory(String)

Crea un nuovo oggetto ReadOnlyMemory<Char> sulla parte della stringa di destinazione.

AsMemory(String, Index)

Crea un nuovo oggetto ReadOnlyMemory<Char> sulla parte della stringa di destinazione a partire da un indice specificato.

AsMemory(String, Int32)

Crea un nuovo oggetto ReadOnlyMemory<Char> sulla parte della stringa di destinazione a partire da una posizione di carattere specificata.

AsMemory(String, Int32, Int32)

Crea un nuovo oggetto ReadOnlyMemory<Char> su una parte della stringa di destinazione a partire da una posizione specificata con una lunghezza.

AsMemory(String, Range)

Crea un nuovo oggetto ReadOnlyMemory<Char> su un intervallo specificato della stringa di destinazione.

AsSpan(String)

Crea un nuovo intervallo di sola lettura su una parte della stringa di destinazione da una posizione specificata per un numero di caratteri specificato.

AsSpan(String, Int32)

Crea un nuovo intervallo di sola lettura su una parte della stringa di destinazione da una posizione specificata fino alla fine della stringa.

AsSpan(String, Int32, Int32)

Crea un nuovo intervallo di sola lettura su una stringa.

IsNormalized(String)

Indica se la stringa specificata è nel formato di normalizzazione Unicode C.

IsNormalized(String, NormalizationForm)

Indica se la stringa è in un formato di normalizzazione Unicode specificato.

Normalize(String)

Normalizza una stringa in base a al formato di normalizzazione Unicode C.

Normalize(String, NormalizationForm)

Normalizza una stringa nel formato di normalizzazione Unicode.

Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.

Ancestors<T>(IEnumerable<T>, XName)

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.

DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.

Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.

Descendants<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.

Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.

Elements<T>(IEnumerable<T>, XName)

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.

InDocumentOrder<T>(IEnumerable<T>)

Restituisce una raccolta di nodi che contiene tutti i nodi nella raccolta di origine ordinati in base all'ordine con cui sono riportati nel documento.

Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.

Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.

Si applica a

Thread safety

Questo tipo è thread-safe.

Vedi anche