CompareOptions Sabit listesi

Tanım

Ad Alanı:

System.Globalization

Bütünleştirilmiş Kod:

System.Runtime.dll

ile CompareInfokullanılacak dize karşılaştırma seçeneklerini tanımlar.

Bu sabit listesi, üyeleri için bit düzeyinde karşılaştırmayı destekler.

public enum class CompareOptions

[System.Flags]
public enum CompareOptions

[<System.Flags>]
type CompareOptions = 

Public Enum CompareOptions

Devralma

Object

ValueType

Enum

CompareOptions

Öznitelikler

FlagsAttribute

Alanlar

IgnoreCase	1	Dize karşılaştırmasının büyük/küçük harf durumunu yoksayması gerektiğini gösterir.
IgnoreKanaType	8	Dize karşılaştırmasının Kana türünü yoksayması gerektiğini gösterir. Kana türü, Japonca dilinde fonetik sesleri temsil eden Japonca hiragana ve katakana karakterlerini ifade eder. Hiragana yerel Japonca ifadeler ve sözcükler için kullanılırken katakana ise "bilgisayar" veya "İnternet" gibi diğer dillerden ödünç alınan sözcükler için kullanılır. Fonetik ses hem hiragana hem de katakana ile ifade edilebilir. Bu değer seçilirse, bir sesin hiragana karakteri aynı ses için katakana karakterine eşit olarak kabul edilir.
IgnoreNonSpace	2	Dize karşılaştırmasının aksan gibi saydam olmayan birleştirme karakterlerini yoksayması gerektiğini gösterir. Unicode Standart, karakter birleştirmeyi, yeni bir karakter oluşturmak için temel karakterlerle birleştirilen karakterler olarak tanımlar. Birleştirilemeyen karakterler, işlenirken tek başına bir aralık konumu kaplamaz.
IgnoreSymbols	4	Dize karşılaştırmasının boşluk karakterleri, noktalama işaretleri, para birimi simgeleri, yüzde işareti, matematiksel simgeler, ve işareti gibi simgeleri yoksayması gerektiğini gösterir.
IgnoreWidth	16	Dize karşılaştırmasının karakter genişliğini yoksayması gerektiğini gösterir. Örneğin, Japonca katakana karakterleri tam genişlikte veya yarım genişlikte yazılabilir. Bu değer seçilirse, tam genişlikli olarak yazılan katakana karakterleri, yarım genişlikli olarak yazılan aynı karakterlere eşit olarak kabul edilir.
None	0	Dize karşılaştırmaları için varsayılan seçenek ayarlarını gösterir.
Ordinal	1073741824	Dize karşılaştırmasının dizenin ardışık Unicode UTF-16 kodlanmış değerlerini kullanması gerektiğini gösterir (kod birimi karşılaştırmasına göre kod birimi), hızlı bir karşılaştırmaya yol açar, ancak kültüre duyarsızdır. XXXX16 kod birimiyle başlayan bir dize, XXXX16 YYYY16'dan küçükse YYYY16 ile başlayan bir dizeden önce gelir. Bu değer diğer CompareOptions değerlerle birleştirilemez ve tek başına kullanılmalıdır.
OrdinalIgnoreCase	268435456	Dize karşılaştırması büyük/küçük harf durumunu yoksaymalı ve ardından sıralı bir karşılaştırma gerçekleştirmelidir. Bu teknik sabit kültürü kullanarak dizeyi büyük harfe dönüştürmeye ve ardından sonuç üzerinde sıralı bir karşılaştırma yapmaya eşdeğerdir.
StringSort	536870912	Dize karşılaştırmasının dize sıralama algoritmasını kullanması gerektiğini gösterir. Bir dize sıralamasında, kısa çizgi ve kesme işareti ile diğer alfasayısal olmayan simgeler alfasayısal karakterlerden önce gelir.

Örnekler

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

Açıklamalar

Bu API hakkında daha fazla bilgi için bkz . CompareOptions için ek API açıklamaları.

Ayrıca bkz.

• .NET'te Temel Dize İşlemleri