CompareOptions CompareOptions CompareOptions CompareOptions Enum

Definición

Define las opciones de comparación de cadenas que se van a utilizar con CompareInfo.Defines the string comparison options to use with CompareInfo.

Esta enumeración tiene el atributo FlagsAttribute, que permite una combinación bit a bit de sus valores de miembro.

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

Campos

IgnoreCase IgnoreCase IgnoreCase IgnoreCase 1

Indica que en la comparación de cadenas no se debe tener en cuenta la distinción entre mayúsculas y minúsculas.Indicates that the string comparison must ignore case.

IgnoreKanaType IgnoreKanaType IgnoreKanaType IgnoreKanaType 8

Indica que en la comparación de cadenas no se debe tener en cuenta el tipo Kana.Indicates that the string comparison must ignore the Kana type. El tipo Kana hace referencia a los caracteres japoneses hiragana y katakana, que representan sonidos fonéticos del idioma japonés.Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. Los caracteres hiragana se utilizan en expresiones y palabras propias del idioma japonés, mientras que los caracteres katakana se utilizan para préstamos léxicos, como "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". Un sonido fonético puede expresarse tanto en caracteres hiragana como katakana.A phonetic sound can be expressed in both hiragana and katakana. Si se selecciona este valor, el carácter hiragana de un sonido se considera equivalente al carácter katakana del mismo sonido.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 que en las comparaciones de cadenas no deben tenerse en cuenta los caracteres combinables sin espaciado, como los diacríticos.Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. El estándar Unicode define los caracteres de combinación como caracteres que se combinan con caracteres base para generar un nuevo carácter.The Unicode Standard defines combining characters as characters that are combined with base characters to produce a new character. Los caracteres combinables sin espaciado no ocupan por sí mismos un espacio cuando se representan.Nonspacing combining characters do not occupy a spacing position by themselves when rendered.

IgnoreSymbols IgnoreSymbols IgnoreSymbols IgnoreSymbols 4

Indica que la comparación de cadenas debe pasar por alto los símbolos, como espacios en blanco, puntuación, símbolos de moneda, signos de porcentaje, símbolos matemáticos, la "y" comercial (&), etc.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 que en la comparación de cadenas no se debe tener en cuenta el ancho de los caracteres.Indicates that the string comparison must ignore the character width. Por ejemplo, los caracteres katakana japoneses se pueden escribir como ancho completo o medio ancho.For example, Japanese katakana characters can be written as full-width or half-width. Si se selecciona este valor, los caracteres katakana escritos como ancho completo se consideran iguales que los mismos caracteres escritos como medio ancho.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 la configuración predeterminada de las opciones para la comparación de cadenas.Indicates the default option settings for string comparisons.

Ordinal Ordinal Ordinal Ordinal 1073741824

Indica que la comparación de cadenas debe usar valores sucesivos de la cadena con codificación Unicode UTF-16 (comparación de unidad de código con unidad de código), lo que tiene como resultado una comparación rápida pero que no reconoce la referencia cultural.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. Una cadena que empieza con una unidad de código XXXX16 va antes que una cadena que empieza por YYYY16, si XXXX16 es menor que YYYY16.A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. Este valor no se puede combinar con otros valores de CompareOptions y se debe usar solo.This value cannot be combined with other CompareOptions values and must be used alone.

OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase OrdinalIgnoreCase 268435456

La comparación de cadenas debe omitir la distinción entre mayúsculas y minúsculas y, a continuación, realizar una comparación de ordinales.String comparison must ignore case, then perform an ordinal comparison. Esta técnica es equivalente a poner la cadena en mayúsculas utilizando la referencia cultural de todos los idiomas y realizar después una comparación de ordinales en el 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 que la comparación de cadenas debe usar el algoritmo de ordenación por cadena.Indicates that the string comparison must use the string sort algorithm. En una ordenación por cadena, el guión y el apóstrofo, así como otros símbolos no alfanuméricos, van delante de los caracteres alfanuméricos.In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.

Ejemplos

En el ejemplo de código siguiente se muestra cómo la ordenación con StringSort difiere de la ordenación sin 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

Comentarios

Estas opciones indican la distinción de mayúsculas y minúsculas o la necesidad de omitir tipos de caracteres.These options denote case sensitivity or necessity to ignore types of characters.

.NET usa tres formas distintas de ordenación: ordenación de palabras, ordenación de cadenas y ordenación ordinal..NET uses three distinct ways of sorting: word sort, string sort, and ordinal sort. La ordenación de palabras realiza una comparación de cadenas que tiene en cuenta la referencia cultural.Word sort performs a culture-sensitive comparison of strings. Algunos caracteres no alfanuméricos podrían tener asignados pesos especiales.Certain nonalphanumeric characters might have special weights assigned to them. Por ejemplo, el guion ("-") podría tener asignado un peso muy pequeño, por lo que las cadenas "coop" y "co-op" aparecerían una junto a la otra en una lista ordenada.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. La ordenación por cadena es similar a la ordenación de palabras, salvo que no hay casos especiales.String sort is similar to word sort, except that there are no special cases. Por lo tanto, todos los símbolos no alfanuméricos van delante de todos los caracteres alfanuméricos.Therefore, all nonalphanumeric symbols come before all alphanumeric characters. El orden ordinal compara las cadenas en función de los valores Unicode de cada elemento de la cadena.Ordinal sort compares strings based on the Unicode values of each element of the string. Para obtener un conjunto de archivos de texto que se pueden descargar y que contienen información sobre los pesos de caracteres utilizados en las operaciones de ordenación y comparación de los sistemas operativos Windows, vea ordenar tablas de pesos.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 obtener la tabla de peso de ordenación de Linux y macOS, consulte la tabla de elementos de intercalación Unicode predeterminada.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table. La versión específica de la tabla de pesos de ordenación en Linux y macOS depende de la versión de las bibliotecas de componentes internacionales de Unicode instaladas en el 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 más información sobre las versiones de los componentes internacionales de Unicode y las versiones de Unicode que implementan, vea la información sobre la descarga de componentes internacionales de Unicode.For information on ICU versions and the Unicode versions that they implement, see Downloading ICU.

El StringSort valor solo se puede usar con CompareInfo.Compare y CompareInfo.GetSortKey.The StringSort value can only be used with CompareInfo.Compare and CompareInfo.GetSortKey. ArgumentExceptionse produce si el valor de StringSort se utiliza CompareInfo.IsPrefixcon CompareInfo.IsSuffix, CompareInfo.IndexOf, o CompareInfo.LastIndexOf.ArgumentException is thrown if the StringSort value is used with CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, or CompareInfo.LastIndexOf.

Nota

Cuando sea posible, debe usar métodos de comparación de cadenas que CompareOptions acepten un valor para especificar el tipo de comparación esperada.When possible, you should use string comparison methods that accept a CompareOptions value to specify the kind of comparison expected. Como norma general, las comparaciones orientadas al usuario son más adecuadas por el uso de opciones lingüísticas (con la referencia cultural actual), mientras que Ordinal las OrdinalIgnoreCasecomparaciones de seguridad deben especificar o.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.

Notas sobre los ordenaciones que tienen en cuenta la referencia culturalNotes on culture-sensitive sorts

Nota

.NET Xore que se ejecutan solo en sistemas Linux y macOS: El comportamiento de la intercalación para las referencias culturales de C y Posix siempre distingue mayúsculas de minúsculas porque estas referencias culturales no usan el orden esperado de la intercalación de 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. Se recomienda que utilice una referencia cultural que no sea de C o Posix para realizar operaciones de ordenación que tengan en cuenta la referencia cultural y no distingan mayúsculas y minúsculas.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Se aplica a

Consulte también: