String Klasa

Definicja

Reprezentuje tekst jako sekwencję jednostek kodu UTF-16.

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

Uwagi

Ciąg jest sekwencyjną kolekcją znaków, która jest używana do reprezentowania tekstu. String Obiekt jest sekwencyjną kolekcją System.Char obiektów reprezentujących ciąg; System.Char obiekt odpowiada jednostce kodu UTF-16. Wartość String obiektu jest zawartością sekwencyjnej kolekcji System.Char obiektów, a ta wartość jest niezmienna (czyli tylko do odczytu). Aby uzyskać więcej informacji na temat niezmienności ciągów, zobacz sekcję Niezmienność i klasa StringBuilder . Maksymalny rozmiar String obiektu w pamięci wynosi 2 GB lub około 1 miliarda znaków.

Aby uzyskać więcej informacji o kodowaniu Unicode, UTF-16, jednostkach kodu, punktach kodu i Char typach, Rune zobacz Wprowadzenie do kodowania znaków na platformie .NET.

W tej sekcji:

Tworzenie wystąpienia obiektu String
Obiekty char i znaki Unicode
Ciągi i Standard Unicode
Ciągi i osadzone znaki null
Ciągi i indeksy
Ciągi o wartości null i puste ciągi
Niezmienność i klasa StringBuilder
Operacje porządkowe a operacje wrażliwe na kulturę
Normalizacji
Operacje na ciągach według kategorii

Tworzenie wystąpienia obiektu String

Wystąpienie obiektu można utworzyć String w następujący sposób:

  • Przypisując literał ciągu do zmiennej String . Jest to najczęściej używana metoda tworzenia ciągu. W poniższym przykładzie użyto przypisania do utworzenia kilku ciągów. Należy pamiętać, że w języku C# i F#, ponieważ ukośnik odwrotny (\) jest znakiem ucieczki, ukośniki literału w ciągu muszą być ucieczki lub cały ciąg musi być @-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
    
    let string1 = "This is a string created by assignment."
    printfn "%s" string1
    let string2a = "The path is C:\\PublicDocuments\\Report1.doc"
    printfn "%s" string2a
    let string2b = @"The path is C:\PublicDocuments\Report1.doc"
    printfn "%s" 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
    
  • String Wywołując konstruktor klasy. Poniższy przykład tworzy wystąpienia ciągów przez wywołanie kilku konstruktorów klas. Należy pamiętać, że niektóre konstruktory zawierają wskaźniki do tablic znaków lub podpisane tablice bajtów jako parametry. Visual Basic nie obsługuje wywołań tych konstruktorów. Aby uzyskać szczegółowe informacje o String konstruktorach, zobacz podsumowanie konstruktora String .

    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
    
    let chars = [| 'w'; 'o'; 'r'; 'd' |]
    let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |]
    
    // Create a string from a character array.
    let string1 = String chars
    printfn "%s" string1
    
    // Create a string that consists of a character repeated 20 times.
    let string2 = String('c', 20)
    printfn "%s" string2
    
    let stringFromBytes =
        // Create a string from a pointer to a signed byte array.
        use pbytes = fixed bytes
        String pbytes
    let stringFromChars = 
        // Create a string from a pointer to a character array.
        use pchars = fixed chars
        String pchars
    
    printfn $"{stringFromBytes}"
    printfn $"{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
    
  • Używając operatora łączenia ciągów (+ w języku C# i F# oraz & lub + w Visual Basic), aby utworzyć pojedynczy ciąg z dowolnej kombinacji String wystąpień i literałów ciągu. Poniższy przykład ilustruje użycie operatora łączenia ciągów.

    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.
    
    let string1 = "Today is " + DateTime.Now.ToString("D") + "."
    printfn $"{string1}"
    
    let string2 = "This is one sentence. " + "This is a second. "
    let string2 = string2 + "This is a third sentence."
    printfn $"{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.
    
  • Po pobraniu właściwości lub wywołaniu metody zwracającej ciąg. W poniższym przykładzie użyto metod String klasy, aby wyodrębnić podciąg z większego ciągu.

    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
    
    let sentence = "This sentence has five words."
    // Extract the second word.
    let startPosition = sentence.IndexOf " " + 1
    let word2 = 
        sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition)
    printfn $"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
    
  • Wywołując metodę formatowania, aby przekonwertować wartość lub obiekt na jego reprezentację ciągu. W poniższym przykładzie użyto funkcji formatowania złożonego , aby osadzić reprezentację ciągu dwóch obiektów w ciągu.

    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.
    
    let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0)
    let temperature = 68.3
    String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature)
    |> printfn "%s"
    // 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.
    

Obiekty char i znaki Unicode

Każdy znak w ciągu jest definiowany przez wartość skalarną Unicode, nazywaną również punktem kodu Unicode lub wartością porządkową (liczbową) znaku Unicode. Każdy punkt kodu jest kodowany przy użyciu kodowania UTF-16, a wartość liczbowa każdego elementu kodowania jest reprezentowana przez Char obiekt.

Uwaga

Należy pamiętać, że ponieważ String wystąpienie składa się z sekwencyjnej kolekcji jednostek kodu UTF-16, można utworzyć String obiekt, który nie jest dobrze sformułowanym ciągiem Unicode. Na przykład można utworzyć ciąg, który ma niski surogat bez odpowiedniego wysokiego zastępczego. Chociaż niektóre metody, takie jak metody kodowania i dekodowania obiektów w System.Text przestrzeni nazw, mogą wykonywać kontrole, aby upewnić się, że ciągi są dobrze sformułowane, String składowe klasy nie zapewniają prawidłowego utworzenia ciągu.

Pojedynczy Char obiekt zwykle reprezentuje pojedynczy punkt kodu, czyli wartość Char liczbową punktu kodu. Na przykład punkt kodu znaku "a" to U+0061. Jednak punkt kodu może wymagać więcej niż jednego zakodowanego elementu (więcej niż jeden Char obiekt). Standard Unicode definiuje dwa typy znaków, które odpowiadają wielu Char obiektom: grafu i punktom uzupełniającym Unicode, które odpowiadają znakom w płaszczyznach uzupełniających Unicode.

  • Grafeme jest reprezentowany przez znak podstawowy, po którym następuje co najmniej jeden znak łączący. Na przykład znak ä jest reprezentowany przez Char obiekt, którego punkt kodu to U+0061, Char po którym następuje obiekt, którego punktem kodu jest U+0308. Ten znak można również zdefiniować za pomocą pojedynczego Char obiektu, który ma punkt kodu U+00E4. Jak pokazano w poniższym przykładzie, porównanie równości uwzględniające kulturę wskazuje, że te dwie reprezentacje są równe, chociaż zwykłe porównanie porządkowe nie. Jeśli jednak dwa ciągi są znormalizowane, porównanie porządkowe wskazuje również, że są one równe. (Aby uzyskać więcej informacji na temat normalizacji ciągów, zobacz sekcję Normalizacja ).

    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
    
    open System
    open System.IO
    
    do
        use sw = new StreamWriter(@".\graphemes.txt")
        let grapheme = "\u0061\u0308"
        sw.WriteLine grapheme
    
        let 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))
    // 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
    
  • Dodatkowy punkt kodu Unicode (para zastępcza) jest reprezentowany przez Char obiekt, którego punkt kodu jest wysokim zastępcą, a następnie Char obiektem, którego punktem kodu jest niski surogat. Jednostki kodu o wysokiej wartości zastępczej wahają się od U+D800 do U+DBFF. Jednostki kodu niskich zastępców wahają się od U+DC00 do U+DFFF. Pary zastępcze są używane do reprezentowania znaków na 16 płaszczyznach uzupełniających Unicode. Poniższy przykład tworzy znak zastępczy i przekazuje go do Char.IsSurrogatePair(Char, Char) metody w celu określenia, czy jest to para zastępcza.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");
    
    Console.WriteLine();
    Console.WriteLine("   Is Surrogate Pair: {0}", 
                      Char.IsSurrogatePair(surrogate[0], surrogate[1]));
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    open System
    
    let surrogate = "\uD800\uDC03"
    for i = 0 to surrogate.Length - 1 do
        printf $"U+{uint16 surrogate[i]:X2} "
    
    printfn $"\n   Is Surrogate Pair: {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
    

Ciągi i standard Unicode

Znaki w ciągu są reprezentowane przez zakodowane jednostki kodu UTF-16, które odpowiadają Char wartościom.

Każdy znak w ciągu ma skojarzona kategorię znaków Unicode, która jest reprezentowana na platformie .NET przez UnicodeCategory wyliczenie. Kategorię znaku lub pary zastępczej można określić, wywołując metodę CharUnicodeInfo.GetUnicodeCategory .

Program .NET utrzymuje własną tabelę znaków i odpowiadające im kategorie, co gwarantuje, że określonej wersji implementacji platformy .NET działającej na różnych platformach zwracane są identyczne informacje o kategorii znaków. We wszystkich wersjach platformy .NET i na wszystkich platformach systemu operacyjnego informacje o kategorii znaków są dostarczane przez bazę danych znaków Unicode.

W poniższej tabeli wymieniono wersje .NET i wersje standardu Unicode, na których opierają się ich kategorie znaków.

Wersja programu .NET Wersja standardu Unicode
.NET Framework 1.1 Standard Unicode, wersja 4.0.0
.NET Framework 2.0 Standard Unicode, wersja 5.0.0
Program .NET Framework 3,5 Standard Unicode, wersja 5.0.0
Program .NET Framework 4 Standard Unicode, wersja 5.0.0
.NET Framework 4.5 Standard Unicode, wersja 6.3.0
.NET Framework 4.5.1 Standard Unicode, wersja 6.3.0
.NET Framework 4.5.2 Standard Unicode, wersja 6.3.0
Program .NET Framework 4.6 Standard Unicode, wersja 6.3.0
.NET Framework 4.6.1 Standard Unicode, wersja 6.3.0
.NET Framework 4.6.2 i nowsze Standard Unicode, wersja 8.0.0
.NET Core 2.1 Standard Unicode, wersja 8.0.0
.NET Core 3.1 Standard Unicode, wersja 11.0.0
.NET 5 Standard Unicode, wersja 13.0.0

Ponadto platforma .NET obsługuje porównanie i sortowanie ciągów na podstawie standardu Unicode. .NET Framework 4 i poprzednie wersje utrzymują własną tabelę danych ciągów. Dotyczy to również wersji .NET Framework, począwszy od wersji .NET Framework 4.5 działającej w Windows 7. Począwszy od .NET Framework 4.5 działającej w Windows 8 i nowszych wersjach systemu operacyjnego Windows, środowisko uruchomieniowe deleguje operacje porównywania ciągów i sortowania do systemu operacyjnego. W programach .NET Core i .NET 5+porównanie ciągów i sortowanie są dostarczane przez składniki międzynarodowe dla bibliotek Unicode (z wyjątkiem wersji Windows wcześniejszych niż Aktualizacja systemu Windows 10 z maja 2019). W poniższej tabeli wymieniono wersje platformy .NET i wersje standardu Unicode, na których opiera się porównanie i sortowanie znaków.

Wersja platformy .NET Wersja standardu Unicode
.NET Framework 1.1 Standard Unicode w wersji 4.0.0
.NET Framework 2.0 Standard Unicode w wersji 5.0.0
Program .NET Framework 3,5 Standard Unicode w wersji 5.0.0
Program .NET Framework 4 Standard Unicode w wersji 5.0.0
.NET Framework 4.5 lub nowszym w wersji Windows 7 Standard Unicode w wersji 5.0.0
.NET Framework 4.5 lub nowszym w systemach operacyjnych Windows 8 i nowszych Windows Standard Unicode w wersji 6.3.0
.NET Core i .NET 5+ Zależy od wersji standardu Unicode obsługiwanej przez bazowy system operacyjny.

Ciągi i osadzone znaki o wartości zerowej

Na platformie .NET String obiekt może zawierać osadzone znaki null, które są liczone jako część długości ciągu. Jednak w niektórych językach, takich jak C i C++, znak null wskazuje koniec ciągu; nie jest traktowana jako część ciągu i nie jest liczone jako część długości ciągu. Oznacza to, że następujące typowe założenia, że programiści i biblioteki C++ napisane w języku C lub C++ mogą niekoniecznie być prawidłowe w przypadku zastosowania do String obiektów:

  • Wartość zwracana przez strlen funkcje lub wcslen nie musi być równa String.Length.

  • Ciąg utworzony przez strcpy_s funkcję or wcscpy_s niekoniecznie jest identyczny z ciągiem utworzonym przez metodę String.Copy .

Należy upewnić się, że natywny kod C i C++ tworzący wystąpienie String obiektów oraz kod przekazywany przez wywołanie platformy nie zakłada, że osadzony String znak null oznacza koniec ciągu.

Osadzone znaki null w ciągu są również traktowane inaczej, gdy ciąg jest sortowany (lub porównywany) i gdy ciąg jest wyszukiwany. Znaki null są ignorowane podczas przeprowadzania porównań z uwzględnieniem kultury między dwoma ciągami, w tym porównania przy użyciu niezmiennej kultury. Są one traktowane tylko w przypadku porównań porządkowych lub niewrażliwych na wielkość liter. Z drugiej strony osadzone znaki null są zawsze brane pod uwagę podczas wyszukiwania ciągu przy użyciu metod, takich jak Contains, StartsWithi IndexOf.

Ciągi i indeksy

Indeks jest pozycją Char obiektu (a nie znakiem Unicode) w obiekcie String. Indeks jest liczbą nienależącą do zera, która rozpoczyna się od pierwszej pozycji w ciągu, czyli zero pozycji indeksu. Wiele metod wyszukiwania, takich jak IndexOf i LastIndexOf, zwraca indeks znaku lub podciągów w wystąpieniu ciągu.

Właściwość Chars[] umożliwia dostęp do poszczególnych Char obiektów według ich pozycji indeksu w ciągu. Chars[] Ponieważ właściwość jest właściwością domyślną (w Visual Basic) lub indeksatorem (w języku C# i F#), można uzyskać dostęp do poszczególnych Char obiektów w ciągu przy użyciu kodu, takiego jak poniżej. Ten kod szuka białych znaków lub znaków interpunkcyjnych w ciągu, aby określić, ile wyrazów zawiera ciąg.

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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for i = 0 to s1.Length - 1 do
    if Char.IsPunctuation s1[i] || Char.IsWhiteSpace s1[i] then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// 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.

String Ponieważ klasa implementuje IEnumerable interfejs, można również iterować obiekty Char w ciągu przy użyciu konstrukcji, jak pokazano w poniższym przykładzieforeach.

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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for ch in s1 do
    if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// 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.

Kolejne wartości indeksu mogą nie odpowiadać kolejnym znakom Unicode, ponieważ znak Unicode może być zakodowany jako więcej niż jeden Char obiekt. W szczególności ciąg może zawierać wieloznaczne jednostki tekstu, które są tworzone przez znak podstawowy, po którym następuje jeden lub więcej znaków łączących lub przez pary zastępcze. Aby pracować z znakami Unicode zamiast Char obiektów, użyj System.Globalization.StringInfo klas i TextElementEnumerator lub String.EnumerateRunes metody i Rune struktury. Poniższy przykład ilustruje różnicę między kodem, który działa z obiektami i kodem, który działa z znakami Char Unicode. Porównuje liczbę znaków lub elementów tekstowych w każdym słowie zdania. Ciąg zawiera dwie sekwencje znaku podstawowego, po którym następuje znak łączący.

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
open System
open System.Globalization

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

for ch in opening do
    // Skip the ' character.
    if ch <> '\u0027' then
        if Char.IsWhiteSpace ch || Char.IsPunctuation ch then
            chars.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

let te = StringInfo.GetTextElementEnumerator opening
while te.MoveNext() do
    let s = te.GetTextElement()
    // Skip the ' character.
    if s <> "\u0027" then
        if String.IsNullOrEmpty(s.Trim()) || (s.Length = 1 && Char.IsPunctuation(Convert.ToChar s)) then
            elements.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

// Display character counts.
printfn "%6s %20s %20s" "Word #" "Char Objects " "Characters"
for i = 0 to chars.Count - 1 do
    printfn "%6d %20d %20d" i chars[i] elements[i]
// 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

Ten przykład działa z elementami tekstowymi przy użyciu StringInfo.GetTextElementEnumerator metody i TextElementEnumerator klasy w celu wyliczenia wszystkich elementów tekstowych w ciągu. Można również pobrać tablicę zawierającą indeks początkowy każdego elementu tekstowego, wywołując metodę StringInfo.ParseCombiningCharacters .

Aby uzyskać więcej informacji na temat pracy z jednostkami tekstu, a nie poszczególnymi Char wartościami, zobacz Wprowadzenie do kodowania znaków na platformie .NET.

Ciągi zerowe i puste ciągi

Ciąg, który został zadeklarowany, ale nie został przypisany, to null. Próba wywołania metod w tym ciągu zgłasza błąd NullReferenceException. Ciąg null różni się od pustego ciągu, który jest ciągiem, którego wartość to "" lub String.Empty. W niektórych przypadkach przekazanie ciągu null lub pustego ciągu jako argumentu w wywołaniu metody zgłasza wyjątek. Na przykład przekazanie ciągu null do Int32.Parse metody zwraca ArgumentNullExceptionwartość , a przekazanie pustego ciągu zwraca wartość FormatException. W innych przypadkach argument metody może być ciągiem null lub pustym ciągiem. Jeśli na przykład udostępniasz implementację IFormattable klasy, chcesz porównać zarówno ciąg null, jak i pusty ciąg z ogólnym specyfikatorem formatu ("G").

Klasa String zawiera następujące dwie metody wygody, które umożliwiają przetestowanie, czy ciąg jest null czy pusty:

  • IsNullOrEmpty, który wskazuje, czy ciąg jest albo null lub jest równy String.Empty. Ta metoda eliminuje konieczność użycia kodu, takiego jak:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    if str = null || str.Equals String.Empty then
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, który wskazuje, czy ciąg ma nullwartość , równa String.Emptysię , czy składa się wyłącznie z znaków odstępu. Ta metoda eliminuje konieczność użycia kodu, takiego jak:

    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 = null || str.Equals String.Empty || str.Trim().Equals String.Empty then
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

W poniższym przykładzie użyto IsNullOrEmpty metody w IFormattable.ToString implementacji klasy niestandardowej Temperature . Metoda obsługuje ciągi formatu "G", "C", "F" i "K". Jeśli pusty ciąg formatu lub ciąg formatu, którego wartość jest null przekazywana do metody, jego wartość zostanie zmieniona na ciąg formatu "G".

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }
public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}
member _.ToString(format: string, provider: IFormatProvider) =
    let format = 
        if String.IsNullOrEmpty format then "G" else format
    
    let provider: IFormatProvider = 
        if provider = null then CultureInfo.CurrentCulture else provider

    match format.ToUpperInvariant() with
    // Return degrees in Celsius.
    | "G"
    | "C" ->
        temp.ToString("F2", provider) + "°C"
    // Return degrees in Fahrenheit.
    | "F" ->
        (temp * 9. / 5. + 32.).ToString("F2", provider) + "°F"
    // Return degrees in Kelvin.
    | "K" ->
        (temp + 273.15).ToString()
    | _ ->
        raise (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

Niezmienność i klasa StringBuilder

String Obiekt jest nazywany niezmiennym (tylko do odczytu), ponieważ nie można zmodyfikować jego wartości po jego utworzeniu. Metody, które wydają się modyfikować String obiekt, zwracają nowy String obiekt zawierający modyfikację.

Ponieważ ciągi są niezmienne, procedury manipulowania ciągami, które wykonują powtarzające się dodatki lub usunięcia do tego, co wydaje się być pojedynczym ciągiem, może dokładnie określić znaczną karę wydajności. Na przykład poniższy kod używa generatora liczb losowych do utworzenia ciągu z 1000 znakami w zakresie 0x0001 do 0x052F. Chociaż kod wydaje się używać łączenia ciągów, aby dołączyć nowy znak do istniejącego ciągu o nazwie str, w rzeczywistości tworzy nowy String obiekt dla każdej operacji łączenia.

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

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

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

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

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

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

do
    let rnd = Random()

    let mutable str = String.Empty
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
    for _ = 0 to 1000 do
        str <- str + (rnd.Next(1, 0x0530) |> char |> string)
        if str.Length % 60 = 0 then
            str <- str + Environment.NewLine
    sw.Write str
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

Można użyć StringBuilder klasy zamiast String klasy dla operacji, które wprowadzają wiele zmian w wartości ciągu. W przeciwieństwie do wystąpień String klasy StringBuilder obiekty są modyfikowalne. Podczas łączenia, dołączania lub usuwania podciągów z ciągu operacje są wykonywane na jednym ciągu. Po zakończeniu modyfikowania wartości StringBuilder obiektu można wywołać jego StringBuilder.ToString metodę, aby przekonwertować ją na ciąg. W poniższym przykładzie użyto w poprzednim przykładzie String , aby połączyć 1000 losowych znaków w zakresie, aby 0x0001 0x052F z obiektem StringBuilder .

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

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

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

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

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

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

do
    let rnd = Random()
    let sb = StringBuilder()
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)

    for _ = 0 to 1000 do
        sb.Append(rnd.Next(1, 0x0530) |> char) |> ignore
        if sb.Length % 60 = 0 then
            sb.AppendLine() |> ignore
    sw.Write(string sb)
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

Operacje porządkowe vs. operacje zależne od kultury

String Członkowie klasy wykonują operacje porządkowe lub wrażliwe na kulturę (język) na String obiekcie. Operacja porządkowa działa na wartości liczbowej każdego Char obiektu. Operacja wrażliwa na kulturę działa na wartość String obiektu i uwzględnia reguły skalowania, sortowania, formatowania i analizowania reguł specyficznych dla kultury. Operacje wrażliwe na kulturę są wykonywane w kontekście jawnie zadeklarowanej kultury lub niejawnej bieżącej kultury. Dwa rodzaje operacji mogą generować bardzo różne wyniki, gdy są wykonywane na tym samym ciągu.

Platforma .NET obsługuje również niewrażliwe na kulturę operacje ciągów językowych przy użyciu niezmiennej kultury (CultureInfo.InvariantCulture), która jest luźno oparta na ustawieniach kultury języka angielskiego niezależnie od regionu. W przeciwieństwie do innych System.Globalization.CultureInfo ustawień, ustawienia niezmiennej kultury są gwarantowane, aby zachować spójność na jednym komputerze, od systemu do systemu i w różnych wersjach platformy .NET. Niezmienna kultura może być postrzegana jako rodzaj czarnej skrzynki, która zapewnia stabilność porównań ciągów i porządkowanie we wszystkich kulturach.

Ważne

Jeśli aplikacja podejmuje decyzję o zabezpieczeniach o identyfikatorze symbolicznym, takim jak nazwa pliku lub nazwany potok, lub o utrwalonych danych, takich jak dane tekstowe w pliku XML, operacja powinna używać porównania porządkowego zamiast porównania wrażliwego na kulturę. Wynika to z faktu, że porównanie wrażliwe na kulturę może przynieść różne wyniki w zależności od kultury, natomiast porównanie porządkowe zależy wyłącznie od wartości binarnej porównywanych znaków.

Ważne

Większość metod wykonujących operacje na ciągach obejmuje przeciążenie, które ma parametr typu StringComparison, co umożliwia określenie, czy metoda wykonuje operację porządkową lub wrażliwą na kulturę. Ogólnie rzecz biorąc, należy wywołać to przeciążenie, aby intencja wywołania metody było jasne. Aby uzyskać najlepsze rozwiązania i wskazówki dotyczące używania operacji porządkowych i wrażliwych na kulturę w ciągach, zobacz Best Practices for Using Strings (Najlepsze rozwiązania dotyczące używania ciągów).

Operacje na potrzeby tworzenia liter, analizowania i formatowania, porównywania i sortowania oraz testowania równości mogą być uwzględniane jako porządkowe lub wrażliwe na kulturę. W poniższych sekcjach omówiono każdą kategorię operacji.

Porada

Zawsze należy wywołać przeciążenie metody, które sprawia, że intencja wywołania metody jest jasna. Na przykład zamiast wywołać Compare(String, String) metodę w celu przeprowadzenia porównania z uwzględnieniem kultury dwóch ciągów przy użyciu konwencji bieżącej kultury, należy wywołać Compare(String, String, StringComparison) metodę z wartością StringComparison.CurrentCulture argumentu comparisonType . Aby uzyskać więcej informacji, zobacz Najlepsze rozwiązania dotyczące używania ciągów.

Tabele wagi sortowania, zestaw plików tekstowych zawierających informacje o wagach znaków używanych w operacjach sortowania i porównywania, można pobrać z następujących linków:

Wielkość liter

Reguły wielkości liter określają sposób zmiany wielkości liter znaku Unicode; na przykład od małych liter do wielkich liter. Często wykonywana jest operacja wielkości liter przed porównaniem ciągów. Na przykład ciąg może zostać przekonwertowany na wielkie litery, aby można go było porównać z innym wielkim ciągiem. Znaki w ciągu można przekonwertować na małe litery, wywołując ToLower metodę or ToLowerInvariant , a następnie przekonwertować je na wielkie litery, wywołując metodę ToUpper or ToUpperInvariant . Ponadto można użyć TextInfo.ToTitleCase metody , aby przekonwertować ciąg na przypadek tytułu.

Uwaga

.NET Core działa tylko w systemach Linux i macOS: Zachowanie sortowania dla kultur C i Posix jest zawsze wrażliwe na wielkość liter, ponieważ te kultury nie używają oczekiwanej kolejności sortowania Unicode. Zalecamy używanie kultury innej niż C lub Posix do wykonywania wrażliwych na kulturę operacji sortowania bez uwzględniania wielkości liter.

Operacje wielkości liter mogą być oparte na regułach bieżącej kultury, określonej kulturze lub niezmiennej kulturze. Ponieważ mapowania wielkości liter mogą się różnić w zależności od używanej kultury, wynik operacji wielkości liter może się różnić w zależności od kultury. Rzeczywiste różnice w wielkości liter to trzy rodzaje:

  • Różnice w przypadku mapowania LITERY ALFABETU ŁACIŃSKIEGO I (U+0049), ALFABET ŁACIŃSKI I (U+0069), WIELKA LITERA I Z KROPKĄ POWYŻEJ (U+0130) i MAŁA LITERA ŁACIŃSKA KROPKA I (U+0131). W kulturach tr-TR (Turecki (Turcja)) i az-Latn-AZ (Azerbejdżan, Łaciński) oraz w kulturach tr, az i az-Latn neutralnych, małe litery alfabetu łacińskiego I to MAŁA LITERA KROPKOWA I, a wielkie litery I to alfabet łaciński MAŁY LITERA I to WIELKA LITERA I Z KROPKĄ POWYŻEJ. We wszystkich innych kulturach, w tym niezmiennej kultury, ALFABET ŁACIŃSKI MAŁA LITERA I i WIELKA LITERA ALFABET ŁACIŃSKI I są małymi literami i wielkimi odpowiednikami.

    W poniższym przykładzie pokazano, w jaki sposób porównanie ciągów zaprojektowane w celu zapobiegania awarii dostępu do systemu plików może zakończyć się niepowodzeniem, jeśli opiera się na porównywaniu wielkości liter z uwzględnieniem kultury. (Należy użyć konwencji wielkości liter w niezmiennej kulturze).

    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
    
    open System
    open System.Globalization
    open System.Threading
    
    let disallowed = "file"
    
    let isAccessAllowed (resource: string) =
        let cultures = 
            [| CultureInfo.CreateSpecificCulture "en-US"
               CultureInfo.CreateSpecificCulture "tr-TR" |]
        let index = resource.IndexOfAny [| '\\'; '/' |]
        let scheme =
            if index > 0 then
                resource.Substring(0, index - 1)
            else 
                null
    
        // Change the current culture and perform the comparison.
        for culture in cultures do
            Thread.CurrentThread.CurrentCulture <- culture
            printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
            printfn $"{resource}"
            printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
            printfn ""
            
    isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
    // 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
    
  • Różnice w przypadku mapowania między niezmienną kulturą a wszystkimi innymi kulturami. W takich przypadkach użycie reguł wielkości liter niezmiennej kultury w celu zmiany znaku na wielkie lub małe litery zwraca ten sam znak. W przypadku wszystkich innych kultur zwraca inny znak. Niektóre znaki, których dotyczy problem, są wymienione w poniższej tabeli.

    Znak Jeśli zmieniono wartość na Zwraca
    ZNAK MICRON (U+00B5) Wielkie litery WIELKA LITERA MU (U+-39C)
    WIELKA LITERA I Z KROPKĄ POWYŻEJ (U+0130) Małe litery MAŁA LITERA I (U+0069)
    MAŁA LITERA KROPKOWA I (U+0131) Wielkie litery WIELKA LITERA I (U+0049)
    MAŁA LITERA S (U+017F) Wielkie litery WIELKA LITERA S (U+0053)
    WIELKA LITERA D Z MAŁĄ LITERĄ Z Z CARON (U+01C5) Małe litery MAŁA LITERA DZ Z KARONEM (U+01C6)
    POŁĄCZENIE GRECKIEGO YPOGEGRAMMENI (U+0345) Wielkie litery WIELKA LITERA IOTA (U+0399)
  • Różnice w przypadku mapowania dwuliterowych par mieszanych wielkości liter w zakresie znaków ASCII. W większości kultur dwuliterowa para dwuliterowa jest równa równoważnej dwuliterowej wielkiej litery lub małej parze. Nie jest to prawdziwe w przypadku następujących dwuliterowych par w następujących kulturach, ponieważ w każdym przypadku są one porównywane z digrafem:

    • "lJ" i "nJ" w kulturze hr-HR (Chorwacka (Chorwacja)).

    • "cH" w kulturach cs-CZ (Czechy)) i sk-SK (Słowacki (Słowacja)).

    • "aA" w kulturze da-DK (Duński (Dania)).

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" i "zS" w kulturze hu-HU (Węgry)).

    • "cH" i "lL" w kulturze es-ES_tradnl (Hiszpania, Tradycyjny Sort)).

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" i "tR" w kulturze vi-VN (Wietnam)).

    Jednak nietypowe jest napotkanie sytuacji, w której wrażliwe na kulturę porównanie tych par powoduje problemy, ponieważ te pary są nietypowe w stałych ciągach lub identyfikatorach.

Poniższy przykład ilustruje niektóre różnice w regułach wielkości liter między kulturami podczas konwertowania ciągów na wielkie litery.

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
open System
open System.Globalization
open System.IO

let showHexValue (s: string) =
    let mutable retval = ""
    for ch in s do
        let bytes = BitConverter.GetBytes ch
        retval <- retval + String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0])
    retval

do
    use sw = new StreamWriter(@".\case.txt")
    let words = [| "file"; "sıfır"; "Dženana" |]
    let cultures = 
        [| CultureInfo.InvariantCulture 
           CultureInfo "en-US"
           CultureInfo "tr-TR" |]

    for word in words do
        sw.WriteLine("{0}:", word)
        for culture in cultures do
            let name =
                 if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name
            let upperWord = word.ToUpper culture
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, upperWord, showHexValue upperWord)
        sw.WriteLine()
    sw.Close()

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

Formatowanie i analizowanie

Formatowanie i analizowanie to operacje odwrotne. Reguły formatowania określają sposób konwertowania wartości, takiej jak data i godzina lub liczba, na reprezentację ciągu, podczas gdy reguły analizowania określają sposób konwertowania reprezentacji ciągu na wartość, taką jak data i godzina. Zarówno formatowanie, jak i reguły analizowania są zależne od konwencji kulturowych. Poniższy przykład ilustruje niejednoznaczność, która może wystąpić podczas interpretowania ciągu daty specyficznego dla kultury. Bez znajomości konwencji kultury, która została użyta do utworzenia ciągu daty, nie można wiedzieć, czy 3.03.01.2011, 3.1.2011 i 01.03.2011 r. reprezentują 3 stycznia 2011 r. lub 1 marca 2011 r.

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
open System
open System.Globalization

let date = DateTime(2011, 3, 1)
let cultures = 
      [| CultureInfo.InvariantCulture
         CultureInfo "en-US"
         CultureInfo "fr-FR" |]

for culture in cultures do
    printfn $"""{(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),-12} {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

Podobnie, jak pokazano w poniższym przykładzie, pojedynczy ciąg może wygenerować różne daty w zależności od kultury, której konwencje są używane w operacji analizowania.

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
open System
open System.Globalization

let dateString = "07/10/2011"
let cultures = 
    [| CultureInfo.InvariantCulture
       CultureInfo.CreateSpecificCulture "en-GB"
       CultureInfo.CreateSpecificCulture "en-US" |]
printfn $"""{"Date String",-12} {"Culture",10} {"Month",8} {"Day",8}\n"""
for culture in cultures do
    let date = DateTime.Parse(dateString, culture)
    printfn $"""{dateString,-12} {(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),10} {date.Month,8} {date.Day,8}"""
// 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

Porównanie ciągów i sortowanie

Konwencje porównywania i sortowania ciągów różnią się w zależności od kultury do kultury. Na przykład kolejność sortowania może być oparta na fonetyce lub na wizualnej reprezentacji znaków. W językach azjatyckich wschodnie znaki są sortowane według pociągnięć i radykalnych ideografów. Sortowanie zależy również od języków kolejności i kultur używanych dla alfabetu. Na przykład język duński ma znak "Æ", który sortuje po znaku "Z" w alfabecie. Ponadto w porównaniach może być rozróżniana wielkość liter lub bez uwzględniania wielkości liter, a reguły wielkości liter mogą się różnić w zależności od kultury. Natomiast porównanie porządkowe używa punktów kodu Unicode poszczególnych znaków w ciągu podczas porównywania i sortowania ciągów.

Reguły sortowania określają kolejność alfabetyczną znaków Unicode i sposób porównania dwóch ciągów ze sobą. Na przykład String.Compare(String, String, StringComparison) metoda porównuje dwa ciągi na podstawie parametru StringComparison . Jeśli wartość parametru to StringComparison.CurrentCulture, metoda wykonuje porównanie językowe, które używa konwencji bieżącej kultury. Jeśli wartość parametru to StringComparison.Ordinal, metoda wykonuje porównanie porządkowe. W związku z tym, jak pokazano w poniższym przykładzie, jeśli bieżąca kultura jest angielska w Stanach Zjednoczonych, pierwsze wywołanie String.Compare(String, String, StringComparison) metody (przy użyciu porównania wrażliwego na kulturę) uwzględnia wartość "a" mniejszą niż "A", ale drugie wywołanie tej samej metody (przy użyciu porównania porządkowego) uwzględnia wartość "a" większą niż "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
open System
open System.Globalization
open System.Threading

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
printfn $"""{String.Compare("A", "a", StringComparison.CurrentCulture)}"""
printfn $"""{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

Platforma .NET obsługuje reguły sortowania wyrazów, ciągów i porządkowych:

  • Sortowanie wyrazów wykonuje porównanie ciągów uwzględniających kulturę, w których do niektórych znaków Unicode nieliczbowych mogą być przypisane specjalne wagi. Na przykład łącznik (-) może mieć przypisaną do niego bardzo małą wagę, tak aby obok siebie na liście posortowanej pojawiały się znaki "coop" i "co-op". Aby uzyskać listę String metod, które porównują dwa ciągi przy użyciu reguł sortowania wyrazów, zobacz sekcję Operacje na ciągach według kategorii .

  • Sortowanie ciągów wykonuje również porównanie uwzględniające kulturę. Jest on podobny do sortowania wyrazów, z tą różnicą, że nie ma żadnych specjalnych przypadków, a wszystkie symbole niefanumeryczne pochodzą przed wszystkimi znakami alfanumerycznymi Unicode. Dwa ciągi można porównać przy użyciu reguł sortowania ciągów, wywołując CompareInfo.Compare przeciążenia metody, które mają options parametr, który jest dostarczany wartość CompareOptions.StringSort. Należy pamiętać, że jest to jedyna metoda zapewniana przez platformę .NET w celu porównania dwóch ciągów przy użyciu reguł sortowania ciągów.

  • Sortowanie porządkowe porównuje ciągi na podstawie wartości liczbowej każdego Char obiektu w ciągu. Porównywanie porządkowe jest automatycznie uwzględniane wielkości liter, ponieważ małe i wielkie wersje znaku mają różne punkty kodu. Jeśli jednak wielkość liter nie jest ważna, możesz określić porównanie porządkowe, które ignoruje wielkość liter. Jest to odpowiednik konwertowania ciągu na wielkie litery przy użyciu niezmiennej kultury, a następnie przeprowadzania porównania porządkowego w wyniku. Aby uzyskać listę String metod, które porównują dwa ciągi przy użyciu reguł sortowania porządkowego, zobacz sekcję Operacje na ciągach według kategorii .

Porównanie wrażliwe na kulturę to każde porównanie, które jawnie lub niejawnie używa CultureInfo obiektu, w tym niezmiennej kultury określonej przez CultureInfo.InvariantCulture właściwość. Niejawna kultura jest bieżącą kulturą, która jest określana przez Thread.CurrentCulture właściwości i CultureInfo.CurrentCulture . Istnieje znaczna różnica w kolejności sortowania znaków alfabetycznych (czyli znaków, dla których Char.IsLetter właściwość zwraca truewartość ) w różnych kulturach. Można określić porównanie wrażliwe na kulturę, które używa konwencji określonej kultury, dostarczając CultureInfo obiekt do metody porównania ciągów, takiej jak Compare(String, String, CultureInfo, CompareOptions). Można określić porównanie wrażliwe na kulturę, które używa konwencji bieżącej kultury, podając StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCaselub dowolny element członkowski CompareOptions wyliczenia innego niż CompareOptions.Ordinal lub CompareOptions.OrdinalIgnoreCase do odpowiedniego Compare przeciążenia metody. Porównanie wrażliwe na kulturę jest zwykle odpowiednie do sortowania, podczas gdy porównanie porządkowe nie jest. Porównanie porządkowe jest ogólnie odpowiednie do określenia, czy dwa ciągi są równe (czyli do określania tożsamości), podczas gdy porównanie wrażliwe na kulturę nie jest.

W poniższym przykładzie przedstawiono różnicę między porównaniem uwzględniającym kulturę i porządkowym. W przykładzie są obliczane trzy ciągi, "Apple", "Æble" i "AEble", przy użyciu porównania porządkowego oraz konwencji kultur da-DK i en-US (każda z nich jest kulturą domyślną w czasie Compare wywoływanej metody). Ponieważ język duński traktuje znak "Æ" jako pojedynczą literę i sortuje go po znaku "Z" w alfabecie, ciąg "Æble" jest większy niż "Apple". Jednak wyrażenie "Æble" nie jest uznawane za równoważne "AEble", więc "Æble" jest również większe niż "AEble". Kultura en-US nie zawiera litery "Æ", ale traktuje ją jako równoważną "AE", co wyjaśnia, dlaczego "Æble" jest mniejsza niż "Apple", ale równa "AEble". Z drugiej strony porównanie porządkowe uważa, że wartość "Apple" jest mniejsza niż "Æble", a "Æble" ma być większa niż "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
open System
open System.Globalization
open System.Threading

let str1 = "Apple"
let str2 = "Æble"
let str3 = "AEble"

// Set the current culture to Danish in Denmark.
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Set the current culture to English in the U.S.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Perform an ordinal comparison.
printfn "Ordinal comparison"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2, StringComparison.Ordinal)}"
printfn $"Comparison of {str2} with {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

Skorzystaj z poniższych ogólnych wskazówek, aby wybrać odpowiednią metodę sortowania lub porównywania ciągów:

  • Jeśli chcesz, aby ciągi powinny być uporządkowane na podstawie kultury użytkownika, należy je porządkować na podstawie konwencji bieżącej kultury. Jeśli kultura użytkownika ulegnie zmianie, kolejność posortowanych ciągów również zmieni się odpowiednio. Na przykład aplikacja tezaurusa powinna zawsze sortować wyrazy na podstawie kultury użytkownika.

  • Jeśli chcesz, aby ciągi powinny być uporządkowane na podstawie konwencji określonej kultury, należy je uporządkować, podając CultureInfo obiekt reprezentujący tę kulturę metodzie porównania. Na przykład w aplikacji przeznaczonej do nauczania uczniów określonego języka chcesz porządkować ciągi na podstawie konwencji jednej z kultur, które mówią tym językiem.

  • Jeśli chcesz, aby kolejność ciągów pozostała niezmieniona w różnych kulturach, należy je porządkować na podstawie konwencji niezmiennej kultury lub użyć porównania porządkowego. Można na przykład użyć sortowania porządkowego do organizowania nazw plików, procesów, mutexes lub nazwanych potoków.

  • W przypadku porównania, które obejmuje decyzję o zabezpieczeniach (na przykład, czy nazwa użytkownika jest prawidłowa), zawsze należy wykonać test porządkowy pod kątem równości, wywołując przeciążenie Equals metody .

Uwaga

Reguły sortowania i wielkości liter używane w porównywaniu ciągów są zależne od wersji platformy .NET. Na platformie .NET Core porównanie ciągów zależy od wersji standardu Unicode obsługiwanej przez bazowy system operacyjny. W .NET Framework 4.5 i nowszych wersjach uruchomionych w systemie Windows 8 lub nowszym sortowanie, wielkość liter, normalizacja i informacje o znakach Unicode są zgodne ze standardem Unicode 6.0. W innych systemach operacyjnych Windows są one zgodne ze standardem Unicode 5.0.

Aby uzyskać więcej informacji na temat reguł sortowania wyrazów, ciągów i porządkowych, zobacz System.Globalization.CompareOptions temat. Aby uzyskać dodatkowe zalecenia dotyczące tego, kiedy używać każdej reguły, zobacz Best Practices for Using Strings (Najlepsze rozwiązania dotyczące używania ciągów).

Zwykle nie wywołujesz metod porównywania ciągów, takich jak Compare bezpośrednio, aby określić kolejność sortowania ciągów. Zamiast tego metody porównania są wywoływane przez metody sortowania, takie jak Array.Sort lub List<T>.Sort. Poniższy przykład wykonuje cztery różne operacje sortowania (sortowanie wyrazów przy użyciu bieżącej kultury, sortowania wyrazów przy użyciu niezmiennej kultury, sortowania porządkowego i sortowania ciągów przy użyciu niezmiennej kultury) bez jawnego wywoływania metody porównania ciągów, chociaż określają typ porównania do użycia. Należy pamiętać, że każdy typ sortowania generuje unikatową kolejność ciągów w tablicy.

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
open System
open System.Collections.Generic
open System.Globalization

// IComparer<String> implementation to perform string sort using an F# object expression.
let scompare = 
    { new IComparer<String> with
        member _.Compare(x, y) =
            CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort) }

let strings = [| "coop"; "co-op"; "cooperative"; "co\u00ADoperative"; "cœur"; "coeur" |]

// Perform a word sort using the current (en-US) culture.
let current = Array.copy strings
Array.Sort(current, StringComparer.CurrentCulture)

// Perform a word sort using the invariant culture.
let invariant = Array.copy strings
Array.Sort(invariant, StringComparer.InvariantCulture)

// Perform an ordinal sort.
let ordinal = Array.copy strings
Array.Sort(ordinal, StringComparer.Ordinal)

// Perform a string sort using the current culture.
let stringSort = Array.copy strings
Array.Sort(stringSort, scompare)

// Display array values
printfn "%13s %13s %15s %13s %13s\n" "Original" "Word Sort" "Invariant Word" "Ordinal Sort" "String Sort"
for i = 0 to strings.Length - 1 do
    printfn "%13s %13s %15s %13s %13s\n" strings[i] current[i] invariant[i] ordinal[i] stringSort[i]

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

Porada

Wewnętrznie platforma .NET używa kluczy sortowania do obsługi porównywania ciągów wrażliwych kulturowo. Każdy znak w ciągu ma kilka kategorii wagi sortowania, w tym alfabetyczne, przypadek i znaki diakrytyczne. Klucz sortowania reprezentowany przez SortKey klasę udostępnia repozytorium tych wag dla określonego ciągu. Jeśli aplikacja wykonuje dużą liczbę operacji wyszukiwania lub sortowania na tym samym zestawie ciągów, możesz zwiększyć jej wydajność, generując i przechowując klucze sortowania dla wszystkich używanych ciągów. Gdy wymagana jest operacja sortowania lub porównania, należy użyć kluczy sortowania zamiast ciągów. Aby uzyskać więcej informacji, zobacz klasę SortKey .

Jeśli nie określisz konwencji porównania ciągów, metody sortowania, takie jak Array.Sort(Array) sortowanie uwzględniające kulturę, rozróżnianie wielkości liter w ciągach. W poniższym przykładzie pokazano, jak zmiana bieżącej kultury wpływa na kolejność posortowanych ciągów w tablicy. Tworzy tablicę trzech ciągów. Najpierw ustawia System.Threading.Thread.CurrentThread.CurrentCulture właściwość na en-US i wywołuje metodę Array.Sort(Array) . Wynikowa kolejność sortowania jest oparta na konwencjach sortowania dla kultury języka angielskiego (Stany Zjednoczone). Następnie przykład ustawia System.Threading.Thread.CurrentThread.CurrentCulture właściwość na da-DK i wywołuje metodę Array.Sort ponownie. Zwróć uwagę, że wynikowa kolejność sortowania różni się od wyników en-US, ponieważ używa konwencji sortowania dla języka duńskiego (Dania).

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
open System
open System.Globalization
open System.Threading

let printIndexAndValues (myArray: string[]) =
    for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
        printfn $"[{i}]: {myArray[i]}" 
    printfn ""

// Create and initialize a new array to store the strings.
let stringArray = [| "Apple"; "Æble"; "Zebra" |]

// Display the values of the array.
printfn "The original string array:"
printIndexAndValues stringArray

// Set the CurrentCulture to "en-US".
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
// Sort the values of the array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"en-US\":"
printIndexAndValues stringArray

// Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
// Sort the values of the Array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"da-DK\":"
printIndexAndValues stringArray
// 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

Ostrzeżenie

Jeśli podstawowym celem porównywania ciągów jest ustalenie, czy są one równe, należy wywołać metodę String.Equals . Zazwyczaj należy użyć Equals polecenia , aby wykonać porównanie porządkowe. Metoda jest przeznaczona String.Compare głównie do sortowania ciągów.

Metody wyszukiwania ciągów, takie jak String.StartsWith i String.IndexOf, mogą również wykonywać porównania ciągów porządkowych lub uwzględniających kulturę. W poniższym przykładzie przedstawiono różnice między porównaniami porządkowymi i uwzględniającymi kulturę IndexOf przy użyciu metody . Wyszukiwanie wrażliwe na kulturę, w którym bieżąca kultura jest angielska (Stany Zjednoczone) traktuje podciąg "oe", aby dopasować ligaturę "ą". Ponieważ łącznik miękki (U+00AD) jest znakiem o zerowej szerokości, wyszukiwanie traktuje łącznik miękki jako równoważny Empty i znajduje dopasowanie na początku ciągu. Z drugiej strony wyszukiwanie porządkowe nie znajduje dopasowania w obu przypadkach.

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
open System

let findInString (s: string) (substring: string) (options: StringComparison) =
    let result = s.IndexOf(substring, options)
    if result <> -1 then
        printfn $"'{substring}' found in {s} at position {result}"
    else
        printfn $"'{substring}' not found in {s}"

// Search for "oe" and "œu" in "œufs" and "oeufs".
let s1 = "œufs"
let s2 = "oeufs"
findInString s1 "oe" StringComparison.CurrentCulture
findInString s1 "oe" StringComparison.Ordinal
findInString s2 "œu" StringComparison.CurrentCulture
findInString s2 "œu" StringComparison.Ordinal
printfn ""

let s3 = "co\u00ADoperative"
findInString s3 "\u00AD" StringComparison.CurrentCulture
findInString s3 "\u00AD" StringComparison.Ordinal

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

Wyszukiwanie w ciągach

Metody wyszukiwania ciągów, takie jak String.StartsWith i String.IndexOf, mogą również wykonywać porównania ciągów porządkowych lub uwzględniających kulturę, aby określić, czy znak lub podciąg znajduje się w określonym ciągu.

Metody wyszukiwania w String klasie, które wyszukują pojedynczy znak, taki jak IndexOf metoda, lub jeden z zestawów znaków, takich jak IndexOfAny metoda, wszystkie wykonują wyszukiwanie porządkowe. Aby wyszukać znak uwzględniający kulturę, należy wywołać metodę CompareInfo , taką jak CompareInfo.IndexOf(String, Char) lub CompareInfo.LastIndexOf(String, Char). Należy pamiętać, że wyniki wyszukiwania znaku przy użyciu porównania porządkowego i wrażliwego na kulturę mogą być bardzo różne. Na przykład wyszukiwanie wstępnie skompilowanego znaku Unicode, takiego jak ligatura "Æ" (U+00C6), może być zgodne z dowolnym wystąpieniem jego składników w prawidłowej sekwencji, takim jak "AE" (U+041U+0045), w zależności od kultury. Poniższy przykład ilustruje różnicę między metodami String.IndexOf(Char) i CompareInfo.IndexOf(String, Char) podczas wyszukiwania pojedynczego znaku. Ligature "æ" (U+00E6) znajduje się w ciągu "antena" podczas korzystania z konwencji kultury en-US, ale nie w przypadku używania konwencji kultury da-DK lub podczas wykonywania porównania porządkowego.

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
open System.Globalization

let cultureNames = [| "da-DK"; "en-US" |]
let str = "aerial"
let ch = 'æ'  // U+00E6

printf "Ordinal comparison -- "
printfn $"Position of '{ch}' in {str}: {str.IndexOf ch}"
                  
for cultureName in cultureNames do
    let ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
    printf $"{cultureName} cultural comparison -- "
    printfn $"Position of '{ch}' in {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

Z drugiej strony metody klasy, które wyszukują ciąg, a nie znak, wykonują wyszukiwanie wrażliwe na kulturę, String jeśli opcje wyszukiwania nie są jawnie określone przez parametr typu StringComparison. Jedynym wyjątkiem jest Contains, który wykonuje wyszukiwanie porządkowe.

Testowanie pod kątem równości

String.Compare Użyj metody , aby określić relację dwóch ciągów w kolejności sortowania. Zazwyczaj jest to operacja wrażliwa na kulturę. Z kolei wywołaj metodę String.Equals , aby przetestować równość. Ponieważ test równości zwykle porównuje dane wejściowe użytkownika z niektórymi znanymi ciągami, takimi jak prawidłowa nazwa użytkownika, hasło lub ścieżka systemu plików, zazwyczaj jest to operacja porządkowa.

Ostrzeżenie

Możliwe jest przetestowanie równości przez wywołanie String.Compare metody i określenie, czy zwracana wartość jest równa zero. Jednak ta praktyka nie jest zalecana. Aby określić, czy dwa ciągi są równe, należy wywołać jedno z przeciążeń String.Equals metody . Preferowanym przeciążeniem do wywołania jest metoda wystąpienia Equals(String, StringComparison) lub metoda statyczna Equals(String, String, StringComparison) , ponieważ obie metody zawierają System.StringComparison parametr, który jawnie określa typ porównania.

W poniższym przykładzie pokazano niebezpieczeństwo wykonywania porównania wrażliwego na kulturę pod kątem równości, gdy zamiast tego należy użyć porządkowego. W takim przypadku celem kodu jest zakazanie dostępu systemu plików z adresów URL rozpoczynających się od "FILE://" lub "file://", wykonując porównanie bez uwzględniania wielkości liter początku adresu URL z ciągiem "FILE://". Jeśli jednak porównanie wrażliwe na kulturę jest wykonywane przy użyciu kultury tureckiej (Turcja) w adresie URL rozpoczynającym się od "file://", porównanie równości nie powiedzie się, ponieważ tureckie wielkie litery "i" to "İ" zamiast "I". W związku z tym dostęp do systemu plików jest nieumyślnie dozwolony. Z drugiej strony, jeśli zostanie wykonane porównanie porządkowe, porównanie równości powiedzie się, a dostęp do systemu plików zostanie odrzucony.

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.
open System
open System.Globalization
open System.Threading

let testForEquality (str: string) (cmp: StringComparison) =
    let position = str.IndexOf "://"
    if position < 0 then false
    else
        let substring = str.Substring(0, position)
        substring.Equals("FILE", cmp)

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "tr-TR"

let filePath = "file://c:/notes.txt"

printfn "Culture-sensitive test for equality:"
if not (testForEquality filePath StringComparison.CurrentCultureIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

printfn "\nOrdinal test for equality:"
if not (testForEquality filePath StringComparison.OrdinalIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

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

Normalizacja

Niektóre znaki Unicode mają wiele reprezentacji. Na przykład dowolny z następujących punktów kodu może reprezentować literę "ắ":

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Wiele reprezentacji dla pojedynczego znaku komplikuje wyszukiwanie, sortowanie, dopasowywanie i inne operacje na ciągach.

Standard Unicode definiuje proces nazywany normalizacją, który zwraca jedną reprezentację binarną znaku Unicode dla dowolnej z jego równoważnych reprezentacji binarnych. Normalizacja może używać kilku algorytmów, nazywanych formularzami normalizacji, które są zgodne z różnymi regułami. Platforma .NET obsługuje formularze normalizacji Unicode C, D, KC i KD. Gdy ciągi zostały znormalizowane do tej samej postaci normalizacji, można je porównać przy użyciu porównania porządkowego.

Porównanie porządkowe to binarne porównanie wartości skalarnej Unicode odpowiadających Char im obiektów w każdym ciągu. Klasa String zawiera szereg metod, które mogą wykonać porównanie porządkowe, w tym następujące:

Można określić, czy ciąg jest znormalizowany do normalizacji formularza C, wywołując String.IsNormalized() metodę, czy można wywołać String.IsNormalized(NormalizationForm) metodę , aby określić, czy ciąg jest znormalizowany do określonej formy normalizacji. Można również wywołać metodę String.Normalize() , aby przekonwertować ciąg na postać normalizacji C, lub wywołać String.Normalize(NormalizationForm) metodę w celu przekonwertowania ciągu na określoną formę normalizacji. Aby uzyskać szczegółowe informacje na temat normalizacji i porównywania ciągów, zobacz Normalize() metody i Normalize(NormalizationForm) .

Poniższy prosty przykład ilustruje normalizację ciągu. Definiuje literę "ố" na trzy różne sposoby w trzech różnych ciągach i używa porównania porządkowego równości, aby określić, że każdy ciąg różni się od pozostałych dwóch ciągów. Następnie konwertuje każdy ciąg na obsługiwane formularze normalizacji, a następnie ponownie wykonuje porównanie porządkowe każdego ciągu w określonej formie normalizacji. W każdym przypadku drugi test równości pokazuje, że ciągi są równe.

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

public ref class Example
{
private:
   StreamWriter^ sw;

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

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

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

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

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

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

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

      sw->Close(); 
   }
};

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

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

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

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

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

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

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

do
    use sw = new StreamWriter(@".\TestNorm1.txt")

    let showBytes (str: string) =
        let mutable result = ""
        for ch in str do
            result <- result + $"{uint16 ch:X4} "
        result.Trim()
    
    let testForEquality (words: string[]) =
        for ctr = 0 to words.Length - 2 do
            for ctr2 = ctr + 1 to words.Length - 1 do
                sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                            words[ctr], showBytes(words[ctr]),
                            words[ctr2], showBytes(words[ctr2]),
                            words[ctr].Equals(words[ctr2], StringComparison.Ordinal))

    let normalizeStrings nf (words: string[]) =
        for i = 0 to words.Length - 1 do
            if not (words[i].IsNormalized nf) then
                words[i] <- words[i].Normalize nf
        words

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

    testForEquality [| s1; s2; s3 |]
    sw.WriteLine()

    // Normalize and compare strings using each normalization form.
    for formName in Enum.GetNames typeof<NormalizationForm> do
        sw.WriteLine("Normalization {0}:\n", formName)
        let nf = Enum.Parse(typeof<NormalizationForm>, formName) :?> NormalizationForm
        let sn = normalizeStrings nf [| s1; s2; s3|]
        testForEquality sn
        sw.WriteLine "\n"

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

Aby uzyskać więcej informacji na temat formularzy normalizacji i normalizacji, zobacz System.Text.NormalizationForm, a także załącznik Standard Unicode #15: Formularze normalizacji Unicode i często zadawane pytania dotyczące normalizacji w witrynie internetowej unicode.org.

Operacje na ciągach według kategorii

Klasa String udostępnia elementy członkowskie do porównywania ciągów, testowania ciągów pod kątem równości, znajdowania znaków lub podciągów w ciągu, modyfikowania ciągu, wyodrębniania podciągów z ciągu, łączenia ciągów, formatowania wartości, kopiowania ciągu i normalizacji ciągu.

Porównywanie ciągów

Ciągi można porównać w celu określenia ich względnej pozycji w kolejności sortowania przy użyciu następujących String metod:

  • Compare Zwraca liczbę całkowitą, która wskazuje relację jednego ciągu z drugim ciągiem w kolejności sortowania.

  • CompareOrdinal Zwraca liczbę całkowitą, która wskazuje relację jednego ciągu z drugim ciągiem na podstawie porównania punktów kodu.

  • CompareTo Zwraca liczbę całkowitą, która wskazuje relację bieżącego wystąpienia ciągu z drugim ciągiem w kolejności sortowania. Metoda CompareTo(String) udostępnia IComparable implementacje i IComparable<T> dla String klasy .

Testowanie ciągów pod kątem równości

Wywołaj metodę , Equals aby określić, czy dwa ciągi są równe. Wystąpienie Equals(String, String, StringComparison) i przeciążenia statyczne Equals(String, StringComparison) umożliwiają określenie, czy porównanie jest wrażliwe na kulturę, czy porządkowe, oraz czy wielkość liter jest uwzględniana, czy ignorowana. Większość testów równości to porządkowe, a porównania równości określające dostęp do zasobu systemowego (takiego jak obiekt systemu plików) powinny zawsze być porządkowe.

Znajdowanie znaków w ciągu

Klasa String zawiera dwa rodzaje metod wyszukiwania:

Ostrzeżenie

Jeśli chcesz wyszukać ciąg dla określonego wzorca, a nie określonego podciągu, użyj wyrażeń regularnych. Aby uzyskać więcej informacji, zobacz .NET Regular Expressions (Wyrażenia regularne platformy .NET).

Modyfikowanie ciągu

Klasa String zawiera następujące metody, które wydają się modyfikować wartość ciągu:

  • Insert Wstawia ciąg do bieżącego String wystąpienia.

  • PadLeft Wstawia jedno lub więcej wystąpień określonego znaku na początku ciągu.

  • PadRight Wstawia jedno lub więcej wystąpień określonego znaku na końcu ciągu.

  • Remove Usuwa podciąg z bieżącego String wystąpienia.

  • Replace Zamienia podciąg na inny podciąg w bieżącym String wystąpieniu.

  • ToLower i ToLowerInvariant przekonwertuj wszystkie znaki w ciągu na małe litery.

  • ToUpper i ToUpperInvariant przekonwertuj wszystkie znaki w ciągu na wielkie litery.

  • Trim Usuwa wszystkie wystąpienia znaku od początku i końca ciągu.

  • TrimEnd usuwa wszystkie wystąpienia znaku z końca ciągu.

  • TrimStart Usuwa wszystkie wystąpienia znaku od początku ciągu.

Ważne

Wszystkie metody modyfikacji ciągów zwracają nowy String obiekt. Nie modyfikują one wartości bieżącego wystąpienia.

Wyodrębnianie podciągów z ciągu

Metoda String.Split oddziela pojedynczy ciąg na wiele ciągów. Przeciążenia metody umożliwiają określenie wielu ograniczników, ograniczenie liczby podciągów wyodrębnionych przez metodę, przycinanie białych znaków z podciągów i określanie, czy puste ciągi (które występują, gdy ograniczniki są sąsiadujące) są uwzględniane wśród zwracanych ciągów.

Łączenie ciągów

Do łączenia ciągów można użyć następujących String metod:

  • Concat łączy co najmniej jeden podciąg w jeden ciąg.

  • Join Łączy co najmniej jeden podciąg w jeden element i dodaje separator między poszczególnymi podciągami.

Formatowanie wartości

Metoda String.Format używa funkcji formatowania złożonego, aby zastąpić jeden lub więcej symboli zastępczych w ciągu ciągiem reprezentującym jakiś obiekt lub wartość. Metoda Format jest często używana do wykonywania następujących czynności:

  • Aby osadzić reprezentację ciągu wartości liczbowej w ciągu.

  • Aby osadzić ciąg reprezentujący wartość daty i godziny w ciągu.

  • Aby osadzić reprezentację ciągu wartości wyliczenia w ciągu.

  • Aby osadzić reprezentację ciągu obiektu, który obsługuje IFormattable interfejs w ciągu.

  • Aby uzasadnić prawą lub uzasadnić lewą podciąg w polu w większym ciągu.

Aby uzyskać szczegółowe informacje na temat operacji formatowania i przykładów, zobacz Format podsumowanie przeciążenia.

Kopiowanie ciągu

Aby utworzyć kopię ciągu, można wywołać następujące String metody:

  • Clone Zwraca odwołanie do istniejącego String obiektu.

  • Copy Tworzy kopię istniejącego ciągu.

  • CopyTo kopiuje część ciągu do tablicy znaków.

Normalizowanie ciągu

W formacie Unicode pojedynczy znak może mieć wiele punktów kodu. Normalizacja konwertuje te równoważne znaki na tę samą reprezentację binarną. Metoda String.Normalize wykonuje normalizację, a String.IsNormalized metoda określa, czy ciąg jest znormalizowany.

Aby uzyskać więcej informacji i przykład, zobacz sekcję Normalizacja wcześniej w tym temacie .

Konstruktory

String(Char*)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków Unicode.

String(Char*, Int32, Int32)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków Unicode, położenia znaku początkowego w tej tablicy i długości.

String(Char, Int32)

Inicjuje String nowe wystąpienie klasy do wartości wskazanej przez określony znak Unicode powtórzony określoną liczbę razy.

String(Char[])

Inicjuje String nowe wystąpienie klasy do znaków Unicode wskazanych w określonej tablicy znaków.

String(Char[], Int32, Int32)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez tablicę znaków Unicode, pozycję znaku początkowego w tej tablicy i długość.

String(ReadOnlySpan<Char>)

Inicjuje String nowe wystąpienie klasy do znaków Unicode wskazanych w określonym zakresie tylko do odczytu.

String(SByte*)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem.

String(SByte*, Int32, Int32)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy i długości.

String(SByte*, Int32, Int32, Encoding)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy, długości i Encoding obiektu.

Pola

Empty

Reprezentuje pusty ciąg. To pole jest tylko do odczytu.

Właściwości

Chars[Int32]

Char Pobiera obiekt na określonej pozycji w bieżącym String obiekcie.

Length

Pobiera liczbę znaków w bieżącym String obiekcie.

Metody

Clone()

Zwraca odwołanie do tego wystąpienia obiektu String.

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

Porównuje podciąg dwóch określonych String obiektów i zwraca liczbę całkowitą, która wskazuje ich względną pozycję w kolejności sortowania.

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

Porównuje podciąg dwóch określonych String obiektów, ignorując lub honorując ich wielkość liter, i zwraca liczbę całkowitą wskazującą ich względną pozycję w kolejności sortowania.

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

Porównuje podciąg dwóch określonych String obiektów, ignorując lub honorując ich przypadek i używając informacji specyficznych dla kultury, aby wpłynąć na porównanie, i zwraca liczbę całkowitą, która wskazuje ich względną pozycję w kolejności sortowania.

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

Porównuje podciąg dwóch określonych String obiektów przy użyciu określonych opcji porównania i informacji specyficznych dla kultury, aby wpłynąć na porównanie, i zwraca liczbę całkowitą wskazującą relację dwóch podciągów do siebie w kolejności sortowania.

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

Porównuje podciąg dwóch określonych obiektów przy użyciu określonych String reguł i zwraca liczbę całkowitą wskazującą ich względną pozycję w kolejności sortowania.

Compare(String, String)

Porównuje dwa określone String obiekty i zwraca liczbę całkowitą wskazującą ich położenie względne w kolejności sortowania.

Compare(String, String, Boolean)

Porównuje dwa określone String obiekty, ignorując lub honorując ich przypadek, i zwraca liczbę całkowitą, która wskazuje ich względną pozycję w kolejności sortowania.

Compare(String, String, Boolean, CultureInfo)

Porównuje dwa określone String obiekty, ignorując lub honorując ich przypadek, i używając informacji specyficznych dla kultury, aby wpłynąć na porównanie, i zwraca liczbę całkowitą, która wskazuje ich względną pozycję w kolejności sortowania.

Compare(String, String, CultureInfo, CompareOptions)

Porównuje dwa określone String obiekty przy użyciu określonych opcji porównania i informacji specyficznych dla kultury, aby wpłynąć na porównanie, i zwraca liczbę całkowitą, która wskazuje relację dwóch ciągów ze sobą w kolejności sortowania.

Compare(String, String, StringComparison)

Porównuje dwa określone String obiekty przy użyciu określonych reguł i zwraca liczbę całkowitą, która wskazuje ich względną pozycję w kolejności sortowania.

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

Porównuje podciąg dwóch określonych String obiektów, oceniając wartości liczbowe odpowiednich Char obiektów w poszczególnych podciągach.

CompareOrdinal(String, String)

Porównuje dwa określone String obiekty, oceniając wartości liczbowe odpowiednich Char obiektów w każdym ciągu.

CompareTo(Object)

Porównuje to wystąpienie z określonym Object wystąpieniem i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej pozycji w kolejności sortowania co określony Object.

CompareTo(String)

Porównuje to wystąpienie z określonym String obiektem i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej pozycji w kolejności sortowania co określony ciąg.

Concat(IEnumerable<String>)

Łączy elementy członkowskie skonstruowanej IEnumerable<T> kolekcji typu String.

Concat(Object)

Tworzy reprezentację ciągu określonego obiektu.

Concat(Object, Object)

Łączy reprezentacje ciągu dwóch określonych obiektów.

Concat(Object, Object, Object)

Łączy reprezentacje ciągów trzech określonych obiektów.

Concat(Object, Object, Object, Object)

Łączy reprezentacje ciągu czterech określonych obiektów i wszystkich obiektów określonych na liście parametrów opcjonalnej długości zmiennej.

Concat(Object[])

Łączy reprezentacje ciągów elementów w określonej Object tablicy.

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

Łączy reprezentacje ciągu dwóch określonych zakresów znaków tylko do odczytu.

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

Łączy reprezentacje ciągów z trzema określonymi zakresami znaków tylko do odczytu.

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

Łączy reprezentacje ciągów czterech określonych zakresów znaków tylko do odczytu.

Concat(String, String)

Łączy dwa określone wystąpienia klasy String.

Concat(String, String, String)

Łączy trzy określone wystąpienia programu String.

Concat(String, String, String, String)

Łączy cztery określone wystąpienia klasy String.

Concat(String[])

Łączy elementy określonej String tablicy.

Concat<T>(IEnumerable<T>)

Łączy członków implementacji IEnumerable<T> .

Contains(Char)

Zwraca wartość wskazującą, czy określony znak występuje w tym ciągu.

Contains(Char, StringComparison)

Zwraca wartość wskazującą, czy określony znak występuje w tym ciągu przy użyciu określonych reguł porównania.

Contains(String)

Zwraca wartość wskazującą, czy określony podciąg występuje w tym ciągu.

Contains(String, StringComparison)

Zwraca wartość wskazującą, czy określony ciąg występuje w tym ciągu przy użyciu określonych reguł porównania.

Copy(String)
Nieaktualne.

Tworzy nowe wystąpienie klasy String o tej samej wartości co określona Stringwartość .

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

Kopiuje określoną liczbę znaków z określonej pozycji w tym wystąpieniu do określonej pozycji w tablicy znaków Unicode.

CopyTo(Span<Char>)

Kopiuje zawartość tego ciągu do zakresu docelowego.

Create(IFormatProvider, DefaultInterpolatedStringHandler)

Tworzy nowy ciąg przy użyciu określonego dostawcy do kontrolowania formatowania określonego ciągu interpolowanego.

Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

Tworzy nowy ciąg przy użyciu określonego dostawcy do kontrolowania formatowania określonego ciągu interpolowanego.

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

Tworzy nowy ciąg o określonej długości i inicjuje go po utworzeniu przy użyciu określonego wywołania zwrotnego.

EndsWith(Char)

Określa, czy koniec tego wystąpienia ciągu jest zgodny z określonym znakiem.

EndsWith(String)

Określa, czy koniec tego wystąpienia ciągu jest zgodny z określonym ciągiem.

EndsWith(String, Boolean, CultureInfo)

Określa, czy koniec tego wystąpienia ciągu jest zgodny z określonym ciągiem w porównaniu z określoną kulturą.

EndsWith(String, StringComparison)

Określa, czy koniec tego wystąpienia ciągu jest zgodny z określonym ciągiem w porównaniu przy użyciu określonej opcji porównania.

EnumerateRunes()

Zwraca wyliczenie Rune z tego ciągu.

Equals(Object)

Określa, czy to wystąpienie i określony obiekt, który również musi być obiektem String , mają tę samą wartość.

Equals(String)

Określa, czy to wystąpienie i inny określony String obiekt mają taką samą wartość.

Equals(String, String)

Określa, czy dwa określone String obiekty mają tę samą wartość.

Equals(String, String, StringComparison)

Określa, czy dwa określone String obiekty mają tę samą wartość. Parametr określa kulturę, wielkość liter i reguły sortowania używane w porównaniu.

Equals(String, StringComparison)

Określa, czy ten ciąg i określony String obiekt mają taką samą wartość. Parametr określa kulturę, wielkość liter i reguły sortowania używane w porównaniu.

Format(IFormatProvider, String, Object)

Zamienia element formatu lub elementy w określonym ciągu na reprezentację ciągu odpowiadającego mu obiektu. Parametr dostarcza informacje o formatowaniu specyficznym dla kultury.

Format(IFormatProvider, String, Object, Object)

Zamienia elementy formatu w ciągu na reprezentację ciągu dwóch określonych obiektów. Parametr dostarcza informacje o formatowaniu specyficznym dla kultury.

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

Zastępuje elementy formatu w ciągu ciągiem reprezentującym trzy określone obiekty. Parametr dostarcza informacje o formatowaniu specyficznym dla kultury.

Format(IFormatProvider, String, Object[])

Zamienia elementy formatu w ciągu na reprezentacje ciągów odpowiadających im obiektów w określonej tablicy. Parametr dostarcza informacje o formatowaniu specyficznym dla kultury.

Format(String, Object)

Zamienia jeden lub więcej elementów formatu w ciągu na reprezentację ciągu określonego obiektu.

Format(String, Object, Object)

Zamienia elementy formatu w ciągu na reprezentację ciągu dwóch określonych obiektów.

Format(String, Object, Object, Object)

Zastępuje elementy formatu w ciągu ciągiem reprezentującym trzy określone obiekty.

Format(String, Object[])

Zamienia element formatu w określonym ciągu na ciąg reprezentujący odpowiedni obiekt w określonej tablicy.

GetEnumerator()

Pobiera obiekt, który może iterować po poszczególnych znakach w tym ciągu.

GetHashCode()

Zwraca kod skrótu dla tego ciągu.

GetHashCode(ReadOnlySpan<Char>)

Zwraca kod skrótu dla podanego zakresu znaków tylko do odczytu.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Zwraca kod skrótu dla podanego zakresu znaków tylko do odczytu przy użyciu określonych reguł.

GetHashCode(StringComparison)

Zwraca kod skrótu dla tego ciągu przy użyciu określonych reguł.

GetPinnableReference()

Zwraca odwołanie do elementu ciągu o wartości zero indeksu.

Ta metoda jest przeznaczona do obsługi kompilatorów .NET i nie jest przeznaczona do wywoływania przez kod użytkownika.

GetType()

Type Pobiera wartość bieżącego wystąpienia.

(Odziedziczone po Object)
GetTypeCode()

Zwraca wartość TypeCode dla String klasy .

IndexOf(Char)

Raportuje indeks zerowy pierwszego wystąpienia określonego znaku Unicode w tym ciągu.

IndexOf(Char, Int32)

Raportuje indeks zerowy pierwszego wystąpienia określonego znaku Unicode w tym ciągu. Wyszukiwanie rozpoczyna się od określonej pozycji znaku.

IndexOf(Char, Int32, Int32)

Zgłasza zerowy indeks pierwszego wystąpienia określonego znaku w tym wystąpieniu. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i sprawdza określoną liczbę pozycji znaków.

IndexOf(Char, StringComparison)

Raportuje indeks zerowy pierwszego wystąpienia określonego znaku Unicode w tym ciągu. Parametr określa typ wyszukiwania do użycia dla określonego znaku.

IndexOf(String)

Raportuje indeks zerowy pierwszego wystąpienia określonego ciągu w tym wystąpieniu.

IndexOf(String, Int32)

Raportuje zerowy indeks pierwszego wystąpienia określonego ciągu w tym wystąpieniu. Wyszukiwanie rozpoczyna się na określonej pozycji znaku.

IndexOf(String, Int32, Int32)

Raportuje zerowy indeks pierwszego wystąpienia określonego ciągu w tym wystąpieniu. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i sprawdza określoną liczbę pozycji znaków.

IndexOf(String, Int32, Int32, StringComparison)

Raportuje indeks oparty na zerowym pierwszym wystąpieniu określonego ciągu w bieżącym String obiekcie. Parametry określają pozycję wyszukiwania początkowego w bieżącym ciągu, liczbę znaków w bieżącym ciągu do wyszukania oraz typ wyszukiwania do użycia dla określonego ciągu.

IndexOf(String, Int32, StringComparison)

Raportuje indeks oparty na zerowym pierwszym wystąpieniu określonego ciągu w bieżącym String obiekcie. Parametry określają pozycję wyszukiwania początkowego w bieżącym ciągu i typ wyszukiwania do użycia dla określonego ciągu.

IndexOf(String, StringComparison)

Raportuje indeks oparty na zerowym pierwszym wystąpieniu określonego ciągu w bieżącym String obiekcie. Parametr określa typ wyszukiwania do użycia dla określonego ciągu.

IndexOfAny(Char[])

Zgłasza zerowy indeks pierwszego wystąpienia w tym wystąpieniu dowolnego znaku w określonej tablicy znaków Unicode.

IndexOfAny(Char[], Int32)

Zgłasza zerowy indeks pierwszego wystąpienia w tym wystąpieniu dowolnego znaku w określonej tablicy znaków Unicode. Wyszukiwanie rozpoczyna się na określonej pozycji znaku.

IndexOfAny(Char[], Int32, Int32)

Zgłasza zerowy indeks pierwszego wystąpienia w tym wystąpieniu dowolnego znaku w określonej tablicy znaków Unicode. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i sprawdza określoną liczbę pozycji znaków.

Insert(Int32, String)

Zwraca nowy ciąg, w którym określony ciąg jest wstawiany na określonej pozycji indeksu w tym wystąpieniu.

Intern(String)

Pobiera odwołanie systemu do określonego Stringelementu .

IsInterned(String)

Pobiera odwołanie do określonego Stringelementu .

IsNormalized()

Wskazuje, czy ten ciąg znajduje się w postaci normalizacji Unicode C.

IsNormalized(NormalizationForm)

Wskazuje, czy ten ciąg znajduje się w określonej postaci normalizacji Unicode.

IsNullOrEmpty(String)

Wskazuje, czy określony ciąg jest null , czy ciąg pusty ("").

IsNullOrWhiteSpace(String)

Wskazuje, czy określony ciąg to null, pusty, czy składa się tylko z białych znaków.

Join(Char, Object[])

Łączy reprezentacje ciągów tablicy obiektów przy użyciu określonego separatora między poszczególnymi elementami członkowskim.

Join(Char, String[])

Łączy tablicę ciągów przy użyciu określonego separatora między poszczególnymi elementami członkowskim.

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

Łączy tablicę ciągów przy użyciu określonego separatora między poszczególnymi elementami, zaczynając od elementu znajdującego startIndex się w value pozycji i łącząc do count elementów.

Join(String, IEnumerable<String>)

Łączy elementy członkowskie skonstruowanej IEnumerable<T> kolekcji typu String, używając określonego separatora między poszczególnymi elementami członkowskim.

Join(String, Object[])

Łączy elementy tablicy obiektów przy użyciu określonego separatora między poszczególnymi elementami.

Join(String, String[])

Łączy wszystkie elementy tablicy ciągów przy użyciu określonego separatora między poszczególnymi elementami.

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

Łączy określone elementy tablicy ciągów przy użyciu określonego separatora między poszczególnymi elementami.

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

Łączy elementy członkowskie kolekcji przy użyciu określonego separatora między każdym elementem członkowskim.

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

Łączy elementy członkowskie kolekcji przy użyciu określonego separatora między każdym elementem członkowskim.

LastIndexOf(Char)

Zgłasza położenie indeksu zerowego ostatniego wystąpienia określonego znaku Unicode w tym wystąpieniu.

LastIndexOf(Char, Int32)

Zgłasza położenie indeksu zerowego ostatniego wystąpienia określonego znaku Unicode w tym wystąpieniu. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków.

LastIndexOf(Char, Int32, Int32)

Raportuje położenie indeksu opartego na zerowym wystąpieniu ostatniego wystąpienia określonego znaku Unicode w podciągu w tym wystąpieniu. Wyszukiwanie rozpoczyna się w określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaków.

LastIndexOf(String)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji.

LastIndexOf(String, Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków.

LastIndexOf(String, Int32, Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji. Wyszukiwanie rozpoczyna się w określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaków.

LastIndexOf(String, Int32, Int32, StringComparison)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaków. Parametr określa typ porównania do wykonania podczas wyszukiwania określonego ciągu.

LastIndexOf(String, Int32, StringComparison)

Raportuje indeks oparty na zerze ostatniego wystąpienia określonego ciągu w bieżącym String obiekcie. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków. Parametr określa typ porównania do wykonania podczas wyszukiwania określonego ciągu.

LastIndexOf(String, StringComparison)

Raportuje indeks oparty na zerze ostatniego wystąpienia określonego ciągu w bieżącym String obiekcie. Parametr określa typ wyszukiwania do użycia dla określonego ciągu.

LastIndexOfAny(Char[])

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia — w tym przypadku jeden znak lub więcej, określone w tablicy Unicode.

LastIndexOfAny(Char[], Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia — w tym przypadku jeden znak lub więcej, określone w tablicy Unicode. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków.

LastIndexOfAny(Char[], Int32, Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia — w tym przypadku jeden znak lub więcej, określone w tablicy Unicode. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaków.

MemberwiseClone()

Tworzy płytkią kopię bieżącego Objectelementu .

(Odziedziczone po Object)
Normalize()

Zwraca nowy ciąg, którego wartość tekstowa jest taka sama jak ten ciąg, ale którego reprezentacja binarna znajduje się w postaci normalizacji Unicode C.

Normalize(NormalizationForm)

Zwraca nowy ciąg, którego wartość tekstowa jest taka sama jak ten ciąg, ale którego reprezentacja binarna znajduje się w określonej postaci normalizacji Unicode.

PadLeft(Int32)

Zwraca nowy ciąg, który wyrównuje znaki w tym wystąpieniu, dopełniając je spacjami po lewej stronie dla określonej całkowitej długości.

PadLeft(Int32, Char)

Zwraca nowy ciąg, który wyrównuje znaki w tym wystąpieniu, dopełniając je po lewej stronie określonym znakiem Unicode dla określonej całkowitej długości.

PadRight(Int32)

Zwraca nowy ciąg, który wyrównuje znaki w tym ciągu, dopełniając je spacjami po prawej stronie dla określonej całkowitej długości.

PadRight(Int32, Char)

Zwraca nowy ciąg, który wyrównuje znaki w tym ciągu, dopełniając je po prawej stronie określonym znakiem Unicode dla określonej długości całkowitej.

Remove(Int32)

Zwraca nowy ciąg, w którym wszystkie znaki w bieżącym wystąpieniu, począwszy od określonej pozycji i kontynuując ostatnią pozycję, zostały usunięte.

Remove(Int32, Int32)

Zwraca nowy ciąg, w którym usunięto określoną liczbę znaków w bieżącym wystąpieniu rozpoczynającym się od określonej pozycji.

Replace(Char, Char)

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego znaku Unicode w tym wystąpieniu są zastępowane innym określonym znakiem Unicode.

Replace(String, String)

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem.

Replace(String, String, Boolean, CultureInfo)

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem przy użyciu podanej kultury i poufności liter.

Replace(String, String, StringComparison)

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem przy użyciu podanego typu porównania.

ReplaceLineEndings()

Zastępuje wszystkie nowe sekwencje w bieżącym ciągu ciągiem NewLine.

ReplaceLineEndings(String)

Zastępuje wszystkie sekwencje nowego wiersza w bieżącym ciągu ciągiem replacementText.

Split(Char, Int32, StringSplitOptions)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie określonego znaku ogranicznika i opcjonalnie opcji. Dzieli ciąg na maksymalną liczbę podciągów na podstawie podanego separatora znaków, opcjonalnie pomijając puste podciągy z wyniku.

Split(Char, StringSplitOptions)

Dzieli ciąg na podciągi na podstawie określonego znaku ogranicznika i opcjonalnie opcji.

Split(Char[])

Dzieli ciąg na podciągi na podstawie określonych znaków ograniczników.

Split(Char[], Int32)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie określonych znaków ograniczników.

Split(Char[], Int32, StringSplitOptions)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie określonych znaków ograniczników i, opcjonalnie, opcji.

Split(Char[], StringSplitOptions)

Dzieli ciąg na podciągi na podstawie określonych znaków i opcji ograniczeń.

Split(String, Int32, StringSplitOptions)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie określonego ciągu ogranicznika i opcjonalnie opcji.

Split(String, StringSplitOptions)

Dzieli ciąg na podciągy oparte na podanym separatorze ciągów.

Split(String[], Int32, StringSplitOptions)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie określonych ciągów ograniczników i opcjonalnie opcji.

Split(String[], StringSplitOptions)

Dzieli ciąg na podciągi na podstawie określonego ciągu rozdzielającego i, opcjonalnie, opcji.

StartsWith(Char)

Określa, czy to wystąpienie ciągu rozpoczyna się od określonego znaku.

StartsWith(String)

Określa, czy początek tego wystąpienia ciągu jest zgodny z określonym ciągiem.

StartsWith(String, Boolean, CultureInfo)

Określa, czy początek tego wystąpienia ciągu jest zgodny z określonym ciągiem w porównaniu z określoną kulturą.

StartsWith(String, StringComparison)

Określa, czy początek tego wystąpienia ciągu jest zgodny z określonym ciągiem w porównaniu przy użyciu określonej opcji porównania.

Substring(Int32)

Pobiera podciąg z tego wystąpienia. Podciąg zaczyna się od określonego położenia znaku i kontynuuje koniec ciągu.

Substring(Int32, Int32)

Pobiera podciąg z tego wystąpienia. Podciąg zaczyna się od określonej pozycji znaku i ma określoną długość.

ToCharArray()

Kopiuje znaki w tym wystąpieniu do tablicy znaków Unicode.

ToCharArray(Int32, Int32)

Kopiuje znaki w określonym podciągu w tym wystąpieniu do tablicy znaków Unicode.

ToLower()

Zwraca kopię tego ciągu przekonwertowaną na małe litery.

ToLower(CultureInfo)

Zwraca kopię tego ciągu przekonwertowaną na małe litery przy użyciu reguł wielkości liter określonej kultury.

ToLowerInvariant()

Zwraca kopię tego String obiektu przekonwertowaną na małe litery przy użyciu reguł wielkości liter niezmiennej kultury.

ToString()

Zwraca to wystąpienie klasy String; nie jest wykonywana żadna rzeczywista konwersja.

ToString(IFormatProvider)

Zwraca to wystąpienie klasy String; nie jest wykonywana żadna rzeczywista konwersja.

ToUpper()

Zwraca kopię tego ciągu przekonwertowaną na wielkie litery.

ToUpper(CultureInfo)

Zwraca kopię tego ciągu przekonwertowaną na wielkie litery przy użyciu reguł wielkości liter określonej kultury.

ToUpperInvariant()

Zwraca kopię tego String obiektu przekonwertowaną na wielkie litery przy użyciu reguł wielkości liter niezmiennej kultury.

Trim()

Usuwa wszystkie wiodące i końcowe znaki odstępu z bieżącego ciągu.

Trim(Char)

Usuwa wszystkie wiodące i końcowe wystąpienia znaku z bieżącego ciągu.

Trim(Char[])

Usuwa wszystkie wiodące i końcowe wystąpienia zestawu znaków określonego w tablicy z bieżącego ciągu.

TrimEnd()

Usuwa wszystkie końcowe znaki odstępu z bieżącego ciągu.

TrimEnd(Char)

Usuwa wszystkie końcowe wystąpienia znaku z bieżącego ciągu.

TrimEnd(Char[])

Usuwa wszystkie końcowe wystąpienia zestawu znaków określonego w tablicy z bieżącego ciągu.

TrimStart()

Usuwa wszystkie wiodące znaki odstępu z bieżącego ciągu.

TrimStart(Char)

Usuwa wszystkie wiodące wystąpienia określonego znaku z bieżącego ciągu.

TrimStart(Char[])

Usuwa wszystkie wiodące wystąpienia zestawu znaków określonych w tablicy z bieżącego ciągu.

TryCopyTo(Span<Char>)

Kopiuje zawartość tego ciągu do zakresu docelowego.

Operatory

Equality(String, String)

Określa, czy dwa określone ciągi mają tę samą wartość.

Implicit(String to ReadOnlySpan<Char>)

Definiuje niejawną konwersję danego ciągu na zakres znaków tylko do odczytu.

Inequality(String, String)

Określa, czy dwa określone ciągi mają różne wartości.

Jawne implementacje interfejsu

IComparable.CompareTo(Object)

Porównuje to wystąpienie z określonym Object wystąpieniem i wskazuje, czy to wystąpienie poprzedza, następuje lub pojawia się w tej samej pozycji w kolejności sortowania co określony Object.

IConvertible.GetTypeCode()

Zwraca wartość TypeCode dla String klasy .

IConvertible.ToBoolean(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)

Aby uzyskać opis tego członka, zobacz ToString(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który iteruje bieżący String obiekt.

IEnumerable<Char>.GetEnumerator()

Zwraca moduł wyliczający, który iteruje bieżący String obiekt.

Metody rozszerzania

ToImmutableArray<TSource>(IEnumerable<TSource>)

Tworzy niezmienną tablicę z określonej kolekcji.

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

Tworzy niezmienny słownik z istniejącej kolekcji elementów, stosując funkcję przekształcania do kluczy źródłowych.

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

Tworzy niezmienny słownik na podstawie niektórych przekształceń sekwencji.

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

Wylicza i przekształca sekwencję oraz tworzy niezmienny słownik jego zawartości.

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

Wylicza i przekształca sekwencję oraz tworzy niezmienny słownik jego zawartości przy użyciu określonego modułu porównania kluczy.

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

Wylicza i przekształca sekwencję oraz tworzy niezmienny słownik jego zawartości przy użyciu określonych porównań kluczy i wartości.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Wylicza sekwencję i tworzy niezmienny zestaw skrótów jego zawartości.

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

Wylicza sekwencję, tworzy niezmienny zestaw skrótów jego zawartości i używa określonego porównania równości dla typu zestawu.

ToImmutableList<TSource>(IEnumerable<TSource>)

Wylicza sekwencję i tworzy niezmienną listę jego zawartości.

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

Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości.

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

Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości przy użyciu określonego modułu porównywania kluczy.

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

Wylicza i przekształca sekwencję i tworzy niezmienny posortowany słownik jego zawartości przy użyciu określonych porównań kluczy i wartości.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Wylicza sekwencję i tworzy niezmienny zestaw posortowany jego zawartości.

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

Wylicza sekwencję, tworzy niezmienny zestaw posortowany jego zawartości i używa określonego porównania.

CopyToDataTable<T>(IEnumerable<T>)

Zwraca element DataTable zawierający kopie DataRow obiektów, biorąc pod uwagę obiekt wejściowy IEnumerable<T> , w którym parametr T ogólny to DataRow.

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

Kopiuje DataRow obiekty do określonego DataTableobiektu , podanego obiektu wejściowego IEnumerable<T> , w którym parametr T ogólny to DataRow.

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

Kopiuje DataRow obiekty do określonego DataTableobiektu , podanego obiektu wejściowego IEnumerable<T> , w którym parametr T ogólny to DataRow.

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

Stosuje funkcję akumulatora po sekwencji.

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

Stosuje funkcję akumulatora po sekwencji. Określona wartość inicjatora jest używana jako początkowa wartość akumulatorowa.

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

Stosuje funkcję akumulatora po sekwencji. Określona wartość inicjatora jest używana jako początkowa wartość akumulatorowa, a określona funkcja służy do wybierania wartości wyniku.

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

Określa, czy wszystkie elementy sekwencji spełniają warunek.

Any<TSource>(IEnumerable<TSource>)

Określa, czy sekwencja zawiera jakiekolwiek elementy.

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

Określa, czy dowolny element sekwencji spełnia warunek.

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

Dołącza wartość na końcu sekwencji.

AsEnumerable<TSource>(IEnumerable<TSource>)

Zwraca dane wejściowe wpisane jako IEnumerable<T>.

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

Oblicza średnią sekwencji Decimal wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza średnią sekwencji Double wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza średnią sekwencji Int32 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza średnią sekwencji Int64 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza średnią sekwencji wartości dopuszczających Decimal wartość null, które są uzyskiwane przez wywołanie funkcji transform na każdym elemecie sekwencji danych wejściowych.

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

Oblicza średnią sekwencji wartości dopuszczających Double wartość null, które są uzyskiwane przez wywołanie funkcji transform na każdym elemecie sekwencji danych wejściowych.

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

Oblicza średnią sekwencji wartości dopuszczających Int32 wartość null, które są uzyskiwane przez wywołanie funkcji transform na każdym elemecie sekwencji danych wejściowych.

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

Oblicza średnią sekwencji wartości dopuszczających Int64 wartość null, które są uzyskiwane przez wywołanie funkcji transform na każdym elemecie sekwencji danych wejściowych.

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

Oblicza średnią sekwencji wartości dopuszczających Single wartość null, które są uzyskiwane przez wywołanie funkcji transform na każdym elemecie sekwencji danych wejściowych.

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

Oblicza średnią sekwencji Single wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

Cast<TResult>(IEnumerable)

Rzutuje elementy elementu IEnumerable na określony typ.

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

Dzieli elementy sekwencji na fragmenty rozmiaru w większości size.

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

Łączy dwie sekwencje.

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

Określa, czy sekwencja zawiera określony element przy użyciu domyślnego porównywania równości.

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

Określa, czy sekwencja zawiera określony element przy użyciu określonego IEqualityComparer<T>elementu .

Count<TSource>(IEnumerable<TSource>)

Zwraca liczbę elementów w sekwencji.

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

Zwraca liczbę reprezentującą, ile elementów w określonej sekwencji spełnia warunek.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Zwraca elementy określonej sekwencji lub wartość domyślną parametru typu w kolekcji pojedynczej, jeśli sekwencja jest pusta.

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

Zwraca elementy określonej sekwencji lub określoną wartość w kolekcji pojedynczej, jeśli sekwencja jest pusta.

Distinct<TSource>(IEnumerable<TSource>)

Zwraca różne elementy z sekwencji przy użyciu domyślnego modułu porównania równości do porównywania wartości.

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

Zwraca różne elementy z sekwencji przy użyciu określonej IEqualityComparer<T> wartości w celu porównania wartości.

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

Zwraca różne elementy z sekwencji zgodnie z określoną funkcją selektora kluczy.

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

Zwraca różne elementy z sekwencji zgodnie z określoną funkcją selektora kluczy i przy użyciu określonego modułu porównującego do porównywania kluczy.

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

Zwraca element w określonym indeksie w sekwencji.

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

Zwraca element w określonym indeksie w sekwencji.

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

Zwraca element w określonym indeksie w sekwencji lub wartość domyślną, jeśli indeks jest poza zakresem.

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

Zwraca element w określonym indeksie w sekwencji lub wartość domyślną, jeśli indeks jest poza zakresem.

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

Tworzy różnicę zestawu dwóch sekwencji przy użyciu domyślnego porównania równości do porównywania wartości.

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

Tworzy różnicę zestawu dwóch sekwencji przy użyciu określonej IEqualityComparer<T> wartości do porównania wartości.

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

Tworzy różnicę zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.

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

Tworzy różnicę zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.

First<TSource>(IEnumerable<TSource>)

Zwraca pierwszy element sekwencji.

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

Zwraca pierwszy element w sekwencji, który spełnia określony warunek.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Zwraca pierwszy element sekwencji lub wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.

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

Zwraca pierwszy element sekwencji lub określoną wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.

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

Zwraca pierwszy element sekwencji, który spełnia warunek lub wartość domyślną, jeśli taki element nie zostanie znaleziony.

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

Zwraca pierwszy element sekwencji, który spełnia warunek lub określoną wartość domyślną, jeśli taki element nie zostanie znaleziony.

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

Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy.

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

Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy i porównuje klucze przy użyciu określonego modułu porównującego.

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

Grupuje elementy sekwencji zgodnie z określoną funkcją selektora kluczy i projektuje elementy dla każdej grupy przy użyciu określonej funkcji.

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

Grupuje elementy sekwencji zgodnie z funkcją selektora kluczy. Klucze są porównywane przy użyciu modułu porównania, a elementy każdej grupy są przewidywane przy użyciu określonej funkcji.

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

Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza.

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

Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Klucze są porównywane przy użyciu określonego porównania.

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

Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Elementy każdej grupy są przewidywane przy użyciu określonej funkcji.

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

Grupuje elementy sekwencji zgodnie z określoną kluczową funkcją wyboru i tworzy wartość wyniku z każdej grupy i klucza. Wartości klucza są porównywane przy użyciu określonego porównania, a elementy każdej grupy są przewidywane przy użyciu określonej funkcji.

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

Koreluje elementy dwóch sekwencji na podstawie równości kluczy i grupuje wyniki. Domyślny moduł porównujący równości służy do porównywania kluczy.

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

Koreluje elementy dwóch sekwencji na podstawie równości klucza i grupuje wyniki. Określony IEqualityComparer<T> element służy do porównywania kluczy.

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

Tworzy część wspólną zestawu dwóch sekwencji przy użyciu domyślnego modułu porównania równości do porównywania wartości.

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

Tworzy część wspólną zestawu dwóch sekwencji, używając określonej IEqualityComparer<T> wartości do porównania wartości.

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

Tworzy przecięcie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.

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

Tworzy przecięcie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.

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

Koreluje elementy dwóch sekwencji na podstawie pasujących kluczy. Domyślny moduł porównywania równości służy do porównywania kluczy.

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

Koreluje elementy dwóch sekwencji na podstawie pasujących kluczy. Określony IEqualityComparer<T> jest używany do porównywania kluczy.

Last<TSource>(IEnumerable<TSource>)

Zwraca ostatni element sekwencji.

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

Zwraca ostatni element sekwencji, który spełnia określony warunek.

LastOrDefault<TSource>(IEnumerable<TSource>)

Zwraca ostatni element sekwencji lub wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.

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

Zwraca ostatni element sekwencji lub określoną wartość domyślną, jeśli sekwencja nie zawiera żadnych elementów.

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

Zwraca ostatni element sekwencji, który spełnia warunek lub wartość domyślną, jeśli taki element nie zostanie znaleziony.

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

Zwraca ostatni element sekwencji, który spełnia warunek lub określoną wartość domyślną, jeśli taki element nie zostanie znaleziony.

LongCount<TSource>(IEnumerable<TSource>)

Zwraca element Int64 reprezentujący całkowitą liczbę elementów w sekwencji.

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

Zwraca element Int64 reprezentujący liczbę elementów w sekwencji spełniających warunek.

Max<TSource>(IEnumerable<TSource>)

Zwraca wartość maksymalną w sekwencji ogólnej.

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

Zwraca wartość maksymalną w sekwencji ogólnej.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Decimal wartość.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Double wartość.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Int32 wartość.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Int64 wartość.

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

Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Decimal do wartości null.

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

Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Double do wartości null.

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

Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Int32 do wartości null.

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

Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Int64 do wartości null.

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

Wywołuje funkcję przekształcania dla każdego elementu sekwencji i zwraca maksymalną wartość dopuszczaną Single do wartości null.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca maksymalną Single wartość.

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

Wywołuje funkcję transform dla każdego elementu sekwencji ogólnej i zwraca maksymalną wynikową wartość.

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

Zwraca wartość maksymalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy.

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

Zwraca wartość maksymalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy i modułem porównującym klucz.

Min<TSource>(IEnumerable<TSource>)

Zwraca wartość minimalną w sekwencji ogólnej.

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

Zwraca wartość minimalną w sekwencji ogólnej.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Decimal .

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Double .

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Int32 .

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Int64 .

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Decimal do wartości null.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Double do wartości null.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Int32 do wartości null.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Int64 do wartości null.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca minimalną wartość dopuszczaną Single do wartości null.

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

Wywołuje funkcję transform dla każdego elementu sekwencji i zwraca wartość minimalną Single .

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

Wywołuje funkcję transform dla każdego elementu sekwencji ogólnej i zwraca minimalną wynikową wartość.

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

Zwraca wartość minimalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy.

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

Zwraca wartość minimalną w sekwencji ogólnej zgodnie z określoną funkcją selektora kluczy i modułem porównującym klucz.

OfType<TResult>(IEnumerable)

Filtruje elementy elementu IEnumerable na podstawie określonego typu.

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

Sortuje elementy sekwencji w kolejności rosnącej zgodnie z kluczem.

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

Sortuje elementy sekwencji w kolejności rosnącej przy użyciu określonego porównania.

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

Sortuje elementy sekwencji w kolejności malejącej zgodnie z kluczem.

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

Sortuje elementy sekwencji w kolejności malejącej przy użyciu określonego porównania.

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

Dodaje wartość na początku sekwencji.

Reverse<TSource>(IEnumerable<TSource>)

Odwraca kolejność elementów w sekwencji.

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

Projektuje każdy element sekwencji w nowym formularzu.

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

Projektuje każdy element sekwencji w nowym formularzu przez dołączenie indeksu elementu.

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

Projektuje każdy element sekwencji i IEnumerable<T> spłaszcza wynikowe sekwencje w jedną sekwencję.

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

Projektuje każdy element sekwencji do IEnumerable<T>obiektu i spłaszcza wynikowe sekwencje w jedną sekwencję. Indeks każdego elementu źródłowego jest używany w przewidywanej formie tego elementu.

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

Projektuje każdy element sekwencji do IEnumerable<T>obiektu , spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym z nich.

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

Projektuje każdy element sekwencji do IEnumerable<T>obiektu , spłaszcza wynikowe sekwencje w jedną sekwencję i wywołuje funkcję selektora wyników w każdym z nich. Indeks każdego elementu źródłowego jest używany w pośredniej przewidywanej formie tego elementu.

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

Określa, czy dwie sekwencje są równe, porównując elementy przy użyciu domyślnego porównania równości dla ich typu.

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

Określa, czy dwie sekwencje są równe, porównując ich elementy przy użyciu określonego IEqualityComparer<T>elementu .

Single<TSource>(IEnumerable<TSource>)

Zwraca jedyny element sekwencji i zgłasza wyjątek, jeśli nie ma dokładnie jednego elementu w sekwencji.

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

Zwraca jedyny element sekwencji, który spełnia określony warunek, i zgłasza wyjątek, jeśli istnieje więcej niż jeden taki element.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Zwraca jedyny element sekwencji lub wartość domyślną, jeśli sekwencja jest pusta; Ta metoda zgłasza wyjątek, jeśli w sekwencji znajduje się więcej niż jeden element.

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

Zwraca jedyny element sekwencji lub określoną wartość domyślną, jeśli sekwencja jest pusta; Ta metoda zgłasza wyjątek, jeśli w sekwencji znajduje się więcej niż jeden element.

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

Zwraca jedyny element sekwencji, który spełnia określony warunek lub wartość domyślną, jeśli taki element nie istnieje; Ta metoda zgłasza wyjątek, jeśli warunek spełnia więcej niż jeden element.

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

Zwraca jedyny element sekwencji, który spełnia określony warunek lub określoną wartość domyślną, jeśli taki element nie istnieje; Ta metoda zgłasza wyjątek, jeśli warunek spełnia więcej niż jeden element.

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

Pomija określoną liczbę elementów w sekwencji, a następnie zwraca pozostałe elementy.

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

Zwraca nową kolekcję wyliczalną zawierającą elementy z source ostatnich count elementów kolekcji źródłowej pominiętą.

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

Pomija elementy w sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe elementy.

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

Pomija elementy w sekwencji, o ile określony warunek jest spełniony, a następnie zwraca pozostałe elementy. Indeks elementu jest używany w logice funkcji predykatu.

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

Oblicza sumę sekwencji Decimal wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza sumę sekwencji Double wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza sumę sekwencji Int32 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza sumę sekwencji Int64 wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Oblicza sumę sekwencji wartości null, które są uzyskiwane Decimal przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.

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

Oblicza sumę sekwencji wartości null, które są uzyskiwane Double przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.

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

Oblicza sumę sekwencji wartości null, które są uzyskiwane Int32 przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.

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

Oblicza sumę sekwencji wartości null, które są uzyskiwane Int64 przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.

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

Oblicza sumę sekwencji wartości null, które są uzyskiwane Single przez wywołanie funkcji transform w każdym elemecie sekwencji danych wejściowych.

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

Oblicza sumę sekwencji Single wartości uzyskanych przez wywołanie funkcji przekształcania dla każdego elementu sekwencji danych wejściowych.

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

Zwraca określoną liczbę ciągłych elementów od początku sekwencji.

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

Zwraca określony zakres ciągłych elementów z sekwencji.

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

Zwraca nową kolekcję wyliczalną zawierającą ostatnie count elementy z klasy source.

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

Zwraca elementy z sekwencji, o ile określony warunek ma wartość true.

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

Zwraca elementy z sekwencji, o ile określony warunek ma wartość true. Indeks elementu jest używany w logice funkcji predykatu.

ToArray<TSource>(IEnumerable<TSource>)

Tworzy tablicę na podstawie elementu IEnumerable<T>.

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

Tworzy obiekt Dictionary<TKey,TValue> na podstawie IEnumerable<T> określonej funkcji selektora klucza.

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

Tworzy element Dictionary<TKey,TValue> IEnumerable<T> na podstawie określonej funkcji selektora kluczy i modułu porównania kluczy.

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

Tworzy element Dictionary<TKey,TValue> IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.

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

Tworzy element Dictionary<TKey,TValue> na IEnumerable<T> podstawie określonej funkcji selektora kluczy, modułu porównania i funkcji selektora elementów.

ToHashSet<TSource>(IEnumerable<TSource>)

Tworzy obiekt na HashSet<T> podstawie elementu IEnumerable<T>.

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

Tworzy obiekt HashSet<T> IEnumerable<T> na podstawie polecenia , comparer aby porównać klucze.

ToList<TSource>(IEnumerable<TSource>)

Tworzy obiekt na List<T> podstawie elementu IEnumerable<T>.

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

Tworzy element Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora kluczy.

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

Tworzy element Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora kluczy i modułu porównywania kluczy.

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

Tworzy element Lookup<TKey,TElement> IEnumerable<T> na podstawie określonych funkcji selektora kluczy i selektora elementów.

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

Tworzy element Lookup<TKey,TElement> na podstawie IEnumerable<T> określonej funkcji selektora kluczy, funkcji selektora elementów i selektora elementów.

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

Próbuje określić liczbę elementów w sekwencji bez wymuszania wyliczenia.

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

Tworzy połączenie zestawu dwóch sekwencji przy użyciu domyślnego porównania równości.

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

Tworzy zestaw unii dwóch sekwencji przy użyciu określonego IEqualityComparer<T>.

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

Tworzy połączenie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.

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

Tworzy połączenie zestawu dwóch sekwencji zgodnie z określoną funkcją selektora kluczy.

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

Filtruje sekwencję wartości na podstawie predykatu.

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

Filtruje sekwencję wartości na podstawie predykatu. Indeks każdego elementu jest używany w logice funkcji predykatu.

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

Tworzy sekwencję krotki z elementami z dwóch określonych sekwencji.

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

Tworzy sekwencję krotki z elementami z trzech określonych sekwencji.

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

Stosuje określoną funkcję do odpowiednich elementów dwóch sekwencji, tworząc sekwencję wyników.

AsParallel(IEnumerable)

Umożliwia równoległość zapytania.

AsParallel<TSource>(IEnumerable<TSource>)

Umożliwia równoległość zapytania.

AsQueryable(IEnumerable)

Konwertuje element IEnumerable na .IQueryable

AsQueryable<TElement>(IEnumerable<TElement>)

Konwertuje rodzajową na ogólną IEnumerable<T> IQueryable<T>wartość .

AsMemory(String)

Tworzy nowy ReadOnlyMemory<Char> element na części ciągu docelowego.

AsMemory(String, Index)

Tworzy nową ReadOnlyMemory<Char> część ciągu docelowego rozpoczynającego się od określonego indeksu.

AsMemory(String, Int32)

Tworzy nowy ReadOnlyMemory<Char> element na części ciągu docelowego rozpoczynającego się od określonej pozycji znaku.

AsMemory(String, Int32, Int32)

Tworzy nowy ReadOnlyMemory<Char> element na części ciągu docelowego rozpoczynającego się od określonej pozycji o długości.

AsMemory(String, Range)

Tworzy nową ReadOnlyMemory<Char> wartość dla określonego zakresu ciągu docelowego.

AsSpan(String)

Tworzy nowy zakres tylko do odczytu dla ciągu.

AsSpan(String, Int32)

Tworzy nowy zakres tylko do odczytu na części ciągu docelowego z określonej pozycji na końcu ciągu.

AsSpan(String, Int32, Int32)

Tworzy nowy zakres tylko do odczytu na części ciągu docelowego z określonej pozycji dla określonej liczby znaków.

IsNormalized(String)

Wskazuje, czy określony ciąg znajduje się w postaci normalizacji Unicode C.

IsNormalized(String, NormalizationForm)

Wskazuje, czy ciąg znajduje się w określonym formularzu normalizacji Unicode.

Normalize(String)

Normalizuje ciąg w postaci normalizacji Unicode C.

Normalize(String, NormalizationForm)

Normalizuje ciąg do określonego formularza normalizacji Unicode.

Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy główne każdego węzła w kolekcji źródłowej.

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

Zwraca filtrowaną kolekcję elementów, które zawierają elementy główne każdego węzła w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .

DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.

Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.

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

Zwraca filtrowaną kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .

Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.

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

Zwraca odfiltrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej. W kolekcji znajdują się tylko elementy, które mają dopasowanie XName .

InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów zawierającą wszystkie węzły w kolekcji źródłowej posortowane w kolejności dokumentu.

Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.

Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.

Zobacz też