String Klasse

Definition

Stellt Text als Sequenz von UTF-16-Codeeinheiten dar.

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)
Vererbung
String
Attribute
Implementiert

Hinweise

Eine Zeichenfolge ist eine sequenzielle Auflistung von Zeichen, die zum Darstellen von Text verwendet werden. Ein String Objekt ist eine sequenzielle Auflistung von System.Char Objekten, die eine Zeichenfolge darstellen. Ein System.Char Objekt entspricht einer UTF-16-Codeeinheit. Der Wert des String Objekts ist der Inhalt der sequenziellen Auflistung von System.Char Objekten und dieser Wert ist unveränderlich (also schreibgeschützt). Weitere Informationen zur Unveränderlichkeit von Zeichenfolgen finden Sie im Abschnitt " Unveränderlichkeit" und im Abschnitt "StringBuilder-Klasse ". Die maximale Größe eines String Objekts im Arbeitsspeicher beträgt 2 GB oder etwa 1 Milliarden Zeichen.

Weitere Informationen zu Unicode, UTF-16, Codeeinheiten, Codepunkten und den Char Rune Und-Typen finden Sie in der Einführung in die Zeichencodierung in .NET.

In diesem Abschnitt

Instanziieren eines String-Objekts
Char-Objekte und Unicode-Zeichen
Zeichenfolgen und Der Unicode-Standard
Zeichenfolgen und eingebettete Nullzeichen
Zeichenfolgen und Indizes
Nullzeichenfolgen und leere Zeichenfolgen
Unveränderlichkeit und die StringBuilder-Klasse
Ordnungs- und Kulturempfindliche Vorgänge
Normalisierung
Zeichenfolgenvorgänge nach Kategorie

Instanziieren eines String-Objekts

Sie können ein String Objekt auf folgende Weise instanziieren:

  • Durch Zuweisen eines Zeichenfolgenliterals zu einer String Variablen. Dies ist die am häufigsten verwendete Methode zum Erstellen einer Zeichenfolge. Im folgenden Beispiel wird die Zuordnung verwendet, um mehrere Zeichenfolgen zu erstellen. Beachten Sie, dass in C# und F#, da der umgekehrte Schrägstrich (\) ein Escapezeichen ist, die Literalrückstriche in einer Zeichenfolge escaped sein müssen oder die gesamte Zeichenfolge sein @-quotedmuss.

    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
    
  • Durch Aufrufen eines String Klassenkonstruktors. Im folgenden Beispiel werden Zeichenfolgen instanziiert, indem mehrere Klassenkonstruktoren aufgerufen werden. Beachten Sie, dass einige der Konstruktoren Zeiger auf Zeichenarrays oder signierte Bytearrays als Parameter enthalten. Visual Basic unterstützt keine Aufrufe dieser Konstruktoren. Ausführliche Informationen zu String Konstruktoren finden Sie in der String Konstruktorzusammenfassung.

    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
    
  • Verwenden Sie den Zeichenfolgenverkettungsoperator (+ in C# und F# und & oder + in Visual Basic), um eine einzelne Zeichenfolge aus einer beliebigen Kombination von String Instanzen und Zeichenfolgenliteralen zu erstellen. Im folgenden Beispiel wird die Verwendung des Zeichenfolgenverkettungsoperators veranschaulicht.

    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.
    
  • Durch Abrufen einer Eigenschaft oder Aufrufen einer Methode, die eine Zeichenfolge zurückgibt. Im folgenden Beispiel werden die Methoden der String Klasse verwendet, um eine Teilzeichenfolge aus einer größeren Zeichenfolge zu extrahieren.

    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
    
  • Durch Aufrufen einer Formatierungsmethode zum Konvertieren eines Werts oder Objekts in die Zeichenfolgendarstellung. Im folgenden Beispiel wird das Zusammengesetztformatierungsfeature verwendet, um die Zeichenfolgendarstellung von zwei Objekten in eine Zeichenfolge einzubetten.

    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.
    

Char-Objekte und Unicode-Zeichen

Jedes Zeichen in einer Zeichenfolge wird durch einen Unicode-Skalarwert definiert, der auch als Unicode-Codepunkt oder den numerischen (numerischen) Wert des Unicode-Zeichens bezeichnet wird. Jeder Codepunkt wird mithilfe der UTF-16-Codierung codiert, und der numerische Wert jedes Elements der Codierung wird durch ein Char Objekt dargestellt.

Hinweis

Beachten Sie, dass eine String Instanz aus einer sequenziellen Auflistung von UTF-16-Codeeinheiten besteht, kann ein String Objekt erstellt werden, das keine gut gebildete Unicode-Zeichenfolge ist. Beispielsweise ist es möglich, eine Zeichenfolge zu erstellen, die ohne entsprechende hohe Surrogate eine niedrige Surrogate aufweist. Obwohl einige Methoden, z. B. die Methoden der Codierung und Decodierung von Objekten im System.Text Namespace, überprüfungen ausführen können, um sicherzustellen, dass Zeichenfolgen gut gebildet sind, stellen Klassenmember nicht sicher, String dass eine Zeichenfolge gut gebildet ist.

Ein einzelnes Char Objekt stellt in der Regel einen einzelnen Codepunkt dar. Das heißt, der numerische Wert des Codes ist gleich dem Char Codepunkt. Der Codepunkt für das Zeichen "a" lautet z. B. U+0061. Ein Codepunkt erfordert jedoch möglicherweise mehr als ein codiertes Element (mehr als ein Char Objekt). Der Unicode-Standard definiert zwei Zeichentypen, die mehreren Char Objekten entsprechen: Graphemes und Unicode-Zusatzcodepunkte, die Zeichen in den Unicode-Zusatzebenen entsprechen.

  • Ein Graphem wird durch ein Basiszeichen dargestellt, gefolgt von einem oder mehreren kombinierten Zeichen. Das Zeichen ä wird beispielsweise durch ein Char Objekt dargestellt, dessen Codepunkt U+0061 ist, gefolgt von einem Char Objekt, dessen Codepunkt U+0308 ist. Dieses Zeichen kann auch durch ein einzelnes Char Objekt definiert werden, das über einen Codepunkt von U+00E4 verfügt. Wie das folgende Beispiel zeigt, gibt ein kulturempfindlicher Vergleich für Gleichheit an, dass diese beiden Darstellungen gleich sind, obwohl ein gewöhnlicher Ordinalvergleich nicht erfolgt. Wenn die beiden Zeichenfolgen jedoch normalisiert sind, gibt ein Ordinalvergleich auch an, dass sie gleich sind. (Weitere Informationen zur Normalisierung von Zeichenfolgen finden Sie im Abschnitt " Normalisierung ".)

    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
    
  • Ein Unicode-Zusatzcodepunkt (ein Surrogate-Paar) wird durch ein Char Objekt dargestellt, dessen Codepunkt ein hohes Surrogate ist, gefolgt von einem Char Objekt, dessen Codepunkt ein niedriger Surrogate ist. Die Codeeinheiten hoher Surrogate reichen von U+D800 bis U+DBFF. Die Codeeinheiten niedriger Surrogate reichen von U+DC00 bis U+DFFF. Surrogate-Paare werden verwendet, um Zeichen in den zusätzlichen 16 Unicode-Ebenen darzustellen. Im folgenden Beispiel wird ein Surrogatezeichen erstellt und an die Char.IsSurrogatePair(Char, Char) Methode übergeben, um zu bestimmen, ob es sich um ein Surrogate-Paar handelt.

    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
    

Zeichenfolgen und Unicode-Standard

Zeichen in einer Zeichenfolge werden durch UTF-16-codierte Codeeinheiten dargestellt, die Werten entsprechen Char .

Jedes Zeichen in einer Zeichenfolge weist eine zugeordnete Unicode-Zeichenkategorie auf, die in .NET durch die UnicodeCategory Enumeration dargestellt wird. Die Kategorie eines Zeichens oder eines Surrogate-Paares kann durch Aufrufen der CharUnicodeInfo.GetUnicodeCategory Methode bestimmt werden.

.NET verwaltet eine eigene Tabelle von Zeichen und entsprechenden Kategorien. Dadurch wird sichergestellt, dass eine bestimmte Version einer .NET-Implementierung, die auf unterschiedlichen Plattformen ausgeführt wird, identische Informationen zu Zeichenkategorien zurückgibt. In allen .NET-Versionen und auf allen Betriebssystemplattformen werden Zeichenkategorieinformationen von der Unicode-Zeichendatenbank bereitgestellt.

Die folgende Tabelle enthält die .NET-Versionen und die Versionen des Unicode-Standards, auf dem ihre Zeichenkategorien basieren.

.NET-Version Version des Unicode-Standards
.NET Framework 1.1 The Unicode Standard, Version 4.0.0 (Der Unicode-Standard, Version 4.0.0)
.NET Framework 2.0 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)
.NET Framework 3.5 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)
.NET Framework 4 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)
.NET Framework 4.5 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)
.NET Framework 4.5.1 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)
.NET Framework 4.5.2 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)
.NET Framework 4.6 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)
.NET Framework 4.6.1 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)
.NET Framework 4.6.2 und höhere Versionen The Unicode Standard, Version 8.0.0 (Der Unicode-Standard, Version 8.0.0)
.NET Core 2.1 The Unicode Standard, Version 8.0.0 (Der Unicode-Standard, Version 8.0.0)
.NET Core 3.1 Unicode-Standard, Version 11.0.0
.NET 5 Der Unicode-Standard, Version 13.0.0

Darüber hinaus unterstützt .NET Zeichenfolgenvergleich und Sortierung basierend auf dem Unicode-Standard. .NET Framework 4 und früheren Versionen verwalten eine eigene Tabelle mit Zeichenfolgendaten. Dies gilt auch für Versionen von .NET Framework ab .NET Framework 4.5, die auf Windows 7 ausgeführt werden. Beginnend mit .NET Framework 4.5, die auf Windows 8 und späteren Versionen des Windows Betriebssystems ausgeführt wird, stellvertretungen die Laufzeitzeichenfolgenvergleichs- und Sortiervorgänge an das Betriebssystem. Bei .NET Core und .NET 5+ werden Zeichenfolgenvergleichs- und Sortierinformationen von internationalen Komponenten für Unicode-Bibliotheken bereitgestellt (außer bei Windows Versionen vor Windows 10 May 2019 Update). In der folgenden Tabelle sind die Versionen von .NET und die Versionen des Unicode-Standards aufgeführt, auf denen Zeichenvergleich und Sortierung basieren.

.NET-Version Version des Unicode-Standards
.NET Framework 1.1 The Unicode Standard, Version 4.0.0 (Der Unicode-Standard, Version 4.0.0)
.NET Framework 2.0 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)
.NET Framework 3.5 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)
.NET Framework 4 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)
.NET Framework 4.5 und höher unter Windows 7 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)
.NET Framework 4.5 und höher auf Windows 8 und höher Windows Betriebssystemen The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)
.NET Core und .NET 5 und höher Hängt von der Version des Unicode-Standards ab, die vom zugrunde liegenden Betriebssystem unterstützt wird.

Zeichenfolgen und eingebettete Nullzeichen

In .NET kann ein String Objekt eingebettete NULL-Zeichen enthalten, die als Teil der Länge der Zeichenfolge zählen. In einigen Sprachen wie C und C++ gibt jedoch ein Nullzeichen das Ende einer Zeichenfolge an; es wird nicht als Teil der Zeichenfolge betrachtet und wird nicht als Teil der Länge der Zeichenfolge gezählt. Dies bedeutet, dass die folgenden allgemeinen Annahmen, dass C- und C++-Programmierer oder Bibliotheken, die in C oder C++ geschrieben wurden, möglicherweise nicht unbedingt gültig sind, wenn sie auf String Objekte angewendet werden:

  • Der von den strlen Funktionen wcslen zurückgegebene Wert entspricht nicht unbedingt String.Length.

  • Die durch die strcpy_s wcscpy_s Methode erstellte Zeichenfolge ist nicht unbedingt identisch mit der Zeichenfolge, die von der String.Copy Methode erstellt wurde.

Sie sollten sicherstellen, dass systemeigener C- und C++-Code, der Objekte instanziiert String , und Code, der über plattformbasiertes Aufrufen übergeben String wird, nicht davon aus, dass ein eingebettetes Nullzeichen das Ende der Zeichenfolge markiert.

Eingebettete NULL-Zeichen in einer Zeichenfolge werden auch anders behandelt, wenn eine Zeichenfolge sortiert (oder verglichen) und eine Zeichenfolge durchsucht wird. Nullzeichen werden ignoriert, wenn kulturempfindliche Vergleiche zwischen zwei Zeichenfolgen ausgeführt werden, einschließlich Vergleiche mithilfe der invarianten Kultur. Sie gelten nur für Ordinal- oder Groß-/Kleinschreibungsvergleiche. Andererseits werden eingebettete NULL-Zeichen immer berücksichtigt, wenn Sie eine Zeichenfolge mit Methoden wie , ContainsStartsWith, und IndexOf.

Zeichenfolgen und Indizes

Ein Index ist die Position eines Char Objekts (nicht ein Unicode-Zeichen) in einem String. Ein Index ist eine nullbasierte, nichtegative Zahl, die von der ersten Position in der Zeichenfolge beginnt, die indexposition null ist. Eine Reihe von Suchmethoden, z IndexOf . B. und LastIndexOf, geben den Index eines Zeichens oder einer Teilzeichenfolge in der Zeichenfolgeninstanz zurück.

Mit der Chars[] Eigenschaft können Sie auf einzelne Char Objekte über die Indexposition in der Zeichenfolge zugreifen. Da die Chars[] Eigenschaft die Standardeigenschaft (in Visual Basic) oder der Indexer (in C# und F#) ist, können Sie mithilfe von Code wie folgendem auf die einzelnen Char Objekte in einer Zeichenfolge zugreifen. Dieser Code sucht nach Leerzeichen oder Interpunktionszeichen in einer Zeichenfolge, um zu bestimmen, wie viele Wörter die Zeichenfolge enthält.

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.

Da die String Klasse die IEnumerable Schnittstelle implementiert, können Sie auch die Char Objekte in einer Zeichenfolge durchlaufen, indem Sie ein foreach Konstrukt verwenden, wie das folgende Beispiel zeigt.

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.

Aufeinanderfolgende Indexwerte entsprechen möglicherweise nicht aufeinander folgenden Unicode-Zeichen, da ein Unicode-Zeichen möglicherweise als mehr als ein Char Objekt codiert werden kann. Insbesondere kann eine Zeichenfolge mehrstellige Texteinheiten enthalten, die durch ein Basiszeichen gebildet werden, gefolgt von einem oder mehreren kombinierten Zeichen oder durch Surrogate-Paare. Um mit Unicode-Zeichen anstelle von Char Objekten zu arbeiten, verwenden Sie die System.Globalization.StringInfo Und-Klassen TextElementEnumerator oder die String.EnumerateRunes Methode und die Rune Struktur. Im folgenden Beispiel wird der Unterschied zwischen Code veranschaulicht, der mit Objekten und Code funktioniert, die mit Char Unicode-Zeichen funktionieren. Es vergleicht die Anzahl der Zeichen oder Textelemente in jedem Wort eines Satzes. Die Zeichenfolge enthält zwei Sequenzen eines Basiszeichens gefolgt von einem kombinierten Zeichen.

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

In diesem Beispiel werden Textelemente mithilfe der StringInfo.GetTextElementEnumerator Methode und der TextElementEnumerator Klasse zum Aufzählen aller Textelemente in einer Zeichenfolge verwendet. Sie können auch ein Array abrufen, das den Startindex jedes Textelements enthält, indem Sie die StringInfo.ParseCombiningCharacters Methode aufrufen.

Weitere Informationen zum Arbeiten mit Texteinheiten anstelle einzelner Char Werte finden Sie in der Einführung in die Zeichencodierung in .NET.

Nullzeichenfolgen und leere Zeichenfolgen

Eine Zeichenfolge, die deklariert wurde, aber kein Wert zugewiesen wurde, ist null. Der Versuch, Methoden für diese Zeichenfolge aufzurufen, löst eine NullReferenceException. Eine NULL-Zeichenfolge unterscheidet sich von einer leeren Zeichenfolge, die eine Zeichenfolge ist, deren Wert "" oder String.Empty"" ist. In einigen Fällen löst das Übergeben einer NULL-Zeichenfolge oder einer leeren Zeichenfolge als Argument in einem Methodenaufruf eine Ausnahme aus. Das Übergeben einer NULL-Zeichenfolge an die Int32.Parse Methode löst z. B. ein ArgumentNullException, und das Übergeben einer leeren Zeichenfolge löst eine FormatException. In anderen Fällen kann ein Methodenargument entweder eine NULL-Zeichenfolge oder eine leere Zeichenfolge sein. Wenn Sie beispielsweise eine IFormattable Implementierung für eine Klasse bereitstellen, möchten Sie sowohl eine NULL-Zeichenfolge als auch eine leere Zeichenfolge mit dem allgemeinen Formatbezeichner ("G") gleichsetzen.

Die String Klasse enthält die folgenden beiden Komfortmethoden, mit denen Sie testen können, ob eine Zeichenfolge oder leer ist null :

  • IsNullOrEmpty, der angibt, ob eine Zeichenfolge entweder null oder gleich String.Emptyist. Diese Methode beseitigt die Notwendigkeit, Code wie die folgenden zu verwenden:

    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, der angibt, ob eine Zeichenfolge gleich String.Emptyist nulloder ausschließlich aus Leerzeichen besteht. Diese Methode beseitigt die Notwendigkeit, Code wie die folgenden zu verwenden:

    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)
    

Im folgenden Beispiel wird die IsNullOrEmpty Methode in der IFormattable.ToString Implementierung einer benutzerdefinierten Temperature Klasse verwendet. Die Methode unterstützt die Zeichenfolgen "G", "C", "F" und "K". Wenn eine leere Formatzeichenfolge oder eine Formatzeichenfolge, deren Wert an die Methode übergeben wird null , wird der Wert in die Formatzeichenfolge "G" geändert.

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

Unveränderlichkeit und die StringBuilder-Klasse

Ein String Objekt wird als unveränderlich bezeichnet (schreibgeschützt), da sein Wert nach der Erstellung nicht geändert werden kann. Methoden, die erscheinen, um ein String Objekt zu ändern, geben tatsächlich ein neues String Objekt zurück, das die Änderung enthält.

Da Zeichenfolgen unveränderlich sind, können Zeichenfolgenmanipulationsroutinen, die wiederholte Ergänzungen oder Löschungen ausführen, was als eine einzelne Zeichenfolge erscheint, eine erhebliche Leistungsstrafe genau festlegen. Der folgende Code verwendet beispielsweise einen Zufallszahlengenerator, um eine Zeichenfolge mit 1000 Zeichen im Bereich 0x0001 zu 0x052F zu erstellen. Obwohl der Code die Zeichenfolgenkoncatenation verwendet, um ein neues Zeichen an die vorhandene Zeichenfolge namens stranzufügen, erstellt er tatsächlich ein neues String Objekt für jeden Verkettungsvorgang.

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

Sie können die StringBuilder Klasse anstelle der String Klasse für Vorgänge verwenden, die mehrere Änderungen am Wert einer Zeichenfolge vornehmen. Im Gegensatz zu Instanzen der String Klasse StringBuilder können Objekte stummgeschaltet werden. Wenn Sie Teilzeichenfolgen aus einer Zeichenfolge verketten, anfügen oder löschen, werden die Vorgänge in einer einzelnen Zeichenfolge ausgeführt. Wenn Sie das Ändern des Werts eines StringBuilder Objekts abgeschlossen haben, können Sie die StringBuilder.ToString Methode aufrufen, um ihn in eine Zeichenfolge zu konvertieren. Im folgenden Beispiel wird das String im vorherigen Beispiel verwendete Beispiel ersetzt, um 1000 zufällige Zeichen im Bereich zu verketten, um 0x0001 mit einem StringBuilder Objekt zu 0x052F.

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

Ordnungs- und Kulturempfindliche Vorgänge

Elemente der String Klasse führen entweder Ordinal- oder kulturempfindliche (sprachliche) Vorgänge für ein String Objekt aus. Ein Ordnungsvorgang wirkt auf den numerischen Wert jedes Char Objekts. Ein kulturempfindlicher Vorgang wirkt auf den Wert des String Objekts und berücksichtigt kulturspezifische Groß- und Kleinschreibung, Sortierung, Formatierung und Analyseregeln. Kulturempfindliche Vorgänge werden im Kontext einer explizit deklarierten Kultur oder der impliziten aktuellen Kultur ausgeführt. Die beiden Arten von Vorgängen können sehr unterschiedliche Ergebnisse erzeugen, wenn sie auf derselben Zeichenfolge ausgeführt werden.

.NET unterstützt auch kulturunabhängige Zeichenfolgenoperationen mit der invarianten Kultur (CultureInfo.InvariantCulture), die lose auf den Kultureinstellungen der englischen Sprache basiert, unabhängig von der Region. Im Gegensatz zu anderen System.Globalization.CultureInfo Einstellungen sind die Einstellungen der invarianten Kultur garantiert, dass sie auf einem einzelnen Computer, von System zu System und in allen Versionen von .NET konsistent bleiben. Die invariante Kultur kann als eine Art schwarzes Feld betrachtet werden, das die Stabilität von Zeichenfolgenvergleichen und die Reihenfolge in allen Kulturen gewährleistet.

Wichtig

Wenn Ihre Anwendung eine Sicherheitsentscheidung über einen symbolischen Bezeichner wie einen Dateinamen oder benannte Pipe oder über beibehaltene Daten wie die textbasierten Daten in einer XML-Datei vornimmt, sollte der Vorgang einen Ordinalvergleich anstelle eines kulturempfindlichen Vergleichs verwenden. Dies liegt daran, dass ein kulturempfindlicher Vergleich je nach der tatsächlichen Kultur unterschiedliche Ergebnisse erzielen kann, während ein Ordinalvergleich ausschließlich vom binären Wert der verglichenen Zeichen abhängt.

Wichtig

Die meisten Methoden, die Zeichenfolgenoperationen ausführen, umfassen eine Überladung mit einem Parameter vom Typ StringComparison, mit dem Sie angeben können, ob die Methode einen Ordinal- oder kulturempfindlichen Vorgang ausführt. Im Allgemeinen sollten Sie diese Überladung aufrufen, um die Absicht Ihres Methodenaufrufs klar zu machen. Bewährte Methoden und Anleitungen für die Verwendung von Ordnungs- und Kultur vertraulichen Vorgängen für Zeichenfolgen finden Sie unter Bewährte Methoden für die Verwendung von Zeichenfolgen.

Vorgänge für Groß- und Kleinschreibung, Analyse und Formatierung, Vergleich und Sortierung sowie Tests auf Gleichheit können entweder ordinal oder kulturempfindlich sein. In den folgenden Abschnitten werden die einzelnen Vorgangskategorien erläutert.

Tipp

Sie sollten immer eine Methodenüberladung aufrufen, die die Absicht des Methodenaufrufs deutlich macht. Anstatt beispielsweise die Compare(String, String) Methode zum Ausführen eines kulturempfindlichen Vergleichs von zwei Zeichenfolgen mithilfe der Konventionen der aktuellen Kultur aufzurufen, sollten Sie die Compare(String, String, StringComparison) Methode mit einem Wert StringComparison.CurrentCulture für das comparisonType Argument aufrufen. Weitere Informationen finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.

Sie können die Sortiergewichtstabellen herunterladen, eine Reihe von Textdateien, die Informationen zu den Zeichengewichten enthalten, die in Sortier- und Vergleichsvorgängen verwendet werden, aus den folgenden Links:

Schreibweise

Casing-Regeln bestimmen, wie die Groß-/Kleinschreibung eines Unicode-Zeichens geändert wird; Beispiel: von Kleinbuchstaben bis Großbuchstaben. Häufig wird ein Groß-/Kleinschreibungsvorgang vor einem Zeichenfolgenvergleich ausgeführt. Beispielsweise kann eine Zeichenfolge in Großbuchstaben konvertiert werden, damit sie mit einer anderen Großbuchstabenzeichenfolge verglichen werden kann. Sie können die Zeichen in einer Zeichenfolge in Kleinbuchstaben konvertieren, indem Sie die ToLower ToLowerInvariant Methode aufrufen, und Sie können sie in Großbuchstaben konvertieren, indem Sie die ToUpper ToUpperInvariant Methode aufrufen. Darüber hinaus können Sie die TextInfo.ToTitleCase Methode verwenden, um eine Zeichenfolge in den Titelfall zu konvertieren.

Hinweis

.NET Core nur auf Linux- und macOS-Systemen ausgeführt: Beim Sortierungsverhalten für die C- und Posix-Kulturen wird immer die Groß-/Kleinschreibung beachtet, da diese Kulturen nicht die erwartete Unicode-Sortierungsreihenfolge verwenden. Bei der Durchführung kulturrelevanter Sortiervorgänge ohne Unterscheidung von Groß-/Kleinschreibung wird empfohlen, eine andere Kultur als C oder Posix zu verwenden.

Casing-Vorgänge können auf den Regeln der aktuellen Kultur, einer angegebenen Kultur oder der invarianten Kultur basieren. Da Fallzuordnungen je nach verwendeter Kultur variieren können, kann das Ergebnis von Groß-/Kleinschreibungen je nach Kultur variieren. Die tatsächlichen Unterschiede bei der Großschreibung sind von drei Arten:

  • Unterschiede bei der Zuordnung des LATEINISCHEN GROßBUCHSTABENS I (U+0049), LATEINISCHER KLEINBUCHSTABEN I (U+0069), LATEINISCHER GROßBUCHSTABEN I MIT PUNKT OBEN (U+0130) und LATEINISCHER KLEINBUCHSTABEN DOTLESS I (U+0131). In den Kulturen tr-TR (Türkei)) und az-Latn-AZ (Aserbaidschan, Lateinisch) und in den Kulturen tr, az und az-Latn neutral ist das Kleinbuchstabenäquivalent DES LATEINISCHEN KLEINBUCHSTABENS I LATEINISCHE KLEINBUCHSTABEN DOTLESS I, und das Großbuchstabenäquivalent des LATEINISCHEN KLEINBUCHSTABENS I ist LATEINISCHER GROßBUCHSTABEN I MIT PUNKT OBEN. In allen anderen Kulturen, einschließlich der invarianten Kultur, LATEINISCHER KLEINBUCHSTABEN I und LATEINISCHER GROßBUCHSTABEN I sind Kleinbuchstaben und Großbuchstaben Äquivalente.

    Im folgenden Beispiel wird veranschaulicht, wie ein Zeichenfolgenvergleich zum Verhindern des Dateisystemzugriffs fehlschlägt, wenn er auf einen kulturempfindlichen Casing-Vergleich basiert. (Die Groß- und Kleinschreibungskonventionen der invarianten Kultur sollten verwendet werden.)

    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
    
  • Unterschiede bei Fallzuordnungen zwischen der invarianten Kultur und allen anderen Kulturen. In diesen Fällen gibt die Verwendung der Groß-/Kleinschreibungsregeln der invarianten Kultur zum Ändern eines Zeichens in Groß- oder Kleinbuchstaben dasselbe Zeichen zurück. Für alle anderen Kulturen gibt es ein anderes Zeichen zurück. Einige der betroffenen Zeichen sind in der folgenden Tabelle aufgeführt.

    Zeichen Wenn geändert in Gibt zurück
    MICRON SIGN (U+00B5) Großbuchstaben GRIECHISCHER GROßBUCHSTABEN MU (U+-39C)
    LATEINISCHER GROßBUCHSTABEN I MIT PUNKT OBEN (U+0130) Kleinbuchstaben LATEINISCHER KLEINER BUCHSTABE I (U+0069)
    LATEINISCHER KLEINER BUCHSTABE DOTLESS I (U+0131) Großbuchstaben LATEINISCHER GROßBUCHSTABEN I (U+0049)
    LATEINISCHER KLEINER BUCHSTABE LONG S (U+017F) Großbuchstaben LATEINISCHE GROßBUCHSTABEN S (U+0053)
    LATEINISCHER GROßBUCHSTABEN D MIT KLEINBUCHSTABEN Z MIT CARON (U+01C5) Kleinbuchstaben LATEINISCHER KLEINER BUCHSTABE DZ MIT CARON (U+01C6)
    KOMBINIEREN VON GRIECHISCHEM YPOGEGRAMMENI (U+0345) Großbuchstaben GRIECHISCHER GROßBUCHSTABEN IOTA (U+0399)
  • Unterschiede bei Fallzuordnungen von Zweibuchstaben-Mixed-Case-Paaren im ASCII-Zeichenbereich. In den meisten Kulturen ist ein Zweibuchstaben-Mixed-Case-Paar gleich dem entsprechenden Zweibuchstaben-Groß- oder Kleinbuchstabenpaar. Dies gilt nicht für die folgenden zwei Buchstabenpaare in den folgenden Kulturen, da sie in jedem Fall mit einem Digraph verglichen werden:

    • "lJ" und "nJ" in der hr-HR (Kroatien)-Kultur.

    • "cH" in den Kulturen cs-CZ (Tschechische Republik)) und sk-SK (Slowakei).

    • "aA" in der da-DK (Dänemark)-Kultur.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" und "zS" in der Hu-HU (Ungarn)-Kultur.

    • "cH" und "lL" in der es-ES_tradnl (Spanisch (Spanien, traditionelle Sortierung)-Kultur.

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" und "tR" in der vi-VN (Vietnam)-Kultur.

    Es ist jedoch ungewöhnlich, auf eine Situation zu stoßen, in der ein kulturempfindlicher Vergleich dieser Paare Probleme verursacht, da diese Paare in festen Zeichenfolgen oder Bezeichnern ungewöhnlich sind.

Im folgenden Beispiel werden einige der Unterschiede bei der Großschreibung von Regeln zwischen Kulturen veranschaulicht, wenn Zeichenfolgen in Großbuchstaben konvertiert werden.

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

Analysieren und Formatieren

Formatierung und Analyse sind umgekehrte Vorgänge. Formatierungsregeln bestimmen, wie ein Wert wie Datum und Uhrzeit oder eine Zahl in die Zeichenfolgendarstellung konvertiert werden soll, während die Analyseregeln bestimmen, wie eine Zeichenfolgendarstellung in einen Wert wie Datum und Uhrzeit konvertiert werden soll. Sowohl formatierungs- als auch analyseregeln sind von kulturellen Konventionen abhängig. Im folgenden Beispiel wird die Zweideutigkeit veranschaulicht, die beim Interpretieren einer kulturspezifischen Datumszeichenfolge entstehen kann. Ohne die Konventionen der Kultur zu kennen, die zum Erstellen einer Datumszeichenfolge verwendet wurde, ist es nicht möglich, zu wissen, ob 03.01.2011, 3.1.2011 und 01.03.2011 den 3. Januar 2011 oder 1. März 2011 darstellen.

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

Ebenso kann eine einzelne Zeichenfolge je nach Kultur, deren Konventionen im Analysevorgang verwendet werden, unterschiedliche Datumsangaben erzeugen.

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

Zeichenfolgenvergleich und Sortierung

Konventionen zum Vergleichen und Sortieren von Zeichenfolgen variieren von Kultur zu Kultur. Die Sortierreihenfolge kann beispielsweise auf Phonetik oder auf der visuellen Darstellung von Zeichen basieren. In ostasiatischen Sprachen werden Zeichen anhand der Anzahl der Striche und der Radikale der Ideogramme sortiert. Die Sortierung hängt außerdem von der Reihenfolge ab, die das Alphabet der jeweiligen Sprache bzw. Kultur aufweist. Im Dänischen gibt es beispielsweise das Zeichen "Æ", das im Alphabet nach dem Zeichen "Z" einsortiert ist. Darüber hinaus können Vergleiche groß- oder kleinschreibungsempfindlich sein, und Die Groß-/Kleinschreibungsregeln können sich je nach Kultur unterscheiden. Ordinalvergleich verwendet dagegen die Unicode-Codepunkte einzelner Zeichen in einer Zeichenfolge beim Vergleichen und Sortieren von Zeichenfolgen.

Sortierregeln bestimmen die alphabetische Reihenfolge von Unicode-Zeichen und wie zwei Zeichenfolgen miteinander verglichen werden. Die Methode vergleicht beispielsweise String.Compare(String, String, StringComparison) zwei Zeichenfolgen basierend auf dem StringComparison Parameter. Wenn der Parameterwert lautet StringComparison.CurrentCulture, führt die Methode einen sprachlichen Vergleich aus, der die Konventionen der aktuellen Kultur verwendet. Wenn der Parameterwert lautet StringComparison.Ordinal, führt die Methode einen Ordinalvergleich aus. Wie im folgenden Beispiel gezeigt wird, betrachtet der erste Aufruf der Methode (mit kulturempfindlichem Vergleich) den ersten Aufruf der String.Compare(String, String, StringComparison) Methode als "a" kleiner als "A", aber der zweite Aufruf der gleichen Methode (mit ordinalem Vergleich) betrachtet "a" größer als "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

.NET unterstützt Word-, Zeichenfolge- und Ordnungsregeln:

  • Bei einer Wortsortierung wird ein kulturabhängiger Vergleich von Zeichenfolgen durchgeführt, bei dem bestimmten nicht alphanumerischen Unicode-Zeichen u. U. bestimmte Gewichtungen zugeordnet sind. Beispielsweise kann der Bindestrich (-) ein sehr kleines Gewicht zugewiesen haben, damit "coop" und "co-op" nebeneinander in einer sortierten Liste angezeigt werden. Eine Liste der Methoden, die String zwei Zeichenfolgen mit Wortsortierregeln vergleichen, finden Sie im Abschnitt "Zeichenfolgenvorgänge nach Kategorie" .

  • Eine Zeichenfolgensortierung führt auch einen kulturempfindlichen Vergleich aus. Es ähnelt einer Wortsortierung, außer dass es keine Sonderfälle gibt, und alle nichtalphanumerischen Symbole kommen vor allen alphanumerischen Unicode-Zeichen. Zwei Zeichenfolgen können mithilfe von Zeichenfolgensortierungsregeln verglichen werden, indem die Methodenüberladungen aufgerufen werden, die CompareInfo.Compare einen options Parameter aufweisen, der einen Wert von CompareOptions.StringSort. Beachten Sie, dass dies die einzige Methode ist, die .NET bereitstellt, um zwei Zeichenfolgen mit Zeichenfolgensortierregeln zu vergleichen.

  • Eine Ordinalsortierung vergleicht Zeichenfolgen anhand des numerischen Werts jedes Char-Objekts in der Zeichenfolge. Bei einem Ordinalvergleich wird automatisch die Groß-/Kleinschreibung beachtet, da die Kleinbuchstaben- und Großbuchstabenversionen eines Zeichens unterschiedliche Codepunkte aufweisen. Wenn der Fall jedoch nicht wichtig ist, können Sie einen Ordnungsvergleich angeben, der den Fall ignoriert. Dies entspricht dem Konvertieren der Zeichenfolge in Großbuchstaben mithilfe der invarianten Kultur und anschließendem Ausführen eines Ordinalvergleichs für das Ergebnis. Eine Liste der Methoden, die String zwei Zeichenfolgen mithilfe von Ordnungsregeln vergleichen, finden Sie im Abschnitt "Zeichenfolgenvorgänge nach Kategorie" .

Ein kulturempfindlicher Vergleich ist ein beliebiger Vergleich, der ein CultureInfo Objekt explizit oder implizit verwendet, einschließlich der invarianten Kultur, die von der CultureInfo.InvariantCulture Eigenschaft angegeben wird. Die implizite Kultur ist die aktuelle Kultur, die durch die und CultureInfo.CurrentCulture die Thread.CurrentCulture Eigenschaften angegeben wird. Die Sortierreihenfolge von alphabetischen Zeichen (also Zeichen, für die die Char.IsLetter Eigenschaft zurückgegeben truewird) ist in allen Kulturen erheblich unterschiedlich. Sie können einen kulturempfindlichen Vergleich angeben, der die Konventionen einer bestimmten Kultur verwendet, indem Sie ein CultureInfo Objekt an eine Zeichenfolgenvergleichsmethode wie z Compare(String, String, CultureInfo, CompareOptions). B. angeben. Sie können einen kulturempfindlichen Vergleich angeben, der die Konventionen der aktuellen Kultur verwendet, indem StringComparison.CurrentCultureStringComparison.CurrentCultureIgnoreCaseSie eine CompareOptions andere CompareOptions.Ordinal Als oder CompareOptions.OrdinalIgnoreCase eine entsprechende Überladung Compare der Methode angeben. Ein kulturempfindlicher Vergleich eignet sich im Allgemeinen für die Sortierung, während ein Ordinalvergleich nicht erfolgt. Ein Ordinalvergleich eignet sich im Allgemeinen für die Bestimmung, ob zwei Zeichenfolgen gleich sind (also zum Bestimmen der Identität), während ein kulturempfindlicher Vergleich nicht erfolgt.

Im folgenden Beispiel wird der Unterschied zwischen kulturempfindlichen und ordinalen Vergleichen veranschaulicht. Im Beispiel werden drei Zeichenfolgen ausgewertet, "Apple", "Æble" und "AEble", wobei ordinaler Vergleich und die Konventionen der Da-DK- und en-US-Kulturen verwendet werden (jedes davon ist die Standardkultur zum Zeitpunkt des Aufrufs der Compare Methode). Da die dänische Sprache das Zeichen "Æ" als einzelner Buchstabe behandelt und nach "Z" im Alphabet sortiert, ist die Zeichenfolge "Æble" größer als "Apple". "Æble" gilt jedoch nicht als Äquivalent zu "AEble", daher ist "Æble" auch größer als "AEble". Die en-US-Kultur enthält nicht den Buchstaben "Æ", behandelt es aber als Äquivalent zu "AE", was erklärt, warum "Æble" kleiner als "Apple" ist, aber gleich "AEble". Ordinalvergleich betrachtet dagegen "Apple" als kleiner als "Æble", und "Æble" ist größer als "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

Verwenden Sie die folgenden allgemeinen Richtlinien, um eine geeignete Sortier- oder Zeichenfolgenvergleichsmethode auszuwählen:

  • Wenn die Zeichenfolgen basierend auf der Kultur des Benutzers sortiert werden sollen, sollten Sie sie basierend auf den Konventionen der aktuellen Kultur bestellen. Wenn sich die Kultur des Benutzers ändert, ändert sich auch die Reihenfolge sortierter Zeichenfolgen entsprechend. Beispielsweise sollte eine Thesaurusanwendung immer Wörter basierend auf der Kultur des Benutzers sortieren.

  • Wenn die Zeichenfolgen basierend auf den Konventionen einer bestimmten Kultur sortiert werden sollen, sollten Sie sie sortieren, indem Sie ein CultureInfo Objekt angeben, das diese Kultur einer Vergleichsmethode darstellt. Beispielsweise möchten Sie in einer Anwendung, die den Schülern eine bestimmte Sprache vermittelt, Zeichenfolgen basierend auf den Konventionen einer der Kulturen angeordnet werden, die diese Sprache sprechen.

  • Wenn die Reihenfolge der Zeichenfolgen in allen Kulturen unverändert bleiben soll, sollten Sie sie basierend auf den Konventionen der invarianten Kultur ordnen oder einen Ordinalvergleich verwenden. Sie würden beispielsweise eine Ordnungssortierung verwenden, um die Namen von Dateien, Prozessen, Mutexes oder benannten Rohren zu organisieren.

  • Für einen Vergleich, der eine Sicherheitsentscheidung umfasst (z. B. ob ein Benutzername gültig ist), sollten Sie immer einen Ordnungstest für die Gleichheit durchführen, indem Sie eine Überladung der Equals Methode aufrufen.

Hinweis

Die kulturempfindlichen Sortier- und Casingregeln, die im Zeichenfolgenvergleich verwendet werden, hängen von der Version des .NET ab. Bei .NET Core hängt der Zeichenfolgenvergleich von der Vom zugrunde liegenden Betriebssystem unterstützten Unicode-Standardversion ab. In .NET Framework 4.5 und höheren Versionen, die auf Windows 8 oder höher ausgeführt werden, entsprechen Sortierung, Groß- und Kleinschreibung, Normalisierung und Unicode-Zeicheninformationen dem Unicode 6.0-Standard. Auf anderen Windows Betriebssystemen entsprechen sie dem Unicode 5.0-Standard.

Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungsregeln finden Sie im System.Globalization.CompareOptions Thema. Weitere Empfehlungen für die Verwendung jeder Regel finden Sie unter Bewährte Methoden für die Verwendung von Zeichenfolgen.

Normalerweise rufen Sie keine Zeichenfolgenvergleichsmethoden auf, z Compare . B. direkt, um die Sortierreihenfolge von Zeichenfolgen zu bestimmen. Stattdessen werden Vergleichsmethoden durch Sortiermethoden wie Array.Sort z. B. oder List<T>.Sort. Im folgenden Beispiel werden vier verschiedene Sortiervorgänge ausgeführt (Wortsortierung mithilfe der aktuellen Kultur, der Wortsortierung mithilfe der invarianten Kultur, der Ordnungssortierung und der Zeichenfolgensortierung mithilfe der invarianten Kultur) ohne explizites Aufrufen einer Zeichenfolgenvergleichsmethode, obwohl sie den zu verwendenden Vergleichstyp angeben. Beachten Sie, dass jeder Sortiertyp eine eindeutige Sortierung von Zeichenfolgen in seinem Array erzeugt.

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

Tipp

Intern verwendet .NET Sortierschlüssel, um den kulturellen Zeichenfolgenvergleich zu unterstützen. Jedem Zeichen in einer Zeichenfolge sind mehrere Sortiergewichtungskategorien zugeordnet, darunter nach Skript, alphabetischer Folge, Groß-/Kleinschreibung und diakritischer Gewichtung. Ein Sortierschlüssel, dargestellt durch die SortKey Klasse, stellt ein Repository dieser Gewichtungen für eine bestimmte Zeichenfolge bereit. Wenn Ihre App eine große Anzahl von Such- oder Sortiervorgängen für dieselbe Gruppe von Zeichenfolgen ausführt, können Sie die Leistung verbessern, indem Sie Sortierschlüssel für alle von ihnen verwendeten Zeichenfolgen generieren und speichern. Wenn ein Sortier- oder Vergleichsvorgang erforderlich ist, verwenden Sie anstelle der Zeichenfolgen die Sortiertasten. Weitere Informationen finden Sie in den Ausführungen zur SortKey-Klasse.

Wenn Sie keine Zeichenfolgenvergleichskonvention angeben, führen Sortiermethoden wie Array.Sort(Array) z. B. eine kulturempfindliche, groß- und kleinschreibungsbezogene Sortierung für Zeichenfolgen aus. Im folgenden Beispiel wird veranschaulicht, wie sich das Ändern der aktuellen Kultur auf die Reihenfolge sortierter Zeichenfolgen in einem Array auswirkt. Es erstellt ein Array von drei Zeichenfolgen. Zuerst wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "en-US" festgelegt, und die Array.Sort(Array)-Methode wird aufgerufen. Die sich daraus ergebende Sortierreihenfolge basiert auf den Sortierkonventionen für die Kultur Englisch (USA). Als Nächstes wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "da-DK" festgelegt und die Array.Sort-Methode erneut aufgerufen. Die sich daraus ergebende Sortierreihenfolge unterscheidet sich von den Ergebnissen für "en-US", da die Sortierkonventionen für "Dänisch (Dänemark)" verwendet werden.

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

Warnung

Wenn Der primäre Zweck beim Vergleichen von Zeichenfolgen besteht darin, festzustellen, ob sie gleich sind, sollten Sie die String.Equals Methode aufrufen. Normalerweise sollten Sie einen Equals Ordinalvergleich durchführen. Die String.Compare Methode soll in erster Linie Zeichenfolgen sortieren.

Zeichenfolgensuchmethoden, z String.StartsWith . B. und String.IndexOf, können auch kulturempfindliche oder ordinale Zeichenfolgenvergleiche durchführen. Im folgenden Beispiel werden die Unterschiede zwischen Ordinal- und kulturempfindlichen Vergleichen mithilfe der IndexOf Methode veranschaulicht. Eine kulturempfindliche Suche, in der die aktuelle Kultur Englisch (USA) ist, betrachtet die Teilzeichenfolge "oe" mit der Ligatur "œ". Da ein weicher Bindestrich (U+00AD) ein Nullbreitenzeichen ist, behandelt die Suche den weichen Bindestrich als gleichwertig und Empty findet eine Übereinstimmung am Anfang der Zeichenfolge. Eine Ordnungssuche findet dagegen in beiden Fällen keine Übereinstimmung.

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

Suchen in Zeichenfolgen

Zeichenfolgensuchmethoden, z String.StartsWith . B. und String.IndexOf, können auch kulturempfindliche oder ordinale Zeichenfolgenvergleiche ausführen, um zu bestimmen, ob ein Zeichen oder eine Teilzeichenfolge in einer angegebenen Zeichenfolge gefunden wird.

Die Suchmethoden in der String Klasse, die nach einem einzelnen Zeichen suchen, z. B. die IndexOf Methode oder eine von einer Reihe von Zeichen, z. B. die IndexOfAny Methode, führen alle eine Ordnungssuche aus. Zum Ausführen einer kulturempfindlichen Suche nach einem Zeichen müssen Sie eine CompareInfo Methode CompareInfo.IndexOf(String, Char) wie z. B. oder CompareInfo.LastIndexOf(String, Char). Beachten Sie, dass die Ergebnisse der Suche nach einem Zeichen mit Ordnungs- und Kulturempfindlichem Vergleich sehr unterschiedlich sein können. Beispielsweise kann eine Suche nach einem vordefinierten Unicode-Zeichen, z. B. der Ligatur "Æ" (U+00C6) je nach Kultur, jedem Vorkommen seiner Komponenten in der richtigen Reihenfolge entsprechen, z. B. "AE" (U+041U+0045). Im folgenden Beispiel wird der Unterschied zwischen den String.IndexOf(Char) CompareInfo.IndexOf(String, Char) Methoden und den Methoden beim Suchen nach einem einzelnen Zeichen veranschaulicht. Die Ligatur "æ" (U+00E6) befindet sich in der Zeichenfolge "Luft" bei Verwendung der Konventionen der en-US-Kultur, aber nicht bei verwendung der Konventionen der da-DK-Kultur oder beim Ausführen eines Ordinalvergleichs.

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

Andererseits führen Klassenmethoden, die anstelle eines Zeichens nach einer Zeichenfolge suchen, eine kulturempfindliche Suche aus, String wenn Suchoptionen nicht explizit durch einen Parameter des Typs StringComparisonangegeben werden. Die einzige Ausnahme ist Contains, die eine Ordnungssuche ausführt.

Testen der Gleichheit

Verwenden Sie die String.Compare Methode, um die Beziehung zweier Zeichenfolgen in der Sortierreihenfolge zu bestimmen. In der Regel handelt es sich um einen kulturempfindlichen Vorgang. Rufen Sie dagegen die String.Equals Methode auf, um die Gleichheit zu testen. Da der Test auf Gleichheit in der Regel die Benutzereingabe mit einer bekannten Zeichenfolge vergleicht, z. B. einen gültigen Benutzernamen, ein Kennwort oder einen Dateisystempfad, ist es in der Regel ein Ordnungsvorgang.

Warnung

Es ist möglich, die Gleichheit zu testen, indem Sie die String.Compare Methode aufrufen und bestimmen, ob der Rückgabewert null ist. Diese Praxis wird jedoch nicht empfohlen. Um zu ermitteln, ob zwei Zeichenfolgen gleich sind, sollten Sie eine der Überladungen der String.Equals Methode aufrufen. Die bevorzugte Überladung zum Aufrufen ist entweder die Instanzmethode Equals(String, StringComparison) oder die statische Equals(String, String, StringComparison) Methode, da beide Methoden einen System.StringComparison Parameter enthalten, der explizit den Vergleichstyp angibt.

Im folgenden Beispiel wird die Gefahr veranschaulicht, dass stattdessen ein kulturempfindlicher Vergleich zur Gleichheit durchgeführt wird, wenn stattdessen ein Ordnungsschema verwendet werden soll. In diesem Fall soll der Code den Dateisystemzugriff von URLs verbieten, die mit "FILE://" oder "file://" beginnen, indem ein Vergleich zwischen Groß-/Kleinschreibung des Anfangs einer URL mit der Zeichenfolge "FILE://" ausgeführt wird. Wenn jedoch ein kulturempfindlicher Vergleich mit der türkischen Kultur (Türkei) auf einer URL ausgeführt wird, die mit "file://" beginnt, schlägt der Vergleich für Gleichheit fehl, da das türkische Großbuchstabenäquivalent des Kleinbuchstabens "i" anstelle von "I" lautet. Daher ist der Dateisystemzugriff versehentlich zulässig. Wenn dagegen ein Ordinalvergleich durchgeführt wird, wird der Vergleich der Gleichheit erfolgreich ausgeführt, und der Dateisystemzugriff wird verweigert.

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.

Normalisierung

Einige Unicode-Zeichen weisen mehrere Darstellungen auf. Beispielsweise kann jeder der folgenden Codepunkte den Buchstaben "ắ" darstellen:

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Mehrere Darstellungen für ein einzelnes Zeichen komplizieren die Suche, Sortierung, Übereinstimmung und andere Zeichenfolgenvorgänge.

Der Unicode-Standard definiert einen Prozess namens Normalisierung, der eine binäre Darstellung eines Unicode-Zeichens für eine der entsprechenden binären Darstellungen zurückgibt. Die Normalisierung kann mehrere Algorithmen verwenden, die als Normalisierungsformulare bezeichnet werden, die verschiedenen Regeln entsprechen. .NET unterstützt Unicode-Normalisierungsformulare C, D, KC und KD. Wenn Zeichenfolgen auf dasselbe Normalisierungsformular normalisiert wurden, können sie mithilfe des Ordinalvergleichs verglichen werden.

Ein Ordinalvergleich ist ein binärer Vergleich des Unicode-Skalarwerts entsprechender Char Objekte in jeder Zeichenfolge. Die String Klasse enthält eine Reihe von Methoden, die einen Ordinalvergleich ausführen können, einschließlich der folgenden:

Sie können bestimmen, ob eine Zeichenfolge in Normalisierungsformular C normalisiert ist, indem Sie die String.IsNormalized() Methode aufrufen, oder Sie können die String.IsNormalized(NormalizationForm) Methode aufrufen, um zu bestimmen, ob eine Zeichenfolge in einem angegebenen Normalisierungsformular normalisiert ist. Sie können die String.Normalize() Methode auch aufrufen, um eine Zeichenfolge in Normalisierungsformular C zu konvertieren, oder Sie können die String.Normalize(NormalizationForm) Methode aufrufen, um eine Zeichenfolge in ein angegebenes Normalisierungsformular zu konvertieren. Schrittweise Informationen zum Normalisieren und Vergleichen von Zeichenfolgen finden Sie in den Normalize() und Normalize(NormalizationForm) Methoden.

Im folgenden einfachen Beispiel wird die Zeichenfolgennormalisierung veranschaulicht. Er definiert den Buchstaben "ố" auf drei verschiedene Arten in drei verschiedenen Zeichenfolgen und verwendet einen Ordnungsvergleich für Gleichheit, um zu bestimmen, dass jede Zeichenfolge von den anderen beiden Zeichenfolgen unterscheidet. Anschließend werden jede Zeichenfolge in die unterstützten Normalisierungsformulare konvertiert und erneut ein Ordinalvergleich jeder Zeichenfolge in einem angegebenen Normalisierungsformular ausgeführt. In jedem Fall zeigt der zweite Test für die Gleichheit, dass die Zeichenfolgen gleich sind.

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

Weitere Informationen zu Normalisierungs- und Normalisierungsformularen finden Sie im Unicode-Standardanhang #15: Unicode-Normalisierungsformulare und häufig gestellte Fragen zur Normalisierung auf der unicode.org Website.System.Text.NormalizationForm

Zeichenfolgenvorgänge nach Kategorie

Die String Klasse enthält Elemente zum Vergleichen von Zeichenfolgen, Testen von Zeichenfolgen für Gleichheit, Suchen von Zeichen oder Teilzeichenfolgen in einer Zeichenfolge, Ändern einer Zeichenfolge, Extrahieren von Teilzeichenfolgen aus einer Zeichenfolge, Kombinieren von Zeichenfolgen, Formatierungswerten, Kopieren einer Zeichenfolge und Normalisieren einer Zeichenfolge.

Vergleichen von Zeichenfolgen

Sie können Zeichenfolgen vergleichen, um die relative Position in der Sortierreihenfolge mithilfe der folgenden String Methoden zu bestimmen:

  • Compare gibt eine ganze Zahl zurück, die die Beziehung einer Zeichenfolge zu einer zweiten Zeichenfolge in der Sortierreihenfolge angibt.

  • CompareOrdinal gibt eine ganze Zahl zurück, die die Beziehung einer Zeichenfolge zu einer zweiten Zeichenfolge basierend auf einem Vergleich ihrer Codepunkte angibt.

  • CompareTo gibt eine ganze Zahl zurück, die die Beziehung der aktuellen Zeichenfolgeninstanz zu einer zweiten Zeichenfolge in der Sortierreihenfolge angibt. Die CompareTo(String) Methode stellt die IComparable und IComparable<T> implementierungen für die String Klasse bereit.

Testen von Zeichenfolgen auf Gleichheit

Sie rufen die Equals Methode auf, um zu bestimmen, ob zwei Zeichenfolgen gleich sind. Mit der Instanz Equals(String, String, StringComparison) und den statischen Equals(String, StringComparison) Überladungen können Sie angeben, ob der Vergleich kulturempfindlich oder ordinal ist und ob der Fall als betrachtet oder ignoriert wird. Die meisten Tests für Die Gleichheit sind Ordnungszeichen, und Vergleiche für Gleichheiten, die den Zugriff auf eine Systemressource (z. B. ein Dateisystemobjekt) bestimmen, sollten immer ordinal sein.

Suchen von Zeichen in einer Zeichenfolge

Die String Klasse enthält zwei Arten von Suchmethoden:

  • Methoden, die einen Boolean Wert zurückgeben, um anzugeben, ob eine bestimmte Teilzeichenfolge in einer Zeichenfolgeninstanz vorhanden ist. Dazu gehören die ContainsMethoden und EndsWithStartsWith Methoden.

  • Methoden, die die Anfangsposition einer Teilzeichenfolge in einer Zeichenfolgeninstanz angeben. Dazu gehören die IndexOfMethoden , IndexOfAny, LastIndexOf, und LastIndexOfAny Methoden.

Warnung

Wenn Sie eine Zeichenfolge für ein bestimmtes Muster anstelle einer bestimmten Teilzeichenfolge durchsuchen möchten, sollten Sie reguläre Ausdrücke verwenden. Weitere Informationen finden Sie unter .NET Regular Expressions.

Ändern einer Zeichenfolge

Die String Klasse enthält die folgenden Methoden, die angezeigt werden, um den Wert einer Zeichenfolge zu ändern:

  • Insert fügt eine Zeichenfolge in die aktuelle String Instanz ein.

  • PadLeft Fügt ein oder mehrere Vorkommen eines angegebenen Zeichens am Anfang einer Zeichenfolge ein.

  • PadRight fügt ein oder mehrere Vorkommen eines angegebenen Zeichens am Ende einer Zeichenfolge ein.

  • Remove löscht eine Teilzeichenfolge aus der aktuellen String Instanz.

  • Replace Ersetzt eine Teilzeichenfolge durch eine andere Teilzeichenfolge in der aktuellen String Instanz.

  • ToLower und ToLowerInvariant konvertieren Sie alle Zeichen in einer Zeichenfolge in Kleinbuchstaben.

  • ToUpper und ToUpperInvariant konvertieren Sie alle Zeichen in einer Zeichenfolge in Großbuchstaben.

  • Trim Entfernt alle Vorkommen eines Zeichens vom Anfang und Ende einer Zeichenfolge.

  • TrimEnd Entfernt alle Vorkommen eines Zeichens vom Ende einer Zeichenfolge.

  • TrimStart Entfernt alle Vorkommen eines Zeichens vom Anfang einer Zeichenfolge.

Wichtig

Alle Zeichenfolgenänderungsmethoden geben ein neues String Objekt zurück. Sie ändern den Wert der aktuellen Instanz nicht.

Extrahieren von Teilzeichenfolgen aus einer Zeichenfolge

Die String.Split Methode trennt eine einzelne Zeichenfolge in mehrere Zeichenfolgen. Überladungen der Methode ermöglichen es Ihnen, mehrere Trennzeichen anzugeben, die Anzahl der Teilzeichenfolgen zu begrenzen, die die Methode extrahiert, leerer Leerraum von Teilzeichenfolgen zu kürzen und anzugeben, ob leere Zeichenfolgen (die auftreten, wenn Trennzeichen nebeneinander liegen) unter den zurückgegebenen Zeichenfolgen enthalten sind.

Kombinieren von Zeichenfolgen

Die folgenden String Methoden können für Zeichenfolgenverkettung verwendet werden:

  • Concat kombiniert eine oder mehrere Teilzeichenfolgen in eine einzelne Zeichenfolge.

  • Join Verkettet eine oder mehrere Teilzeichenfolgen in ein einzelnes Element und fügt ein Trennzeichen zwischen den einzelnen Teilzeichenfolgen hinzu.

Formatieren von Werten

Die String.Format Methode verwendet das Zusammengesetztformatierungsfeature, um einen oder mehrere Platzhalter in einer Zeichenfolge durch die Zeichenfolgendarstellung einiger Objekte oder Werte zu ersetzen. Die Format Methode wird häufig verwendet, um Folgendes auszuführen:

  • So betten Sie die Zeichenfolgendarstellung eines numerischen Werts in eine Zeichenfolge ein.

  • So betten Sie die Zeichenfolgendarstellung eines Datums- und Uhrzeitwerts in eine Zeichenfolge ein.

  • So betten Sie die Zeichenfolgendarstellung eines Enumerationswerts in eine Zeichenfolge ein.

  • So betten Sie die Zeichenfolgendarstellung eines Objekts ein, das die IFormattable Schnittstelle in einer Zeichenfolge unterstützt.

  • Um eine Teilzeichenfolge in einem Feld in einer größeren Zeichenfolge nach rechts oder links zu rechtfertigen.

Ausführliche Informationen zu Formatierungsvorgängen und Beispielen finden Sie in der Format Überladungszusammenfassung.

Kopieren einer Zeichenfolge

Sie können die folgenden String Methoden aufrufen, um eine Kopie einer Zeichenfolge zu erstellen:

  • Clone gibt einen Verweis auf ein vorhandenes String Objekt zurück.

  • Copy erstellt eine Kopie einer vorhandenen Zeichenfolge.

  • CopyTo kopiert einen Teil einer Zeichenfolge in ein Zeichenarray.

Normalisieren einer Zeichenfolge

In Unicode kann ein einzelnes Zeichen mehrere Codepunkte aufweisen. Die Normalisierung konvertiert diese gleichwertigen Zeichen in dieselbe binäre Darstellung. Die String.Normalize Methode führt die Normalisierung aus, und die String.IsNormalized Methode bestimmt, ob eine Zeichenfolge normalisiert ist.

Weitere Informationen und ein Beispiel finden Sie im Abschnitt "Normalisierung " weiter oben in diesem Thema.

Konstruktoren

String(Char*)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen bestimmt wird.

String(Char*, Int32, Int32)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von Unicode-Zeichen, durch die Position des ersten Zeichens innerhalb dieses Arrays und durch eine Länge bestimmt wird.

String(Char, Int32)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein angegebenes so oft wie angegeben wiederholtes Unicode-Zeichen bestimmt wird.

String(Char[])

Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen Zeichenarray genannten Unicode-Zeichen.

String(Char[], Int32, Int32)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein Array von Unicode-Zeichen, die Position des ersten Zeichens innerhalb dieses Arrays und eine Länge bestimmt wird.

String(ReadOnlySpan<Char>)

Initialisiert eine neue Instanz der String-Klasse mit den im angegebenen schreibgeschützten Bereich genannten Unicode-Zeichen.

String(SByte*)

Initialisiert eine neue Instanz der String-Klasse mit dem durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegebenen Wert.

String(SByte*, Int32, Int32)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays und die Länge angegeben wird.

String(SByte*, Int32, Int32, Encoding)

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch einen angegebenen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen, die Startposition innerhalb dieses Arrays, eine Länge und ein Encoding-Objekt angegeben wird.

Felder

Empty

Stellt die leere Zeichenfolge dar. Dieses Feld ist schreibgeschützt.

Eigenschaften

Chars[Int32]

Ruft das Char-Objekt an einer angegebenen Zeichenposition innerhalb des aktuellen String-Objekts ab.

Length

Ruft die Anzahl der Zeichen im aktuellen String-Objekt ab.

Methoden

Clone()

Gibt einen Verweis auf diese Instanz von Stringzurück.

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

Vergleicht zwei angegebene String-Objekte und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

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

Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

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

Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt und der Vergleich durch kulturspezifische Informationen beeinflusst wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

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

Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten mit den festgelegten Vergleichsoptionen und kulturspezifischen Informationen, die den Vergleich beeinflussen, und gibt eine ganze Zahl zurück, die die Beziehung der beiden Teilzeichenfolgen zueinander in der Sortierreihenfolge angibt.

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

Vergleicht Teilzeichenfolgen von zwei angegebenen String-Objekten gemäß den angegebenen Vergleichsregeln und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

Compare(String, String)

Vergleicht zwei angegebene String-Objekte und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

Compare(String, String, Boolean)

Vergleicht zwei angegebene String-Objekte, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

Compare(String, String, Boolean, CultureInfo)

Vergleicht zwei angegebene String-Objekte, wobei ihre Groß- und Kleinschreibung entweder ignoriert oder berücksichtigt und der Vergleich durch kulturspezifische Informationen beeinflusst wird, und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

Compare(String, String, CultureInfo, CompareOptions)

Vergleicht zwei angegebene String-Objekte mit den festgelegten Vergleichsoptionen und kulturspezifischen Informationen, die den Vergleich beeinflussen, und gibt eine ganze Zahl zurück, die die Beziehung der beiden Zeichenfolgen zueinander in der Sortierreihenfolge angibt.

Compare(String, String, StringComparison)

Vergleicht zwei angegebene String-Objekte gemäß den angegebenen Vergleichsregeln und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt.

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

Vergleicht Teilzeichenfolgen zweier angegebener String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Teilzeichenfolgen ausgewertet werden.

CompareOrdinal(String, String)

Vergleicht zwei String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden.

CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Object und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie das angegebene Object aufgeführt wird.

CompareTo(String)

Vergleicht diese Instanz mit einem angegebenen String-Objekt und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie die angegebene Zeichenfolge aufgeführt wird.

Concat(IEnumerable<String>)

Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String.

Concat(Object)

Erstellt die Zeichenfolgendarstellung eines angegebenen Objekts.

Concat(Object, Object)

Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte.

Concat(Object, Object, Object)

Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten.

Concat(Object, Object, Object, Object)

Verkettet die Zeichenfolgenentsprechungen von vier angegebenen Objekten sowie aller in einer optionalen Parameterliste variabler Länger angegebenen Objekte.

Concat(Object[])

Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array.

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

Verkettet die Zeichenfolgendarstellung von zwei angegebenen schreibgeschützten Zeichenspannen.

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

Verkettet die Zeichenfolgendarstellung von drei angegebenen schreibgeschützten Zeichenspannen.

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

Verkettet die Zeichenfolgendarstellung von vier angegebenen schreibgeschützten Zeichenspannen.

Concat(String, String)

Verkettet zwei angegebene Instanzen von String.

Concat(String, String, String)

Verkettet zwei angegebene Instanzen von String.

Concat(String, String, String, String)

Verkettet zwei angegebene Instanzen von String.

Concat(String[])

Verkettet die Elemente eines angegebenen String-Arrays.

Concat<T>(IEnumerable<T>)

Verkettet die Member einer IEnumerable<T>-Implementierung.

Contains(Char)

Gibt einen Wert zurück, der angibt, ob ein angegebenes Zeichen in dieser Zeichenfolge vorkommt.

Contains(Char, StringComparison)

Gibt mithilfe der festgelegten Vergleichsregeln einen Wert zurück, der angibt, ob ein angegebenes Zeichen innerhalb der Zeichenfolge auftritt.

Contains(String)

Gibt einen Wert zurück, der angibt, ob eine angegebene untergeordnete Zeichenfolge in dieser Zeichenfolge vorkommt.

Contains(String, StringComparison)

Gibt mithilfe der festgelegten Vergleichsregeln einen Wert zurück, der angibt, ob eine angegebene Zeichenfolge innerhalb der Zeichenfolge auftritt.

Copy(String)
Veraltet.

Erstellt eine neue Instanz von String mit demselben Wert wie eine angegebene Instanz von String.

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

Kopiert eine angegebene Anzahl von Zeichen von einer angegebenen Position in dieser Instanz an eine angegebene Position in einem Array von Unicode-Zeichen.

CopyTo(Span<Char>)

Kopiert den Inhalt dieser Zeichenfolge in den Zielbereich.

Create(IFormatProvider, DefaultInterpolatedStringHandler)

Erstellt eine neue Zeichenfolge mithilfe des angegebenen Anbieters, um die Formatierung der angegebenen interpolierten Zeichenfolge zu steuern.

Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

Erstellt eine neue Zeichenfolge mithilfe des angegebenen Anbieters, um die Formatierung der angegebenen interpolierten Zeichenfolge zu steuern.

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

Erstellt eine neue Zeichenfolge mit einer bestimmten Länge und initialisiert sie nach der Erstellung unter Verwendung des angegebenen Rückrufs.

EndsWith(Char)

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit dem angegebenen Zeichen übereinstimmt.

EndsWith(String)

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.

EndsWith(String, Boolean, CultureInfo)

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt.

EndsWith(String, StringComparison)

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt.

EnumerateRunes()

Gibt eine Enumeration von Rune aus der Zeichenfolge zurück.

Equals(Object)

Bestimmt, ob diese Instanz und ein angegebenes Objekt, das ebenfalls ein String-Objekt sein muss, denselben Wert haben.

Equals(String)

Bestimmt, ob diese Instanz und ein anderes angegebenes String-Objekt denselben Wert haben.

Equals(String, String)

Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben.

Equals(String, String, StringComparison)

Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben. Ein Parameter gibt die Kultur, Berücksichtigung von Groß- und Kleinschreibung und Sortierregeln, die für den Vergleich verwendet werden.

Equals(String, StringComparison)

Bestimmt, ob diese Zeichenfolge und ein angegebenes String-Objekt denselben Wert haben. Ein Parameter gibt die Kultur, Berücksichtigung von Groß- und Kleinschreibung und Sortierregeln, die für den Vergleich verwendet werden.

Format(IFormatProvider, String, Object)

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

Format(IFormatProvider, String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

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

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

Format(IFormatProvider, String, Object[])

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Ein Parameter liefert kulturspezifische Formatierungsinformationen.

Format(String, Object)

Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts.

Format(String, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten.

Format(String, Object, Object, Object)

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten.

Format(String, Object[])

Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array.

GetEnumerator()

Ruft ein Objekt ab, das die einzelnen Zeichen dieser Zeichenfolge durchlaufen kann.

GetHashCode()

Gibt den Hashcode für diese Zeichenfolge zurück.

GetHashCode(ReadOnlySpan<Char>)

Gibt den Hashcode für die angegebene schreibgeschützte Zeichenspanne zurück.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Gibt den Hashcode für die angegebene schreibgeschützte Zeichenspanne gemäß der festgelegten Regeln zurück.

GetHashCode(StringComparison)

Gibt den Hashcode für diese Zeichenfolge gemäß der festgelegten Regeln zurück.

GetPinnableReference()

Gibt einen Verweis auf das Element der Zeichenfolge zurück, das sich bei Index 0 befindet.

Diese Methode soll .NET-Compiler unterstützen und nicht durch Benutzercode aufgerufen werden.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
GetTypeCode()

Gibt TypeCode für die String-Klasse zurück.

IndexOf(Char)

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an.

IndexOf(Char, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Die Suche beginnt an einer angegebenen Zeichenposition.

IndexOf(Char, Int32, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Zeichens in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.

IndexOf(Char, StringComparison)

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Ein Parameter gibt den Typ der Suche für das angegebene Zeichen an.

IndexOf(String)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an.

IndexOf(String, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.

IndexOf(String, Int32, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.

IndexOf(String, Int32, Int32, StringComparison)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Parameter geben die Anfangssuchposition in der aktuellen Zeichenfolge, die Anzahl der Zeichen in der aktuellen Zeichenfolge und den Typ der Suche für die angegebene Zeichenfolge an.

IndexOf(String, Int32, StringComparison)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Parameter geben die Anfangssuchposition in der aktuellen Zeichenfolge und den Typ der Suche an, die für die angegebene Zeichenfolge verwendet werden soll.

IndexOf(String, StringComparison)

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.

IndexOfAny(Char[])

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an.

IndexOfAny(Char[], Int32)

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition.

IndexOfAny(Char[], Int32, Int32)

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft.

Insert(Int32, String)

Gibt eine neue Zeichenfolge zurück, in der eine angegebene Zeichenfolge an einer angegebenen Indexposition in dieser Instanz eingefügt wird.

Intern(String)

Ruft den Verweis des Systems auf den angegebenen String ab.

IsInterned(String)

Ruft einen Verweis auf einen angegebenen String ab.

IsNormalized()

Gibt an, ob diese Zeichenfolge in der Unicode-Normalisierungsform C vorliegt.

IsNormalized(NormalizationForm)

Gibt an, ob diese Zeichenfolge in der angegebenen Unicode-Normalisierungsform vorliegt.

IsNullOrEmpty(String)

Gibt an, ob die angegebene Zeichenfolge null oder eine leere Zeichenfolge ("") ist.

IsNullOrWhiteSpace(String)

Gibt an, ob eine angegebene Zeichenfolge null ist, leer ist oder nur aus Leerzeichen besteht.

Join(Char, Object[])

Verwendet die Zeichenfolgendarstellungen eines Objektarrays mithilfe der angegebenen Trennlinie zwischen den einzelnen Elementen.

Join(Char, String[])

Verkettet ein Zeichenfolgenarray mithilfe der angegebenen Trennlinie zwischen den einzelnen Elementen.

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

Verkettet ein Zeichenfolgenarray mithilfe der angegebenen Trennlinie zwischen den einzelnen Elementen. Dabei beginnt das Array mit dem Element in value an der Position startIndex, und verkettet bis zu count Elemente.

Join(String, IEnumerable<String>)

Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.

Join(String, Object[])

Verkettet die Elemente eines Objektarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.

Join(String, String[])

Verkettet alle Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.

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

Verkettet die angegebenen Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen.

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

Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.

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

Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern.

LastIndexOf(Char)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an.

LastIndexOf(Char, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.

LastIndexOf(Char, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens des angegebenen Unicode-Zeichens in einer Teilzeichenfolge dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.

LastIndexOf(String)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an.

LastIndexOf(String, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.

LastIndexOf(String, Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.

LastIndexOf(String, Int32, Int32, StringComparison)

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.

LastIndexOf(String, Int32, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an.

LastIndexOf(String, StringComparison)

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an.

LastIndexOfAny(Char[])

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an.

LastIndexOfAny(Char[], Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt.

LastIndexOfAny(Char[], Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
Normalize()

Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der Unicode-Normalisierungsform C vorliegt.

Normalize(NormalizationForm)

Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der angegebenen Unicode-Normalisierungsform vorliegt.

PadLeft(Int32)

Gibt eine neue Zeichenfolge zurück, bei der die Zeichen in dieser Instanz rechtsbündig ausgerichtet werden, indem die linke Seite mit Leerzeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.

PadLeft(Int32, Char)

Gibt eine neue Zeichenfolge zurück, bei der die Zeichen in dieser Instanz rechtsbündig ausgerichtet werden, indem die linke Seite mit einem angegebenen Unicode-Zeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.

PadRight(Int32)

Gibt eine neue Zeichenfolge zurück, deren Zeichen linksbündig ausgerichtet werden, indem die rechte Seite mit Leerzeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.

PadRight(Int32, Char)

Gibt eine neue Zeichenfolge zurück, deren Zeichen linksbündig ausgerichtet werden, indem die rechte Seite mit einem angegebenen Unicode-Zeichen aufgefüllt wird, um eine angegebene Gesamtlänge zu erreichen.

Remove(Int32)

Gibt eine neue Zeichenfolge zurück, in der alle Zeichen in der aktuellen Instanz, beginnend an einer angegebenen Position und sich über die letzte Position fortsetzend, gelöscht wurden.

Remove(Int32, Int32)

Gibt eine neue Zeichenfolge zurück, in der eine bestimmte Anzahl von Zeichen in er aktuellen Instanz, beginnend an einer angegebenen Position, gelöscht wurden.

Replace(Char, Char)

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen eines angegebenen Unicode-Zeichens in dieser Instanz durch ein anderes angegebenes Unicode-Zeichen ersetzt wurden.

Replace(String, String)

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.

Replace(String, String, Boolean, CultureInfo)

Gibt mithilfe der angegebenen Kultur und der Angabe zur Groß-/Kleinschreibung eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.

Replace(String, String, StringComparison)

Gibt mithilfe des bereitgestellten Vergleichstyps eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden.

ReplaceLineEndings()

Ersetzt alle Neuenlinesequenzen in der aktuellen Zeichenfolge durch NewLine.

ReplaceLineEndings(String)

Ersetzt alle Neuenlinesequenzen in der aktuellen Zeichenfolge durch replacementText.

Split(Char, Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt. Hier wird eine Zeichenfolge in eine maximale Anzahl von Teilzeichenfolgen anhand des angegebenen Ersatztrennzeichens unterteilt, wobei optional leere Teilzeichenfolgen aus dem Ergebnis ausgelassen werden.

Split(Char, StringSplitOptions)

Hier wird eine Zeichenfolge anhand eines angegebenen Trennzeichens und optional von Optionen in Teilzeichenfolgen unterteilt.

Split(Char[])

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in Teilzeichenfolgen unterteilt.

Split(Char[], Int32)

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen in eine maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(Char[], Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(Char[], StringSplitOptions)

Hier wird eine Zeichenfolge anhand der angegebenen Trennzeichen und der Optionen in Teilzeichenfolgen unterteilt.

Split(String, Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(String, StringSplitOptions)

Unterteilt eine Zeichenfolge anhand der angegebenen Zeichenfolgentrennlinie in Teilzeichenfolgen.

Split(String[], Int32, StringSplitOptions)

Hier wird eine Zeichenfolge anhand von angegebenen Trennzeichenfolgen und optional von Optionen in die maximale Anzahl von Teilzeichenfolgen unterteilt.

Split(String[], StringSplitOptions)

Hier wird eine Zeichenfolge anhand einer angegebenen Trennzeichenfolge und optional von Optionen in Teilzeichenfolgen unterteilt.

StartsWith(Char)

Bestimmt, ob diese Zeichenfolgeninstanz mit dem angegebenen Zeichen beginnt.

StartsWith(String)

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt.

StartsWith(String, Boolean, CultureInfo)

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt.

StartsWith(String, StringComparison)

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt.

Substring(Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt.

Substring(Int32, Int32)

Ruft eine Teilzeichenfolge dieser Instanz ab. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge.

ToCharArray()

Kopiert die Zeichen dieser Instanz in ein Array von Unicode-Zeichen.

ToCharArray(Int32, Int32)

Kopiert die Zeichen einer angegebenen Teilzeichenfolge dieser Instanz in ein Array von Unicode-Zeichen.

ToLower()

Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück.

ToLower(CultureInfo)

Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.

ToLowerInvariant()

Gibt eine in Kleinbuchstaben konvertierte Kopie dieses String -Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.

ToString()

Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt.

ToString(IFormatProvider)

Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt.

ToUpper()

Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück.

ToUpper(CultureInfo)

Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden.

ToUpperInvariant()

Gibt eine in Großbuchstaben konvertierte Kopie dieses String -Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden.

Trim()

Entfernt alle führenden und nachgestellten Leerraumzeichen aus der aktuellen Zeichenfolge.

Trim(Char)

Entfernt alle führenden und nachgestellten Instanzen eines Zeichens aus der aktuellen Zeichenfolge.

Trim(Char[])

Entfernt alle führenden und nachgestellten Vorkommen der Zeichen im angegebenen Array aus der aktuellen Zeichenfolge.

TrimEnd()

Entfernt alle nachgestellten Leerraumzeichen aus der aktuellen Zeichenfolge.

TrimEnd(Char)

Entfernt alle nachgestellten Vorkommen eines Zeichens aus der aktuellen Zeichenfolge.

TrimEnd(Char[])

Entfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus der aktuellen Zeichenfolge.

TrimStart()

Entfernt alle führenden Leerraumzeichen aus der aktuellen Zeichenfolge.

TrimStart(Char)

Entfernt alle führenden Vorkommen eines bestimmten Zeichens aus der aktuellen Zeichenfolge.

TrimStart(Char[])

Entfernt alle führenden Vorkommen der Zeichen im angegebenen Array aus der aktuellen Zeichenfolge.

TryCopyTo(Span<Char>)

Kopiert den Inhalt dieser Zeichenfolge in den Zielbereich.

Operatoren

Equality(String, String)

Bestimmt, ob zwei angegebene Zeichenfolgen denselben Wert haben.

Implicit(String to ReadOnlySpan<Char>)

Definiert eine implizite Konvertierung einer angegebenen Zeichenfolge in einen schreibgeschützten Zeichenbereich.

Inequality(String, String)

Bestimmt, ob zwei angegebene Zeichenfolgen verschiedene Werte haben.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Object und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie das angegebene Object aufgeführt wird.

IConvertible.GetTypeCode()

Gibt TypeCode für die String-Klasse zurück.

IConvertible.ToBoolean(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToString(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator()

Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft.

IEnumerable<Char>.GetEnumerator()

Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft.

Erweiterungsmethoden

ToImmutableArray<TSource>(IEnumerable<TSource>)

Erstellt ein unveränderliches Array aus der angegebenen Auflistung.

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

Erstellt ein unveränderliches Wörterbuch aus einer bestehenden Kollektion von Elementen, mit der Anwendung einer Transformationsfunktion zum Quellschlüssel.

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

Erstellt ein unveränderliches Wörterbuch basierend auf einer Sequenztransformation.

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

Listet eine Sequenz auf und transformiert sie; und erzeugt ein unveränderliches Wörterbuch ihrer Inhalte.

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

Listet eine Sequenz auf und transformiert sie; und erzeugt mithilfe des angegebenen Schlüsselvergleichs ein unveränderliches Wörterbuch ihrer Inhalte.

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

Listet eine Sequenz auf und transformiert sie; und erzeugt mithilfe des angegebenen Schlüssel- und Wertevergleichs ein unveränderliches Wörterbuch ihrer Inhalte.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Listet eine Sequenz auf und erzeugt ein unveränderliches Hashset ihrer Inhalte.

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

Listet eine Sequenz auf, erzeugt ein unveränderliches Hashset ihres Inhalts und verwendet den angegebenen Gleichheitsvergleich für den Settyp.

ToImmutableList<TSource>(IEnumerable<TSource>)

Listet eine Sequenz auf und erzeugt eine unveränderliche Liste ihrer Inhalte.

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

Listet eine Sequenz auf, transformiert sie und erzeugt ein unveränderliches sortiertes Wörterbuch ihrer Inhalte.

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

Listet eine Sequenz auf, transformiert sie und erzeugt mithilfe des angegebenen Schlüsselvergleichs ein unveränderliches sortiertes Wörterbuch ihrer Inhalte.

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

Listet eine Sequenz auf, transformiert sie und erzeugt mithilfe des angegebenen Schlüssel- und Wertevergleichs ein unveränderliches sortiertes Wörterbuch ihrer Inhalte.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Listet eine Sequenz auf und erzeugt ein unveränderlich sortierte Gruppe ihrer Inhalte.

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

Listet eine Sequenz auf, erzeugt ein unveränderlich sortierte Gruppe ihrer Inhalte und verwendet den angegeben Vergleich.

CopyToDataTable<T>(IEnumerable<T>)

Gibt eine DataTable zurück, die Kopien der DataRow-Objekte enthält, wenn ein IEnumerable<T>-Eingabeobjekt vorhanden ist, bei dem der generische Parameter T den Wert DataRow hat.

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

Kopiert DataRow-Objekte in die angegebene DataTable, bei einem IEnumerable<T>-Eingabeobjekt, bei dem der generische Parameter T den Wert DataRow aufweist.

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

Kopiert DataRow-Objekte in die angegebene DataTable, bei einem IEnumerable<T>-Eingabeobjekt, bei dem der generische Parameter T den Wert DataRow aufweist.

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

Wendet eine Akkumulatorfunktion auf eine Sequenz an

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

Wendet eine Akkumulatorfunktion auf eine Sequenz an Der angegebene Startwert wird als erster Akkumulatorwert verwendet.

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

Wendet eine Akkumulatorfunktion auf eine Sequenz an Der angegebene Startwert wird als erster Akkumulatorwert verwendet, und der Ergebniswert wird mit der angegebenen Funktion ausgewählt.

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

Bestimmt, ob alle Elemente einer Sequenz eine Bedingung erfüllen.

Any<TSource>(IEnumerable<TSource>)

Bestimmt, ob eine Sequenz Elemente enthält.

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

Bestimmt, ob ein Element einer Sequenz eine Bedingung erfüllt.

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

Fügt einen Wert an das Ende der Sequenz an.

AsEnumerable<TSource>(IEnumerable<TSource>)

Gibt die Eingabe als IEnumerable<T> typisiert zurück

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

Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Decimal-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Double-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Int32-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Int64-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Single-Werten, die NULL zulassen, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet den Durchschnitt einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ um

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

Teilt die Elemente einer Sequenz in Teile der Größe auf size.

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

Verkettet zwei Sequenzen

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

Bestimmt mithilfe des Standardgleichheitsvergleichs, ob eine Sequenz ein angegebenes Element enthält

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

Bestimmt mithilfe eines angegebenen IEqualityComparer<T>, ob eine Sequenz ein angegebenes Element enthält

Count<TSource>(IEnumerable<TSource>)

Gibt die Anzahl der Elemente in einer Sequenz zurück

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

Gibt eine Zahl zurück, die die Anzahl der Elemente in der angegebenen Sequenz angibt, die eine Bedingung erfüllen

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Gibt die Elemente der angegebenen Sequenz oder den Standardwert des Typparameters in einer Singletonauflistung zurück, wenn die Sequenz leer ist

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

Gibt die Elemente der angegebenen Sequenz oder den angegebenen Wert in einer Singletonauflistung zurück, wenn die Sequenz leer ist.

Distinct<TSource>(IEnumerable<TSource>)

Gibt mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück

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

Gibt mithilfe eines angegebenen IEqualityComparer<T> zum Vergleichen von Werten unterschiedliche Elemente aus einer Sequenz zurück

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

Gibt unterschiedliche Elemente aus einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion zurück.

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

Gibt unterschiedliche Elemente aus einer Sequenz gemäß einer angegebenen Schlüsselauswahlfunktion zurück und verwendet einen angegebenen Vergleichsgeber zum Vergleichen von Schlüsseln.

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

Gibt das Element an einem angegebenen Index in einer Sequenz zurück

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

Gibt das Element an einem angegebenen Index in einer Sequenz zurück

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

Gibt das Element an einem angegebenen Index in einer Sequenz oder einen Standardwert zurück, wenn der Index außerhalb des gültigen Bereichs liegt.

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

Gibt das Element an einem angegebenen Index in einer Sequenz oder einen Standardwert zurück, wenn der Index außerhalb des gültigen Bereichs liegt.

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

Erzeugt die Differenzmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten

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

Erzeugt mithilfe des angegebenen IEqualityComparer<T> die Differenzmenge zweier Sequenzen zum Vergleichen von Werten

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

Erzeugt den Satzunterschied von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion.

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

Erzeugt den Satzunterschied von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion.

First<TSource>(IEnumerable<TSource>)

Gibt das erste Element einer Sequenz zurück

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

Gibt das erste Element in einer Sequenz zurück, das eine angegebene Bedingung erfüllt.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Gibt das erste Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.

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

Gibt das erste Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält.

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

Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen Standardwert, wenn ein solches Element nicht gefunden wird.

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

Gibt das erste Element der Sequenz zurück, das eine Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird.

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

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion

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

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und vergleicht die Schlüssel mithilfe eines angegebenen Vergleichs

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

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und projiziert die Elemente für jede Gruppe mithilfe einer angegebenen Funktion

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

Gruppiert die Elemente einer Sequenz entsprechend einer Schlüsselauswahlfunktion Die Schlüssel werden mithilfe eines Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.

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

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert.

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

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Schlüssel werden mithilfe eines angegebenen Vergleichs verglichen.

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

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.

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

Gruppiert die Elemente einer Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und erstellt aus jeder Gruppe und ihrem Schlüssel einen Ergebniswert. Schlüsselwerte werden mithilfe eines angegebenen Vergleichs verglichen, und die Elemente jeder Gruppe werden mithilfe einer angegebenen Funktion projiziert.

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

Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.

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

Korreliert die Elemente von zwei Sequenzen anhand der Gleichheit der Schlüssel und gruppiert die Ergebnisse Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.

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

Erzeugt die Schnittmenge zweier Sequenzen mithilfe des Standardgleichheitsvergleichs zum Vergleichen von Werten

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

Erzeugt mithilfe des angegebenen IEqualityComparer<T> zum Vergleichen von Werten die Schnittmenge von zwei Sequenzen

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

Erzeugt die festgelegte Schnittmenge von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion.

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

Erzeugt die festgelegte Schnittmenge von zwei Sequenzen gemäß einer angegebenen Schlüsselauswahlfunktion.

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

Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln Schlüssel werden mithilfe des Standardgleichheitsvergleichs verglichen.

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

Korreliert die Elemente von zwei Sequenzen auf der Grundlage von übereinstimmenden Schlüsseln Schlüssel werden mithilfe eines angegebenen IEqualityComparer<T> verglichen.

Last<TSource>(IEnumerable<TSource>)

Gibt das letzte Element einer Sequenz zurück

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

Gibt das letzte Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt.

LastOrDefault<TSource>(IEnumerable<TSource>)

Gibt das letzte Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz keine Elemente enthält.

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

Gibt das letzte Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz keine Elemente enthält.

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

Gibt das letzte Element einer Sequenz, das eine Bedingung erfüllt, oder einen Standardwert zurück, wenn ein solches Element nicht gefunden wird.

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

Gibt das letzte Element einer Sequenz zurück, die eine Bedingung erfüllt oder einen angegebenen Standardwert, wenn kein solches Element gefunden wird.

LongCount<TSource>(IEnumerable<TSource>)

Gibt ein Int64 zurück, das die Gesamtanzahl der Elemente in einer Sequenz darstellt

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

Gibt ein Int64 zurück, das die Anzahl der Elemente in einer Sequenz darstellt, die eine Bedingung erfüllen

Max<TSource>(IEnumerable<TSource>)

Gibt den Höchstwert in einer generischen Sequenz zurück

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

Gibt den Höchstwert in einer generischen Sequenz zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Decimal-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Double-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int32-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int64-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Decimal-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Double-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int32-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Int64-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Single-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den maximalen Single-Wert zurück

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

Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf, und gibt den höchsten Ergebniswert zurück

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

Gibt den Maximalwert in einer generischen Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion zurück.

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

Gibt den Maximalwert in einer generischen Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselvergleich zurück.

Min<TSource>(IEnumerable<TSource>)

Gibt den Mindestwert in einer generischen Sequenz zurück

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

Gibt den Mindestwert in einer generischen Sequenz zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Decimal-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Double-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int32-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int64-Wert zurück

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Decimal-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Double-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int32-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Int64-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Single-Wert zurück, der NULL-Werte zulässt

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

Ruft für jedes Element einer Sequenz eine Transformationsfunktion auf, und gibt den minimalen Single-Wert zurück

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

Ruft für jedes Element einer generischen Sequenz eine Transformationsfunktion auf, und gibt den niedrigsten Ergebniswert zurück

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

Gibt den Minimalwert in einer generischen Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion zurück.

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

Gibt den Minimalwert in einer generischen Sequenz entsprechend einer angegebenen Schlüsselauswahlfunktion und einem Schlüsselvergleich zurück.

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs

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

Sortiert die Elemente einer Sequenz in aufsteigender Reihenfolge nach einem Schlüssel

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

Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in aufsteigender Reihenfolge

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

Sortiert die Elemente einer Sequenz in absteigender Reihenfolge nach einem Schlüssel

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

Sortiert die Elemente einer Sequenz mithilfe eines angegebenen Vergleichs in absteigender Reihenfolge.

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

Fügt einen Wert am Anfang der Sequenz ein.

Reverse<TSource>(IEnumerable<TSource>)

Kehrt die Reihenfolge der Elemente in einer Sequenz um

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

Projiziert jedes Element einer Sequenz in ein neues Format.

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

Projiziert jedes Element einer Sequenz in ein neues Format, indem der Index des Elements integriert wird

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

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen in einer einzigen Sequenz zusammen

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

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, und fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen Der Index jedes Quellelements wird im projizierten Format des jeweiligen Elements verwendet.

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

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf.

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

Projiziert jedes Element einer Sequenz in ein IEnumerable<T>, fasst die resultierenden Sequenzen zu einer einzigen Sequenz zusammen und ruft für jedes Element in dieser Sequenz eine Ergebnisauswahlfunktion auf. Der Index jedes Quellelements wird im projizierten Zwischenformat des jeweiligen Elements verwendet.

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

Bestimmt, ob zwei Sequenzen gleich sind, indem die Elemente mithilfe des Standardgleichheitsvergleichs für ihren Typ verglichen werden

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

Bestimmt, ob zwei Sequenzen gleich sind, indem ihre Elemente mithilfe eines angegebenen IEqualityComparer<T> verglichen werden

Single<TSource>(IEnumerable<TSource>)

Gibt das einzige Element einer Sequenz zurück und löst eine Ausnahme aus, wenn nicht genau ein Element in der Sequenz vorhanden ist.

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

Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, und löst eine Ausnahme aus, wenn mehrere solche Elemente vorhanden sind.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Gibt das einzige Element einer Sequenz oder einen Standardwert zurück, wenn die Sequenz leer ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind.

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

Gibt das einzige Element einer Sequenz oder einen angegebenen Standardwert zurück, wenn die Sequenz leer ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente in der Sequenz vorhanden sind.

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

Gibt das einzige Element einer Sequenz, das eine angegebene Bedingung erfüllt, oder einen Standardwert zurück, wenn kein solches Element vorhanden ist. Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen.

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

Gibt das einzige Element einer Sequenz zurück, das eine angegebene Bedingung erfüllt, oder einen angegebenen Standardwert, wenn kein solches Element vorhanden ist; Diese Methode löst eine Ausnahme aus, wenn mehrere Elemente die Bedingung erfüllen.

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

Umgeht eine festgelegte Anzahl von Elementen in einer Sequenz und gibt dann die übrigen Elemente zurück

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

Gibt eine neue aufzählbare Auflistung zurück, die die Elemente aus source enthält, wobei die letzten count Elemente der Quellauflistung entfernt wurden.

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

Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück

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

Umgeht Elemente in einer Sequenz, solange eine angegebene Bedingung true ist, und gibt dann die übrigen Elemente zurück In der Logik der Prädikatfunktion wird der Index des Elements verwendet.

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

Berechnet die Summe einer Sequenz von Decimal-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Double-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Int32-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Int64-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Decimal-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Double-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Int32-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Int64-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Single-Werten, die NULL zulassen, und die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Berechnet die Summe einer Sequenz von Single-Werten, die durch den Aufruf einer Transformationsfunktion für jedes Element der Eingabesequenz ermittelt werden

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

Gibt eine angegebene Anzahl von zusammenhängenden Elementen ab dem Anfang einer Sequenz zurück

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

Gibt einen angegebenen Bereich zusammenhängender Elemente aus einer Sequenz zurück.

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

Gibt eine neue aufzählbare Auflistung zurück, die die letzten count Elemente aus source enthält.

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

Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung TRUE ist

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

Gibt Elemente aus einer Sequenz zurück, solange eine angegebene Bedingung TRUE ist In der Logik der Prädikatfunktion wird der Index des Elements verwendet.

ToArray<TSource>(IEnumerable<TSource>)

Erstellt ein Array aus einem IEnumerable<T>.

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

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion

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

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs

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

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion

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

Erstellt ein Dictionary<TKey,TValue> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion

ToHashSet<TSource>(IEnumerable<TSource>)

Erstellt ein HashSet<T> aus einem IEnumerable<T>.

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

Erstellt ein HashSet<T>-Element aus einem IEnumerable<T>-Element mithilfe des comparer zum Vergleichen von Schlüsseln.

ToList<TSource>(IEnumerable<TSource>)

Erstellt ein List<T> aus einem IEnumerable<T>.

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

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion

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

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> gemäß einer angegebenen Schlüsselauswahlfunktion und eines angegebenen Schlüsselvergleichs

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

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> entsprechend der angegebenen Schlüsselauswahlfunktion und Elementauswahlfunktion

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

Erstellt ein Lookup<TKey,TElement> aus einem IEnumerable<T> entsprechend einer angegebenen Schlüsselauswahlfunktion, einem Vergleich und einer Elementauswahlfunktion

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

Diese Methode versucht, die Anzahl der Elemente in einer Sequenz zu bestimmen, ohne eine Enumeration zu erzwingen.

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

Erzeugt die Vereinigungsmenge von zwei Sequenzen mithilfe des Standardgleichheitsvergleichs

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

Erzeugt mithilfe eines angegebenen IEqualityComparer<T> die Vereinigungsmenge von zwei Sequenzen

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

Erzeugt die Set-Union von zwei Sequenzen entsprechend einer angegebenen Tastenauswahlfunktion.

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

Erzeugt die Set-Union von zwei Sequenzen entsprechend einer angegebenen Tastenauswahlfunktion.

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

Filtert eine Sequenz von Werten basierend auf einem Prädikat.

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

Filtert eine Sequenz von Werten basierend auf einem Prädikat. In der Logik der Prädikatfunktion wird der Index der einzelnen Elemente verwendet.

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

Erzeugt eine Tupelsequenz mit Elementen aus den beiden angegebenen Sequenzen.

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

Erzeugt eine Sequenz von Tuples mit Elementen aus den drei angegebenen Sequenzen.

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

Wendet eine Funktion auf die entsprechenden Elemente von zwei Sequenzen an, und erzeugt eine Sequenz der Ergebnisse

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.

AsParallel<TSource>(IEnumerable<TSource>)

Ermöglicht die Parallelisierung einer Abfrage.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Konvertiert ein generisches IEnumerable<T> in ein generisches IQueryable<T>.

AsMemory(String)

Erstellt ein neues ReadOnlyMemory<Char> über den Abschnitt der Zielzeichenfolge.

AsMemory(String, Index)

Erstellt ein neues ReadOnlyMemory<Char> über einen Abschnitt der Zielzeichenfolge, beginnend bei einem angegebenen Index.

AsMemory(String, Int32)

Erstellt ein neues ReadOnlyMemory<Char> über einen Abschnitt der Zielzeichenfolge, beginnend bei einer angegebenen Zeichenposition.

AsMemory(String, Int32, Int32)

Erstellt ein neues ReadOnlyMemory<Char> über einen Abschnitt der Zielzeichenfolge, beginnend bei einer angegebenen Position mit einer Länge.

AsMemory(String, Range)

Erstellt ein neues ReadOnlyMemory<Char> über einen angegebenen Bereich der Zielzeichenfolge.

AsSpan(String)

Erstellt eine neue schreibgeschützte Spanne über eine Zeichenfolge.

AsSpan(String, Int32)

Erstellt eine neue schreibgeschützte Spanne über einen Abschnitt der Zielzeichenfolge von einer angegebenen Position aus bis zum Ende der Zeichenfolge.

AsSpan(String, Int32, Int32)

Erstellt eine neue schreibgeschützte Spanne über einen Abschnitt der Zielzeichenfolge von einer angegebenen Position aus für eine angegebene Anzahl von Zeichen.

IsNormalized(String)

Gibt an, ob diese angegebene Zeichenfolge in der Unicode-Normalisierungsform C vorliegt.

IsNormalized(String, NormalizationForm)

Gibt an, ob eine Zeichenfolge in einer angegebenen Unicode-Normalisierungsform vorliegt.

Normalize(String)

Normalisiert eine Zeichenfolge in eine Unicode-Normalisierungsform C.

Normalize(String, NormalizationForm)

Normalisiert eine Zeichenfolge in die angegebene Unicode-Normalisierungsform.

Ancestors<T>(IEnumerable<T>)

Gibt eine Auflistung von Elementen zurück, die die übergeordneten Elemente der einzelnen Knoten in der Quellauflistung enthält.

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

Gibt eine gefilterte Auflistung von Elementen zurück, die die übergeordneten Elemente der einzelnen Knoten in der Quellauflistung enthält. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.

DescendantNodes<T>(IEnumerable<T>)

Gibt eine Auflistung der Nachfolgerknoten jedes Dokuments und Elements in der Quellauflistung zurück.

Descendants<T>(IEnumerable<T>)

Gibt eine Auflistung von Elementen zurück, die die Nachfolgerelemente jedes Elements und Dokuments in der Quellauflistung enthält.

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

Gibt eine gefilterte Auflistung von Elementen zurück, die die Nachfolgerelemente jedes Elements und Dokuments in der Quellauflistung enthält. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.

Elements<T>(IEnumerable<T>)

Gibt eine Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück.

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

Gibt eine gefilterte Auflistung der untergeordneten Elemente jedes Elements und Dokuments in der Quellauflistung zurück. Nur Elemente, die über einen übereinstimmenden XName verfügen, sind in der Auflistung enthalten.

InDocumentOrder<T>(IEnumerable<T>)

Gibt eine in Dokumentreihenfolge sortierte Auflistung von Knoten zurück, die alle Knoten in der Quellauflistung enthält.

Nodes<T>(IEnumerable<T>)

Gibt eine Auflistung der untergeordneten Knoten jedes Dokuments und Elements in der Quellauflistung zurück.

Remove<T>(IEnumerable<T>)

Entfernt jeden Knoten in der Quellauflistung aus seinem übergeordneten Knoten.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.

Siehe auch