CompareOptions Wyliczenie

Odwołanie

Definicja

Przestrzeń nazw:: System.Globalization

Zestaw:: System.Globalization.dll

Zestaw:: System.Runtime.dll

Zestaw:: mscorlib.dll

Zestaw:: netstandard.dll

Ważne

Niektóre informacje odnoszą się do produktu w wersji wstępnej, który może zostać znacząco zmodyfikowany przed wydaniem. Firma Microsoft nie udziela żadnych gwarancji, jawnych lub domniemanych, w odniesieniu do informacji podanych w tym miejscu.

Definiuje opcje porównania ciągów do użycia z CompareInfo.

To wyliczenie obsługuje bitową kombinację jego wartości składowych.

public enum class CompareOptions

[System.Flags]
public enum CompareOptions

[System.Flags]
[System.Serializable]
public enum CompareOptions

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

[<System.Flags>]
type CompareOptions =

[<System.Flags>]
[<System.Serializable>]
type CompareOptions =

[<System.Flags>]
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type CompareOptions =

Public Enum CompareOptions

Dziedziczenie: Object

ValueType

Enum
CompareOptions

Atrybuty: FlagsAttribute SerializableAttribute ComVisibleAttribute

Pola

IgnoreCase	1	Wskazuje, że porównanie ciągów musi ignorować wielkość liter.
IgnoreKanaType	8	Wskazuje, że porównanie ciągów musi ignorować typ Kana. Typ Kana odnosi się do japońskich znaków hiragana i katakana, które reprezentują dźwięki fonetyczne w języku japońskim. Hiragana jest używana do natywnych wyrażeń japońskich i wyrazów, podczas gdy katakana jest używana do słów pożyczonych z innych języków, takich jak "komputer" lub "Internet". Dźwięk fonetyczny można wyrazić zarówno w hiraganie, jak i katakanie. Jeśli ta wartość jest zaznaczona, znak hiragana dla jednego dźwięku jest uznawany za równy znak katakana dla tego samego dźwięku.
IgnoreNonSpace	2	Wskazuje, że porównanie ciągów musi ignorować znaki nieobjętą kombinacją znaków, takich jak znaki diakrytyczne. Standard Unicode definiuje łączenie znaków jako znaków połączonych ze znakami podstawowymi w celu utworzenia nowego znaku. Podczas renderowania znaki łączące nie zajmują pozycji odstępów.
IgnoreSymbols	4	Wskazuje, że porównanie ciągów musi ignorować symbole, takie jak znaki odstępu, znaki interpunkcyjne, symbole waluty, znak procentu, symbole matematyczne, znak i tak dalej.
IgnoreWidth	16	Wskazuje, że porównanie ciągów musi ignorować szerokość znaku. Na przykład japońskie znaki katakana mogą być zapisywane jako pełnej szerokości lub pół szerokości. Jeśli ta wartość jest zaznaczona, znaki katakana zapisane jako pełnej szerokości są traktowane jako równe tym samym znakom zapisanym jako pół szerokość.
None	0	Wskazuje domyślne ustawienia opcji dla porównań ciągów.
Ordinal	1073741824	Wskazuje, że porównanie ciągów musi używać kolejnych wartości zakodowanych w formacie Unicode UTF-16 ciągu (jednostki kodu według porównania jednostek kodu), co prowadzi do szybkiego porównania, ale takiego, który jest niewrażliwy na kulturę. Ciąg rozpoczynający się od jednostki kodu XXXX16 występuje przed ciągiem rozpoczynającym się od RRRR16, jeśli XXXX16 jest mniejszy niż RRRR16. Tej wartości nie można połączyć z innymi CompareOptions wartościami i należy jej używać samodzielnie.
OrdinalIgnoreCase	268435456	Porównanie ciągów musi ignorować wielkość liter, a następnie wykonać porównanie porządkowe. Ta technika jest równoważna konwersji ciągu na wielkie litery przy użyciu niezmiennej kultury, a następnie przeprowadzania porównania porządkowego w wyniku.
StringSort	536870912	Wskazuje, że porównanie ciągów musi używać algorytmu sortowania ciągów. W sortowaniu ciągu łącznik i apostrof, a także inne symbole niefanumeryczne, są przed znakami alfanumerycznymi.

Przykłady

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

Uwagi

Aby uzyskać więcej informacji na temat tego interfejsu API, zobacz dodatkowe uwagi dotyczące interfejsu API dla funkcji CompareOptions.

Dotyczy

Zobacz też

Podstawowe operacje na ciągach na platformie .NET