String String String String Class

Definizione

Rappresenta il testo come sequenza di unità di codice UTF-16.Represents text as a sequence of UTF-16 code units.

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

Commenti

Una stringa è una raccolta sequenziale di caratteri utilizzata per rappresentare il testo.A string is a sequential collection of characters that is used to represent text. Un String oggetto è una raccolta sequenziale System.Char di oggetti che rappresentano una stringa; System.Char un oggetto corrisponde a un'unità di codice UTF-16.A String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. Il valore dell' String oggetto è il contenuto della raccolta sequenziale di System.Char oggetti e tale valore non è modificabile (ovvero è di sola lettura).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). Per ulteriori informazioni sull'immutabilità delle stringhe, vedere la sezione immutabilità e la classe StringBuilder più avanti in questo argomento.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. La dimensione massima di un String oggetto in memoria è 2GB o circa 1 miliardo caratteri.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

Nota

Alcuni degli esempi in C# in questo articolo vengono eseguiti nello strumento di esecuzione e playground per codice inline Try.NET.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Quando è presente, selezionare il pulsante Esegui per eseguire un esempio in una finestra interattiva.When present, select the Run button to run an example in an interactive window. Dopo aver eseguito il codice, è possibile modificarlo ed eseguire il codice modificato selezionando di nuovo Esegui.Once you execute the code, you can modify it and run the modified code by selecting Run again. Il codice modificato viene eseguito nella finestra interattiva o, se la compilazione non riesce, la finestra interattiva visualizza tutti i messaggi di errore del compilatore C#.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

Contenuto della sezione:In this section:

Creazione di un'istanza di un oggetto String Instantiating a String object
Oggetti Char e caratteri Unicode Char objects and Unicode characters
Stringhe e standard Unicode Strings and The Unicode Standard
Stringhe e caratteri null incorporati Strings and embedded null characters
Stringhe e indici Strings and indexes
Stringhe null e stringhe vuote Null strings and empty strings
Immutabilità e classe StringBuilder Immutability and the StringBuilder class
Confronto ordinale e operazioni dipendenti dalle impostazioni cultura Ordinal vs. culture-sensitive operations
Normalizzazione Normalization
Operazioni di stringa per categoriaString operations by category

Creazione di un'istanza di un oggetto StringInstantiating a String object

È possibile creare un'istanza String di un oggetto nei modi seguenti:You can instantiate a String object in the following ways:

  • Assegnando un valore letterale stringa a String una variabile.By assigning a string literal to a String variable. Questo è il metodo usato più di frequente per la creazione di una stringa.This is the most commonly used method for creating a string. Nell'esempio seguente viene utilizzata l'assegnazione per creare più stringhe.The following example uses assignment to create several strings. Si noti che C#in, poiché la barra\rovesciata () è un carattere di escape, le barre rovesciate letterali in una stringa devono essere sottoposte a escape o l'intera stringa deve essere @-quoted.Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-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 String costruttore di classe.By calling a String class constructor. Nell'esempio seguente viene creata un'istanza delle stringhe chiamando diversi costruttori della classe.The following example instantiates strings by calling several class constructors. Si noti che alcuni costruttori includono puntatori a matrici di caratteri o matrici di byte firmate come parametri.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic non supporta le chiamate a questi costruttori.Visual Basic does not support calls to these constructors. Per informazioni dettagliate sui String costruttori, vedere il riepilogo String del costruttore.For detailed information about String constructors, see the String constructor summary.

    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      
    
  • Utilizzando l'operatore di concatenazione delle stringhe ( C# + in e & o + in Visual Basic) per creare una singola stringa da qualsiasi String combinazione di istanze e valori letterali stringa.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. Nell'esempio seguente viene illustrato l'utilizzo dell'operatore di concatenazione di stringhe.The following example illustrates the use of the string concatenation operator.

    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.By retrieving a property or calling a method that returns a string. Nell'esempio seguente vengono usati i metodi della String classe per estrarre una sottostringa da una stringa più grande.The following example uses the methods of the String class to extract a substring from a larger string.

    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.By calling a formatting method to convert a value or object to its string representation. Nell'esempio seguente viene usata la funzionalità di formattazione composita per incorporare la rappresentazione di stringa di due oggetti in una stringa.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

    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 UnicodeChar objects and Unicode characters

Ogni carattere in una stringa è definito da un valore scalare Unicode, detto anche punto di codice Unicode o dal valore ordinale (numerico) del carattere Unicode.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Ogni punto di codice viene codificato utilizzando la codifica UTF-16 e il valore numerico di ogni elemento della codifica è rappresentato da un Char oggetto.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

Nota

Si noti che, poiché String un'istanza è costituita da una raccolta sequenziale di unità di codice UTF-16, è String possibile creare un oggetto che non sia una stringa Unicode ben formata.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. Ad esempio, è possibile creare una stringa con un surrogato basso senza un surrogato alto corrispondente.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. Sebbene alcuni metodi, ad esempio i metodi di codifica e decodifica degli oggetti nello System.Text spazio dei nomi, possano eseguire controlli per assicurarsi che le stringhe siano in formato corretto, String i membri della classe non assicurano che una stringa sia ben formata.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

Un singolo Char oggetto rappresenta in genere un singolo punto Char di codice, ovvero il valore numerico di è uguale al punto di codice.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Ad esempio, il punto di codice per il carattere "a" è U + 0061.For example, the code point for the character "a" is U+0061. Tuttavia, un punto di codice potrebbe richiedere più di un elemento codificato (più di un Char oggetto).However, a code point might require more than one encoded element (more than one Char object). Lo standard Unicode definisce due tipi di caratteri che corrispondono a più Char oggetti: grafemi e i punti di codice supplementari Unicode che corrispondono ai caratteri nei piani supplementari Unicode.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • Un grafema è rappresentato da un carattere di base seguito da uno o più caratteri combinati.A grapheme is represented by a base character followed by one or more combining characters. Il carattere ä, ad esempio, è rappresentato da Char un oggetto il cui punto di codice è u + 0061 Char seguito da un oggetto il cui punto di codice è u + 0308.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. Questo carattere può anche essere definito da un singolo Char oggetto con un punto di codice di U + 00E4.This character can also be defined by a single Char object that has a code point of U+00E4. Come illustrato nell'esempio seguente, un confronto con distinzione delle impostazioni cultura per l'uguaglianza indica che queste due rappresentazioni sono uguali, sebbene non sia un normale confronto ordinale.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. Tuttavia, se le due stringhe vengono normalizzate, un confronto ordinale indica anche che sono uguali.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. Per ulteriori informazioni sulla normalizzazione delle stringhe, vedere la sezione relativa alla normalizzazione .(For more information on normalizing strings, see the Normalization section.)

    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, ovvero una coppia di surrogati, è Char rappresentato da un oggetto il cui punto di codice è un Char surrogato alto seguito da un oggetto il cui punto di codice è un surrogato basso.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. Le unità di codice dei surrogati alti sono comprese tra U + D800 e U + DBFF.The code units of high surrogates range from U+D800 to U+DBFF. Le unità di codice dei surrogati bassi sono comprese tra U + DC00 e U + DFFF.The code units of low surrogates range from U+DC00 to U+DFFF. Le coppie di surrogati vengono usate per rappresentare i caratteri nei 16 piani supplementari Unicode.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. Nell'esempio seguente viene creato un carattere surrogato e passato al Char.IsSurrogatePair(Char, Char) metodo per determinare se si tratta di una coppia di surrogati.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    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+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
    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 UnicodeStrings and the Unicode Standard

I caratteri in una stringa sono rappresentati da unità di codice con codifica UTF-16, che Char corrispondono ai valori.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

A ogni carattere in una stringa è associata una categoria di caratteri Unicode, rappresentata in .NET dall' UnicodeCategory enumerazione.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. La categoria di un carattere o di una coppia di surrogati può essere determinata CharUnicodeInfo.GetUnicodeCategory chiamando il metodo.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.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..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. Quando .NET Core è in esecuzione in Linux e macOS, le informazioni sulle categorie di caratteri vengono ottenute dalle librerie International componenti per Unicode.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

Nella tabella seguente sono elencate le versioni di .NET e le versioni dello standard Unicode su cui si basano le categorie di caratteri.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

Versione di .NET.NET version Versione dello standard UnicodeVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Standard Unicode, versione 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 Standard Unicode, versione 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Standard Unicode, versione 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Standard Unicode, versione 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 Standard Unicode, versione 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.51.NET Framework 4.51 Standard Unicode, versione 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.52.NET Framework 4.52 Standard Unicode, versione 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 Standard Unicode, versione 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.61.NET Framework 4.61 Standard Unicode, versione 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.2 e versioni successive.NET Framework 4.6.2 and later versions Standard Unicode, versione 8.0.0The Unicode Standard, Version 8.0.0
.NET Core (tutte le versioni).NET Core (all versions) Standard Unicode, versione 8.0.0The Unicode Standard, Version 8.0.0

.NET supporta inoltre il confronto e l'ordinamento delle stringhe in base allo standard Unicode.In addition, .NET supports string comparison and sorting based on the Unicode standard. Nelle versioni del .NET Framework tramite .NET Framework 4.NET Framework 4, il .NET Framework gestisce la propria tabella di dati stringa.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. Questo vale anche per le versioni del .NET Framework a partire da .NET Framework 4.5.NET Framework 4.5 in esecuzione in Windows 7.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. A partire da .NET Framework 4.5.NET Framework 4.5 in esecuzione nella finestra 8 e versioni successive del sistema operativo Windows, il runtime delega le operazioni di ordinamento e confronto delle stringhe al sistema operativo.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. In .NET Core le informazioni sul confronto e l'ordinamento delle stringhe sono fornite dai componenti internazionali per le librerie Unicode. Nella tabella seguente sono elencate le versioni di .NET e le versioni dello standard Unicode su cui si basa il confronto e l'ordinamento dei caratteri.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

Versione di .NET.NET version Versione dello standard UnicodeVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Standard Unicode, versione 4.0.0The Unicode Standard, Version 4.0.0
Il .NET Framework 2,0The .NET Framework 2.0 Standard Unicode, versione 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Standard Unicode, versione 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Standard Unicode, versione 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5e versioni successive in Windows 7and later on Windows 7 Standard Unicode, versione 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5e versioni successive nei sistemi operativi Windows 8 e versioni successiveand later on Windows 8 and later Windows operating systems Standard Unicode, versione 6.3.0The Unicode Standard, Version 6.3.0
.NET Core (tutte le versioni).NET Core (all versions) Dipende dalla versione dello standard Unicode supportato dal sistema operativo sottostante.Depends on the version of the Unicode Standard supported by the underlying operating system.

Stringhe e caratteri null incorporatiStrings and embedded null characters

In .NET un String oggetto può includere caratteri null incorporati, che vengono conteggiati come parte della lunghezza della stringa.In .NET, a String object can include embedded null characters, which count as a part of the string's length. Tuttavia, in alcuni linguaggi, ad esempio C C++e, un carattere null indica la fine di una stringa. non viene considerata parte della stringa e non viene conteggiata come parte della lunghezza della stringa.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. Ciò significa che le seguenti ipotesi comuni che c e C++ programmatori o librerie scritte in c o C++ che potrebbero creare informazioni sulle stringhe non sono necessariamente valide quando vengono String applicate agli oggetti:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • Il valore restituito dalle funzioni strlen o wcslen non è necessariamente uguale String.Lengtha.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • La stringa creata dalle strcpy_s funzioni o wcscpy_s non è necessariamente identica alla stringa creata dal String.Copy metodo.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

È necessario assicurarsi che il codice C C++ e il codice nativo String che crea un'istanza di oggetti e String il codice passato oggetti tramite Platform Invoke non presuppongano che un carattere null incorporato contrassegni la fine della stringa.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

I caratteri null incorporati in una stringa vengono trattati anche in modo diverso quando una stringa viene ordinata (o confrontata) e quando viene eseguita la ricerca di una stringa.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. I caratteri null vengono ignorati quando si eseguono confronti con distinzione delle impostazioni cultura tra due stringhe, inclusi i confronti che usano la lingua inglese.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Vengono considerati solo per i confronti ordinali o senza distinzione tra maiuscole e minuscole.They are considered only for ordinal or case-insensitive ordinal comparisons. D'altra parte, i caratteri null incorporati vengono sempre considerati durante la ricerca di una stringa con Containsmetodi StartsWithcome, IndexOfe.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Stringhe e indiciStrings and indexes

Un indice è la posizione di un Char oggetto (non un carattere Unicode) in un Stringoggetto.An index is the position of a Char object (not a Unicode character) in a String. Un indice è un numero in base zero e non negativo che inizia dalla prima posizione nella stringa, ovvero la posizione di indice zero.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. Un numero di metodi di ricerca, ad IndexOf esempio LastIndexOfe, restituisce l'indice di un carattere o di una sottostringa nell'istanza della stringa.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

La Chars[Int32] proprietà consente di accedere ai Char singoli oggetti in base alla posizione di indice nella stringa.The Chars[Int32] property lets you access individual Char objects by their index position in the string. Poiché la Chars[Int32] proprietà è la proprietà predefinita (in Visual Basic) o l'indicizzatore (in C#), è possibile accedere ai singoli Char oggetti in una stringa utilizzando codice come il seguente.Because the Chars[Int32] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. Questo codice cerca gli spazi vuoti o i caratteri di punteggiatura in una stringa per determinare il numero di parole contenute nella stringa.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

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 IEnumerable Char classe implementa l'interfaccia, è anche possibile scorrere gli oggetti in una stringa usando un foreach costrutto, come illustrato nell'esempio seguente. StringBecause the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

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 Char più di un oggetto.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. In particolare, una stringa può contenere unità di testo di più caratteri, formate da un carattere di base seguito da uno o più caratteri combinati o da coppie di surrogati.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Per lavorare con i caratteri Unicode anziché Char con gli oggetti, System.Globalization.StringInfo usare TextElementEnumerator le classi e.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. Nell'esempio seguente viene illustrata la differenza tra il codice che Char funziona con gli oggetti e il codice che funziona con i caratteri Unicode.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Confronta il numero di caratteri o gli elementi di testo in ogni parola di una frase.It compares the number of characters or text elements in each word of a sentence. La stringa include due sequenze di un carattere di base seguito da un carattere di combinazione.The string includes two sequences of a base character followed by a combining character.

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 StringInfo.GetTextElementEnumerator il metodo e TextElementEnumerator la classe per enumerare tutti gli elementi di testo in una stringa.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. È anche possibile recuperare una matrice che contiene l'indice iniziale di ogni elemento di testo chiamando il StringInfo.ParseCombiningCharacters metodo.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Per ulteriori informazioni sull'utilizzo delle unità di testo anziché dei singoli Char valori, vedere la StringInfo classe.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Stringhe null e stringhe vuoteNull strings and empty strings

Una stringa che è stata dichiarata ma a cui non è stato nullassegnato un valore è.A string that has been declared but has not been assigned a value is null. Il tentativo di chiamare metodi su tale stringa genera un' NullReferenceExceptioneccezione.Attempting to call methods on that string throws a NullReferenceException. Una stringa null è diversa da una stringa vuota, ovvero una stringa il cui valore è "" o String.Empty.A null string is different from an empty string, which is a string whose value is "" or 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.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Se ad esempio si passa una stringa null al Int32.Parse metodo, viene ArgumentNullExceptiongenerata un'eccezione e il passaggio di una FormatExceptionstringa vuota genera un'eccezione.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. In altri casi, un argomento del metodo può essere una stringa null o una stringa vuota.In other cases, a method argument can be either a null string or an empty string. Se, ad esempio, si fornisce un' IFormattable implementazione per una classe, è necessario equiparare sia una stringa null sia una stringa vuota con l'identificatore di formato generale ("G").For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

La String classe include i due metodi pratici seguenti che consentono di verificare se una stringa è null o vuota:The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, che indica se una stringa è null o è uguale a. String.EmptyIsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Questo metodo elimina la necessità di usare codice come il seguente:This method eliminates the need to use code such as the following:

    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, è String.Emptyuguale a o è costituita esclusivamente da spazi vuoti.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Questo metodo elimina la necessità di usare codice come il seguente:This method eliminates the need to use code such as the following:

    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 usato IsNullOrEmpty il metodo IFormattable.ToString nell'implementazione di una classe Temperature personalizzata.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. Il metodo supporta le stringhe di formato "G", "C", "F" e "K".The method supports the "G", "C", "F", and "K" format strings. Se una stringa di formato vuota o una stringa di formato il null cui valore viene passato al metodo, il relativo valore viene modificato nella stringa di formato "G".If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

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 StringBuilderImmutability and the StringBuilder class

Un String oggetto viene chiamato non modificabile (sola lettura), perché il relativo valore non può essere modificato dopo la creazione.A String object is called immutable (read-only), because its value cannot be modified after it has been created. I metodi che sembrano modificare un String oggetto restituiscono effettivamente un String nuovo oggetto che contiene la modifica.Methods that appear to modify a String object actually return a new String object that contains the modification.

Poiché le stringhe non sono modificabili, le routine di manipolazione di stringhe che eseguono aggiunte o eliminazioni ripetute in una singola stringa possono comportare una riduzione significativa delle prestazioni.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. Il codice seguente, ad esempio, usa un generatore di numeri casuali per creare una stringa con 1000 caratteri nell'intervallo compreso tra 0x0001 e 0x052F.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Sebbene il codice sembri usare la concatenazione di stringhe per aggiungere un nuovo carattere alla stringa stresistente denominata, crea effettivamente un String nuovo oggetto per ogni operazione di concatenazione.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

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 += Convert.ToChar(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 utilizzare la StringBuilder classe anziché la String classe per le operazioni che apportano più modifiche al valore di una stringa.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. A differenza delle istanze della String classe, StringBuilder gli oggetti sono modificabili; quando si concatenano, accodano o eliminano sottostringhe da una stringa, le operazioni vengono eseguite su una singola stringa.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. Al termine della modifica del valore di un StringBuilder oggetto, è possibile chiamare il relativo StringBuilder.ToString metodo per convertirlo in una stringa.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. Nell'esempio seguente viene sostituito String il valore usato nell'esempio precedente per concatenare i caratteri casuali 1000 nell'intervallo a 0x0001 a StringBuilder 0x052F con un oggetto.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

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(Convert.ToChar(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

Confronto ordinale e operazioni dipendenti dalle impostazioni culturaOrdinal vs. culture-sensitive operations

I membri della String classe eseguono operazioni ordinali o con distinzione delle impostazioni cultura (linguistiche String ) su un oggetto.Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Un'operazione ordinale agisce sul valore numerico di ogni Char oggetto.An ordinal operation acts on the numeric value of each Char object. Un'operazione con distinzione delle impostazioni cultura agisce sul valore dell' String oggetto e prende in considerazione le regole di combinazione di maiuscole e minuscole specifiche delle impostazioni cultura, l'ordinamento, la formattazione e l'analisi.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. Le operazioni dipendenti dalle impostazioni cultura vengono eseguite nel contesto di una lingua dichiarata in modo esplicito o delle impostazioni cultura correnti implicite.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. I due tipi di operazioni possono produrre risultati molto diversi quando vengono eseguiti sulla stessa stringa.The two kinds of operations can produce very different results when they are performed on the same string.

.NET supporta anche le operazioni di stringa linguistica indipendenti dalle impostazioni cultura utilizzando le impostazioni culturaCultureInfo.InvariantCultureinvarianti (), che sono vagamente basate sulle impostazioni cultura della lingua inglese indipendentemente dall'area..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. A differenza di System.Globalization.CultureInfo altre impostazioni, le impostazioni della lingua inglese sono sempre coerenti in un singolo computer, da sistema a sistema e in tutte le versioni di .NET.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. La lingua inglese può essere considerata come un tipo di black box che garantisce la stabilità dei confronti tra stringhe e l'ordinamento in tutte le impostazioni cultura.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Importante

Se l'applicazione prende una decisione di sicurezza relativa a un identificatore simbolico, ad esempio un nome di file o un named pipe o informazioni sui dati salvati in modo permanente, ad esempio i dati basati su testo in un file XML, l'operazione deve usare un confronto ordinale anziché un confronto con distinzione delle impostazioni cultura.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. Questo perché un confronto con distinzione delle impostazioni cultura può produrre risultati diversi a seconda delle impostazioni cultura attive, mentre un confronto ordinale dipende esclusivamente dal valore binario dei caratteri confrontati.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

Importante

La maggior parte dei metodi che eseguono operazioni di stringa includono un overload con un StringComparisonparametro di tipo, che consente di specificare se il metodo esegue un'operazione ordinale o con distinzione delle impostazioni cultura.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. In generale, è consigliabile chiamare questo overload per rendere chiaro lo scopo della chiamata al metodo.In general, you should call this overload to make the intent of your method call clear. Per procedure consigliate e istruzioni per l'uso di operazioni ordinali e dipendenti dalle impostazioni cultura sulle stringhe, vedere procedure consigliate per l'uso di stringhe.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

Le operazioni per la combinazione di maiuscolee minuscole, l' analisi e la formattazione, il confronto e l'ordinamentoe il test di uguaglianza possono essere ordinali o dipendenti dalle impostazioni cultura.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. Le sezioni seguenti illustrano ogni categoria di operazioni.The following sections discuss each category of operation.

Suggerimento

È sempre necessario chiamare un overload del metodo che rende chiaro lo scopo della chiamata al metodo.You should always call a method overload that makes the intent of your method call clear. Compare(String, String) Anziché chiamare il metodo per eseguire un confronto con distinzione delle impostazioni cultura di due stringhe usando le convenzioni delle impostazioni cultura correnti, ad esempio, è necessario chiamare Compare(String, String, StringComparison) il StringComparison.CurrentCulture metodo con comparisonType un valore per argomento.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. Per altre informazioni, vedere Best Practices for Using Strings (Procedure consigliate per l'uso di stringhe).For more information, see Best Practices for Using Strings.

È possibile scaricare le tabelle di ordinamento spessore, un set di file di testo che contengono informazioni sugli spessori dei caratteri usati nelle operazioni di ordinamento e confronto per i sistemi operativi Windows, e la tabella degli elementi delle regole di confronto Unicode predefinite, la tabella di ordinamento spessore per Linux e MacOS.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

Maiuscole e minuscoleCasing

Le regole di combinazione di maiuscole e minuscole determinano come modificare le maiuscole di un carattere Unicode; ad esempio, da minuscolo a maiuscolo.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Un'operazione di combinazione di maiuscole e minuscole viene eseguita prima di un confronto tra stringhe.Often, a casing operation is performed before a string comparison. Ad esempio, una stringa può essere convertita in lettere maiuscole in modo che possa essere confrontata con un'altra stringa maiuscola.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. È possibile convertire i caratteri di una stringa in lettere minuscole chiamando ToLower il ToLowerInvariant metodo o ed è possibile convertirli in maiuscolo chiamando il ToUpper metodo o ToUpperInvariant .You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. Inoltre, è possibile usare il TextInfo.ToTitleCase metodo per convertire una stringa in maiuscole/minuscole.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Nota

.NET core in esecuzione solo in sistemi Linux e macOS: Il comportamento delle regole di confronto per le impostazioni cultura C e Posix prevede sempre la distinzione maiuscole/minuscole perché queste impostazioni cultura non usano l'ordine delle regole di confronto Unicode previsto..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. È 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.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Le operazioni di combinazione di maiuscole e minuscole possono essere basate sulle regole delle impostazioni cultura correnti, sulle impostazioni cultura specificate o sulle impostazioni cultura invarianti.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. Poiché i mapping tra maiuscole e minuscole possono variare a seconda delle impostazioni cultura utilizzate, il risultato delle operazioni di combinazione può variare in base alle impostazioni cultura.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. Le differenze effettive nella combinazione di maiuscole e minuscole sono tre tipi:The actual differences in casing are of three kinds:

  • Differenze nella combinazione di maiuscole e minuscole di LATIN CAPITAL LETTER I (U + 0049), LATIN SMALL LETTER I (U + 0069), LATIN CAPITAL lettera I con punto precedente (U + 0130) e LATIN SMALL LETTER DOTLESS I (U + 0131).Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). Nelle impostazioni cultura di TR-TR (turco (Turchia)) e AZ-Latn-AZ (Azerbaijan, Latin) e nelle impostazioni cultura neutre TR, AZ e AZ-Latn, l'equivalente minuscolo di LATIN CAPITAL LETTER I è latino SMALL LETTER DOTLESS I e l'equivalente maiuscolo di LATIN SMALL LETTER I is LETTERA MAIUSCOLA CON IL PUNTO SOPRA.In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. In tutte le altre impostazioni cultura, incluse la lingua inglese, la minuscola latina I e i caratteri maiuscoli sono equivalenti.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    Nell'esempio seguente viene illustrato come un confronto di stringhe progettato per impedire l'accesso file system possa avere esito negativo se si basa su un confronto tra maiuscole e minuscole.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. Sono state usate le convenzioni di combinazione delle maiuscole e minuscole delle impostazioni cultura invarianti.(The casing conventions of the invariant culture should have been used.)

    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.Differences in case mappings between the invariant culture and all other cultures. In questi casi, l'utilizzo delle regole di maiuscole e minuscole delle impostazioni cultura invarianti per modificare un carattere in maiuscolo o minuscolo restituisce lo stesso carattere.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Per tutte le altre impostazioni cultura, viene restituito un carattere diverso.For all other cultures, it returns a different character. Nella tabella seguente sono elencati alcuni dei caratteri interessati.Some of the affected characters are listed in the following table.

    CarattereCharacter Se modificato inIf changed to Valore restituitoReturns
    SEGNO MICRON (U + 00B5)MICRON SIGN (U+00B5) MaiuscoleUppercase LETTERA MAIUSCOLA GRECA MU (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    LETTERA LATINA MAIUSCOLA CON PUNTO SOPRA (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) MinuscoleLowercase MINUSCOLO (ALFABETO LATINO) I (U + 0069)LATIN SMALL LETTER I (U+0069)
    LATIN SMALL LETTER DOTLESS I (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) MaiuscoleUppercase LETTERA LATINA MAIUSCOLA (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    CARATTERI MINUSCOLI LATINI S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) MaiuscoleUppercase LATIN CAPITAL LETTER S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    LETTERA MAIUSCOLA LATINA D CON LETTERA MINUSCOLA Z CON CARON (U + 01C5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) MinuscoleLowercase LETTERA LATINA PICCOLA DZ CON CARON (U + 01C6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    COMBINAZIONE DI YPOGEGRAMMENI GRECI (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) MaiuscoleUppercase LETTERA MAIUSCOLA GRECA IOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • Differenze nei mapping tra maiuscole e minuscole di coppie di due lettere maiuscole/minuscole nell'intervallo di caratteri ASCII.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. Nella maggior parte delle impostazioni cultura, una coppia di due lettere maiuscole/minuscole è uguale alla coppia di due lettere maiuscole o minuscole equivalente.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. Questa situazione non è valida per le coppie di due lettere seguenti nelle impostazioni cultura seguenti, perché in ogni caso vengono confrontate con un digramma:This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • "lJ" e "nJ" nelle impostazioni cultura HR-HR (croato (Croazia))."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" nelle impostazioni cultura CS-CZ (Repubblica Ceca) e SK-SK (slovacca)."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" nelle impostazioni cultura da-DK (danese (Danimarca))."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" e "zS" nelle impostazioni cultura di hu-HU (Ungheria)."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" e "lL" nelle impostazioni cultura es-ES_tradnl (Spagnolo (Spagna, ordinamento tradizionale))."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU", "tH" e "tR" nelle impostazioni cultura vi-VN (Vietnam)."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    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.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

Nell'esempio seguente vengono illustrate alcune delle differenze tra le regole di maiuscole e minuscole tra le impostazioni cultura durante la conversione di stringhe in maiuscolo.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

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 formattazioneParsing and formatting

La formattazione e l'analisi sono operazioni inverse.Formatting and parsing are inverse operations. 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 come data e ora.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. Le regole di formattazione e analisi dipendono da convenzioni culturali.Both formatting and parsing rules are dependent on cultural conventions. Nell'esempio seguente viene illustrata l'ambiguità che può verificarsi quando si interpreta una stringa di data specifica delle impostazioni cultura.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. Senza conoscere le convenzioni delle impostazioni cultura utilizzate per produrre una stringa di data, non è possibile sapere se 03/01/2011, 3/1/2011 e 01/03/2011 rappresentano il 3 gennaio 2011 o il 1 ° marzo 2011.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 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 in base alle impostazioni cultura di cui vengono usate le convenzioni nell'operazione di analisi.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

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 tra stringhe e ordinamentoString comparison and sorting

Le convenzioni per il confronto e l'ordinamento delle stringhe variano in base alle impostazioni cultura.Conventions for comparing and sorting strings vary from culture to culture. Il tipo di ordinamento, ad esempio, può essere basato su fonetica o sulla rappresentazione visiva dei caratteri.For example, the sort order may be based on phonetics or on the visual representation of characters. Nelle lingue asiatiche orientali, i caratteri vengono ordinati in base al tratto e al radicale degli ideogrammi.In East Asian languages, characters are sorted by the stroke and radical of ideographs. L'ordinamento dipende anche dalle lingue degli ordini e dalle impostazioni cultura usate per l'alfabeto.Sorting also depends on the order languages and cultures use for the alphabet. Ad esempio, il linguaggio danese ha un carattere "Æ" che ordina dopo "Z" nell'alfabeto.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. Inoltre, i confronti possono fare distinzione tra maiuscole e minuscole o senza distinzione tra maiuscole e minuscole e, in alcuni casi, le regole di maiuscole e minuscoleIn addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. 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.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Le regole di ordinamento determinano l'ordine alfabetico dei caratteri Unicode e il modo in cui due stringhe vengono confrontate tra loro.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Il String.Compare(String, String, StringComparison) metodo, ad esempio, confronta due stringhe in base al StringComparison parametro.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Se il valore del parametro StringComparison.CurrentCultureè, il metodo esegue un confronto linguistico che utilizza le convenzioni delle impostazioni cultura correnti; se il StringComparison.Ordinalvalore del parametro è, il metodo esegue un confronto ordinale.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. Di conseguenza, come illustrato nell'esempio seguente, se le impostazioni cultura correnti sono U.S. In inglese la prima chiamata al String.Compare(String, String, StringComparison) 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 "a".Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "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 di Word, stringa e ordinali:.NET supports word, string, and ordinal sort rules:

  • Un ordinamento di Word esegue un confronto con distinzione delle impostazioni cultura delle stringhe in cui alcuni caratteri Unicode non alfanumerici possono avere pesi speciali assegnati.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Ad esempio, il trattino (-) potrebbe avere un peso molto ridotto, in modo che "Coop" e "co-op" siano visualizzati uno accanto all'altro in un elenco ordinato.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Per un elenco dei String metodi che confrontano due stringhe utilizzando le regole di ordinamento di Word, vedere la sezione operazioni sulle stringhe per categoria .For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Un ordinamento delle stringhe esegue anche un confronto con distinzione delle impostazioni cultura.A string sort also performs a culture-sensitive comparison. È simile a un ordinamento di parole, tranne per il fatto che non esistono casi particolari e che tutti i simboli non alfanumerici precedono tutti i caratteri alfanumerici Unicode.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. È possibile confrontare due stringhe utilizzando le regole di ordinamento delle stringhe CompareInfo.Compare chiamando gli overload del metodo che options dispongono di un parametro a cui CompareOptions.StringSortè stato fornito il valore.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. Si noti che questo è l'unico metodo fornito da .NET per confrontare due stringhe utilizzando le regole di ordinamento delle stringhe.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Un ordinamento ordinale confronta le stringhe in base al valore numerico di Char ogni oggetto della stringa.An ordinal sort compares strings based on the numeric value of each Char object in the string. Un confronto ordinale fa distinzione tra maiuscole e minuscole perché le versioni minuscole e maiuscole di un carattere hanno punti di codice diversi.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. Tuttavia, se la distinzione tra maiuscole e minuscole non è importante, è possibile specificare un confronto ordinale che ignori case.However, if case is not important, you can specify an ordinal comparison that ignores case. Equivale a convertire la stringa in maiuscolo usando la lingua inglese e quindi a eseguire un confronto ordinale sul risultato.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Per un elenco dei String metodi che confrontano due stringhe utilizzando le regole di ordinamento ordinali, vedere la sezione operazioni sulle stringhe per categoria .For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Un confronto con distinzione delle impostazioni cultura è un confronto che usa CultureInfo CultureInfo.InvariantCulture in modo esplicito o implicito un oggetto, incluse le impostazioni cultura invarianti specificate dalla proprietà.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. Le impostazioni cultura implicite sono le impostazioni cultura correnti, specificate dalle Thread.CurrentCulture proprietà CultureInfo.CurrentCulture e.The implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Il tipo di ordinamento dei caratteri alfabetici, ovvero i caratteri per i quali la Char.IsLetter proprietà restituisce true, rappresenta una variazione notevole tra le impostazioni cultura.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. È possibile specificare un confronto con distinzione delle impostazioni cultura che usa le convenzioni di impostazioni cultura specifiche fornendo CultureInfo un oggetto a un metodo di confronto Compare(String, String, CultureInfo, CompareOptions)tra stringhe, ad esempio.You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). È possibile specificare un confronto StringComparison.CurrentCulturecon distinzione delle impostazioni cultura che utilizza le convenzioni delle impostazioni cultura correnti fornendo, StringComparison.CurrentCultureIgnoreCase CompareOptions o qualsiasi membro CompareOptions.Ordinal dell'enumerazione diverso da o CompareOptions.OrdinalIgnoreCase a un oggetto appropriato. Overload del Compare metodo.You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. Un confronto con distinzione delle impostazioni cultura è in genere appropriato per l'ordinamento, mentre un confronto ordinale non lo è.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. 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 è.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

Nell'esempio seguente viene illustrata la differenza tra il confronto tra dipendenti dalle impostazioni cultura e il confronto ordinale.The following example illustrates the difference between culture-sensitive and ordinal comparison. Nell'esempio vengono valutate tre stringhe, "Apple", "Æble" e "AEble", utilizzando il confronto ordinale e le convenzioni delle impostazioni cultura da-DK e en-US, ognuna delle quali è la lingua predefinita al Compare momento della chiamata del metodo.The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). Poiché il linguaggio danese considera il carattere "Æ" come una singola lettera e lo ordina dopo "Z" nell'alfabeto, la stringa "Æble" è maggiore di "Apple".Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". Tuttavia, "Æble" non è considerato equivalente a "AEble", quindi "Æble" è anche maggiore di "AEble".However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". Le impostazioni cultura en-US non includono la lettera "Æ", ma la considera come equivalente a "AE", che spiega perché "Æble" è minore di "Apple" ma è uguale a "AEble".The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". Il confronto ordinale, d'altra parte, considera "Apple" come minore di "Æble" e "Æble" è maggiore di "AEble".Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "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 appropriato per l'ordinamento o il confronto di stringhe:Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • Se si desidera che le stringhe siano ordinate in base alle impostazioni cultura dell'utente, è necessario ordinarle in base alle convenzioni delle impostazioni cultura correnti.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. Se le impostazioni cultura dell'utente cambiano, l'ordine delle stringhe ordinate cambierà di conseguenza.If the user's culture changes, the order of sorted strings will also change accordingly. Un'applicazione del thesaurus, ad esempio, deve sempre ordinare le parole in base alle impostazioni cultura dell'utente.For example, a thesaurus application should always sort words based on the user's culture.

  • Se si desidera che le stringhe siano ordinate in base alle convenzioni di impostazioni cultura specifiche, è necessario ordinarle fornendo un CultureInfo oggetto che rappresenta le impostazioni cultura a un metodo di confronto.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. Ad esempio, in un'applicazione progettata per insegnare agli studenti una determinata lingua, si desidera che le stringhe siano ordinate in base alle convenzioni di una delle impostazioni cultura che parlano tale lingua.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • Se si vuole che l'ordine delle stringhe rimanga invariato tra le diverse impostazioni cultura, è necessario ordinarle in base alle convenzioni della lingua inglese o usare un confronto ordinale.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. È ad esempio possibile utilizzare un ordinamento ordinale per organizzare i nomi di file, processi, mutex o named pipe.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • Per un confronto che prevede una decisione sulla sicurezza, ad esempio se un nome utente è valido, è sempre necessario eseguire un test ordinale per verificarne l'uguaglianza chiamando Equals un overload del metodo.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

Nota

Le regole di ordinamento e di maiuscole e minuscole dipendenti dalle impostazioni cultura utilizzate nel confronto tra stringhe dipendono dalla versione di .NET.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. In .NET Framework 4,5 e versioni successive in esecuzione nel Windows 8Windows 8 sistema operativo, le informazioni relative a ordinamento, maiuscole e minuscole e caratteri Unicode sono conformi allo standard Unicode 6,0.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. In altri sistemi operativi Windows è conforme allo standard Unicode 5,0.On other Windows operating systems, it conforms to the Unicode 5.0 standard. In .NET Core dipende dalla versione dello standard Unicode supportata dal sistema operativo sottostante.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Per ulteriori informazioni sulle regole di ordinamento di Word, stringa e ordinale, System.Globalization.CompareOptions vedere l'argomento.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Per consigli aggiuntivi su quando usare ogni regola, vedere procedure consigliate per l'uso delle stringhe.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

In genere, non si chiamano metodi di confronto tra stringhe Compare come direttamente per determinare l'ordinamento delle stringhe.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. Al contrario, i metodi di confronto vengono chiamati dai metodi di Array.Sort ordinamento List<T>.Sort, ad esempio o.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. Nell'esempio seguente vengono eseguite quattro operazioni di ordinamento diverse (ordinamento di Word utilizzando le impostazioni cultura correnti, ordinamento di Word utilizzando le impostazioni cultura invarianti, ordinamento ordinale e ordinamento stringa utilizzando le impostazioni cultura invarianti) senza chiamare esplicitamente un metodo di confronto tra stringhe, Sebbene specifichino il tipo di confronto da utilizzare.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. Si noti che ogni tipo di ordinamento produce un ordinamento univoco delle stringhe nella matrice.Note that each type of sort produces a unique ordering of strings in its array.

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 le chiavi di ordinamento per supportare il confronto di stringhe con distinzione culturale.Internally, .NET uses sort keys to support culturally sensitive string comparison. A ogni carattere di una stringa vengono assegnate diverse categorie di pesi di ordinamento, inclusi alfabetici, maiuscole e minuscole.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. Una chiave di ordinamento, rappresentata SortKey dalla classe, fornisce un repository di questi pesi per una determinata stringa.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. Se l'app esegue un numero elevato di operazioni di ricerca o di ordinamento sullo stesso set di stringhe, è possibile migliorarne le prestazioni generando e archiviando le chiavi di ordinamento per tutte le stringhe utilizzate.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. Quando è necessaria un'operazione di ordinamento o di confronto, utilizzare le chiavi di ordinamento anziché le stringhe.When a sort or comparison operation is required, you use the sort keys instead of the strings. Per altre informazioni, vedere la classe SortKey.For more information, see the SortKey class.

Se non si specifica una convenzione di confronto tra stringhe, i metodi di Array.Sort(Array) ordinamento, ad esempio, eseguono un ordinamento dipendente dalle impostazioni cultura e con distinzione tra maiuscole e minuscole nelle stringhe.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. Nell'esempio seguente viene illustrato come la modifica delle impostazioni cultura correnti influisca sull'ordine delle stringhe ordinate in una matrice.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Viene creata una matrice di tre stringhe.It creates an array of three strings. Innanzitutto, imposta la System.Threading.Thread.CurrentThread.CurrentCulture proprietà su en-US e chiama il Array.Sort(Array) metodo.First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. Il tipo di ordinamento risultante è basato sulle convenzioni di ordinamento per le impostazioni cultura inglesi (Stati Uniti).The resulting sort order is based on sorting conventions for the English (United States) culture. L'esempio imposta quindi la System.Threading.Thread.CurrentThread.CurrentCulture proprietà su da-DK e chiama di nuovo il Array.Sort metodo.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. Si noti che l'ordinamento risultante è diverso dai risultati en-US perché usa le convenzioni di ordinamento per Danish (Danimarca).Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

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 di stringhe è determinare se sono uguali, è necessario chiamare il String.Equals metodo.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. In genere, è consigliabile Equals utilizzare per eseguire un confronto ordinale.Typically, you should use Equals to perform an ordinal comparison. Il String.Compare metodo è destinato principalmente a ordinare le stringhe.The String.Compare method is intended primarily to sort strings.

I metodi di ricerca di String.StartsWith stringhe, ad esempio e String.IndexOf, possono anche eseguire confronti tra stringhe dipendenti dalle impostazioni cultura o ordinali.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. Nell'esempio seguente vengono illustrate le differenze tra il confronto ordinale e quello con distinzione IndexOf delle impostazioni cultura utilizzando il metodo.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. Una ricerca dipendente dalle impostazioni cultura in cui le impostazioni cultura correnti sono in inglese (Stati Uniti) considera la sottostringa "OE" in modo che corrisponda alla legatura "œ".A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Poiché un segno meno flessibile (U + 00AD) è un carattere di larghezza zero, la ricerca considera il trattino morbido come Empty equivalente a e trova una corrispondenza all'inizio della stringa.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. Una ricerca ordinale, d'altra parte, non trova una corrispondenza in entrambi i casi.An ordinal search, on the other hand, does not find a match in either case.

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

Ricerca di stringheSearching Strings

I metodi di ricerca di stringhe String.StartsWith , String.IndexOfad esempio e, possono anche eseguire confronti di stringhe dipendenti dalle impostazioni cultura o ordinali per determinare se un carattere o una sottostringa è presente in una stringa specificata.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

I metodi di ricerca nella String classe che cercano un singolo carattere, ad esempio il IndexOf metodo, o uno di un set di caratteri, ad esempio il IndexOfAny metodo, eseguono una ricerca ordinale.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. Per eseguire una ricerca dipendente dalle impostazioni cultura per un carattere, è necessario chiamare CompareInfo un metodo CompareInfo.IndexOf(String, Char) come o CompareInfo.LastIndexOf(String, Char).To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). Si noti che i risultati della ricerca di un carattere con il confronto ordinale e con distinzione delle impostazioni cultura possono essere molto diversi.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Ad esempio, una ricerca di un carattere Unicode precomposto come la legatura "Æ" (U + 00C6) potrebbe corrispondere a qualsiasi occorrenza dei componenti nella sequenza corretta, ad esempio "AE" (U + 041U + 0045), a seconda delle impostazioni cultura.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. Nell'esempio seguente viene illustrata la differenza tra String.IndexOf(Char) i CompareInfo.IndexOf(String, Char) metodi e durante la ricerca di un singolo carattere.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. 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.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

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, String i metodi di classe che cercano una stringa anziché 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 tipo. StringComparisonOn the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. L'unica eccezione è Contains, che esegue una ricerca ordinale.The sole exception is Contains, which performs an ordinal search.

Verifica dell'uguaglianzaTesting for equality

Utilizzare il String.Compare metodo per determinare la relazione tra due stringhe nell'ordinamento.Use the String.Compare method to determine the relationship of two strings in the sort order. Si tratta in genere di un'operazione con distinzione delle impostazioni cultura.Typically, this is a culture-sensitive operation. Al contrario, chiamare il String.Equals metodo per verificare l'uguaglianza.In contrast, call the String.Equals method to test for equality. Poiché il test di uguaglianza in genere confronta l'input dell'utente con una stringa nota, ad esempio un nome utente valido, una password o un percorso di file system, si tratta in genere di un'operazione ordinale.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

Avviso

È possibile verificare l'uguaglianza chiamando il String.Compare metodo e determinando se il valore restituito è zero.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. Tuttavia, questa pratica non è consigliata.However, this practice is not recommended. Per determinare se due stringhe sono uguali, è necessario chiamare uno degli overload del String.Equals metodo.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. L'overload preferito da chiamare è il metodo dell' Equals(String, StringComparison) istanza o il metodo Equals(String, String, StringComparison) statico, perché entrambi i metodi includono System.StringComparison un parametro che specifica in modo esplicito il tipo di confronto.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

Nell'esempio seguente viene illustrato il rischio di eseguire un confronto con distinzione delle impostazioni cultura per verificarne l'uguaglianza quando invece è necessario usare un numero ordinale.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. 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 all'inizio di un URL con la stringa "FILE://".In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". Tuttavia, se un confronto con distinzione delle impostazioni cultura viene eseguito utilizzando le impostazioni cultura turche (Turchia) in 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".However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". Di conseguenza, file system accesso è inavvertitamente consentito.As a result, file system access is inadvertently permitted. D'altra parte, se viene eseguito un confronto ordinale, il confronto per l'uguaglianza ha esito positivo e l'accesso file system viene negato.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

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.

NormalizationNormalization

Alcuni caratteri Unicode hanno più rappresentazioni.Some Unicode characters have multiple representations. Ad esempio, uno dei seguenti punti di codice può rappresentare la lettera "ắ":For example, any of the following code points can represent the letter "ắ":

  • U + 1EAFU+1EAF

  • U+0103 U+0301U+0103 U+0301

  • U+0061 U+0306 U+0301U+0061 U+0306 U+0301

Più rappresentazioni per un singolo carattere complicano la ricerca, l'ordinamento, la corrispondenza e altre operazioni di stringa.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

Lo standard Unicode definisce un processo denominato normalizzazione che restituisce una rappresentazione binaria di un carattere Unicode per qualsiasi rappresentazione binaria equivalente.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. La normalizzazione può usare diversi algoritmi, detti forme di normalizzazione, che seguono regole diverse.Normalization can use several algorithms, called normalization forms, that follow different rules. .NET supporta i formati di normalizzazione Unicode C, D, KC e KD..NET supports Unicode normalization forms C, D, KC, and KD. Quando le stringhe sono state normalizzate nello stesso formato di normalizzazione, possono essere confrontate tramite il confronto ordinale.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Un confronto ordinale è un confronto binario del valore scalare Unicode dei Char corrispondenti oggetti in ogni stringa.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. La String classe include un numero di metodi che possono eseguire un confronto ordinale, inclusi i seguenti:The String class includes a number of methods that can perform an ordinal comparison, including the following:

È possibile determinare se una stringa viene normalizzata nel formato di normalizzazione C chiamando String.IsNormalized() il metodo oppure è possibile chiamare il String.IsNormalized(NormalizationForm) metodo per determinare se una stringa viene normalizzata in base a un formato di normalizzazione specificato.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. È anche possibile chiamare il String.Normalize() metodo per convertire una stringa nel formato di normalizzazione C oppure è possibile chiamare String.Normalize(NormalizationForm) il metodo per convertire una stringa in un formato di normalizzazione specificato.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. Per informazioni dettagliate sulla normalizzazione e il confronto di stringhe, vedere i Normalize() metodi e. Normalize(NormalizationForm)For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

Nel semplice esempio seguente viene illustrata la normalizzazione delle stringhe.The following simple example illustrates string normalization. Definisce la lettera "ố" in tre modi diversi in tre stringhe diverse e usa un confronto ordinale per verificare l'uguaglianza per determinare che ogni stringa è diversa dalle altre due stringhe.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. Converte quindi ogni stringa nei form di normalizzazione supportati e di nuovo esegue un confronto ordinale di ogni stringa in un formato di normalizzazione specificato.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. In ogni caso, il secondo test per verificarne l'uguaglianza indica che le stringhe sono uguali.In each case, the second test for equality shows that the strings are equal.

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 += String.Format("{0} ", Convert.ToUInt16(ch).ToString("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 ulteriori informazioni sui form di normalizzazione e normalizzazione, vedere System.Text.NormalizationForm, nonché l'allegato standard Unicode #15: Moduli di normalizzazione Unicode e domande frequenti sulla normalizzazione nel sito Web Unicode.org.For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Operazioni di stringa per categoriaString operations by category

La String classe fornisce i membri per confrontare le stringhe, testare le stringhe per verificarne l'uguaglianza, trovare caratteri o sottostringhe in una stringa, modificare una stringa, estrarre sottostringhe da una stringa, combinare stringhe, formattare valori, copiare una stringa e normalizzazione di una stringa.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

Confronto di stringheComparing strings

È possibile confrontare le stringhe per determinarne la posizione relativa nell'ordinamento usando i metodi seguenti String :You can compare strings to determine their relative position in the sort order by using the following String methods:

  • CompareRestituisce un intero che indica la relazione tra una stringa e una seconda stringa nell'ordinamento.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinalRestituisce un intero che indica la relazione tra una stringa e una seconda stringa in base a un confronto dei punti di codice.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareToRestituisce un intero che indica la relazione dell'istanza di stringa corrente con una seconda stringa nell'ordinamento.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. Il CompareTo(String) metodo fornisce le IComparable implementazioni e IComparable<T> per la String classe.The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Test delle stringhe per verificarne l'uguaglianzaTesting strings for equality

Chiamare il Equals metodo per determinare se due stringhe sono uguali.You call the Equals method to determine whether two strings are equal. L'istanza Equals(String, String, StringComparison) di e gli Equals(String, StringComparison) overload statici consentono di specificare se il confronto è dipendente dalle impostazioni cultura o ordinale e se il case viene considerato o ignorato.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. La maggior parte dei test per verificarne 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.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

Ricerca di caratteri in una stringaFinding characters in a string

La String classe include due tipi di metodi di ricerca:The String class includes two kinds of search methods:

Avviso

Se si desidera eseguire la ricerca di una stringa per un determinato motivo anziché una sottostringa specifica, è necessario utilizzare espressioni regolari.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Per altre informazioni, vedere espressioni regolari di .NET.For more information, see .NET Regular Expressions.

Modifica di una stringaModifying a string

La String classe include i metodi seguenti che sembrano modificare il valore di una stringa:The String class includes the following methods that appear to modify the value of a string:

  • Insertinserisce una stringa nell'istanza corrente String .Insert inserts a string into the current String instance.

  • PadLeftinserisce una o più occorrenze di un carattere specificato all'inizio di una stringa.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRightinserisce una o più occorrenze di un carattere specificato alla fine di una stringa.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • RemoveElimina una sottostringa dall'istanza String corrente.Remove deletes a substring from the current String instance.

  • Replacesostituisce una sottostringa con un'altra sottostringa String nell'istanza corrente.Replace replaces a substring with another substring in the current String instance.

  • ToLowere ToLowerInvariant convertono tutti i caratteri di una stringa in minuscolo.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUppere ToUpperInvariant convertono tutti i caratteri di una stringa in lettere maiuscole.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • TrimRimuove tutte le occorrenze di un carattere dall'inizio e dalla fine di una stringa.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEndRimuove tutte le occorrenze di un carattere alla fine di una stringa.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStartRimuove tutte le occorrenze di un carattere dall'inizio di una stringa.TrimStart removes all occurrences of a character from the beginning of a string.

Importante

Tutti i metodi di modifica delle stringhe String restituiscono un nuovo oggetto.All string modification methods return a new String object. Non modificano il valore dell'istanza corrente.They don't modify the value of the current instance.

Estrazione di sottostringhe da una stringaExtracting substrings from a string

Il String.Split metodo separa una singola stringa in più stringhe.The String.Split method separates a single string into multiple strings. Gli overload del metodo consentono di specificare più delimitatori, determinare il numero massimo di sottostringhe che il metodo estrae e determinare se le stringhe vuote (che si verificano quando i delimitatori sono adiacenti) sono incluse tra le stringhe restituite.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Combinazione di stringheCombining strings

Per la String concatenazione di stringhe è possibile usare i metodi seguenti:The following String methods can be used for string concatenation:

  • Concatcombina una o più sottostringhe in una singola stringa.Concat combines one or more substrings into a single string.

  • JoinConcatena una o più sottostringhe in un singolo elemento e aggiunge un separatore tra ciascuna sottostringa.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Formattazione di valoriFormatting values

Il String.Format metodo usa la funzionalità di formattazione composita per sostituire uno o più segnaposto in una stringa con la rappresentazione di stringa di un oggetto o di un valore.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. Il Format metodo viene spesso utilizzato per eseguire le operazioni seguenti:The Format method is often used to do the following:

  • Per incorporare la rappresentazione di stringa di un valore numerico in una stringa.To embed the string representation of a numeric value in a string.

  • Per incorporare la rappresentazione di stringa di un valore di data e ora in una stringa.To embed the string representation of a date and time value in a string.

  • Per incorporare la rappresentazione di stringa di un valore di enumerazione in una stringa.To embed the string representation of an enumeration value in a string.

  • Per incorporare la rappresentazione di stringa di un oggetto che IFormattable supporta l'interfaccia in una stringa.To embed the string representation of some object that supports the IFormattable interface in a string.

  • Per giustificare a destra o a sinistra una sottostringa in un campo all'interno di una stringa più grande.To right-justify or left-justify a substring in a field within a larger string.

Per informazioni dettagliate sulle operazioni di formattazione ed esempi, vedere Format Riepilogo dell'overload.For detailed information about formatting operations and examples, see the Format overload summary.

Copia di una stringaCopying a string

Per creare una copia di String una stringa, è possibile chiamare i metodi seguenti:You can call the following String methods to make a copy of a string:

  • CloneRestituisce un riferimento a un oggetto String esistente.Clone returns a reference to an existing String object.

  • CopyCrea una copia di una stringa esistente.Copy creates a copy of an existing string.

  • CopyTocopia una parte di una stringa in una matrice di caratteri.CopyTo copies a portion of a string to a character array.

Normalizzazione di una stringaNormalizing a string

In Unicode un singolo carattere può avere più punti di codice.In Unicode, a single character can have multiple code points. La normalizzazione converte questi caratteri equivalenti nella stessa rappresentazione binaria.Normalization converts these equivalent characters into the same binary representation. Il String.Normalize metodo esegue la normalizzazione e il String.IsNormalized metodo determina se una stringa viene normalizzata.The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Per ulteriori informazioni e un esempio, vedere la sezione relativa alla normalizzazione più indietro in questo argomento.For more information and an example, see the Normalization section earlier in this topic.

Costruttori

String(Char*) String(Char*) String(Char*) String(Char*)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico puntatore a una matrice di caratteri Unicode.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32) 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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inizializza una nuova istanza della classe String sul valore indicato da uno specifico carattere Unicode ripetuto un numero precisato di volte.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

Inizializza una nuova istanza della classe String sul valore indicato da una matrice di caratteri Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) 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.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) 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.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) 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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) 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.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Campi

Empty Empty Empty Empty

Rappresenta la stringa vuota.Represents the empty string. Questo campo è di sola lettura.This field is read-only.

Proprietà

Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

Ottiene l'oggetto Char in una posizione specificata dell'oggetto String corrente.Gets the Char object at a specified position in the current String object.

Length Length Length Length

Ottiene il numero di caratteri nell'oggetto String corrente.Gets the number of characters in the current String object.

Metodi

Clone() Clone() Clone() Clone()

Restituisce un riferimento a questa istanza della classe String.Returns a reference to this instance of String.

Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) 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.Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) 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.Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) 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.Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) 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.Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) 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.Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

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

Confronta due oggetti String specificati e restituisce un intero che ne indica la posizione relativa nell'ordinamento.Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean) 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.Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) 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.Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) 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.Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison) 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.Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) 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.Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

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

Confronta due oggetti String specificati in base all'analisi dei valori numerici dei corrispondenti oggetti Char in ogni stringa.Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) 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.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String) CompareTo(String) CompareTo(String) 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.Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

Concatena i membri di una raccolta IEnumerable<T> costruita di tipo String.Concatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

Crea la rappresentazione di stringa di un oggetto specificato.Creates the string representation of a specified object.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

Concatena le rappresentazioni di stringa di due oggetti specificati.Concatenates the string representations of two specified objects.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

Concatena le rappresentazioni di stringa di tre oggetti specificati.Concatenates the string representations of three specified objects.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) 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.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

Concatena le rappresentazioni di stringa degli elementi in una matrice Object specificata.Concatenates the string representations of the elements in a specified Object array.

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

Concatena le rappresentazioni stringa di due intervalli di caratteri di sola lettura specificati.Concatenates the string representations of two specified read-only character spans.

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

Concatena le rappresentazioni stringa di tre intervalli di caratteri di sola lettura specificati.Concatenates the string representations of three specified read-only character spans.

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

Concatena le rappresentazioni stringa di quattro intervalli di caratteri di sola lettura specificati.Concatenates the string representations of four specified read-only character spans.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

Concatena due istanze specificate della classe String.Concatenates two specified instances of String.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

Concatena tre istanze specificate della classe String.Concatenates three specified instances of String.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

Concatena quattro istanze specificate della classe String.Concatenates four specified instances of String.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

Concatena gli elementi di una matrice di oggetti String specificati.Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

Concatena i membri di un'implementazione di IEnumerable<T>.Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)

Restituisce un valore che indica se un carattere specificato è presente all'interno della stringa.Returns a value indicating whether a specified character occurs within this string.

Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) 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.Returns a value indicating whether a specified character occurs within this string, using the specified comparison rules.

Contains(String) Contains(String) Contains(String) Contains(String)

Restituisce un valore che indica se una sottostringa specificata è presente all'interno della stringa.Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) 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.Returns a value indicating whether a specified string occurs within this string, using the specified comparison rules.

Copy(String) Copy(String) Copy(String) Copy(String)

Crea una nuova istanza dell'oggetto String con lo stesso valore di un'istanza dell'oggetto String specificata.Creates a new instance of String with the same value as a specified String.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) 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.Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

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

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata.Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo)

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante le impostazioni cultura specificate.Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison)

Determina se la fine di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante l'opzione di confronto specificata.Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

EnumerateRunes() EnumerateRunes() EnumerateRunes() EnumerateRunes()

Restituisce un'enumerazione di Rune da questa stringa.Returns an enumeration of Rune from this string.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se questa istanza e un oggetto specificato, che deve essere anche un oggetto String, hanno lo stesso valore.Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String) Equals(String) Equals(String) Equals(String)

Determina se questa istanza e un altro oggetto String specificato hanno lo stesso valore.Determines whether this instance and another specified String object have the same value.

Equals(String, String) Equals(String, String) Equals(String, String) Equals(String, String)

Determina se due oggetti String specificati hanno lo stesso valore.Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison)

Determina se due oggetti String specificati hanno lo stesso valore.Determines whether two specified String objects have the same value. Un parametro specifica le impostazioni cultura, l'eventuale distinzione fra maiuscole e minuscole e le regole di ordinamento usate per effettuare il confronto.A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison)

Determina se questa stringa e un oggetto String specificato hanno lo stesso valore.Determines whether this string and a specified String object have the same value. Un parametro specifica le impostazioni cultura, l'eventuale distinzione fra maiuscole e minuscole e le regole di ordinamento usate per effettuare il confronto.A parameter specifies the culture, case, and sort rules used in the comparison.

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

Sostituisce uno o più elementi di formato presenti in una stringa specificata con la rappresentazione di stringa dell'oggetto corrispondente.Replaces the format item or items in a specified string with the string representation of the corresponding object. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

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

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.Replaces the format items in a string with the string representation of two specified objects. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

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

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.Replaces the format items in a string with the string representation of three specified objects. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) 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.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Un parametro fornisce le informazioni di formattazione specifiche delle impostazioni cultura.A parameter supplies culture-specific formatting information.

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

Sostituisce uno o più elementi di formato in una stringa con la rappresentazione di stringa di un oggetto specificato.Replaces one or more format items in a string with the string representation of a specified object.

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

Sostituisce gli elementi di formato presenti in una stringa con la rappresentazione di stringa di due oggetti specificati.Replaces the format items in a string with the string representation of two specified objects.

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

Sostituisce gli elementi di formato in una stringa con le rappresentazioni di stringa di tre oggetti specificati.Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) 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.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Recupera un oggetto che può eseguire l'iterazione fra i singoli caratteri di questa stringa.Retrieves an object that can iterate through the individual characters in this string.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Restituisce il codice hash di questa stringa.Returns the hash code for this string.

GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>)

Restituisce il codice hash per l'intervallo di caratteri di sola lettura specificato.Returns the hash code for the provided read-only character span.

GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison)

Restituisce il codice hash per l'intervallo di caratteri di sola lettura specificato usando le regole specificate.Returns the hash code for the provided read-only character span using the specified rules.

GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)

Restituisce il codice hash per questa stringa usando le regole specificate.Returns the hash code for this string using the specified rules.

GetPinnableReference() GetPinnableReference() GetPinnableReference() GetPinnableReference()

Restituisce un riferimento all'elemento della stringa in corrispondenza dell'indice zero.Returns a reference to the element of the string at index zero.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

Restituisce l'oggetto TypeCode per la classe String.Returns the TypeCode for class String.

IndexOf(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa.Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32)

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. La ricerca ha inizio alla posizione del carattere specificata.The search starts at a specified character position.

IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32)

Restituisce l'indice in base zero della prima occorrenza del carattere specificato in questa istanza.Reports the zero-based index of the first occurrence of the specified character in this instance. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)

Restituisce l'indice in base zero della prima occorrenza del carattere Unicode specificato in questa stringa.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Un parametro specifica il tipo di ricerca da usare per il carattere specificato.A parameter specifies the type of search to use for the specified character.

IndexOf(String) IndexOf(String) IndexOf(String) IndexOf(String)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza.Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza.Reports the zero-based index of the first occurrence of the specified string in this instance. La ricerca ha inizio alla posizione del carattere specificata.The search starts at a specified character position.

IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata in questa istanza.Reports the zero-based index of the first occurrence of the specified string in this instance. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente.Reports the zero-based index of the first occurrence of the specified string in the current String object. 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.Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente.Reports the zero-based index of the first occurrence of the specified string in the current String object. I parametri specificano la posizione iniziale della ricerca nella stringa corrente e il tipo di ricerca da usare per la stringa specificata.Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison)

Restituisce l'indice in base zero della prima occorrenza della stringa specificata nell'oggetto String corrente.Reports the zero-based index of the first occurrence of the specified string in the current String object. Un parametro specifica il tipo di ricerca da usare per la stringa specificata.A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) 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.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) 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.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. La ricerca ha inizio alla posizione del carattere specificata.The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) 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.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. La ricerca viene eseguita iniziando dalla posizione specificata dei caratteri ed esamina un determinato numero di posizioni.The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

Restituisce una nuova stringa in cui una stringa specificata viene inserita in una posizione di indice specificata in questa istanza.Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String) Intern(String) Intern(String) Intern(String)

Recupera il riferimento del sistema all'oggetto String specificato.Retrieves the system's reference to the specified String.

IsInterned(String) IsInterned(String) IsInterned(String) IsInterned(String)

Recupera un riferimento a un oggetto String specificato.Retrieves a reference to a specified String.

IsNormalized() IsNormalized() IsNormalized() IsNormalized()

Specifica se la stringa è nel formato di normalizzazione Unicode C.Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm)

Specifica se la stringa è nel formato di normalizzazione Unicode indicato.Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String)

Indica se la stringa specificata è null o una stringa vuota ("").Indicates whether the specified string is null or an empty string ("").

IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String)

Indica se una stringa specificata è null, vuota o è composta solo da spazi vuoti.Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[])
Join(Char, String[]) Join(Char, String[]) Join(Char, String[]) Join(Char, String[])
Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32)
Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>)

Concatena i membri di una raccolta IEnumerable<T> costruita di tipo String, usando tra i membri il separatore specificato.Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[]) Join(String, Object[]) Join(String, Object[]) Join(String, Object[])

Concatena gli elementi di una matrice di oggetti, usando tra gli elementi il separatore specificato.Concatenates the elements of an object array, using the specified separator between each element.

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

Concatena tutti gli elementi di una matrice di stringhe, usando tra gli elementi il separatore specificato.Concatenates all the elements of a string array, using the specified separator between each element.

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

Concatena gli elementi specificati di una matrice di stringhe, usando tra gli elementi il separatore specificato.Concatenates the specified elements of a string array, using the specified separator between each element.

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

Concatena i membri di una raccolta, usando tra i membri il separatore specificato.Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di un carattere Unicode specificato all'interno di questa istanza.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di un carattere Unicode specificato all'interno di questa istanza.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) 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.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. 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.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza.Reports the zero-based index position of the last occurrence of a specified string within this instance. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Restituisce la posizione nell'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno di questa istanza.Reports the zero-based index position of the last occurrence of a specified string within this instance. 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.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) 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.Reports the zero-based index position of the last occurrence of a specified string within this instance. 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.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Un parametro specifica il tipo di confronto da effettuare durante la ricerca della stringa specificata.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno dell'oggetto String corrente.Reports the zero-based index of the last occurrence of a specified string within the current String object. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.The search starts at a specified character position and proceeds backward toward the beginning of the string. Un parametro specifica il tipo di confronto da effettuare durante la ricerca della stringa specificata.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Restituisce l'indice in base zero dell'ultima occorrenza di una stringa specificata all'interno dell'oggetto String corrente.Reports the zero-based index of the last occurrence of a specified string within the current String object. Un parametro specifica il tipo di ricerca da usare per la stringa specificata.A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) 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.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) 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.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. La ricerca inizia in corrispondenza di una posizione di carattere specificata e continua all'indietro verso l'inizio della stringa.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) 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.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. 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.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() 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.Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) 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.Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) 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.Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) 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.Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

PadRight(Int32) PadRight(Int32) PadRight(Int32) 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.Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) 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.Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32) Remove(Int32) Remove(Int32) 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.Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) 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.Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) 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.Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String) Replace(String, String) Replace(String, String) 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.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo)
Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison)
Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Suddivide una stringa in sottostringhe basate sui caratteri in una matrice.Splits a string into substrings that are based on the characters in an array.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Suddivide una stringa in un numero massimo di sottostringhe in base ai caratteri in una matrice.Splits a string into a maximum number of substrings based on the characters in an array. Numero massimo di sottostringhe da restituire.You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Suddivide una stringa in un numero massimo di sottostringhe in base ai caratteri in una matrice.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Suddivide una stringa in sottostringhe in base ai caratteri in una matrice.Splits a string into substrings based on the characters in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

Suddivide una stringa in un numero massimo di sottostringhe in base alle stringe in una matrice.Splits a string into a maximum number of substrings based on the strings in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Suddivide una stringa in sottostringhe in base alle stringhe in una matrice.Splits a string into substrings based on the strings in an array. È possibile specificare se le sottostringhe includono elementi della matrice vuota.You can specify whether the substrings include empty array elements.

StartsWith(Char) StartsWith(Char) StartsWith(Char) StartsWith(Char)
StartsWith(String) StartsWith(String) StartsWith(String) StartsWith(String)

Determina se l'inizio di questa istanza di stringa corrisponde alla stringa specificata.Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo)

Determina se l'inizio di questa istanza di stringa corrisponde alla stringa specificata se confrontata mediante le impostazioni cultura specificate.Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison)

Determina se l'inizio di questa istanza di stringa corrisponde alla stringa specificata se confrontata usando l'opzione di confronto specificata.Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

Recupera una sottostringa da questa istanza.Retrieves a substring from this instance. La sottostringa inizia in corrispondenza di un carattere specificato e continua fino alla fine della stringa.The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

Recupera una sottostringa da questa istanza.Retrieves a substring from this instance. La sottostringa inizia in corrispondenza della posizione del carattere specificata e ha la lunghezza specificata.The substring starts at a specified character position and has a specified length.

ToCharArray() ToCharArray() ToCharArray() ToCharArray()

Copia i caratteri di questa istanza in una matrice di caratteri Unicode.Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32)

Copia i caratteri di una determinata sottostringa di questa istanza in una matrice di caratteri Unicode.Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower() ToLower() ToLower() ToLower()

Restituisce una copia di questa stringa convertita in caratteri minuscoli.Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) 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.Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() 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.Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString() ToString() ToString() ToString()

Restituisce questa istanza di String. Non viene eseguita alcuna conversione effettiva.Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Restituisce questa istanza di String. Non viene eseguita alcuna conversione effettiva.Returns this instance of String; no actual conversion is performed.

ToUpper() ToUpper() ToUpper() ToUpper()

Restituisce una copia di questa stringa convertita in caratteri maiuscoli.Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo) 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.Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant() ToUpperInvariant() ToUpperInvariant() 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.Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim() Trim() Trim() Trim()

Rimuove tutti gli spazi vuoti iniziali e finali dall'oggetto String corrente.Removes all leading and trailing white-space characters from the current String object.

Trim(Char) Trim(Char) Trim(Char) Trim(Char)
Trim(Char[]) Trim(Char[]) Trim(Char[]) Trim(Char[])

Rimuove dall'oggetto String corrente tutte le occorrenze iniziali e finali di un set di caratteri specificati in una matrice.Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

TrimEnd() TrimEnd() TrimEnd() TrimEnd()
TrimEnd(Char) TrimEnd(Char) TrimEnd(Char) TrimEnd(Char)
TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[])

Rimuove dall'oggetto String corrente tutte le occorrenze finali di un set di caratteri specificati in una matrice.Removes all trailing occurrences of a set of characters specified in an array from the current String object.

TrimStart() TrimStart() TrimStart() TrimStart()
TrimStart(Char) TrimStart(Char) TrimStart(Char) TrimStart(Char)
TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[])

Rimuove dall'oggetto String corrente tutte le occorrenze iniziali di un set di caratteri specificati in una matrice.Removes all leading occurrences of a set of characters specified in an array from the current String object.

Operatori

Equality(String, String) Equality(String, String) Equality(String, String) Equality(String, String)

Determina se due stringhe specificate hanno lo stesso valore.Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>)
Inequality(String, String) Inequality(String, String) Inequality(String, String) Inequality(String, String)

Determina se due stringhe specificate hanno valori diversi.Determines whether two specified strings have different values.

Implementazioni dell'interfaccia esplicita

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

Per una descrizione di questo membro, vedere ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Per una descrizione di questo membro, vedere ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Per una descrizione di questo membro, vedere ToChar(IFormatProvider).For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Per una descrizione di questo membro, vedere ToDateTime(IFormatProvider).For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Per una descrizione di questo membro, vedere ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Per una descrizione di questo membro, vedere ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Per una descrizione di questo membro, vedere ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Per una descrizione di questo membro, vedere ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Per una descrizione di questo membro, vedere ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

Per una descrizione di questo membro, vedere ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Per una descrizione di questo membro, vedere ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione dell'oggetto String corrente.Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator()

Restituisce un enumeratore che esegue l'iterazione dell'oggetto String corrente.Returns an enumerator that iterates through the current String object.

Metodi di estensione

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) 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.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) 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.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) 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.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.Converts an IEnumerable to an IQueryable.

AsMemory(String) AsMemory(String) AsMemory(String) AsMemory(String)

Crea un nuovo oggetto ReadOnlyMemory<Char> sulla parte della stringa di destinazione.Creates a new ReadOnlyMemory<Char> over the portion of the target string.

AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index)

Crea un nuovo oggetto ReadOnlyMemory<Char> sulla parte della stringa di destinazione a partire da un indice specificato.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified index.

AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32)

Crea un nuovo oggetto ReadOnlyMemory<Char> sulla parte della stringa di destinazione a partire da una posizione di carattere specificata.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified character position.

AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) 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.Creates a new ReadOnlyMemory<Char> over a portion of the target string beginning at a specified position with a length.

AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range)

Crea un nuovo oggetto ReadOnlyMemory<Char> su un intervallo specificato della stringa di destinazione.Creates a new ReadOnlyMemory<Char> over a specified range of the target string.

AsSpan(String) AsSpan(String) AsSpan(String) 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.Creates a new read-only span over a portion of the target string from a specified position for a specified number of characters.

AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32) 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.Creates a new read-only span over a portion of the target string from a specified position to the end of the string.

AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32)

Crea un nuovo intervallo di sola lettura su una stringa.Creates a new read-only span over a string.

IsNormalized(String) IsNormalized(String) IsNormalized(String) IsNormalized(String)

Indica se la stringa specificata è nel formato di normalizzazione Unicode C.Indicates whether the specified string is in Unicode normalization form C.

IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm)

Indica se la stringa è in un formato di normalizzazione Unicode specificato.Indicates whether a string is in a specified Unicode normalization form.

Normalize(String) Normalize(String) Normalize(String) Normalize(String)

Normalizza una stringa in base a al formato di normalizzazione Unicode C.Normalizes a string to a Unicode normalization form C.

Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm)

Normalizza una stringa nel formato di normalizzazione Unicode.Normalizes a string to the specified Unicode normalization form.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a collection of elements that contains the ancestors of every node in the source collection.

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

Restituisce una raccolta di elementi filtrati che contiene i predecessori di ciascun nodo nella raccolta di origine.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi discendenti di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

Restituisce una raccolta di elementi che contiene gli elementi discendenti di ciascun elemento e documento nella raccolta di origine.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) 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.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

Restituisce una raccolta di elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a collection of the child elements of every element and document in the source collection.

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

Restituisce una raccolta filtrata degli elementi figlio di ciascun elemento e documento nella raccolta di origine.Returns a filtered collection of the child elements of every element and document in the source collection. Solo gli elementi che hanno un oggetto XName corrispondente vengono inclusi nella raccolta.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) 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.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

Restituisce una raccolta di nodi figlio di ciascun documento ed elemento nella raccolta di origine.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

Rimuove ciascun nodo nella raccolta di origine dal nodo padre.Removes every node in the source collection from its parent node.

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche