StringComparison Enumeration

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Assembly:

mscorlib.dll

Assembly:

netstandard.dll

Gibt die Kultur-, Groß-/Kleinschreibungs- und Sortierregeln an, die von bestimmten Überladungen der Compare(String, String)- und Equals(Object)-Methode verwendet werden.

C#

public enum StringComparison

C#

[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum StringComparison

Vererbung

Object

ValueType

Enum

StringComparison

Attribute

ComVisibleAttribute SerializableAttribute

Felder

CurrentCulture	0	Vergleichen Sie Zeichenfolgen mithilfe kulturabhängiger Sortierregeln und der aktuellen Kultur.
CurrentCultureIgnoreCase	1	Vergleichen Sie Zeichenfolgen mithilfe von kulturabhängigen Sortierregeln, der aktuellen Kultur und durch Ignorieren der Groß-/Kleinschreibung für die verglichenen Zeichenfolgen.
InvariantCulture	2	Vergleichen Sie Zeichenfolgen mithilfe kulturabhängiger Sortierregeln und der invarianten Kultur.
InvariantCultureIgnoreCase	3	Vergleichen Sie Zeichenfolgen mithilfe von kulturabhängigen Sortierregeln, der invarianten Kultur und durch Ignorieren der Groß-/Kleinschreibung für die verglichenen Zeichenfolgen.
Ordinal	4	Vergleichen Sie Zeichenfolgen mithilfe von ordinalen (binären) Sortierregeln.
OrdinalIgnoreCase	5	Vergleichen Sie Zeichenfolgen mithilfe von ordinalen (binären) Sortierregeln und durch Ignorieren der Groß-/Kleinschreibung für die verglichenen Zeichenfolgen.

Beispiele

Im folgenden Beispiel werden drei Zeichenfolgensätze mit jedem Element der StringComparison Enumeration verglichen. Die Vergleiche verwenden die Konventionen der englischen (USA), Thai (Thailand) und türkische (Türkei) Kulturen. Beachten Sie, dass die Zeichenfolgen "a" und "a-" in der Kultur "th-TH" als gleichwertig angesehen werden, aber nicht in den anderen Kulturen, während "i" und "İ" in der "tr-TR"-Kultur als gleichwertig angesehen werden, wenn der Fall ignoriert wird, aber nicht in den anderen Kulturen.

C#

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

public class Example3
{
    public static void Main()
    {
        String[] cultureNames = { "en-US", "th-TH", "tr-TR" };
        String[] strings1 = { "a", "i", "case", };
        String[] strings2 = { "a-", "\u0130", "Case" };
        StringComparison[] comparisons = (StringComparison[])Enum.GetValues(typeof(StringComparison));

        foreach (var cultureName in cultureNames)
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
            Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name);
            for (int ctr = 0; ctr <= strings1.GetUpperBound(0); ctr++)
            {
                foreach (var comparison in comparisons)
                    Console.WriteLine("   {0} = {1} ({2}): {3}", strings1[ctr],
                                      strings2[ctr], comparison,
                                      String.Equals(strings1[ctr], strings2[ctr], comparison));

                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}
// The example displays the following output:
//    Current Culture: en-US
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: th-TH
//       a = a- (CurrentCulture): True
//       a = a- (CurrentCultureIgnoreCase): True
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: tr-TR
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): True
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True

Hinweise

Die StringComparison Aufzählung wird verwendet, um anzugeben, ob ein Zeichenfolgenvergleich die aktuelle Kultur oder die invarianten Kultur, Wort- oder Ordinalsortierungsregeln verwenden sollte und groß- oder kleinschreibungsempfindlich sein soll.

Wichtig

Wenn Sie eine Zeichenfolgenvergleichsmethode wie String.Compare, String.Equalsoder String.IndexOf, aufrufen, sollten Sie immer eine Überladung aufrufen, die einen Parameter des Typs StringComparison enthält, damit Sie den Typ des Vergleichs angeben können, den die Methode ausführt. Weitere Informationen finden Sie unter Empfohlene Vorgehensweisen für die Verwendung von Zeichenfolgen in .NET Framework.

Ein Vorgang, der Word-Sortierregeln verwendet, führt einen Kultur-sensiblen Vergleich durch, bei dem bestimmte nichtalphanumerische Unicode-Zeichen möglicherweise spezielle Gewichtungen zugewiesen haben. Mithilfe von Wortsortierungsregeln und den Konventionen einer bestimmten Kultur kann der Bindestrich ("-") eine sehr kleine Gewichtung zugewiesen sein, sodass "coop" und "co-op" in einer sortierten Liste nebeneinander angezeigt werden.

Hinweis

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

Ein Vorgang, der ordinale Sortierregeln verwendet, führt einen Vergleich basierend auf dem numerischen Wert (Unicode-Codepunkt) jeder Char in der Zeichenfolge aus. Ein Ordinalvergleich ist schnell, aber kulturlos. Wenn Sie ordinale Sortierregeln verwenden, um Zeichenfolgen zu sortieren, die mit Unicode-Zeichen (U+) beginnen, kommt die Zeichenfolge U+xxxx vor der Zeichenfolge U+yyyyy, wenn der Wert von xxxx numerischer Wert kleiner als yy ist.

Weitere Informationen zu Vergleichen finden Sie in den System.String Kurshinweisen. Weitere Informationen zu Kultur finden Sie in den System.Globalization.CultureInfo Kurshinweisen. Richtlinien zum Verwenden von Ordinal- oder Kultur-sensiblen Vergleichsregeln oder den Regeln der invarianten Kultur finden Sie unter Bewährte Methoden für die Verwendung von Zeichenfolgen. Eine Reihe von Textdateien, die Informationen zu den Zeichengewichten enthalten, die in Sortier- und Vergleichsvorgängen für Windows Betriebssysteme verwendet werden, finden Sie unter Sortieren von Gewichtstabellen. Eine Sortiergewichtstabelle für Linux und macOS finden Sie in der Tabelle "Standard-Unicode-Sortierelement".

Gilt für

Siehe auch

• String
• Compare(String, String)
• Compare(String, String)
• CompareOrdinal(String, String)
• InvariantCulture