CompareOptions Enumeração

Definição

Namespace:

System.Globalization

Assembly:

System.Runtime.dll

Define as opções de comparação da cadeia de caracteres que serão usadas com CompareInfo.

Essa enumeração dá suporte a uma combinação bit a bit dos valores de membro.

public enum class CompareOptions

[System.Flags]
public enum CompareOptions

[<System.Flags>]
type CompareOptions = 

Public Enum CompareOptions

Herança

Object

ValueType

Enum

CompareOptions

Atributos

FlagsAttribute

Campos

IgnoreCase	1	Indica se a comparação de cadeia de caracteres deve ignorar a diferenciação entre maiúsculas e minúsculas.
IgnoreKanaType	8	Indica se a comparação de cadeia de caracteres deve ignorar o tipo Kana. O tipo Kana refere-se aos caracteres japoneses Hiragana e Katakana que representam sons fonéticos em japonês. O Hiragana é usado em expressões e palavras japonesas nativas, enquanto o Katakana é usado para palavras emprestadas de outros idiomas, como “computador” ou “Internet”. Um som fonético pode ser expresso em Hiragana e em Katakana. Se esse valor estiver selecionado, o caractere Hiragana de um som será considerado igual ao caractere Katakana do mesmo som.
IgnoreNonSpace	2	Indica se a comparação de cadeia de caracteres deve ignorar caracteres sem espaçamento, como sinais diacríticos. O Padrão Unicode define caracteres sem espaçamento como caracteres que são combinados com caracteres de base para produzir um novo caractere. Caracteres sem espaçamento não ocupam uma posição de espaçamento por si só quando renderizados.
IgnoreSymbols	4	Indica se a comparação de cadeia de caracteres deve ignorar símbolos, como caracteres de espaço em branco, pontuação, símbolos de moeda, o sinal de porcentagem, símbolos matemáticos, o E comercial e assim por diante.
IgnoreWidth	16	Indica se a comparação de cadeia de caracteres deve ignorar a largura do caractere. Por exemplo, os caracteres japoneses Katakana podem ser escritos em largura inteira ou em meia largura. Se esse valor for selecionado, os caracteres Katakana escritos como largura inteira serão considerados iguais aos mesmos caracteres escritos em meia largura.
None	0	Indica as configurações padrão das opções para comparações de cadeia de caracteres.
Ordinal	1073741824	Indica que a comparação de cadeia de caracteres deve usar valores Unicode UTF-16 codificados e sucessivos da cadeia de caracteres (unidade de código por comparação de unidade de código), levando a uma comparação rápida, mas que não leva em conta a cultura. Uma cadeia de caracteres que começa com uma unidade de código XXXX16 vem antes de uma cadeia de caracteres que começa com YYYY16, se XXXX16 for menor que YYYY16. Esse valor não pode ser combinado com outros valores CompareOptions e deve ser usada sozinho.
OrdinalIgnoreCase	268435456	A comparação de cadeia de caracteres deve ignorar a diferenciação entre maiúsculas e minúsculas, então faça uma comparação ordinal. Essa técnica é equivalente a converter a cadeia de caracteres em letras maiúsculas usando a cultura invariável e, em seguida, executar uma comparação ordinal no resultado.
StringSort	536870912	Indica se a comparação de cadeia de caracteres deve usar o algoritmo de classificação de cadeia de caracteres. Em uma classificação de cadeia de caracteres, o hífen e o apóstrofo, bem como outros símbolos não alfanuméricos, vêm antes de caracteres alfanuméricos.

Exemplos

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

Comentários

Para obter mais informações sobre essa API, consulte Comentários de API complementares para CompareOptions.

Confira também

• Operações básicas de cadeia de caracteres no .NET