CompareOptions CompareOptions CompareOptions CompareOptions Enum

Definição

Define as opções de comparação da cadeia de caracteres que serão usadas com CompareInfo.Defines the string comparison options to use with CompareInfo.

Esta enumeração tem um atributo FlagsAttribute que permite uma combinação bit a bit dos seus valores membros.

public enum class CompareOptions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CompareOptions
type CompareOptions = 
Public Enum CompareOptions
Herança
CompareOptionsCompareOptionsCompareOptionsCompareOptions
Atributos

Campos

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Indica se a comparação de cadeia de caracteres deve ignorar a diferenciação entre maiúsculas e minúsculas.Indicates that the string comparison must ignore case.

IgnoreKanaType IgnoreKanaType IgnoreKanaType IgnoreKanaType 8

Indica se a comparação de cadeia de caracteres deve ignorar o tipo Kana.Indicates that the string comparison must ignore the Kana type. O tipo Kana refere-se aos caracteres japoneses Hiragana e Katakana que representam sons fonéticos em japonês.Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. O Hiragana é usado em expressões e palavras japonesas nativas, enquanto o Katakana é usado para palavras emprestadas de outros idiomas, como “computador” ou “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". Um som fonético pode ser expresso em Hiragana e em Katakana.A phonetic sound can be expressed in both hiragana and katakana. Se esse valor estiver selecionado, o caractere Hiragana de um som será considerado igual ao caractere Katakana do mesmo som.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

Indica se a comparação de cadeia de caracteres deve ignorar caracteres sem espaçamento, como sinais diacríticos.Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. O Padrão Unicode define caracteres sem espaçamento como caracteres que são combinados com caracteres de base para produzir um novo caractere.The Unicode Standard defines combining characters as characters that are combined with base characters to produce a new character. Caracteres sem espaçamento não ocupam uma posição de espaçamento por si só quando renderizados.Nonspacing combining characters do not occupy a spacing position by themselves when rendered.

IgnoreSymbols IgnoreSymbols IgnoreSymbols 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.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

Indica se a comparação de cadeia de caracteres deve ignorar a largura do caractere.Indicates that the string comparison must ignore the character width. Por exemplo, os caracteres japoneses Katakana podem ser escritos em largura inteira ou em meia largura.For example, Japanese katakana characters can be written as full-width or half-width. Se esse valor for selecionado, os caracteres Katakana escritos como largura inteira serão considerados iguais aos mesmos caracteres escritos em meia largura.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

Indica as configurações padrão das opções para comparações de cadeia de caracteres.Indicates the default option settings for string comparisons.

Ordinal Ordinal Ordinal 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.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. 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.A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. Esse valor não pode ser combinado com outros valores CompareOptions e deve ser usada sozinho.This value cannot be combined with other CompareOptions values and must be used alone.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 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.String comparison must ignore case, then perform an ordinal comparison. 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.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

Indica se a comparação de cadeia de caracteres deve usar o algoritmo de classificação de cadeia de caracteres.Indicates that the string comparison must use the string sort algorithm. 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.In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.

Exemplos

O exemplo de código a seguir mostra como classificar com StringSort difere da classificação sem 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
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 'New
      
      ' 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 'Main

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

Comentários

Essas opções denotam a diferenciação de maiusculas ou necessidade para ignorar os tipos de caracteres.These options denote case sensitivity or necessity to ignore types of characters.

O .NET usa três formas diferentes de classificação: classificação, classificação de cadeia de caracteres e classificação ordinal do word..NET uses three distinct ways of sorting: word sort, string sort, and ordinal sort. Classificação de palavra executa uma comparação sensível à cultura de cadeias de caracteres.Word sort performs a culture-sensitive comparison of strings. Determinados caracteres não alfanuméricos podem ter pesos especiais atribuídos a eles.Certain nonalphanumeric characters might have special weights assigned to them. Por exemplo, o hífen ("-") pode ter um peso muito pequeno atribuído a ele de modo que "coop" e "co-op" apareçam próximos uns dos outros em uma lista classificada.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. Classificação de cadeia de caracteres é semelhante à classificação de palavra, exceto que há não há casos especiais.String sort is similar to word sort, except that there are no special cases. Portanto, todos os símbolos não alfanuméricos vêm antes de todos os caracteres alfanuméricos.Therefore, all nonalphanumeric symbols come before all alphanumeric characters. Classificação ordinal compara cadeias de caracteres com base nos valores de cada elemento da cadeia de caracteres Unicode.Ordinal sort compares strings based on the Unicode values of each element of the string. Para um conjunto para download de arquivos de texto que contêm informações sobre os pesos de caractere usado em operações de classificação e comparação para os sistemas operacionais Windows, consulte tabelas de classificação de peso.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. Para a tabela de peso de classificação para Linux e macOS, consulte o tabela de elemento de agrupamento de Unicode padrão.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table. A versão específica da tabela de peso de classificação do Linux e macOS depende da versão das bibliotecas de Componentes internacionais para Unicode instaladas no sistema.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. Para obter informações sobre versões de ICU e as versões Unicode que elas implementam, veja Baixar ICU.For information on ICU versions and the Unicode versions that they implement, see Downloading ICU.

O StringSort só pode ser usado com o valor CompareInfo.Compare e CompareInfo.GetSortKey.The StringSort value can only be used with CompareInfo.Compare and CompareInfo.GetSortKey. ArgumentException será gerada se o valor de StringSort é usado com CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, ou CompareInfo.LastIndexOf.ArgumentException is thrown if the StringSort value is used with CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, or CompareInfo.LastIndexOf.

Observação

Quando possível, você deve usar métodos de comparação de cadeia de caracteres que aceitam um CompareOptions valor para especificar o tipo de comparação esperado.When possible, you should use string comparison methods that accept a CompareOptions value to specify the kind of comparison expected. Como regra geral, as comparações de voltadas ao usuário são mais bem atendidas pelo uso das opções linguísticas (usando a cultura atual), ao mesmo tempo segurança comparações devem especificar Ordinal ou OrdinalIgnoreCase.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.

Observações sobre classificações sensíveis à culturaNotes on culture-sensitive sorts

Observação

.NET Core em execução apenas em sistemas Linux e macOS: O comportamento de ordenação das culturas do C e do Posix sempre diferencia maiúsculas de minúsculas porque essas culturas não usam a sequência de ordenação Unicode esperada..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. Recomendamos usar uma cultura diferente de C ou Posix para executar operações de classificação que diferenciam culturas e maiúsculas de minúsculas.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Aplica-se a

Veja também