String String String String Class

Definition

Stellt Text als Sequenz von UTF-16-Codeeinheiten dar. Represents text as a sequence of UTF-16 code units.

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

Hinweise

Eine Zeichenfolge ist eine sequenzielle Auflistung von Zeichen, die zur Darstellung von Text verwendet wird.A string is a sequential collection of characters that is used to represent text. Ein String Objekt ist eine sequenzielle Auflistung von System.Char Objekte, die darstellen, eine Zeichenfolge, ein System.Char -Objekt entspricht einer Codeeinheit UTF-16.A String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. Der Wert des der String Objekt ist der Inhalt der sequenziellen Auflistung von System.Char Objekte und unveränderlichen Wert (d.h., sie ist schreibgeschützt).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). Weitere Informationen über die Unveränderlichkeit von Zeichenfolgen finden Sie unter den Unveränderlichkeit und der StringBuilder-Klasse weiter unten in diesem Thema.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. Die maximale Größe einer String Objekt im Arbeitsspeicher ist 2 GB oder etwa 1 Milliarde Zeichen.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

In diesem AbschnittIn this section:

Instanziieren ein String-Objekt Instantiating a String object
Char-Objekten und Unicode-Zeichen Char objects and Unicode characters
Zeichenfolgen und Unicode-Standard Strings and The Unicode Standard
Zeichenfolgen und eingebettete Null-Zeichen Strings and embedded null characters
Zeichenfolgen und Indizes Strings and indexes
NULL-Zeichenfolgen und leere Zeichenfolgen Null strings and empty strings
Unveränderlichkeit von und der StringBuilder-Klasse Immutability and the StringBuilder class
Ordnungszahl im Vergleich zu kulturabhängige Operationen Ordinal vs. culture-sensitive operations
Normalisierung Normalization
Zeichenfolgenoperationen nach KategorieString operations by category

Instanziieren ein String-ObjektInstantiating a String object

Instanziieren Sie ein String Objekt auf folgende Weise:You can instantiate a String object in the following ways:

  • Durch Zuweisen eines Zeichenfolgenliterals zu einem String Variable.By assigning a string literal to a String variable. Dies ist die am häufigsten verwendete Methode zum Erstellen einer Zeichenfolge.This is the most commonly used method for creating a string. Im folgende Beispiel wird eine Zuweisung zum Erstellen von mehreren Zeichenfolgen verwendet.The following example uses assignment to create several strings. Beachten Sie, dass in c#, da der umgekehrte Schrägstrich (\) ist ein Escapezeichen, Literale umgekehrte Schrägstriche in einer Zeichenfolge muss mit Escapezeichen versehen werden, oder die gesamte Zeichenfolge muss @-quoted.Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-quoted.

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc 
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc      
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc      
    
  • Durch Aufrufen einer String Klassenkonstruktor.By calling a String class constructor. Im folgende Beispiel wird die Zeichenfolgen durch Aufrufen von Konstruktoren für verschiedene Klassen instanziiert.The following example instantiates strings by calling several class constructors. Beachten Sie, dass einige der Konstruktoren Zeiger auf Zeichenarrays oder Byte mit Vorzeichen von Arrays als Parameter.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic unterstützt keine Aufrufe dieser Konstruktoren.Visual Basic does not support calls to these constructors. Ausführliche Informationen zu String Konstruktoren finden Sie unter den String Konstruktor Zusammenfassung.For detailed information about String constructors, see the String constructor summary.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word  
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word  
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc      
    
  • Mithilfe des Operators für zeichenfolgenverkettung (+ in C# geschrieben und & oder + in Visual Basic) zum Erstellen einer einzelnen Zeichenfolge aus einer beliebigen Kombination String Instanzen und Zeichenfolgenliterale.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. Das folgende Beispiel veranschaulicht die Verwendung der der Operator für zeichenfolgenverkettung.The following example illustrates the use of the string concatenation operator.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • Zum Abrufen einer Eigenschaft oder Aufrufen einer Methode, die eine Zeichenfolge zurückgibt.By retrieving a property or calling a method that returns a string. Im folgenden Beispiel wird die Methoden der String Klasse, um eine Teilzeichenfolge aus einer größeren Zeichenfolge zu extrahieren.The following example uses the methods of the String class to extract a substring from a larger string.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • Durch Aufrufen einer Formatierungsmethode auf, um einen Wert oder Objekt in seine Zeichenfolgendarstellung zu konvertieren.By calling a formatting method to convert a value or object to its string representation. Im folgenden Beispiel wird die kombinierte Formatierung Funktion, um die Zeichenfolgendarstellung von zwei Objekten in eine Zeichenfolge einzubetten.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

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

Char-Objekten und Unicode-ZeichenChar objects and Unicode characters

Jedes Zeichen in einer Zeichenfolge wird durch eine Unicode-Skalarwert, die auch als Unicode-Codepunkt oder den Ordinalwert des Unicode-Zeichens (numerischen) definiert.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Jeder Codepunkt mithilfe von UTF-16-Codierung codiert ist und der numerische Wert der einzelnen Elemente der Codierung wird dargestellt, indem eine Char Objekt.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

Hinweis

Beachten Sie, dass da ein String Instanz besteht aus einer sequenziellen Auflistung von UTF-16-Codeeinheiten, es ist möglich, erstellen Sie eine String -Objekt, das keine Unicode-Zeichenfolge wohlgeformt ist.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. Beispielsweise ist es möglich, eine Zeichenfolge zu erstellen, die ein niedriges Ersatzzeichen ohne entsprechende hohes Ersatzzeichen ist.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. Obwohl einige Methoden, z. B. die Methoden der Codierung und Decodierung von Objekten in der System.Text Namespace kann überprüft, stellen Sie sicher, dass die Zeichenfolgen wohlgeformt sind String Klassenmember ist nicht sichergestellt, dass eine Zeichenfolge wohlgeformt ist.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

Ein einzelnes Char Objekt in der Regel stellt einen einzelnen Codepunkt, d. h., der numerische Wert des der Char Codepunkt entspricht.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Z. B. den Codepunkt für das Zeichen "a" ist U + 0061 ist.For example, the code point for the character "a" is U+0061. Erfordert jedoch ein Codepunkt möglicherweise mehr als ein codiertes-Element (mehr als eine Char Objekt).However, a code point might require more than one encoded element (more than one Char object). Der Unicode-Standard definiert zwei Arten von Zeichen, die entsprechen mehreren Char Objekte: Graphemes und zusätzliche Unicode-Codepunkten, die den zusätzlichen Ebenen der Unicode-Zeichen entsprechen.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • Eine zwischen graphemgruppen wird durch ein Basiszeichen, gefolgt von einem oder mehreren Kombination von Zeichen dargestellt.A grapheme is represented by a base character followed by one or more combining characters. Beispielsweise wird das Zeichen "ä" dargestellt, durch ein Char Objekt, dessen Codepunkt U + 0061 ist gefolgt von einem Char Objekt, dessen Codepunkt U + 0308.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. Dieses Zeichen auch definiert werden, indem ein einzelnes Char Objekt, das einen Codepunkt U + 00E4 verfügt.This character can also be defined by a single Char object that has a code point of U+00E4. Wie im folgenden Beispiel wird gezeigt, gibt ein kulturabhängigen Vergleich, Gleichheit, dass diese beiden datendarstellungen gleich, und sind zwar ein Ordinalvergleich durch gewöhnlicher nicht der Fall ist.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. Wenn die beiden Zeichenfolgen normalisiert sind, gibt hingegen ein ordinalen Vergleich auch, dass sie gleich sind.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (Weitere Informationen zum Normalisieren von Zeichenfolgen finden Sie unter den Normalisierung Abschnitt.)(For more information on normalizing strings, see the Normalization section.)

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Unicode zusätzliche Codepunkt (ein Ersatzzeichenpaar) wird durch eine Char Objekt, dessen Code ein hohes Ersatzzeichen ist, gefolgt von einer Char -Objekt, dessen Codepunkt ein niedriges Ersatzzeichen ist.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. Die Codeeinheiten der hohe Ersatzzeichen-Bereich von U + D800 bis U + DBFF liegt.The code units of high surrogates range from U+D800 to U+DBFF. Die Codeeinheiten der niedrige Ersatzzeichen liegen zwischen U + DC00 und U + DFFF.The code units of low surrogates range from U+DC00 to U+DFFF. Ersatzzeichenpaare werden verwendet, um Zeichen in den 16 zusätzlichen Unicode-Ebenen darstellen.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. Das folgende Beispiel erstellt ein Ersatzzeichen und übergibt es an der Char.IsSurrogatePair(Char, Char) Methode, um zu bestimmen, ob es sich um ein Ersatzzeichenpaar ist.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

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

Zeichenfolgen und Unicode-StandardStrings and the Unicode Standard

Werden die Zeichen in einer Zeichenfolge von UTF-16-codierte Codeeinheiten, die den entsprechen dargestellt Char Werte.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Jedes Zeichen in einer Zeichenfolge verfügt über eine zugeordnete Unicode-Zeichenkategorie, die in .NET von dargestellt ist die UnicodeCategory Enumeration.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. Die Kategorie eines Zeichens oder ein Ersatzzeichenpaar kann bestimmt werden, indem die CharUnicodeInfo.GetUnicodeCategory Methode.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.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..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. Wenn .NET Core unter Linux und macOS ausgeführt wird, werden Informationen zu Zeichenkategorien von International Components for Unicode-Bibliotheken bereitgestellt.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

Die folgende Tabelle enthält die .NET-Versionen und die Versionen des Unicode-Standards, auf dem ihre Zeichenkategorien basieren.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

.NET-Version.NET version Version des Unicode-StandardsVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 The Unicode Standard, Version 4.0.0 (Der Unicode-Standard, Version 4.0.0)The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 The Unicode Standard, Version 5.0.0 (Der Unicode-Standard, Version 5.0.0)The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)The Unicode Standard, Version 6.3.0
.NET Framework 4.51.NET Framework 4.51 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)The Unicode Standard, Version 6.3.0
.NET Framework 4.52.NET Framework 4.52 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)The Unicode Standard, Version 6.3.0
.NET Framework 4.61.NET Framework 4.61 The Unicode Standard, Version 6.3.0 (Der Unicode-Standard, Version 6.3.0)The Unicode Standard, Version 6.3.0
.NET Framework 4.6.2 und höhere Versionen.NET Framework 4.6.2 and later versions The Unicode Standard, Version 8.0.0 (Der Unicode-Standard, Version 8.0.0)The Unicode Standard, Version 8.0.0
.NET Core (alle Versionen).NET Core (all versions) The Unicode Standard, Version 8.0.0 (Der Unicode-Standard, Version 8.0.0)The Unicode Standard, Version 8.0.0

Darüber hinaus .NET unterstützt Zeichenfolgenvergleich und Sortierung basierend auf den Unicode-Standard.In addition, .NET supports string comparison and sorting based on the Unicode standard. In Versionen von .NET Framework durch die .NET Framework 4.NET Framework 4, .NET Framework verwaltet eine eigene Tabelle von Zeichenfolgendaten.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. Dies gilt auch für Versionen von .NET Framework ab, mit der .NET Framework 4.5.NET Framework 4.5 auf Windows 7 ausgeführt wird.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. Beginnend mit der .NET Framework 4.5.NET Framework 4.5 auf Windows 8 und höheren Versionen des Windows-Betriebssystems ausgeführt werden, die die Common Language Runtime-Delegaten Zeichenfolge Vergleichs- und Sortiervorgänge für das Betriebssystem.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. Zeichenfolgenvergleich in .NET Core, und Sortieren von Informationen über International Components for Unicode Bibliotheken. Die folgende Tabelle enthält die Versionen von .NET und die Versionen von Unicode-Standard auf, welches Zeichen als Vergleich und Sortierung basieren.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

Version von .NET.NET version Version des Unicode-StandardsVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Der Unicode-Standard, Version 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0The .NET Framework 2.0 Der Unicode-Standard, Version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3,5.NET Framework 3.5 Der Unicode-Standard, Version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Der Unicode-Standard, Version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 und höher unter Windows 7 and later on Windows 7 Der Unicode-Standard, Version 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 und höher unter Windows 8 und späteren Windows-Betriebssystemen and later on Windows 8 and later Windows operating systems Der Unicode-Standard, Version 6.3.0The Unicode Standard, Version 6.3.0
.NET Core (alle Versionen).NET Core (all versions) Hängt von der Version des Unicode-Standards, die von dem zugrunde liegenden Betriebssystem unterstützt werden.Depends on the version of hte Unicode Standard supported by the underlying operating system.

Zeichenfolgen und eingebettete Null-ZeichenStrings and embedded null characters

In .NET eine String Objekt kann eingebetteten Null-Zeichen, die Anzahl der im Rahmen der die Länge der Zeichenfolge enthalten.In .NET, a String object can include embedded null characters, which count as a part of the string's length. In einigen Sprachen wie C und C++ gibt ein Null-Zeichen jedoch an das Ende einer Zeichenfolge; Es ist nicht Teil der Zeichenfolge berücksichtigt und zählt nicht als Teil der die Länge der Zeichenfolge.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. Dies bedeutet, dass die folgenden allgemeinen Annahmen, die in C oder C++ geschriebene Bibliotheken oder C- und C++-Programmierer über Zeichenfolgen, die möglicherweise nicht unbedingt gültig, wenn Sie zugewiesen sind String Objekte:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • Der Rückgabewert von der strlen oder wcslen Funktionen ist nicht unbedingt gleich String.Length.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • Die Zeichenfolge, die erstellt werden, indem Sie die strcpy_s oder wcscpy_s Funktionen ist nicht unbedingt identisch, mit der Zeichenfolge, die erstellt werden, indem die String.Copy Methode.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

Sie sollten sicherstellen, dass diese systemeigene C- und C++-Code, der instanziiert String Objekte und Code, der übergeben wird String Objekte über Platform aufrufen, nicht davon ausgehen, dass ein Null-Zeichen am Ende der Zeichenfolge kennzeichnet.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

Eingebettete Null-Zeichen in einer Zeichenfolge werden auch anders behandelt werden, wenn eine Zeichenfolge sortiert (bzw. im Vergleich) und eine Zeichenfolge gesucht wird.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. NULL-Zeichen werden ignoriert, wenn kulturabhängige Vergleiche zwischen zwei Zeichenfolgen, einschließlich vergleichen, die mit der invarianten Kultur ausgeführt wird.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Diese sind nur für die Ordinalvergleiche, bei Ordnungszahl oder Groß-/Kleinschreibung berücksichtigt.They are considered only for ordinal or case-insensitive ordinal comparisons. Auf der anderen Seite eingebettete Null-Zeichen werden immer berücksichtigt, wenn eine Zeichenfolge mit Methoden wie z. B. Suche Contains, StartsWith, und IndexOf.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Zeichenfolgen und IndizesStrings and indexes

Ein Index ist die Position des ein Char Objekt (nicht in ein Unicode-Zeichen) in einem String.An index is the position of a Char object (not a Unicode character) in a String. Ein Index ist eine nullbasierte, nicht negative Zahl, die von der ersten Position in der Zeichenfolge, beginnt die Indexposition 0 (null) ist.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. Eine Reihe von Suchmethoden z. B. IndexOf und LastIndexOf, den Index eines Zeichens zurück, oder in der Zeichenfolgeninstanz Teilzeichenfolge.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

Die Chars[Int32] Eigenschaft ermöglicht den Zugriff auf einzelne Char Objekte durch ihre Indexposition in der Zeichenfolge.The Chars[Int32] property lets you access individual Char objects by their index position in the string. Da die Chars[Int32] -Eigenschaft ist die Standardeigenschaft (in Visual Basic) oder der Indexer (in c#), es stehen die einzelnen Char Objekte in einer Zeichenfolge durch folgenden Code verwenden.Because the Chars[Int32] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. Dieser Code sucht nach Leerzeichen oder Satzzeichen in eine Zeichenfolge, um zu bestimmen, wie viele Wörter der Zeichenfolge enthält.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

using namespace System;

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

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

public class Example
{
   public static 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.
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 implementiert die IEnumerable -Schnittstelle, Sie können auch durchlaufen die Char Objekte in eine Zeichenfolge mit einer foreach Konstrukt, wie im folgenden Beispiel gezeigt.Because the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

using namespace System;

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

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

public class Example
{
   public static void Main()
   {
      string s1 = "This string consists of a single short sentence.";
      int nWords = 0;

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

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

Aufeinander folgende Indexwerte entspricht möglicherweise nicht aufeinander folgende Unicode-Zeichen, da Unicode Zeichen möglicherweise als mehr als ein codiert Char Objekt.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. Insbesondere kann eine Zeichenfolge mit mehreren Zeichen Texteinheiten enthalten, die von einem Basiszeichen gefolgt durch eine oder mehrere Kombinationszeichen oder Ersatzzeichenpaare gebildet werden.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Arbeiten mit Unicode-Zeichen anstelle von Char Objekte zu verwenden, die System.Globalization.StringInfo und TextElementEnumerator Klassen.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. Das folgende Beispiel veranschaulicht den Unterschied zwischen Code, mit der Funktionsweise Char Benutzerobjekten und Code, die mit Unicode-Zeichen.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Die Anzahl der Zeichen oder Text-Elemente in jedem Wort im Satz verglichen.It compares the number of characters or text elements in each word of a sentence. Die Zeichenfolge enthält zwei Sequenzen aus einem Basiszeichen, gefolgt von einer Kombination von Zeichen.The string includes two sequences of a base character followed by a combining character.

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

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

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

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

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

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

public class Example
{
   public static void Main()
   {
      // 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++;
         }
      }

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

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

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

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

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

Dieses Beispiel funktioniert mit Textelemente mithilfe der StringInfo.GetTextElementEnumerator Methode und die TextElementEnumerator Klasse alle Textelemente in einer Zeichenfolge aufgelistet werden.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. Sie können auch ein Array, das durch den Aufruf der Startindex für jedes Textelement enthält Abrufen der StringInfo.ParseCombiningCharacters Methode.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Weitere Informationen zum Arbeiten mit Einheiten von eher Text als einzelnen Char -Werte finden Sie in der StringInfo Klasse.For more information about working with units of text rather than individual Char values, see the StringInfo class.

NULL-Zeichenfolgen und leere ZeichenfolgenNull strings and empty strings

Eine Zeichenfolge, die deklariert wurde, jedoch wurde kein Wert zugewiesen ist null.A string that has been declared but has not been assigned a value is null. Es wird versucht, das Aufrufen von Methoden für diese Zeichenfolge löst eine NullReferenceException.Attempting to call methods on that string throws a NullReferenceException. Eine null-Zeichenfolge unterscheidet sich von der eine leere Zeichenfolge ist, d. h. eine Zeichenfolge, deren Wert "" oder String.Empty.A null string is different from an empty string, which is a string whose value is "" or String.Empty. In einigen Fällen löst eine Ausnahme aus, wenn Sie eine null-Zeichenfolge oder eine leere Zeichenfolge als Argument in einem Methodenaufruf übergeben.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Übergeben Sie z. B. eine null-Zeichenfolge, die Int32.Parse -Methode löst eine ArgumentNullException, und übergeben eine leere Zeichenfolge löst eine FormatException.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. In anderen Fällen kann ein Methodenargument entweder eine null-Zeichenfolge oder eine leere Zeichenfolge sein.In other cases, a method argument can be either a null string or an empty string. Wenn Sie bereit sind z. B. eine IFormattable Implementierung für eine Klasse, mit der allgemeine Formatbezeichner ("G") sowohl eine null-Zeichenfolge und eine leere Zeichenfolge entsprechen sollen.For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

Die String Klasse enthält die folgenden zwei Hilfsmethoden, mit denen Sie überprüfen, ob eine Zeichenfolge ist null oder leer sein:The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, der angibt, ob eine Zeichenfolge, die eine ist null oder gleich String.Empty.IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Diese Methode entfällt das Code wie den folgenden verwenden:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, der angibt, ob eine Zeichenfolge ist null, gleich String.Empty, oder ausschließlich aus Leerzeichen besteht.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Diese Methode entfällt das Code wie den folgenden verwenden:This method eliminates the need to use code such as the following:

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

Im folgenden Beispiel wird die IsNullOrEmpty -Methode in der die IFormattable.ToString Implementierung eines benutzerdefinierten Temperature Klasse.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. Die Methode unterstützt die Formatzeichenfolgen "G", "C", "F" und "K".The method supports the "G", "C", "F", and "K" format strings. Wenn eine leere Zeichenfolge oder ein Format, deren Wert eine Zeichenfolge ist null übergeben an die Methode wird der Wert mit der Formatzeichenfolge "G" geändert.If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

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

Unveränderlichkeit von und der StringBuilder-KlasseImmutability and the StringBuilder class

Ein String Objekt wird als unveränderlich (schreibgeschützt), da der Wert kann nicht geändert werden, nachdem es erstellt wurde.A String object is called immutable (read-only), because its value cannot be modified after it has been created. Methoden, die angezeigt werden, so ändern Sie eine String Objekt tatsächlich ein neues zurückzugeben String Objekt, das die Änderung enthält.Methods that appear to modify a String object actually return a new String object that contains the modification.

Da Zeichenfolgen unveränderlich sind, wiederholt Zeichenfolge-manipulationsroutinen, die ausgeführt werden, Hinzufügungen oder löschungen von aussieht, dass eine einzelne Zeichenfolge beträchtliche Leistungseinbußen genauer kann.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. Der folgende Code verwendet beispielsweise eine Zufallszahlen-Generators zum Erstellen einer Zeichenfolge mit 1000 Zeichen im Bereich von 0 x 0001, 0x052F.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Obwohl der Code angezeigt, zum Verketten von Zeichenfolgen zu verwenden wird, um ein neues Zeichen an die vorhandene Zeichenfolge, die mit dem Namen Anfügen str, tatsächlich wird ein neuer String Objekt für jeden Verkettungsvorgang.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

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

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

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

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

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

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

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

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

Können Sie die StringBuilder -Klasse anstelle der String -Klasse für Vorgänge, die mehrere Änderungen an den Wert einer Zeichenfolge vornehmen.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. Im Gegensatz zu Instanzen der String -Klasse, StringBuilder Objekte sind änderbar, wenn Sie verketten, Anfügen oder Löschen von untergeordneten Zeichenfolgen aus einer Zeichenfolge, die Vorgänge werden für eine einzelne Zeichenfolge.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. Sobald Sie abgeschlossen haben, Ändern des Werts einer StringBuilder Objekt, rufen Sie die StringBuilder.ToString Methode in eine Zeichenfolge zu konvertieren.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. Im folgenden Beispiel ersetzt die String im vorherigen Beispiel zum Verketten von 1000 zufällige Zeichen im Bereich von 0 x 0001 bis 0x052F mit verwendet eine StringBuilder Objekt.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

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

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

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

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

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

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

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

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

Ordnungszahl im Vergleich zu kulturabhängige OperationenOrdinal vs. culture-sensitive operations

Mitglieder der String Klasse entweder Ordnungszahl- oder kulturabhängige (linguistische) Vorgänge ausführen, auf eine String Objekt.Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Ein ordinaler-Vorgang ausgeführt wird, nach dem numerischen Wert der einzelnen Char Objekt.An ordinal operation acts on the numeric value of each Char object. Eine kulturabhängige Operation wird der Wert, der die String -Objekt, und nimmt kulturspezifische Groß-/Kleinschreibung, Sortierung, Formatierung, und Analyseregeln berücksichtigen.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. Führen Sie kulturabhängige Operationen im Kontext einer explizit deklarierten Kultur oder implizite der aktuellen Kultur.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. Die beiden Arten von Vorgängen können sehr unterschiedliche Ergebnisse erzeugen, wenn sie auf die gleiche Zeichenfolge ausgeführt werden.The two kinds of operations can produce very different results when they are performed on the same string.

.NET unterstützt auch kulturunabhängige linguistische Zeichenfolgenoperationen mit der invarianten Kultur (CultureInfo.InvariantCulture), die lose basiert auf den kultureinstellungen der englischen Sprache unabhängig von der Region..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. Im Gegensatz zu anderen System.Globalization.CultureInfo Einstellungen, die Einstellungen der invarianten Kultur sind garantiert auf einem einzelnen Computer, vom System System und für Versionen von .NET konsistent bleiben.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. Die invariante Kultur kann als eine Art von Blackbox, die gewährleistet die Stabilität von Zeichenfolgenvergleichen betrieben und Bestellungen sein, in allen Kulturen.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Wichtig

Wenn die Anwendung eine sicherheitsentscheidung zu einen symbolischen Bezeichner wie z. B. ein Dateiname macht oder die named Pipe oder über persistente Daten wie z. B. die textbasierte Daten in eine XML-Datei, sollte der Vorgang einen Ordinalvergleich anstelle einen kulturabhängigen Vergleich verwenden.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. Grund hierfür ist ein kulturabhängiger Vergleich zu anderen Ergebnissen je nach Kultur aktiviert ist, führen kann hingegen ein Ordinalvergleich ausschließlich auf den binären Wert der verglichenen Zeichen abhängt.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

Wichtig

Die meisten Methoden, die Zeichenfolgenvorgänge umfassen eine Überladung, die einen vom Typ Parameter StringComparison, können Sie angeben, ob die Methode eine Ordnungszahl oder kulturabhängige Operation ausführt.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. Im Allgemeinen sollten Sie diese Überladung, um den Zweck der Methode eindeutig zu machen aufrufen.In general, you should call this overload to make the intent of your method call clear. Best Practices und Anleitungen zur Verwendung von Ordnungszahlen und kulturabhängige Vorgänge auf Zeichenfolgen, finden Sie unter bewährte Methoden für die Verwendung von Zeichenfolgen.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

Vorgänge für Schreibweise, Analyse und Formatierung, Vergleich und Sortierung, und Testen auf Gleichheit kann entweder Ordnungszahl oder kulturabhängig.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. Den folgenden Abschnitten werden die einzelnen Kategorien des Vorgangs.The following sections discuss each category of operation.

Tipp

Sie sollten immer eine methodenüberladung aufrufen, die den Zweck der Methode eindeutig macht.You should always call a method overload that makes the intent of your method call clear. Z. B. statt der Compare(String, String) Methode, um einen kulturabhängigen Vergleich von zwei Zeichenfolgen mithilfe der Konventionen der aktuellen Kultur ausführen rufen Sie die Compare(String, String, StringComparison) Methode mit einem Wert von StringComparison.CurrentCulture für die comparisonType Argument.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. Weitere Informationen finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.For more information, see Best Practices for Using Strings.

Sie können die sortieren Gewichtung Tabellen, einen Satz von Textdateien mit Informationen zu den Zeichen Gewichtungen verwendet bei Sortier- und Vergleichsregeln für Windows-Betriebssysteme und die Unicode Standard Sortierung-Elementtabelle, die Gewichtung Sortiertabelle für Linux und MacOS.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

SchreibweiseCasing

Groß-/ Kleinschreibregeln bestimmen, wie die Groß-/Kleinschreibung von einem Unicode-Zeichen ändern wird. z. B. von Kleinbuchstaben in Großbuchstaben.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Häufig wird ein Vorgang zur Groß-und Kleinschreibung vor einen Zeichenfolgenvergleich durchgeführt.Often, a casing operation is performed before a string comparison. Beispielsweise kann eine Zeichenfolge in Großbuchstaben konvertiert werden, damit er mit einer anderen Großbuchstaben Zeichenfolge verglichen werden kann.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. Sie können die Zeichen in eine Zeichenfolge, die durch den Aufruf in Kleinbuchstaben konvertieren die ToLower oder ToLowerInvariant Methode, und Sie können sie durch den Aufruf in Großbuchstaben konvertieren die ToUpper oder ToUpperInvariant Methode.You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. Darüber hinaus können Sie die TextInfo.ToTitleCase Methode zum Konvertieren einer Zeichenfolge in titelschreibung.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Schreibweise Vorgänge können auf die Regeln für die aktuelle Kultur, einer angegebenen Kultur oder der invarianten Kultur basieren.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. Da schreibungszuordnungen abhängig von der verwendeten Kultur variieren können, kann das Ergebnis der Schreibweise Vorgänge basierend auf Kultur variieren.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. Die tatsächlichen Unterschiede in Groß-/Kleinschreibung gibt es drei Arten:The actual differences in casing are of three kinds:

  • Unterschiede in der Zuordnung der Schreibweise des LATIN CAPITAL LETTER I (U + 0049), kleinen Buchstaben LATEINISCH I (U + 0069), LATIN CAPITAL LETTER I mit Punkt oben (U + 0130) und LATIN kleine Buchstaben ohne Punkte I (U + 0131).Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). In die Latn-Verfügbarkeitszonenübergreifende (Aserbaidschan, Lateinisch)-Kulturen und tr-TR (Türkisch (Türkei)) und in der tr az und az-Latn neutrale Kulturen die kleinbuchstabenentsprechung von LATIN CAPITAL LETTER I ist LATIN kleine Buchstaben ohne Punkte I und ist der entsprechende Großbuchstabe LATIN kleine Buchstaben I LATIN CAPITAL LETTER ICH MIT PUNKT OBEN.In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. In allen anderen Kulturen einschließlich der invarianten Kultur, kleine Buchstaben LATEINISCH I und LATIN CAPITAL LETTER ich die Groß- und Kleinbuchstaben Entsprechungen sind.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    Im folgenden Beispiel wird veranschaulicht, wie einen Zeichenfolgenvergleich entwickelt zu Dateisystemzugriff zu verhindern, dass durchgeführt werden können, wenn es auf einem Vergleich kulturabhängig Groß-/Kleinschreibung verwendet.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (Die Groß-/ Kleinschreibungskonventionen der invarianten Kultur sollte verwendet werden.)(The casing conventions of the invariant culture should have been used.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • Unterschiede in der Groß-/Kleinschreibung Zuordnungen zwischen der invarianten Kultur und alle anderen Kulturen.Differences in case mappings between the invariant culture and all other cultures. In diesen Fällen gibt das gleiche Zeichen zurück, wenn Sie mit der Groß-/ Kleinschreibregeln der invarianten Kultur, um ein Zeichen in Groß-oder Kleinbuchstaben zu ändern.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Für alle anderen Kulturen wird ein anderes Zeichen zurückgegeben.For all other cultures, it returns a different character. Einige der betroffenen Zeichen sind in der folgenden Tabelle aufgeführt.Some of the affected characters are listed in the following table.

    ZeichenCharacter Wenn in geändertIf changed to RückgabeReturns
    NM-ANMELDUNG (U + 00B5)MICRON SIGN (U+00B5) GroßbuchstabenUppercase GRIECHISCHEN GROSSBUCHSTABEN MU (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    LATIN CAPITAL LETTER ICH PUNKT OBEN (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) KleinbuchstabenLowercase LATEINISCHE KLEINE BUCHSTABE I (U + 0069)LATIN SMALL LETTER I (U+0069)
    KLEINES LATEINISCHES DOTLESS ICH (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) GroßbuchstabenUppercase LATIN CAPITAL LETTER ICH (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    KLEINES LATEINISCHES LANGE S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) GroßbuchstabenUppercase LATIN CAPITAL LETTER S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    LATEINISCHE GROSSBUCHSTABEN D MIT KLEINEN BUCHSTABEN Z MIT HÄKCHEN (U + 01C 5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) KleinbuchstabenLowercase KLEINES LATEINISCHES DZ MIT HÄKCHEN (U + 01C 6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    KOMBINIEREN VON YPOGRAMMENI (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) GroßbuchstabenUppercase GRIECHISCHEN GROSSBUCHSTABEN IOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • Unterschiede in der Groß-/Kleinschreibung Zuordnungen von zwei Buchstaben bestehenden gemischter-Paare im ASCII-Zeichenbereich.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. In den meisten Kulturen ist ein kleingeschriebener zweibuchstabiger-gemischter-Paar gleich an das entsprechende Paar aus zwei Buchstaben bestehenden Groß- oder Kleinbuchstaben.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. Dies gilt nicht für die folgenden Paare aus zwei Buchstaben in den folgenden Kulturen, da in jedem Fall sie nicht auf einen Digraph verglichen werden:This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • "lJ" und "nJ", in die Kultur hr-HR (Kroatisch (Kroatien))."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" in der Cs-CZ (Tschechisch (Tschechische Republik)) und Kulturen der sk-SK (Slowakisch (Slowakei))."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" in der Kultur da-DK (Dänisch (Dänemark))."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" und "zS" in der Kultur Hu-HU (Ungarisch (Ungarn))."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" und "lL" in der Kultur es-ES_tradnl (Spanisch (Spanien, Traditionelle Sortierung))."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "gI", "kH", "nG" "Notification Hub", "pH", "qU", "tH" und "tR" in der Kultur des vi-VN (Vietnamesisch (Vietnam))."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    Es ist jedoch ungewöhnlich, die eine Situation, in der ein kulturabhängiger Vergleich dieser Paare Probleme erstellt, auftreten, da diese Paare feste Zeichenfolgen oder Bezeichner selten auftreten.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

Das folgende Beispiel veranschaulicht einige der Unterschiede in der Groß-/ Kleinschreibregeln zwischen Kulturen, die beim Konvertieren von Zeichenfolgen in Großbuchstaben.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

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

String^ ShowHexValue(String^ s);

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

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

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

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

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

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

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

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

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

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

Analyse und FormatierungParsing and formatting

Formatierung und Analyse sind umgekehrte Vorgänge.Formatting and parsing are inverse operations. Formatierungsregeln bestimmen Sie, wie einen Wert, z. B. ein Datum und Uhrzeit oder eine Zahl ist, in seine zeichenfolgenentsprechung konvertiert während Analyseregeln Gewusst wie: Konvertieren einer Zeichenfolgendarstellung in einen Wert wie z. B. Datum und Uhrzeit bestimmen.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. Kulturelle Konventionen hängen sowohl Formatierung und Analyse für Regeln.Both formatting and parsing rules are dependent on cultural conventions. Das folgende Beispiel veranschaulicht die Mehrdeutigkeit, die auftreten kann, wenn eine kulturspezifische Datumszeichenfolge zu interpretieren.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. Ohne Kenntnis der Konventionen der Kultur, die verwendet wurde, um eine Datumszeichenfolge zu erzeugen, ist es nicht möglich, um herauszufinden, ob 03/01/2011, 3/1/2011 und 01/03/2011 3. Januar 2011 oder 1. März 2011 darstellen.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 2011.

using namespace System;
using namespace System::Globalization;

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

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

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

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

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

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

Auf ähnliche Weise wie im folgenden Beispiel wird gezeigt, kann eine einzelne Zeichenfolge unterschiedliche Daten je nach Kultur erstellen, dessen Konventionen in den Analysevorgang verwendet werden.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

using namespace System;
using namespace System::Globalization;

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

using System;
using System.Globalization;

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

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

Zeichenfolgenvergleich und-SortierungString comparison and sorting

Konventionen für die vergleichenden und sortierenden Zeichenfolgen variieren Kultur.Conventions for comparing and sorting strings vary from culture to culture. Beispielsweise kann die Sortierreihenfolge auf der Phonetik oder der visuellen Darstellung von Zeichen basieren.For example, the sort order may be based on phonetics or on the visual representation of characters. In ostasiatischen Sprachen werden Zeichen anhand der Anzahl der Striche und der Radikale der Ideogramme sortiert.In East Asian languages, characters are sorted by the stroke and radical of ideographs. Die Sortierung hängt außerdem von der Reihenfolge ab, die das Alphabet der jeweiligen Sprache bzw. Kultur aufweist.Sorting also depends on the order languages and cultures use for the alphabet. Im Dänischen gibt es beispielsweise das Zeichen "Æ", das im Alphabet nach dem Zeichen "Z" einsortiert ist.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. Darüber hinaus können es sich bei Vergleichen Groß-/Kleinschreibung oder Groß-/Kleinschreibung, und in einigen Fällen Regeln Groß-und Kleinschreibung unterscheiden sich auch nach Kultur.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. Ordinalvergleich, verwendet die Unicode-Codepunkte einzelner Zeichen auf der anderen Seite in einer Zeichenfolge, die beim Vergleichen und Sortieren von Zeichenfolgen.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Sortierregeln bestimmen, dass die alphabetische Reihenfolge der Unicode-Zeichen und wie Zeichenfolgen miteinander vergleichen.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Z. B. die String.Compare(String, String, StringComparison) Methode vergleicht zwei Zeichenfolgen, die auf der Grundlage der StringComparison Parameter.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Wenn der Parameterwert ist StringComparison.CurrentCulture, die Methode führt einen linguistischen Vergleich, der die Konventionen der aktuellen Kultur; verwendet, wenn der Parameterwert ist StringComparison.Ordinal, die Methode führt einen Ordinalvergleich.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. Folglich, wie das folgende Beispiel zeigt, wenn die aktuelle Kultur Englisch Englisch, der erste Aufruf der String.Compare(String, String, StringComparison) (mithilfe von kulturabhängigen Vergleich) Methode betrachtet, "a" kleiner als "A", aber der zweite Aufruf (mit Ordinalvergleich) derselben Methode betrachtet "a" größer als "A".Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "A".

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

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

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

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

.NET unterstützt Wort-, Zeichenfolgen- und Ordinalsortierregeln:.NET supports word, string, and ordinal sort rules:

  • 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.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Z. B. der Bindestrich (-) möglicherweise eine sehr geringe Gewichtung zugeordnet, sodass "Coop" und "coop" in einer sortierten Liste nebeneinander angezeigt werden.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Eine Liste mit den String Methoden, Vergleichen von zwei Zeichenfolgen mithilfe der Word-Sortierregeln, finden Sie unter der Zeichenfolgenoperationen nach Kategorie Abschnitt.For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Eine führt auch einen kulturabhängigen Vergleich.A string sort also performs a culture-sensitive comparison. Es ähnelt einer wortsortierung, außer dass es keine Sonderfälle gibt und alle nicht alphanumerischen Symbole vor allen alphanumerischen Unicode-Zeichen sind.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. Zwei Zeichenfolgen können verglichen werden, mithilfe von Zeichenfolge-Sortierregeln durch Aufrufen der CompareInfo.Compare Überladungen der Methode, die eine options Parameter bereitgestellte Wert CompareOptions.StringSort.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. Beachten Sie, dass dies nur eine Methode enthält, die .NET zum Vergleichen von zwei Zeichenfolgen mithilfe von Zeichenfolge-Sortierregeln bereitstellt.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Eine Ordinalsortierung vergleicht Zeichenfolgen anhand des numerischen Werts jedes Char-Objekts in der Zeichenfolge.An ordinal sort compares strings based on the numeric value of each Char object in the string. Ein ordinalen Vergleich ist automatisch die Groß-/Kleinschreibung beachtet, da die Groß- und Kleinbuchstaben Versionen eines Zeichens verschiedene Codepunkte aufweisen.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. Wenn Fall nicht wichtig ist, können Sie jedoch einen ordinalen Vergleich angeben, der Groß-und Kleinschreibung ignoriert.However, if case is not important, you can specify an ordinal comparison that ignores case. Dies entspricht dem Konvertieren der Zeichenfolge in Großbuchstaben unter Verwendung der invarianten Kultur, und klicken Sie dann einen Ordinalvergleich ausführen, auf dem Ergebnis.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Eine Liste mit den String Methoden, Vergleichen von zwei Zeichenfolgen mithilfe der ordinalen Sortierregeln, finden Sie unter der Zeichenfolgenoperationen nach Kategorie Abschnitt.For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Ein kulturabhängiger Vergleich ist ein Vergleich, explizit oder implizit verwendet, eine CultureInfo -Objekts, einschließlich der invarianten Kultur, die angegeben wird die CultureInfo.InvariantCulture Eigenschaft.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. Die implizite Kultur ist die aktuelle Kultur, die von angegeben wird die Thread.CurrentCulture und CultureInfo.CurrentCulture Eigenschaften.The implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Ist es beträchtliche Abweichung in der Sortierreihenfolge von alphabetischen Zeichen (d. h. Zeichen für die die Char.IsLetter -Eigenschaft gibt true) über Kulturen hinweg.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. Sie können angeben, dass einen kulturabhängiger Vergleich, der die Konventionen einer bestimmten Kultur durch Angabe verwendet eine CultureInfo Objekt auf einer Zeichenfolgenvergleichsmethode wie Compare(String, String, CultureInfo, CompareOptions).You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). Können Sie angeben, einen kulturabhängigen Vergleich, der die Konventionen der aktuellen Kultur durch Angabe verwendet StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, oder ein Mitglied der CompareOptions Enumeration außer CompareOptions.Ordinal oder CompareOptions.OrdinalIgnoreCase auf einen entsprechenden Überladen von der Compare Methode.You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. Ein kulturabhängiger Vergleich ist im Allgemeinen gut geeignet für die Sortierung während ein ordinalen Vergleich nicht ist.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. Ein ordinalen Vergleich ist im Allgemeinen gut geeignet, um zu bestimmen, ob zwei Zeichenfolgen gleich sind (d. h. bei der identitätsbestimmung) dagegen ein kulturabhängigen Vergleich nicht ist.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

Das folgende Beispiel veranschaulicht den Unterschied zwischen kulturabhängige und ordinalen Vergleich.The following example illustrates the difference between culture-sensitive and ordinal comparison. Im Beispiel, das ausgewertet wird, drei Zeichenfolgen, "Apple", "Æble" und "AEble", die mithilfe von ordinalen Vergleich und die Konventionen der Kulturen da-DK "und" En-US (von denen jeder ist die Standardkultur, zum Zeitpunkt der Compare Methode wird aufgerufen).The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). Da die dänische Sprache das Zeichen "Æ" als einzelner Buchstabe wird und sie nach "Z" im Alphabet beginnen sortiert, ist die Zeichenfolge "Æble" größer als "Apple".Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". "Æble" ist jedoch nicht äquivalent zu "AEble", angesehen, ist die "Æble" auch größer als "AEble".However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". Die Kultur En-US interpretiert als Entsprechung zu "AE", die erklärt, warum "Æble" kleiner als "Apple", aber gleich "AEble" ist jedoch nicht der Buchstabe "Æ" enthalten.The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". Ordinalvergleich, berücksichtigt dagegen auf "Apple" kleiner als "Æble" und "Æble" größer als "AEble" sein.Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "AEble".

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

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

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

Verwenden Sie die folgenden allgemeinen Richtlinien, um eine entsprechende Sortierung oder Zeichenfolge Vergleichsmethode auszuwählen:Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • Wenn Sie die Zeichenfolgen sortiert werden basierend auf der Kultur des Benutzers möchten, müssen Sie basierend auf der die Konventionen der aktuellen Kultur Reihenfolge.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. Wenn die Kultur des Benutzers ändert, wird die Reihenfolge der sortierten Zeichenfolgen auch entsprechend geändert.If the user's culture changes, the order of sorted strings will also change accordingly. Beispielsweise sollte eine Thesaurus-Anwendung immer Wörter, die basierend auf der Kultur des Benutzers sortieren.For example, a thesaurus application should always sort words based on the user's culture.

  • Gegebenenfalls die Zeichenfolgen, die bestellt werden basierend auf den Konventionen einer bestimmten Kultur bestellen Sie sie durch Angabe einer CultureInfo -Objekt, das die Kultur für eine Vergleichsmethode darstellt.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. Beispielsweise sollen in einer Anwendung entwickelt, um Schüler und Studenten mit eine bestimmte Sprache zu unterrichten, Zeichenfolgen, die bestellt werden basierend auf den Konventionen der eine der Kulturen, die diese Sprache spricht.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • Wenn Sie die Reihenfolge der Zeichenfolgen über Kulturen hinweg unverändert bleiben möchten, sollten Sie in beliebiger Reihenfolge basierend auf den Konventionen der invarianten Kultur oder verwenden einen Ordinalvergleich durch.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. Beispielsweise würde eine Ordinalsortierung verwenden, um die Namen der Dateien, Prozesse, Mutexe zu organisieren oder named Pipes.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • Einen Vergleich, der eine sicherheitsentscheidung (z. B., ob ein Benutzername gültig ist) umfasst, sollten Sie immer einen Ordnungszahlen Test auf Gleichheit durch Aufruf einer Überladung der Ausführen der Equals Methode.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

Hinweis

Der kulturabhängige Sortierung und Groß-/Kleinschreibung beim Zeichenfolgenvergleich verwendete Regeln, abhängig von der Version von .NET ab.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. In der .NET Framework 4.5 und höheren Versionen, die unter der Windows 8Windows 8 operating System, Sortierung, die Groß-/Kleinschreibung, Normalisierung und Unicode-Zeichen-Informationen für den Standard Unicode 6.0 entspricht.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. Bei anderen Windows-Betriebssystemen entspricht es der standard Unicode 5.0.On other Windows operating systems, it conforms to the Unicode 5.0 standard. In .NET Core hängt die Version des Unicode-Standards, die von dem zugrunde liegenden Betriebssystem unterstützt werden.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Weitere Informationen über Wort-, Zeichenfolgen- und Ordinalsortierregeln finden Sie unter den System.Globalization.CompareOptions Thema.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Zusätzliche Empfehlungen zur Verwendung für jede Regel finden Sie unter bewährte Methoden für die Verwendung von Zeichenfolgen.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

Normalerweise Sie keine Vergleichsmethoden aufrufen, Zeichenfolge wie z. B. Compare direkt auf die Sortierreihenfolge von Zeichenfolgen bestimmt.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. Stattdessen werden die Methoden zum Zeichenfolgenvergleich durch Methoden wie z. B. sortieren aufgerufen Array.Sort oder List<T>.Sort.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. Im folgenden Beispiel wird die vier verschiedenen Sortieroperationen (Word-Sortierung mit der aktuellen Kultur, wortsortierung mit der invarianten Kultur, Ordinalsortierung und String-Sortierung, die mit der invarianten Kultur) ohne den expliziten Aufruf einer Methode zum Zeichenfolgenvergleich, Obwohl sie den Typ des Vergleichs mit angeben.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. Beachten Sie, dass jede Art von Sortierreihenfolge erzeugt eine eindeutige Sortierung der Zeichenfolgen im Array.Note that each type of sort produces a unique ordering of strings in its array.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Tipp

Intern verwendet .NET Sortierschlüssel zur Unterstützung kulturabhängiger Zeichenfolgenvergleich.Internally, .NET uses sort keys to support culturally sensitive string comparison. Jedem Zeichen in einer Zeichenfolge sind mehrere Sortiergewichtungskategorien zugeordnet, darunter nach Skript, alphabetischer Folge, Groß-/Kleinschreibung und diakritischer Gewichtung.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. Ein Sortierschlüssel, dargestellt durch die SortKey Klasse, ein Repository für diese Gewichtungen für eine bestimmte Zeichenfolge enthält.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. Wenn eine große Anzahl von Suche und Sortiervorgänge in der gleichen Gruppe von Zeichenfolgen in Ihre app ausgeführt wird, können Sie die Leistung verbessern, indem generieren und speichern die Sortierschlüssel für alle Zeichenfolgen, die verwendet wird.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. Wenn eine Sortierung oder ein Vergleich erforderlich ist, verwenden Sie die Sortierschlüssel anstelle der Zeichenfolgen.When a sort or comparison operation is required, you use the sort keys instead of the strings. Weitere Informationen finden Sie in den Ausführungen zur SortKey-Klasse.For more information, see the SortKey class.

Wenn Sie nicht, dass eine Zeichenfolge Vergleich-Konvention angeben, Sortierfunktionen, z. B. Array.Sort(Array) eine Kultur, Unterscheidung nach Groß-/Kleinschreibung beachtet die Sortierung für Zeichenfolgen durchführen.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. Im folgende Beispiel wird veranschaulicht, wie das Ändern der aktuellen Kultur die Reihenfolge der sortierten Zeichenfolgen in einem Array wirkt sich auf.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Es wird ein Array von drei Zeichenfolgen erstellt.It creates an array of three strings. Zuerst wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "en-US" festgelegt, und die Array.Sort(Array)-Methode wird aufgerufen.First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. Die sich daraus ergebende Sortierreihenfolge basiert auf den Sortierkonventionen für die Kultur Englisch (USA).The resulting sort order is based on sorting conventions for the English (United States) culture. Als Nächstes wird die System.Threading.Thread.CurrentThread.CurrentCulture-Eigenschaft auf "da-DK" festgelegt und die Array.Sort-Methode erneut aufgerufen.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. 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.Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

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

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

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

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

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

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

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

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

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

Warnung

Wenn das primäre Ziel Vergleichen von Zeichenfolgen ist, um zu bestimmen, ob sie gleich sind, rufen Sie die String.Equals Methode.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. Verwenden Sie in der Regel Equals einen Ordinalvergleich ausführen.Typically, you should use Equals to perform an ordinal comparison. Die String.Compare -Methode dient in erster Linie zum Sortieren von Zeichenfolgen.The String.Compare method is intended primarily to sort strings.

Zeichenfolgensuchmethoden, z. B. String.StartsWith und String.IndexOf, auch können kulturabhängig oder Ordinalzahl Zeichenfolgenvergleiche ausführen.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. Das folgende Beispiel veranschaulicht die Unterschiede zwischen der Ordinalzahl und kulturabhängige Vergleiche mit der IndexOf Methode.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. Eine kulturabhängige Suche in der die aktuelle Kultur Englisch (Vereinigte Staaten) ist, berücksichtigt die Teilzeichenfolge "Oe" entsprechend der Ligatur "œ".A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Da Sie ein bedingten Bindestrich (U + 00AD) eine Breite von NULL-Zeichen ist, behandelt die Suche der bedingten Bindestrich als Entsprechung zu Empty und findet eine Übereinstimmung am Anfang der Zeichenfolge.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. Eine Ordinalsuche, wird eine Übereinstimmung in beiden Fällen auf der anderen Seite nicht gefunden.An ordinal search, on the other hand, does not find a match in either case.

using namespace System;

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

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

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

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

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

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

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

Suchen von ZeichenfolgenSearching Strings

Zeichenfolgensuchmethoden, z. B. String.StartsWith und String.IndexOf, auch Aktualisierungsoption kulturabhängig oder ordinalen Vergleich von Zeichenfolgen zu bestimmen, ob ein Zeichen oder eine Teilzeichenfolge in einer angegebenen Zeichenfolge gefunden wird.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

Die Search-Methoden in der String -Klasse, die für ein einzelnes Zeichen, z. B. Suchen der IndexOf Methode oder zu einem Satz von Zeichen, z. B. die IndexOfAny -Methode, alle eine ordinale Suche ausführen.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. Um eine kulturabhängige Suche nach einem Zeichen auszuführen, rufen Sie eine CompareInfo Methode, z. B. CompareInfo.IndexOf(String, Char) oder CompareInfo.LastIndexOf(String, Char).To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). Beachten Sie, dass die Ergebnisse der Suche nach einem Zeichen, die mithilfe von Ordnungszahlen und kulturabhängige Vergleich sehr unterschiedlich sein können.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Beispielsweise könnte eine Suche für ein zusammengesetztes Unicodezeichen, z. B. die Ligatur "Æ" (U + 00 C 6) entspricht jedem Vorkommen der Komponenten in der richtigen Reihenfolge, z. B. "AE" (U + 041U + 0045), je nach Kultur.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. Das folgende Beispiel veranschaulicht den Unterschied zwischen der String.IndexOf(Char) und CompareInfo.IndexOf(String, Char) Methoden bei der Suche nach der ein einzelnes Zeichen.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. Die Ligatur "Æ" (U + 00E6) wurde in der Zeichenfolge "Luftbild" bei Verwendung der Konventionen der Kultur En-US, jedoch nicht, wenn die Konventionen der Kultur da-DK verwendet oder wenn Sie einen Ordinalvergleich ausführen gefunden.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

using System;
using System.Globalization;

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

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

Auf der anderen Seite String -Klassenmethoden, die Suche nach einer Zeichenfolge anstelle eines Zeichens eine kulturabhängige Suche durchführen, wenn Suchoptionen durch einen Parameter vom Typ nicht explizit angegeben werden StringComparison.On the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. Die einzige Ausnahme ist Contains, die eine ordinale Suche durchführt.The sole exception is Contains, which performs an ordinal search.

Testen auf GleichheitTesting for equality

Verwenden der String.Compare Methode, um die Beziehung zwischen zwei Zeichenfolgen in der Sortierreihenfolge festzulegen.Use the String.Compare method to determine the relationship of two strings in the sort order. Dies ist normalerweise eine kulturabhängige Operation.Typically, this is a culture-sensitive operation. Im Gegensatz dazu rufen Sie die String.Equals Methode zum Testen auf Gleichheit.In contrast, call the String.Equals method to test for equality. Da der Test auf Gleichheit in der Regel der Benutzereingabe mit einer bekannten Zeichenfolge, z. B. einen gültigen Benutzernamen ein, ein Kennwort oder einen Dateisystempfad, vergleicht wird er in der Regel eine Ordnungszahl Vorgang.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

Warnung

Es ist möglich, Testen auf Gleichheit durch Aufrufen der String.Compare -Methode und bestimmen, ob der Rückgabewert 0 (null) ist.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. Diese Vorgehensweise ist jedoch nicht empfohlen.However, this practice is not recommended. Um zu bestimmen, ob zwei Zeichenfolgen gleich sind, sollten Sie eine der Überladungen von Aufrufen der String.Equals Methode.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. Die bevorzugte Überladung aufrufen, ist entweder wird die Instanz Equals(String, StringComparison) oder die statische Equals(String, String, StringComparison) -Methode, da beide Methoden enthalten eine System.StringComparison Parameter, der explizit den Typ des Vergleichs angibt.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

Das folgende Beispiel zeigt die Gefahr der Ausführung eines kulturabhängigen Vergleichs, Gleichheit, wenn eine Ordinalzahl, die eine stattdessen verwendet werden soll.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. Die Absicht des Codes werden in diesem Fall den Dateisystemzugriff von URLs zu verhindern, die mit "FILE://" oder "file://" beginnen, Groß-/Kleinschreibung Vergleich des Anfangs einer URL mit der Zeichenfolge "FILE://" ausgeführt.In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". Jedoch, wenn ein kulturabhängiger Vergleich ausgeführt wird, mit der Türkisch (Türkei)-Kultur in einer URL, die mit "file://" beginnt, schlägt fehl der Vergleich für Gleichheit, weil Türkisch Großbuchstaben den Kleinbuchstaben "i" "İ" anstelle von "I" entspricht.However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". Daher wird der Dateisystemzugriff versehentlich zulässig.As a result, file system access is inadvertently permitted. Andererseits, wenn ein ordinalen Vergleich ausgeführt wird, wird der Vergleich für Gleichheit ist erfolgreich, und Dateisystemzugriff verweigert wird.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

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

bool TestForEquality(String^ str, StringComparison cmp);

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

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

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

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

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

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

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

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

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

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

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

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

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

NormalisierungNormalization

Einige Unicode-Zeichen umfassen mehrere Darstellungen.Some Unicode characters have multiple representations. Beispielsweise kann eine der folgenden Code verweist den Buchstaben "ắ" darstellen:For example, any of the following code points can represent the letter "ắ":

  • U + 1EAFU+1EAF

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

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

Mehrere Darstellungen für ein einzelnes Zeichen suchen, sortieren, Abgleich und andere Zeichenfolgenoperationen verkompliziert werden.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

Die Unicode-standard definiert einen Prozess namens Normalisierung, die eine binäre Darstellung eines Unicode-Zeichens für jede der entsprechende binäre Darstellung zurückgibt.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. Normalisierung können mehrere Algorithmen, so genannte Normalisierungsformen, die verschiedene Regeln einhalten.Normalization can use several algorithms, called normalization forms, that follow different rules. .NET unterstützt Unicode-Normalisierungsformen C, D, KC und KD..NET supports Unicode normalization forms C, D, KC, and KD. Wenn Sie Zeichenfolgen in die gleiche Normalisierungsform normalisiert wurden, können sie mithilfe von ordinalen Vergleich verglichen werden.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Ein ordinalen Vergleich ist ein binärer Vergleich von der Unicode-Skalarwert des entsprechenden Char Objekte in jeder Zeichenfolge.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. Die String Klasse enthält eine Reihe von Methoden, die einen Ordinalvergleich durch, einschließlich der folgenden ausführen können:The String class includes a number of methods that can perform an ordinal comparison, including the following:

Können Sie bestimmen, ob eine Zeichenfolge in der Normalisierungsform C, durch den Aufruf normalisiert wird der String.IsNormalized() -Methode, oder Sie rufen die String.IsNormalized(NormalizationForm) Methode, um zu bestimmen, ob eine Zeichenfolge in eine angegebene Normalisierungsform normalisiert wurde.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. Sie können auch aufrufen, die String.Normalize() Methode zum Konvertieren einer Zeichenfolge in der Normalisierungsform C, oder Sie können Aufrufen der String.Normalize(NormalizationForm) Methode zum Konvertieren einer Zeichenfolge in eine angegebene Normalisierungsform.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. Detaillierte Informationen zu normalisieren, und Vergleichen von Zeichenfolgen finden Sie die Normalize() und Normalize(NormalizationForm) Methoden.For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

Das folgende einfache Beispiel veranschaulicht die Normalisierung von Zeichenfolgen.The following simple example illustrates string normalization. Er definiert den Buchstaben "ố" auf drei verschiedene Arten in drei verschiedenen Zeichenfolgen und verwendet einen ordinalen Vergleich, Gleichheit, um zu bestimmen, dass jede Zeichenfolge von den anderen beiden Zeichenfolgen unterscheidet.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. Es konvertiert dann jede Zeichenfolge in den unterstützten Normalisierungsformen und führt erneut einen Ordinalvergleich von jeder Zeichenfolge in einer angegebenen Normalisierungsform.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. In jedem Fall zeigt der zweite Test auf Gleichheit an, dass die Zeichenfolgen gleich sind.In each case, the second test for equality shows that the strings are equal.

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

public ref class Example
{
private:
   StreamWriter^ sw;

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

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

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

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

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

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

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

      sw->Close(); 
   }
};

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

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

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

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

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

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

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

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

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

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

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

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

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

Weitere Informationen zu Normalisierung und Normalisierungsformen, finden Sie unter System.Text.NormalizationForm, als auch Unicode Standard Annex #15: Unicode Normalization Forms und Normalisierung – häufig gestellte Fragen auf der Unicode.org-Website.For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Zeichenfolgenoperationen nach KategorieString operations by category

Die String Klasse enthält Elemente zum Vergleichen von Zeichenfolgen, das Testen von Zeichenfolgen auf Gleichheit überprüfen, Suchen nach Zeichen oder Teilzeichenfolgen in einer Zeichenfolge, die Änderung einer Zeichenfolge, und Extrahieren von Teilzeichenfolgen aus einer Zeichenfolge, die Zeichenfolgen, Formatieren von Werten, das Kopieren einer Zeichenfolge kombiniert und normalisiert eine Zeichenfolge an.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

Vergleichen von ZeichenfolgenComparing strings

Sie können Zeichenfolgen vergleichen, um ihre relative Position in der Sortierreihenfolge bestimmen mithilfe der Folgendes String Methoden:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • Compare Gibt eine Ganzzahl, die die Beziehung aus einer Zeichenfolge in eine zweite Zeichenfolge in der Sortierreihenfolge angibt.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinal Gibt eine Ganzzahl, die die Beziehung aus einer Zeichenfolge in eine zweite Zeichenfolge auf Basis eines Wertevergleichs der die Codepunkte angibt.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareTo Gibt eine Ganzzahl, die die Beziehung des die aktuelle Zeichenfolgeninstanz mit einer zweiten Zeichenfolge in der Sortierreihenfolge angibt.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. Die CompareTo(String) Methode bietet die IComparable und IComparable<T> Implementierungen für die String Klasse.The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Testen von Zeichenfolgen auf GleichheitTesting strings for equality

Rufen Sie die Equals Methode, um zu bestimmen, ob zwei Zeichenfolgen gleich sind.You call the Equals method to determine whether two strings are equal. Die Instanz Equals(String, String, StringComparison) und der statischen Equals(String, StringComparison) Überladungen können Sie angeben, ob der Vergleich kulturabhängig oder Ordinalzahl ist, und gibt an, ob Fall berücksichtigt oder ignoriert wird.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. Die meisten Tests für Gleichheit die Ordinalvergleiche darstellen, und Vergleiche auf Gleichheit, die bestimmen, den Zugriff auf eine Systemressource (z. B. ein Dateisystemobjekt) sollten immer ordinal sein.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

Suchen von Zeichen in einer ZeichenfolgeFinding characters in a string

Die String Klasse enthält zwei verschiedene Suchmethoden:The String class includes two kinds of search methods:

Warnung

Wenn Sie eine Zeichenfolge für eine bestimmte Teilzeichenfolge, anstatt einem bestimmten Muster suchen möchten, sollten Sie reguläre Ausdrücke verwenden.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Weitere Informationen finden Sie unter reguläre Ausdrücke von .NET.For more information, see .NET Regular Expressions.

Ändern einer ZeichenfolgeModifying a string

Die String Klasse enthält die folgenden Methoden, die zum Ändern des Werts einer Zeichenfolge angezeigt werden:The String class includes the following methods that appear to modify the value of a string:

  • Insert Fügt eine Zeichenfolge mit dem aktuellen String Instanz.Insert inserts a string into the current String instance.

  • PadLeft Fügt einem oder mehreren Vorkommen eines angegebenen Zeichens am Anfang einer Zeichenfolge.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRight Fügt einem oder mehreren Vorkommen eines angegebenen Zeichens am Ende einer Zeichenfolge.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Remove Löscht eine Teilzeichenfolge aus dem aktuellen String Instanz.Remove deletes a substring from the current String instance.

  • Replace ersetzt eine Teilzeichenfolge durch eine andere Teilzeichenfolge in der aktuellen String Instanz.Replace replaces a substring with another substring in the current String instance.

  • ToLower und ToLowerInvariant alle Zeichen in einer Zeichenfolge in Kleinbuchstaben zu konvertieren.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpper und ToUpperInvariant alle Zeichen in einer Zeichenfolge in Großbuchstaben zu konvertieren.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trim Entfernt alle Vorkommen von einem Zeichen am Anfang und Ende einer Zeichenfolge.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEnd Entfernt alle Vorkommen eines Zeichens vom Ende einer Zeichenfolge.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStart Entfernt alle Vorkommen eines Zeichens vom Anfang einer Zeichenfolge.TrimStart removes all occurrences of a character from the beginning of a string.

Wichtig

Alle Änderungen von Zeichenfolgenmethoden zurück auf ein neues String Objekt.All string modification methods return a new String object. Ändern sie nicht den Wert der aktuellen Instanz.They don't modify the value of the current instance.

Extrahieren von untergeordneten Zeichenfolgen aus einer ZeichenfolgeExtracting substrings from a string

Die String.Split Methode trennt eine einzelne Zeichenfolge in mehrere Zeichenfolgen.The String.Split method separates a single string into multiple strings. Überladungen der Methode können Sie angeben, mehrere Trennzeichen, um die maximale Anzahl von Teilzeichenfolgen zu bestimmen, die die Methode extrahiert, und um zu bestimmen, ob leere Zeichenfolgen (die auftreten, wenn die Trennzeichen aneinandergrenzen) für die zurückgegebenen Zeichenfolgen enthalten sind.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Kombinieren von ZeichenfolgenCombining strings

Die folgenden String können Methoden für die zeichenfolgenverkettung verwendet werden:The following String methods can be used for string concatenation:

  • Concat werden ein oder mehrere Teilzeichenfolgen in einer einzelnen Zeichenfolge kombiniert.Concat combines one or more substrings into a single string.

  • Join verkettet eine oder mehrere Teilzeichenfolgen in ein einzelnes Element und fügt ein Trennzeichen zwischen den Teilzeichenfolgen.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Formatieren von WertenFormatting values

Die String.Format Methode, die Funktion für kombinierte Formatierung verwendet, um einen oder mehrere Platzhalter in einer Zeichenfolge durch die Zeichenfolgendarstellung von einigen Objekt oder den Wert zu ersetzen.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. Die Format Methode wird häufig verwendet, um Folgendes auszuführen:The Format method is often used to do the following:

  • Um die Zeichenfolgendarstellung eines numerischen Werts in einer Zeichenfolge einzubetten.To embed the string representation of a numeric value in a string.

  • Die Zeichenfolgendarstellung eines Werts für Datum und Uhrzeit in eine Zeichenfolge einzubetten.To embed the string representation of a date and time value in a string.

  • Die Zeichenfolgendarstellung eines Enumerationswerts in eine Zeichenfolge einzubetten.To embed the string representation of an enumeration value in a string.

  • Die Zeichenfolgendarstellung von einem Objekt eingebettet, die unterstützt die IFormattable Schnittstelle in einer Zeichenfolge.To embed the string representation of some object that supports the IFormattable interface in a string.

  • Rechtsbündig oder linksbündig einer Teilzeichenfolge in ein Feld innerhalb einer größeren Zeichenfolge.To right-justify or left-justify a substring in a field within a larger string.

Ausführliche Informationen zur Formatierung, Vorgänge und Beispiele finden Sie unter den Format Zusammenfassung überladen.For detailed information about formatting operations and examples, see the Format overload summary.

Kopieren einer ZeichenfolgeCopying a string

Sie können den folgenden Aufruf String Methoden, um eine Kopie einer Zeichenfolge zu erstellen:You can call the following String methods to make a copy of a string:

  • Clone Gibt einen Verweis auf ein vorhandenes String Objekt.Clone returns a reference to an existing String object.

  • Copy erstellt eine Kopie einer vorhandenen Zeichenfolge.Copy creates a copy of an existing string.

  • CopyTo Kopiert einen Teil einer Zeichenfolge in ein Zeichenarray.CopyTo copies a portion of a string to a character array.

Eine Zeichenfolge normalisierenNormalizing a string

Im Unicode-Format kann ein einzelnes Zeichen über mehrere Codepunkte haben.In Unicode, a single character can have multiple code points. Normalisierung konvertiert diese entsprechende Zeichen in der gleichen binäre Darstellung.Normalization converts these equivalent characters into the same binary representation. Die String.Normalize Methode führt die Normalisierung aus, und die String.IsNormalized Methode bestimmt, ob eine Zeichenfolge normalisiert wurde.The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Weitere Informationen und ein Beispiel finden Sie unter den Normalisierung weiter oben in diesem Thema.For more information and an example, see the Normalization section earlier in this topic.

Konstruktoren

String(Char*) String(Char*) String(Char*) 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. Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

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

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

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

Initialisiert eine neue Instanz der String-Klasse mit dem Wert, der durch ein angegebenes so oft wie angegeben wiederholtes Unicode-Zeichen bestimmt wird. Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

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

Initialisiert eine neue Instanz der String-Klasse mit dem durch ein Array von Unicode-Zeichen angegebenen Wert. Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

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

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

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) String(SByte*)

Initialisiert eine neue Instanz der String-Klasse mit dem durch einen Zeiger auf ein Array von 8-Bit-Ganzzahlen mit Vorzeichen angegebenen Wert. Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

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

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

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

Felder

Empty Empty Empty Empty

Stellt die leere Zeichenfolge dar. Represents the empty string. Dieses Feld ist schreibgeschützt. This field is read-only.

Eigenschaften

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

Ruft das Char-Objekt an einer angegebenen Zeichenposition innerhalb des aktuellen String-Objekts ab. Gets the Char object at a specified position in the current String object.

Length Length Length Length

Ruft die Anzahl der Zeichen im aktuellen String-Objekt ab. Gets the number of characters in the current String object.

Methoden

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

Gibt einen Verweis auf diese Instanz von String zurück. Returns a reference to this instance of String.

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

Vergleicht zwei angegebene String-Objekte und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

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

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

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

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

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

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

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

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

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

Vergleicht zwei angegebene String-Objekte und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

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

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

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

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

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

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

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

Vergleicht zwei angegebene String-Objekte gemäß den angegebenen Vergleichsregeln und gibt eine ganze Zahl zurück, die ihre relative Position in der Sortierreihenfolge angibt. Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

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

Vergleicht Teilzeichenfolgen zweier angegebener String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Teilzeichenfolgen ausgewertet werden. Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

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

Vergleicht zwei String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden. Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

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

CompareTo(String) CompareTo(String) CompareTo(String) CompareTo(String)

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

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

Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String. Concatenates the members of a constructed IEnumerable<T> collection of type String.

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

Erstellt die Zeichenfolgendarstellung eines angegebenen Objekts. Creates the string representation of a specified object.

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

Verkettet die Zeichenfolgendarstellungen zweier angegebener Objekte. Concatenates the string representations of two specified objects.

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

Verkettet die Zeichenfolgendarstellungen von drei angegebenen Objekten. Concatenates the string representations of three specified objects.

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

Verkettet die Zeichenfolgenentsprechungen von vier angegebenen Objekten sowie aller in einer optionalen Parameterliste variabler Länger angegebenen Objekte. Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

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

Verkettet die Zeichenfolgendarstellungen der Elemente in einem angegebenen Object-Array. Concatenates the string representations of the elements in a specified Object array.

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

Verkettet zwei angegebene Instanzen von String. Concatenates two specified instances of String.

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

Verkettet zwei angegebene Instanzen von String. Concatenates three specified instances of String.

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

Verkettet zwei angegebene Instanzen von String. Concatenates four specified instances of String.

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

Verkettet die Elemente eines angegebenen String-Arrays. Concatenates the elements of a specified String array.

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

Verkettet die Member einer IEnumerable<T>-Implementierung. Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)
Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)
Contains(String) Contains(String) Contains(String) Contains(String)

Gibt einen Wert zurück, der angibt, ob eine angegebene untergeordnete Zeichenfolge in dieser Zeichenfolge vorkommt. Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison)
Copy(String) Copy(String) Copy(String) Copy(String)

Erstellt eine neue Instanz von String mit demselben Wert wie eine angegebene Instanz von String. Creates a new instance of String with the same value as a specified String.

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

Kopiert eine angegebene Anzahl von Zeichen von einer angegebenen Position in dieser Instanz an eine angegebene Position in einem Array von Unicode-Zeichen. Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

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

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt. Determines whether the end of this string instance matches the specified string.

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

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt. Determines whether the end of this string instance matches the specified string when compared using the specified culture.

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

Bestimmt, ob das Ende dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt. Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

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

Bestimmt, ob diese Instanz und ein angegebenes Objekt, das ebenfalls ein String-Objekt sein muss, denselben Wert haben. Determines whether this instance and a specified object, which must also be a String object, have the same value.

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

Bestimmt, ob diese Instanz und ein anderes angegebenes String-Objekt denselben Wert haben. Determines whether this instance and another specified String object have the same value.

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

Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben. Determines whether two specified String objects have the same value.

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

Bestimmt, ob zwei angegebene String-Objekte denselben Wert haben. Determines whether two specified String objects have the same value. Ein Parameter gibt die Kultur, Berücksichtigung von Groß- und Kleinschreibung und Sortierregeln, die für den Vergleich verwendet werden. A parameter specifies the culture, case, and sort rules used in the comparison.

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

Bestimmt, ob diese Zeichenfolge und ein angegebenes String-Objekt denselben Wert haben. Determines whether this string and a specified String object have the same value. Ein Parameter gibt die Kultur, Berücksichtigung von Groß- und Kleinschreibung und Sortierregeln, die für den Vergleich verwendet werden. A parameter specifies the culture, case, and sort rules used in the comparison.

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

Ersetzt die Formatelemente in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung des angegebenen Objekts. Replaces the format item or items in a specified string with the string representation of the corresponding object. Ein Parameter liefert kulturspezifische Formatierungsinformationen. A parameter supplies culture-specific formatting information.

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

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Replaces the format items in a string with the string representation of two specified objects. Ein Parameter liefert kulturspezifische Formatierungsinformationen. A parameter supplies culture-specific formatting information.

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

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. Replaces the format items in a string with the string representation of three specified objects. Ein Parameter liefert kulturspezifische Formatierungsinformationen. An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellungen entsprechender Objekte in einem angegebenen Array. Replaces the format items in a string with the string representations of corresponding objects in a specified array. Ein Parameter liefert kulturspezifische Formatierungsinformationen. A parameter supplies culture-specific formatting information.

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

Ersetzt mindestens ein Formatelement in einer Zeichenfolge durch die Zeichenfolgendarstellung eines angegebenen Objekts. Replaces one or more format items in a string with the string representation of a specified object.

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

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von zwei angegebenen Objekten. Replaces the format items in a string with the string representation of two specified objects.

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

Ersetzt die Formatelemente in einer Zeichenfolge durch die Zeichenfolgendarstellung von drei angegebenen Objekten. Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

Ersetzt das Formatelement in einer angegebenen Zeichenfolge durch die Zeichenfolgendarstellung eines entsprechenden Objekts in einem angegebenen Array. Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

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

Ruft ein Objekt ab, das die einzelnen Zeichen dieser Zeichenfolge durchlaufen kann. Retrieves an object that can iterate through the individual characters in this string.

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

Gibt den Hashcode für diese Zeichenfolge zurück. Returns the hash code for this string.

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

Ruft den Type der aktuellen Instanz ab. Gets the Type of the current instance.

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

Gibt einen TypeCode für das String zurück. Returns the TypeCode for class String.

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

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

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

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Unicode-Zeichens in dieser Zeichenfolge an. Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Die Suche beginnt an einer angegebenen Zeichenposition. The search starts at a specified character position.

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

Gibt den NULL-basierten Index des ersten Vorkommens des angegebenen Zeichens in dieser Instanz an. Reports the zero-based index of the first occurrence of the specified character in this instance. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft. The search starts at a specified character position and examines a specified number of character positions.

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

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Reports the zero-based index of the first occurrence of the specified string in this instance.

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

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Reports the zero-based index of the first occurrence of the specified string in this instance. Die Suche beginnt an einer angegebenen Zeichenposition. The search starts at a specified character position.

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

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge in dieser Instanz an. Reports the zero-based index of the first occurrence of the specified string in this instance. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft. The search starts at a specified character position and examines a specified number of character positions.

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

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Reports the zero-based index of the first occurrence of the specified string in the current String object. 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. Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

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

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Reports the zero-based index of the first occurrence of the specified string in the current String object. Parameter geben die Anfangssuchposition in der aktuellen Zeichenfolge und den Typ der Suche an, die für die angegebene Zeichenfolge verwendet werden soll. Parameters specify the starting search position in the current string and the type of search to use for the specified string.

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

Gibt den NULL-basierten Index des ersten Vorkommens der angegebenen Zeichenfolge im aktuellen String-Objekt an. Reports the zero-based index of the first occurrence of the specified string in the current String object. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an. A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[])

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32)

Gibt den NULL-basierten Index des ersten Vorkommens eines beliebigen Zeichens aus einem angegebenen Array von Unicode-Zeichen in dieser Instanz an. Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Die Suche beginnt an einer angegebenen Zeichenposition. The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) 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. Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Die Suche beginnt an einer angegebenen Zeichenposition, und es wird eine angegebene Anzahl von Zeichenpositionen überprüft. The search starts at a specified character position and examines a specified number of character positions.

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

Gibt eine neue Zeichenfolge zurück, in der eine angegebene Zeichenfolge an einer angegebenen Indexposition in dieser Instanz eingefügt wird. Returns a new string in which a specified string is inserted at a specified index position in this instance.

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

Ruft den Verweis des Systems auf den angegebenen String ab. Retrieves the system's reference to the specified String.

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

Ruft einen Verweis auf einen angegebenen String ab. Retrieves a reference to a specified String.

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

Gibt an, ob diese Zeichenfolge in der Unicode-Normalisierungsform C vorliegt. Indicates whether this string is in Unicode normalization form C.

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

Gibt an, ob diese Zeichenfolge in der angegebenen Unicode-Normalisierungsform vorliegt. Indicates whether this string is in the specified Unicode normalization form.

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

Gibt an, ob die angegebene Zeichenfolge null oder eine Empty-Zeichenfolge ist. Indicates whether the specified string is null or an Empty string.

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

Gibt an, ob eine angegebene Zeichenfolge null ist, leer ist oder nur aus Leerzeichen besteht. Indicates whether a specified string is null, empty, or consists only of white-space characters.

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

Verkettet die Member einer erstellten IEnumerable<T>-Auflistung vom Typ String und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern. Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

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

Verkettet die Elemente eines Objektarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen. Concatenates the elements of an object array, using the specified separator between each element.

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

Verkettet alle Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen. Concatenates all the elements of a string array, using the specified separator between each element.

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

Verkettet die angegebenen Elemente eines Zeichenfolgenarrays und verwendet das angegebene Trennzeichen zwischen den einzelnen Elementen. Concatenates the specified elements of a string array, using the specified separator between each element.

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

Verkettet die Member einer Auflistung und verwendet das angegebene Trennzeichen zwischen den einzelnen Membern. Concatenates the members of a collection, using the specified separator between each member.

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

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an. Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

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

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines angegebenen Unicode-Zeichens in dieser Instanz an. Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt. The search starts at a specified character position and proceeds backward toward the beginning of the string.

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

Gibt die NULL-basierte Indexposition des letzten Vorkommens des angegebenen Unicode-Zeichens in einer Teilzeichenfolge dieser Instanz an. Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

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

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Reports the zero-based index position of the last occurrence of a specified string within this instance.

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

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt. The search starts at a specified character position and proceeds backward toward the beginning of the string.

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

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

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

Gibt die NULL-basierte Indexposition des letzten Vorkommens einer angegebenen Zeichenfolge in dieser Instanz an. Reports the zero-based index position of the last occurrence of a specified string within this instance. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge. The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an. A parameter specifies the type of comparison to perform when searching for the specified string.

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

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Reports the zero-based index of the last occurrence of a specified string within the current String object. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt. The search starts at a specified character position and proceeds backward toward the beginning of the string. Ein Parameter gibt den Typ des bei der Suche nach der angegebenen Zeichenfolge auszuführenden Vergleichs an. A parameter specifies the type of comparison to perform when searching for the specified string.

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

Gibt den NULL-basierten Index des letzten Vorkommens einer angegebenen Zeichenfolge im aktuellen String-Objekt an. Reports the zero-based index of the last occurrence of a specified string within the current String object. Ein Parameter gibt den Typ der Suche für die angegebene Zeichenfolge an. A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[])

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Die Suche beginnt an einer angegebenen Zeichenposition und wird rückwärts bis zum Anfang der Zeichenfolge fortgesetzt. The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32)

Gibt die NULL-basierte Indexposition des letzten Vorkommens eines oder mehrerer angegebener Zeichen eines Unicode-Arrays in dieser Instanz an. Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Die Suche beginnt an einer angegebenen Zeichenposition und verläuft für eine angegebene Anzahl von Zeichenpositionen rückwärts zum Anfang der Zeichenfolge. The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

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

Erstellt eine flache Kopie des aktuellen Object. Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der Unicode-Normalisierungsform C vorliegt. Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm)

Gibt eine neue Zeichenfolge zurück, deren Textwert mit dieser Zeichenfolge übereinstimmt, deren binäre Darstellung jedoch in der angegebenen Unicode-Normalisierungsform vorliegt. Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) PadLeft(Int32)

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

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char)

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

PadRight(Int32) PadRight(Int32) PadRight(Int32) PadRight(Int32)

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

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char)

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

Remove(Int32) Remove(Int32) Remove(Int32) Remove(Int32)

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

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

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

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

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

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Gibt eine neue Zeichenfolge zurück, in der alle Vorkommen einer angegebenen Zeichenfolge in der aktuellen Instanz durch eine andere angegebene Zeichenfolge ersetzt wurden. Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

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

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen. Splits a string into substrings that are based on the characters in an array.

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

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen. Splits a string into a maximum number of substrings based on the characters in an array. Sie geben außerdem die maximale Anzahl der zurückzugebenden Teilzeichenfolgen an. You also specify the maximum number of substrings to return.

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

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in eine maximale Anzahl von Teilzeichenfolgen. Splits a string into a maximum number of substrings based on the characters in an array.

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

Unterteilt eine Zeichenfolge anhand der Zeichen in einem Array in Teilzeichenfolgen. Splits a string into substrings based on the characters in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen. You can specify whether the substrings include empty array elements.

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

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in eine maximale Anzahl von Teilzeichenfolgen. Splits a string into a maximum number of substrings based on the strings in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen. You can specify whether the substrings include empty array elements.

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

Unterteilt eine Zeichenfolge anhand der Zeichenfolgen in einem Array in Teilzeichenfolgen. Splits a string into substrings based on the strings in an array. Sie können angeben, ob die Teilzeichenfolgen auch leere Arrayelemente umfassen. You can specify whether the substrings include empty array elements.

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

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz mit der angegebenen Zeichenfolge übereinstimmt. Determines whether the beginning of this string instance matches the specified string.

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

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Kultur mit der angegebenen Zeichenfolge übereinstimmt. Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

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

Bestimmt, ob der Anfang dieser Zeichenfolgeninstanz bei einem Vergleich unter Verwendung der angegebenen Vergleichsoption mit der angegebenen Zeichenfolge übereinstimmt. Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

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

Ruft eine Teilzeichenfolge dieser Instanz ab. Retrieves a substring from this instance. Die untergeordnete Zeichenfolge beginnt in einer angegebenen Zeichenposition und wird an das Ende der Zeichenfolge fortgesetzt. The substring starts at a specified character position and continues to the end of the string.

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

Ruft eine Teilzeichenfolge dieser Instanz ab. Retrieves a substring from this instance. Die Teilzeichenfolge beginnt an einer angegebenen Zeichenposition und hat eine angegebene Länge. The substring starts at a specified character position and has a specified length.

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

Kopiert die Zeichen dieser Instanz in ein Array von Unicode-Zeichen. Copies the characters in this instance to a Unicode character array.

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

Kopiert die Zeichen einer angegebenen Teilzeichenfolge dieser Instanz in ein Array von Unicode-Zeichen. Copies the characters in a specified substring in this instance to a Unicode character array.

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

Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück. Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo)

Gibt eine in Kleinbuchstaben konvertierte Kopie dieser Zeichenfolge zurück, wobei die Regeln der Groß- und Kleinschreibung der angegebenen Kultur verwendet werden. Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() ToLowerInvariant()

Gibt eine in Kleinbuchstaben konvertierte Kopie dieses String-Objekts zurück, wobei die Regeln der Groß- und Kleinschreibung der invarianten Kultur verwendet werden. Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

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

Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt. Returns this instance of String; no actual conversion is performed.

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

Gibt diese Instanz von String zurück. Es wird keine wirkliche Konvertierung durchgeführt. Returns this instance of String; no actual conversion is performed.

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

Gibt eine in Großbuchstaben konvertierte Kopie dieser Zeichenfolge zurück. Returns a copy of this string converted to uppercase.

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

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

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

Entfernt alle führenden und nachgestellten Leerraumzeichen aus dem aktuellen String-Objekt. Removes all leading and trailing white-space characters from the current String object.

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

Entfernt alle führenden und nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt. Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

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

Entfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt. Removes all trailing occurrences of a set of characters specified in an array from the current String object.

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

Entfernt alle nachgestellten Vorkommen der Zeichen im angegebenen Array aus dem aktuellen String-Objekt. Removes all leading occurrences of a set of characters specified in an array from the current String object.

Operatoren

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

Bestimmt, ob zwei angegebene Zeichenfolgen denselben Wert haben. Determines whether two specified strings have the same value.

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

Bestimmt, ob zwei angegebene Zeichenfolgen verschiedene Werte haben. Determines whether two specified strings have different values.

Explizite Schnittstellenimplementierungen

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

Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider). For a description of this member, see ToBoolean(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider). For a description of this member, see ToByte(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToChar(IFormatProvider). For a description of this member, see ToChar(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToDateTime(IFormatProvider). For a description of this member, see ToDateTime(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider). For a description of this member, see ToDecimal(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider). For a description of this member, see ToDouble(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider). For a description of this member, see ToInt16(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider). For a description of this member, see ToInt32(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider). For a description of this member, see ToInt64(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider). For a description of this member, see ToSByte(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider). For a description of this member, see ToSingle(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider). For a description of this member, see ToType(Type, IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider). For a description of this member, see ToUInt16(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider). For a description of this member, see ToUInt32(IFormatProvider).

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

Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider). For a description of this member, see ToUInt64(IFormatProvider).

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

Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft. Returns an enumerator that iterates through the current String object.

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

Gibt einen Enumerator zurück, der das aktuelle String-Objekt durchläuft. Returns an enumerator that iterates through the current String object.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher. This type is thread safe.

Siehe auch