Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Enumeración CompareOptions

 

Publicado: octubre de 2016

Define las opciones de comparación de cadenas para usar con CompareInfo.

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

Espacio de nombres:   System.Globalization
Ensamblado:  mscorlib (en mscorlib.dll)

[SerializableAttribute]
[FlagsAttribute]
[ComVisibleAttribute(true)]
public enum CompareOptions

Nombre de miembroDescripción
IgnoreCase

Indica que la comparación de cadenas debe omitir mayúsculas y minúsculas.

IgnoreKanaType

Indica que la comparación de cadenas debe omitir el tipo de Kana. El tipo kana hace referencia a los caracteres japoneses hiragana y katakana, que representan sonidos fonéticos del idioma japonés. Hiragana se utiliza para expresiones japonés nativo y palabras, mientras que katakana se utiliza para las palabras que se toma prestados de otros lenguajes, como "equipo" o "Internet". Un sonido fonético puede expresarse en caracteres hiragana y katakana. Si se selecciona este valor, el carácter hiragana de un sonido se considera igual al carácter katakana del mismo sonido.

IgnoreNonSpace

Indica que la comparación de cadenas debe omitir los caracteres de combinación, como los signos diacríticos. El Unicode Standard define los caracteres de combinación como caracteres que se combinan con caracteres base para producir un nuevo carácter. Los caracteres de combinación no ocupan un espacio por sí solos cuando se representa.

IgnoreSymbols

Indica que la comparación de cadenas debe omitir símbolos, como caracteres de espacio en blanco, puntuación, símbolos de moneda, el signo de porcentaje, símbolos matemáticos, la y comercial y así sucesivamente.

IgnoreWidth

Indica que la comparación de cadenas debe omitir el ancho de caracteres. Por ejemplo, los caracteres katakana japonés pueden escribirse como ancho completo o de ancho medio. Si se selecciona este valor, los caracteres katakana escritos como ancho completo se consideran iguales a los mismos caracteres escritos como medio ancho.

None

Indica la configuración predeterminada para las comparaciones de cadenas.

Ordinal

Indica que la comparación de cadenas debe usar valores sucesivos de codificación Unicode UTF-16 de la cadena (unidad de código mediante la comparación de la unidad de código), dando lugar a una comparación rápida pero que es la referencia cultural. Una cadena a partir de una unidad de código XXXX16 precede a una cadena a partir de aaaa16, si XXXX16 es menor que YYYY16. Este valor no se puede combinar con otras CompareOptions valores y debe utilizarse solo.

OrdinalIgnoreCase

Comparación de cadenas debe omitir mayúsculas y minúsculas, y después realizar una comparación ordinal. Esta técnica es equivalente a convertir la cadena en mayúsculas utilizando la referencia cultural invariable y, a continuación, realizar una comparación de ordinales en el resultado.

StringSort

Indica que la comparación de cadenas debe usar el algoritmo de ordenación de cadenas. En una ordenación por cadena, el guión y el apóstrofo, así como otros símbolos no alfanuméricos, vienen antes de caracteres alfanuméricos.

Estas opciones establecen entre mayúsculas y minúsculas o la necesidad de omitir tipos de caracteres.

.NET Framework utiliza tres formas diferentes de ordenar: ordenación, ordenación por cadena y ordenación ordinal de word. Ordenación de palabras realiza una comparación dependiente de la referencia cultural de cadenas. Algunos caracteres no alfanuméricos pueden tener pesos especiales asignados. 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. Ordenación por cadena es similar a la ordenación por palabra, salvo que no hay casos especiales. Por lo tanto, todos los símbolos alfanuméricos preceden a todos los caracteres alfanuméricos. Ordenación ordinal compara las cadenas basadas en los valores Unicode de cada elemento de la cadena.

El StringSort valor sólo puede utilizarse con CompareInfo.Compare y CompareInfo.GetSortKey. ArgumentException se produce si la StringSort valor se utiliza con CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, o CompareInfo.LastIndexOf.

System_CAPS_noteNota

Cuando sea posible, la aplicación debe utilizar los métodos de comparación de cadenas que aceptan un CompareOptions valor para especificar el tipo de comparación esperada. Como regla general, el uso de opciones lingüísticas (mediante la referencia cultural actual), y la seguridad, deben especificar las comparaciones sirve mejor las comparaciones de cara al usuario Ordinal o OrdinalIgnoreCase.

El siguiente ejemplo de código muestra cómo ordenar con StringSort difiere de la ordenación sin StringSort.

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

*/

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Silverlight
Disponible desde 2.0
Windows Phone Silverlight
Disponible desde 7.0
Windows Phone
Disponible desde 8.1
Volver al principio
Mostrar: