StringComparison StringComparison StringComparison StringComparison Enum

Definition

Gibt die Kultur-, Groß-/Kleinschreibungs- und Sortierregeln an, die von bestimmten Überladungen der Compare(String, String)- und Equals(Object)-Methode verwendet werden.Specifies the culture, case, and sort rules to be used by certain overloads of the Compare(String, String) and Equals(Object) methods.

public enum class StringComparison
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum StringComparison
type StringComparison = 
Public Enum StringComparison
Vererbung
StringComparisonStringComparisonStringComparisonStringComparison
Attribute

Felder

CurrentCulture CurrentCulture CurrentCulture CurrentCulture 0

Vergleichen Sie Zeichenfolgen mithilfe kulturabhängiger Sortierregeln und der aktuellen Kultur.Compare strings using culture-sensitive sort rules and the current culture.

CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase CurrentCultureIgnoreCase 1

Vergleichen Sie Zeichenfolgen mithilfe von kulturabhängigen Sortierregeln, der aktuellen Kultur und durch Ignorieren der Groß-/Kleinschreibung für die verglichenen Zeichenfolgen.Compare strings using culture-sensitive sort rules, the current culture, and ignoring the case of the strings being compared.

InvariantCulture InvariantCulture InvariantCulture InvariantCulture 2

Vergleichen Sie Zeichenfolgen mithilfe kulturabhängiger Sortierregeln und der invarianten Kultur.Compare strings using culture-sensitive sort rules and the invariant culture.

InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase InvariantCultureIgnoreCase 3

Vergleichen Sie Zeichenfolgen mithilfe von kulturabhängigen Sortierregeln, der invarianten Kultur und durch Ignorieren der Groß-/Kleinschreibung für die verglichenen Zeichenfolgen.Compare strings using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings being compared.

Ordinal Ordinal Ordinal Ordinal 4

Vergleichen Sie Zeichenfolgen mithilfe von ordinalen (binären) Sortierregeln.Compare strings using ordinal (binary) sort rules.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 5

Vergleichen Sie Zeichenfolgen mithilfe von ordinalen (binären) Sortierregeln und durch Ignorieren der Groß-/Kleinschreibung für die verglichenen Zeichenfolgen.Compare strings using ordinal (binary) sort rules and ignoring the case of the strings being compared.

Beispiele

Im folgenden Beispiel werden vier Sätze von Wörtern mit jedem Mitglied der StringComparison Enumeration.The following example compares four sets of words by using each member of the StringComparison enumeration. Die Vergleiche, die Konventionen der Samisch, Nördliche (Schweden) Kulturen Englisch (USA) und verwenden.The comparisons use the conventions of the English (United States) and Sami, Northern (Sweden) cultures. Beachten Sie, dass die Zeichenfolgen "Encyclopædia" und "Enzyklopädie" entspricht in der Kultur En-US, aber nicht in den Sami-, Nördliche (Schweden) Kultur berücksichtigt werden.Note that the strings "encyclopædia" and "encyclopedia" are considered equivalent in the en-US culture but not in the Sami, Northern (Sweden) culture.

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

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "en-US", "se-SE" };
      String[] strings1 = { "case",  "encyclopædia",  
                            "encyclopædia", "Archæology" };
      String[] strings2 = { "Case", "encyclopaedia", 
                            "encyclopedia" , "ARCHÆOLOGY" };
      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
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): True
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
//    
//    
//    Current Culture: se-SE
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): False
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "se-SE" }
      Dim strings1() As String = { "case",  "encyclopædia",  
                                   "encyclopædia", "Archæology" }
      Dim strings2() As String = { "Case", "encyclopaedia", 
                                   "encyclopedia" , "ARCHÆOLOGY" }
      Dim comparisons() As StringComparison = CType([Enum].GetValues(GetType(StringComparison)),
                                           StringComparison())
      
      For Each cultureName In cultureNames
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name)
         For ctr As Integer = 0 To strings1.GetUpperBound(0)
            For Each comparison In comparisons
               Console.WriteLine("   {0} = {1} ({2}): {3}", strings1(ctr),
                                 strings2(ctr), comparison, 
                                 String.Equals(strings1(ctr), strings2(ctr), comparison))
            Next
            Console.WriteLine()         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Current Culture: en-US
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): True
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
'    
'    
'    Current Culture: se-SE
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): False
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True

Hinweise

Die StringComparison Enumeration wird verwendet, um anzugeben, ob ein Zeichenfolgenvergleichs verwenden Sie die aktuelle Kultur oder der invarianten Kultur, Word oder ordinalen Sortierregeln, und Groß- und Kleinschreibung beachtet werden.The StringComparison enumeration is used to specify whether a string comparison should use the current culture or the invariant culture, word or ordinal sort rules, and be case-sensitive or case-insensitive.

Wichtig

Beim Aufruf einer Zeichenfolgenvergleichsmethode wie z. B. String.Compare, String.Equals, oder String.IndexOf, Sie sollten immer aufrufen, eine Überladung, die einen Parameter vom Typ enthält StringComparison , damit Sie den Typ des Vergleichs angeben können, die die Methode ausführt.When you call a string comparison method such as String.Compare, String.Equals, or String.IndexOf, you should always call an overload that includes a parameter of type StringComparison so that you can specify the type of comparison that the method performs. 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.

Ein Vorgang, der Sortieroperation führt einen kulturabhängigen Vergleich, bei dem bestimmten nicht alphanumerischen Unicode-Zeichen bestimmte Gewichtung zugeordnet, die Ihnen möglicherweise.An operation that uses word sort rules performs a culture-sensitive comparison wherein certain nonalphanumeric Unicode characters might have special weights assigned to them. Mit Word-Sortierregeln und den Konventionen einer bestimmten Kultur, dem Bindestrich ("-") ggf. eine sehr geringe Gewichtung zugeordnet, sodass "Coop" und "coop" in einer sortierten Liste nebeneinander angezeigt werden.Using word sort rules and the conventions of a specific culture, 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.

Hinweis

Ausführen von .NET Core nur auf Linux- und macOS-Systemen: Beim Sortierungsverhalten für die C- und Posix-Kulturen ist immer die Groß-/Kleinschreibung zu beachten, weil diese Kulturen nicht die erwartete Unicode-Sortierreihenfolge verwenden..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. Bei der Durchführung kulturrelevanter Sortiervorgänge ohne Unterscheidung von Groß-/Kleinschreibung wird empfohlen, eine andere Kultur als C oder Posix zu verwenden.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Ein Vorgang, der ordinalen Sortierregeln verwendet, führt einen Vergleich aus, basierend auf den numerischen Wert (Unicode-Codepunkt) der einzelnen Char in der Zeichenfolge.An operation that uses ordinal sort rules performs a comparison based on the numeric value (Unicode code point) of each Char in the string. Ein ordinalen Vergleich ist schnell, aber kulturunabhängige.An ordinal comparison is fast but culture-insensitive. Wenn Sie ordinalen Sortierregeln verwenden, um Zeichenfolgen zu sortieren, die mit Unicode-Zeichen (U +) beginnen, werden die Zeichenfolge U + Xxxx vor der Zeichenfolge U + Yyyy kommt, wenn der Wert des Xxxx numerisch kleiner als Yyyy.When you use ordinal sort rules to sort strings that start with Unicode characters (U+), the string U+xxxx comes before the string U+yyyy if the value of xxxx is numerically less than yyyy.

Weitere Informationen zu vergleichen, finden Sie unter den System.String Klasse "Hinweise".For more information about comparisons, see the System.String class remarks. Weitere Informationen zur Kultur finden Sie unter den System.Globalization.CultureInfo Klasse "Hinweise".For more information about culture, see the System.Globalization.CultureInfo class remarks. Richtlinien dazu, wann, ordinal oder kulturabhängigen Vergleichsregeln oder die Regeln der invarianten Kultur zu verwenden, finden Sie unter bewährte Methoden für die Verwendung von Zeichenfolgen.For guidelines on when to use ordinal or culture-sensitive comparison rules or the rules of the invariant culture, see Best Practices for Using Strings. Für eine Gruppe von Textdateien mit Informationen zu Zeichen Gewichtungen Sortier- und Vergleichsregeln-Vorgänge für Windows-Betriebssysteme verwendet werden soll, finden Sie unter sortieren Gewichtung Tabellen.For a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, see Sorting Weight Tables. Die Gewichtung Sortiertabelle für Linux und MacOS finden Sie unter den Standard Unicode-Sortierung-Elementtabelle.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table.

Gilt für:

Siehe auch