CompareOptions Enumeration

Definition

Definiert die mit CompareInfo zu verwendenden Optionen für den Zeichenfolgenvergleich.Defines the string comparison options to use with CompareInfo.

Diese Enumeration weist ein FlagsAttribute-Attribut auf, die eine bitweise Kombination der Memberwerte zulässt.

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

Felder

IgnoreCase 1

Gibt an, dass beim Zeichenfolgenvergleich die Groß- und Kleinschreibung nicht beachtet wird.Indicates that the string comparison must ignore case.

IgnoreKanaType 8

Gibt an, dass beim Zeichenfolgenvergleich Zeichen vom Typ Kana ignoriert werden.Indicates that the string comparison must ignore the Kana type. Der Kana-Zeichentyp bezieht sich auf die japanischen Hiragana- und Katakana-Schriftzeichen, die im Japanischen phonetische Laute darstellen.Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. Hiragana wird für japanische Ausdrücke und Wörter verwendet, während Katakana für Lehnwörter aus anderen Sprachen, z. B. "Computer" oder "Internet", verwendet wird.Hiragana is used for native Japanese expressions and words, while katakana is used for words borrowed from other languages, such as "computer" or "Internet". Ein phonetischer Laut kann sowohl in Hiragana als auch in Katakana dargestellt werden.A phonetic sound can be expressed in both hiragana and katakana. Wenn dieser Wert ausgewählt ist, wird das Hiragana-Zeichen für einen Laut als gleichwertig mit dem Katakana-Zeichen für denselben Laut betrachtet.If this value is selected, the hiragana character for one sound is considered equal to the katakana character for the same sound.

IgnoreNonSpace 2

Gibt an, dass bei Zeichenfolgenvergleichen Kombinationszeichen ohne horizontalen Vorschub, z. B. diakritische Zeichen, ignoriert werden.Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. Der Unicode-Standard definiert Kombinationszeichen als Zeichen, die mit Basiszeichen kombiniert werden, um ein neues Zeichen zu erzeugen.The Unicode Standard defines combining characters as characters that are combined with base characters to produce a new character. Kombinationszeichen ohne horizontalen Vorschub nehmen bei der Darstellung keinen über die Breite des Basiszeichens hinausgehenden Platz ein.Nonspacing combining characters do not occupy a spacing position by themselves when rendered.

IgnoreSymbols 4

Gibt an, dass der Zeichenfolgenvergleich Symbole ignorieren muss, z.B. Leerräume, Satzzeichen, Währungssymbole, das Prozentzeichen, mathematische Symbole, das kaufmännische Und usw.Indicates that the string comparison must ignore symbols, such as white-space characters, punctuation, currency symbols, the percent sign, mathematical symbols, the ampersand, and so on.

IgnoreWidth 16

Gibt an, dass beim Zeichenfolgenvergleich die Zeichenbreite ignoriert wird.Indicates that the string comparison must ignore the character width. Japanische Katakana-Zeichen können z. B. in voller oder halber Breite geschrieben werden.For example, Japanese katakana characters can be written as full-width or half-width. Wenn dieser Wert ausgewählt ist, werden die in voller Breite geschriebenen Katakana-Zeichen als denselben in halber Breite geschriebenen Zeichen gleichwertig betrachtet.If this value is selected, the katakana characters written as full-width are considered equal to the same characters written as half-width.

None 0

Gibt die Standardeinstellungen der Optionen für Zeichenfolgenvergleiche an.Indicates the default option settings for string comparisons.

Ordinal 1073741824

Gibt an, dass der Zeichenfolgenvergleich aufeinanderfolgende Unicode UTF-16-codierte Werte der Zeichenfolge verwenden muss (Vergleich von Codeeinheiten). Dies führt zu einem schnellen, jedoch kulturunabhängigen Vergleich.Indicates that the string comparison must use successive Unicode UTF-16 encoded values of the string (code unit by code unit comparison), leading to a fast comparison but one that is culture-insensitive. Eine Zeichenfolge, die mit der Codeeinheit „XXXX16“ beginnt, kommt vor einer Zeichenfolge, die mit „YYYY16“ beginnt, wenn XXXX16 kleiner als YYYY16 ist.A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. Dieser Wert kann nicht mit anderen CompareOptions-Werten kombiniert werden und muss allein verwendet werden.This value cannot be combined with other CompareOptions values and must be used alone.

OrdinalIgnoreCase 268435456

Beim Zeichenfolgenvergleich darf die Groß- und Kleinschreibung nicht berücksichtigt werden, und anschließend muss ein ordinaler Vergleich erfolgen.String comparison must ignore case, then perform an ordinal comparison. Dieses Verfahren entspricht dem Konvertieren der Zeichenfolge in Großbuchstaben mithilfe der invarianten Kultur und dem anschließenden Ordinalvergleich mit dem Ergebnis.This technique is equivalent to converting the string to uppercase using the invariant culture and then performing an ordinal comparison on the result.

StringSort 536870912

Gibt an, dass beim Zeichenfolgenvergleich der Zeichenfolgensortieralgorithmus verwendet werden muss.Indicates that the string comparison must use the string sort algorithm. Bei der Zeichenfolgensortierung werden Bindestriche und Apostrophe sowie andere nicht alphanumerische Symbole vor alphanumerischen Zeichen aufgeführt.In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.

Beispiele

Im folgenden Codebeispiel wird gezeigt, wie die Sortierung mit StringSort von der Sortierung ohne StringSort abweicht.The following code example shows how sorting with StringSort differs from sorting without StringSort.

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

// __gc public class SamplesCompareOptions {
ref class MyStringComparer: public IComparer
{
public:

   // Constructs a comparer using the specified CompareOptions.
   CompareInfo^ myComp;
   CompareOptions myOptions;
   MyStringComparer( CompareInfo^ cmpi, CompareOptions options )
      : myComp( cmpi ), myOptions( options )
   {}

   // Compares strings with the CompareOptions specified in the constructor.
   virtual int Compare( Object^ a, Object^ b )
   {
      if ( a == b )
            return 0;

      if ( a == nullptr )
            return  -1;

      if ( b == nullptr )
            return 1;

      String^ sa = dynamic_cast<String^>(a);
      String^ sb = dynamic_cast<String^>(b);
      if ( sa != nullptr && sb != nullptr )
            return myComp->Compare( sa, sb, myOptions );

      throw gcnew ArgumentException( "a and b should be strings." );
   }
};

int main()
{
   
   // Creates and initializes an array of strings to sort.
   array<String^>^myArr = {"cant","bill's","coop","cannot","billet","can't","con","bills","co-op"};
   Console::WriteLine( "\nInitially, " );
   IEnumerator^ myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }

   
   // Creates and initializes a Comparer to use.
   //CultureInfo* myCI = new CultureInfo(S"en-US", false);
   MyStringComparer^ myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::None );
   
   // Sorts the array without StringSort.
   Array::Sort( myArr, myComp );
   Console::WriteLine( "\nAfter sorting without CompareOptions::StringSort:" );
   myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }

   
   // Sorts the array with StringSort.
   myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::StringSort );
   Array::Sort( myArr, myComp );
   Console::WriteLine( "\nAfter sorting with CompareOptions::StringSort:" );
   myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }
}

/*
This code produces the following output.

Initially,
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting without CompareOptions::StringSort:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions::StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop
*/
using System;
using System.Collections;
using System.Globalization;


public class SamplesCompareOptions  {

   private class MyStringComparer: IComparer {
      private CompareInfo myComp;   
      private CompareOptions myOptions = CompareOptions.None;

      // Constructs a comparer using the specified CompareOptions.
      public MyStringComparer( CompareInfo cmpi, CompareOptions options )  {
         myComp = cmpi;
         this.myOptions = options;
      }

      // Compares strings with the CompareOptions specified in the constructor.
      public int Compare(Object a, Object b) {
         if (a == b) return 0;
         if (a == null) return -1;
         if (b == null) return 1;

         String sa = a as String;
         String sb = b as String;
         if (sa != null && sb != null)
            return myComp.Compare(sa, sb, myOptions);
         throw new ArgumentException("a and b should be strings.");

      }
   }
   
   public static void Main()  {

      // Creates and initializes an array of strings to sort.
      String[] myArr = new String[9] { "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op" };
      Console.WriteLine( "\nInitially," );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

      // Creates and initializes a Comparer to use.
      //CultureInfo myCI = new CultureInfo( "en-US", false );
      MyStringComparer myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None);

      // Sorts the array without StringSort.
      Array.Sort( myArr, myComp );
      Console.WriteLine( "\nAfter sorting without CompareOptions.StringSort:" );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

      // Sorts the array with StringSort.
      myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort);
      Array.Sort( myArr, myComp );
      Console.WriteLine( "\nAfter sorting with CompareOptions.StringSort:" );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

   }

}

/*
This code produces the following output.

Initially,
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting without CompareOptions.StringSort:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions.StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop

*/
Imports System.Collections
Imports System.Globalization

Public Class SamplesCompareOptions

   Private Class MyStringComparer
      Implements IComparer

      Private myComp As CompareInfo
      Private myOptions As CompareOptions = CompareOptions.None
      
      ' Constructs a comparer using the specified CompareOptions.
      Public Sub New(cmpi As CompareInfo, options As CompareOptions)
         myComp = cmpi
         Me.myOptions = options
      End Sub
      
      ' Compares strings with the CompareOptions specified in the constructor.
      Public Function Compare(a As [Object], b As [Object]) As Integer Implements IComparer.Compare
         If a = b Then
            Return 0
         End If
         If a Is Nothing Then
            Return - 1
         End If
         If b Is Nothing Then
            Return 1
         End If 

         Dim sa As [String] = a
         Dim sb As [String] = b
         If Not (sa Is Nothing) And Not (sb Is Nothing) Then
            Return myComp.Compare(sa, sb, myOptions)
         End If
         Throw New ArgumentException("a and b should be strings.")

      End Function 'Compare 

   End Class


   Public Shared Sub Main()
      
      ' Creates and initializes an array of strings to sort.
      Dim myArr() As [String] = {"cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"}
      Console.WriteLine()
      Console.WriteLine("Initially,")
      Dim myStr As [String]
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

      ' Creates and initializes a Comparer to use.
      'CultureInfo myCI = new CultureInfo( "en-US", false );
      Dim myComp As New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None)
      
      ' Sorts the array without StringSort.
      Array.Sort(myArr, myComp)
      Console.WriteLine()
      Console.WriteLine("After sorting without CompareOptions.StringSort:")
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

      ' Sorts the array with StringSort.
      myComp = New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort)
      Array.Sort(myArr, myComp)
      Console.WriteLine()
      Console.WriteLine("After sorting with CompareOptions.StringSort:")
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

   End Sub

End Class


'This code produces the following output.
'
'Initially,
'cant
'bill's
'coop
'cannot
'billet
'can't
'con
'bills
'co-op
'
'After sorting without CompareOptions.StringSort:
'billet
'bills
'bill's
'cannot
'cant
'can't
'con
'coop
'co-op
'
'After sorting with CompareOptions.StringSort:
'bill's
'billet
'bills
'can't
'cannot
'cant
'co-op
'con
'coop

Hinweise

Diese Optionen kennzeichnen die Groß-/Kleinschreibung oder die Notwendigkeit, Zeichen Typen zu ignorieren.These options denote case sensitivity or necessity to ignore types of characters.

.NET verwendet drei verschiedene Arten der Sortierung: Wort Sortierung, Zeichen folgen Sortierung und Ordinalsortierung..NET uses three distinct ways of sorting: word sort, string sort, and ordinal sort. Die Wort Sortierung führt einen Kultur abhängigen Vergleich von Zeichen folgen aus.Word sort performs a culture-sensitive comparison of strings. Bestimmten nicht alphanumerischen Zeichen können spezielle Gewichtungen zugewiesen werden.Certain nonalphanumeric characters might have special weights assigned to them. Beispielsweise wird dem Bindestrich ("-") ggf. eine sehr geringe Gewichtung zugeordnet, sodass "coop" und "co-op" 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. Die Sortierung von Zeichen folgen ähnelt der Wort Sortierung, mit dem Unterschied, dass es keine besonderen Fälle gibt.String sort is similar to word sort, except that there are no special cases. Daher stehen alle nicht alphanumerischen Symbole vor allen alphanumerischen Zeichen.Therefore, all nonalphanumeric symbols come before all alphanumeric characters. Ordinalsort vergleicht Zeichen folgen basierend auf den Unicode-Werten der einzelnen Elemente der Zeichenfolge.Ordinal sort compares strings based on the Unicode values of each element of the string. Einen herunterladbaren Satz von Textdateien, die Informationen zu den in Sortier-und Vergleichs Vorgängen für Windows-Betriebssysteme verwendeten Zeichen Gewichtungen enthalten, finden Sie unter Sortieren von Gewichtungs Tabellen.For a downloadable 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. Informationen zur Sortier Gewichtungs Tabelle für Linux und macOS finden Sie in der Unicode-Standard Sortierungs Element Tabelle.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table. Die spezifische Version der Sortiergewichtungstabelle unter Linux und macOS hängt von der auf dem System installierten Version der International Components for Unicode ab.The specific version of the sort weight table on Linux and macOS depends on the version of the International Components for Unicode libraries installed on the system. Informationen zu ICU-Versionen und den Unicode-Versionen, die durch sie implementiert werden, finden Sie unter Downloading ICU.For information on ICU versions and the Unicode versions that they implement, see Downloading ICU.

Der StringSort Wert kann nur mit CompareInfo.Compare und CompareInfo.GetSortKeyverwendet werden.The StringSort value can only be used with CompareInfo.Compare and CompareInfo.GetSortKey. ArgumentExceptionwird ausgelöst, wenn der StringSort-Wert mit CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOfoder CompareInfo.LastIndexOfverwendet wird.ArgumentException is thrown if the StringSort value is used with CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, or CompareInfo.LastIndexOf.

Hinweis

Wenn möglich, sollten Sie Zeichen folgen Vergleichsmethoden verwenden, die CompareOptions einen Wert akzeptieren, um die Art des erwarteten Vergleichs anzugeben.When possible, you should use string comparison methods that accept a CompareOptions value to specify the kind of comparison expected. Als allgemeine Regel werden bei der Verwendung linguistischer Optionen (unter Verwendung der aktuellen Kultur) die Benutzer seitigen Vergleiche am besten bedient, während bei Sicherheits Vergleiche oder Ordinal OrdinalIgnoreCaseangegeben wird.As a general rule, user-facing comparisons are best served by the use of linguistic options (using the current culture), while security comparisons should specify Ordinal or OrdinalIgnoreCase.

Hinweise zu Kultur abhängigen SortierungenNotes on culture-sensitive sorts

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.

Gilt für:

Siehe auch