CompareOptions CompareOptions CompareOptions CompareOptions Enum

Definicja

Definiuje opcje porównywania ciągów, które mają CompareInfobyć używane z.Defines the string comparison options to use with CompareInfo.

To wyliczenie ma atrybut FlagsAttribute zezwalający na bitową kombinację jego wartości składowych.

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

Pola

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Wskazuje, że wynikiem porównania ciągów musi być ignorowanie wielkości liter.Indicates that the string comparison must ignore case.

IgnoreKanaType IgnoreKanaType IgnoreKanaType IgnoreKanaType 8

Wskazuje, że porównanie ciągów musi ignorować typ kana.Indicates that the string comparison must ignore the Kana type. Typ kana odnosi się do japońskich znaków hiragana i katakana, które reprezentują dźwięki fonetyczne w języku japońskim.Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. Hiragana służy do natywnych wyrażeń japońskich i słów, natomiast znaki katakana są używane w przypadku wyrazów pożyczonych z innych języków, takich jak "Computer" lub "Internet".Hiragana is used for native Japanese expressions and words, while katakana is used for words borrowed from other languages, such as "computer" or "Internet". Dźwięk fonetyczny może być wyrażony zarówno jako Hiragana, jak i katakana.A phonetic sound can be expressed in both hiragana and katakana. W przypadku wybrania tej wartości znak hiragana dla jednego dźwięku jest uznawany za znak katakana dla tego samego dźwięku.If this value is selected, the hiragana character for one sound is considered equal to the katakana character for the same sound.

IgnoreNonSpace IgnoreNonSpace IgnoreNonSpace IgnoreNonSpace 2

Wskazuje, że porównanie ciągów musi ignorować nieodstępy łączące znaki, takie jak znaki diakrytyczne.Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. Standard Unicode definiuje łączenie znaków jako znaków, które są połączone z znakami podstawowymi w celu utworzenia nowego znaku.The Unicode Standard defines combining characters as characters that are combined with base characters to produce a new character. Znaki nierozdzielające nie zajmują odstępu, gdy są renderowane.Nonspacing combining characters do not occupy a spacing position by themselves when rendered.

IgnoreSymbols IgnoreSymbols IgnoreSymbols IgnoreSymbols 4

Wskazuje, że porównanie ciągów musi ignorować symbole, takie jak znaki odstępu, interpunkcja, symbole waluty, znak procentu, symbole matematyczne, znak handlowego i tak dalej.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 IgnoreWidth IgnoreWidth IgnoreWidth 16

Wskazuje, że porównanie ciągów musi ignorować szerokość znaków.Indicates that the string comparison must ignore the character width. Na przykład japońskie znaki katakana mogą być zapisywane w postaci pełnej szerokości lub połówkowej szerokości.For example, Japanese katakana characters can be written as full-width or half-width. W przypadku wybrania tej wartości znaki katakana zapisywane jako Pełna szerokość są uważane za takie same jak znaki o połówkowej szerokości.If this value is selected, the katakana characters written as full-width are considered equal to the same characters written as half-width.

None None None None 0

Wskazuje domyślne ustawienia opcji dla porównywania ciągów.Indicates the default option settings for string comparisons.

Ordinal Ordinal Ordinal Ordinal 1073741824

Wskazuje, że porównanie ciągów musi używać kolejnych wartości zakodowanych w formacie Unicode UTF-16 (kod jednostkowy według porównania jednostek kodu), co prowadzi do szybkiego porównania, ale nie jest rozróżniana kultura.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. Ciąg zaczynający się od jednostki kodu XXXX16 występuje przed ciągiem rozpoczynającym się od YYYY16, jeśli XXXX16 jest mniejszy niż YYYY16.A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. Tej wartości nie można łączyć z innymi CompareOptions wartościami i muszą one być używane samodzielnie.This value cannot be combined with other CompareOptions values and must be used alone.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 268435456

Wynikiem porównania ciągów musi być ignorowanie wielkości liter, a następnie przeprowadzenie porównania porządkowego.String comparison must ignore case, then perform an ordinal comparison. Ta technika jest równoznaczna z konwertowaniem ciągu na wielkie litery przy użyciu kultury niezmiennej, a następnie przeprowadzenie porównania porządkowego w wyniku.This technique is equivalent to converting the string to uppercase using the invariant culture and then performing an ordinal comparison on the result.

StringSort StringSort StringSort StringSort 536870912

Wskazuje, że porównanie ciągów musi używać algorytmu sortowania ciągu.Indicates that the string comparison must use the string sort algorithm. W przypadku sortowania ciągu łącznik i apostrof, a także inne symbole inne niż alfanumeryczne, są przed znakami alfanumerycznymi.In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.

Przykłady

Poniższy przykład kodu pokazuje, jak sortowanie za pomocą StringSort różni się od sortowania bez StringSort.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 'MyStringComparer


   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 'SamplesCompareOptions 


'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

Uwagi

Te opcje oznaczają czułość wielkości liter lub konieczność ignorowania typów znaków.These options denote case sensitivity or necessity to ignore types of characters.

Platforma .NET używa trzech odrębnych sposobów sortowania: sortowania wyrazów, sortowania ciągów i sortowania porządkowego..NET uses three distinct ways of sorting: word sort, string sort, and ordinal sort. Sortowanie w programie Word wykonuje porównanie uwzględniające kulturę ciągów.Word sort performs a culture-sensitive comparison of strings. Niektóre znaki niealfanumeryczne mogą mieć przypisane specjalne wagi.Certain nonalphanumeric characters might have special weights assigned to them. Na przykład łącznik ("-") może mieć przypisaną bardzo małą wagę, tak aby "coop" i "współ-op" pojawiły się obok siebie na sortowanej liście.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. Sortowanie ciągów jest podobne do sortowania wyrazów, z tą różnicą, że nie istnieją specjalne przypadki.String sort is similar to word sort, except that there are no special cases. W związku z tym wszystkie symbole, które nie są alfanumeryczne, są przed wszystkimi znakami alfanumerycznymi.Therefore, all nonalphanumeric symbols come before all alphanumeric characters. Sortowanie porządkowe porównuje ciągi na podstawie wartości Unicode każdego elementu ciągu.Ordinal sort compares strings based on the Unicode values of each element of the string. Aby pobrać zestaw plików tekstowych, które zawierają informacje o wagach znaków używanych w operacjach sortowania i porównywania dla systemów operacyjnych Windows, zobacz Sortowanie tabel wagi.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. W tabeli waga sortowania dla systemów Linux i macOS zobacz domyślną tabelę elementów sortowania w formacie Unicode.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table. Określona wersja tabeli posortowanych wag w systemie Linux i macOS zależy od wersji międzynarodowych składników dla bibliotek Unicode zainstalowanych w systemie.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. Aby uzyskać informacje na temat wersji ICU i wersji standardu Unicode, które implementują, zobacz pobieranie ICU.For information on ICU versions and the Unicode versions that they implement, see Downloading ICU.

Wartość może być używana tylko z CompareInfo.Compare i CompareInfo.GetSortKey. StringSortThe StringSort value can only be used with CompareInfo.Compare and CompareInfo.GetSortKey. ArgumentExceptionjest zgłaszany, jeśli wartość StringSort jest używana CompareInfo.IsPrefixz CompareInfo.IsSuffix, CompareInfo.IndexOf,, CompareInfo.LastIndexOflub.ArgumentException is thrown if the StringSort value is used with CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, or CompareInfo.LastIndexOf.

Uwaga

Jeśli jest to możliwe, należy użyć metod porównywania ciągów, CompareOptions które akceptują wartość, aby określić rodzaj oczekiwanego porównania.When possible, you should use string comparison methods that accept a CompareOptions value to specify the kind of comparison expected. Zgodnie z ogólną zasadą porównania związane z użytkownikiem są najlepszym rozwiązaniem przy użyciu opcji lingwistycznych (przy użyciu bieżącej kultury), podczas gdy porównania zabezpieczeń powinny Ordinal określać OrdinalIgnoreCaselub.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.

Uwagi dotyczące sortowania z uwzględnieniem kulturNotes on culture-sensitive sorts

Uwaga

.NET core uruchomiony tylko w systemach Linux i macOS: Zachowanie sortowania dla języków C i Posix zawsze jest wielkość liter, ponieważ te kultur nie należy używać w oczekiwanej kolejności sortowania Unicode..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. Zalecamy użycie kultury innej niż C lub Posix dla operacji wrażliwych na kulturę, bez uwzględniania wielkości liter sortowania.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Dotyczy

Zobacz też