Exportar (0) Imprimir
Expandir todo
Este artículo proviene de un motor de traducción automática. Mueva el puntero sobre las frases del artículo para ver el texto original. Más información.
Traducción
Original

SortKey (Clase)

Representa el resultado de asignar una cadena a su criterio de ordenación.

System.Object
  System.Globalization.SortKey

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

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class SortKey

El tipo SortKey expone los siguientes miembros.

  NombreDescripción
Propiedad públicaKeyDataObtiene la matriz de bytes que representa el objeto SortKey actual.
Propiedad públicaOriginalStringObtiene la cadena original utilizada para crear el objeto SortKey actual.
Arriba

  NombreDescripción
Método públicoMiembro estáticoCompareCompara dos claves de ordenación.
Método públicoEqualsDetermina si el objeto especificado es igual al objeto SortKey actual. (Invalida a Object.Equals(Object)).
Método protegidoFinalize Permite que un objeto intente liberar recursos y realizar otras operaciones de limpieza antes de ser reclamado por la recolección de elementos no utilizados. (Se hereda de Object).
Método públicoGetHashCodeSirve como función hash para el objeto SortKey actual que es adecuado para los algoritmos hash y las estructuras de datos, como una tabla hash. (Invalida a Object.GetHashCode()).
Método públicoGetType Obtiene el Typede la instancia actual. (Se hereda de Object).
Método protegidoMemberwiseClone Crea una copia superficial del Object actual. (Se hereda de Object).
Método públicoToStringDevuelve una cadena que representa el actual objeto SortKey. (Invalida a Object.ToString()).
Arriba

Una comparación de dos cadenas en la que se tiene en cuenta la referencia cultural depende de si cada carácter de las cadenas tiene varias categorías de prioridad de ordenación, entre las que se incluyen el tipo de alfabeto, el orden alfabético, el uso de mayúsculas y minúsculas y los signos diacríticos. Una clave de ordenación sirve como repositorio de estas categorías para una determinada cadena. El valor de un objeto de SortKey es los datos clave, que es una serie de bytes que codifiquen la cadena, las reglas cultura- específicas de ordenación, y opciones definidas por el usuario de la comparación. Una comparación en la que se utilizan criterios de ordenación está compuesta por una comparación bit a bit de los datos clave correspondientes en cada criterio de ordenación.

El método de CompareInfo.GetSortKey devuelve una instancia de la clase de SortKey que refleja la asignación cultura- confidencial de caracteres de una cadena especificada. La propiedad de SortKey.KeyData criterio de ordenación es una matriz de bytes que contiene los datos del criterio de ordenación y refleja las convenciones de la referencia cultural actual y las CompareOptions definido por el usuario especificado cuando se crea la clave. Por ejemplo, si crea un criterio de ordenación llamando al método de GetSortKey(String, CompareOptions) con un valor de CompareOptions.IgnoreCase, una comparación de cadenas que utiliza el criterio de ordenación no distingue entre mayúsculas y minúsculas.

Después de crear un criterio de ordenación para una cadena, comparará criterios de ordenación llamando al método estático de SortKey.Compare . Este método realiza una comparación simple de byte-por- byte, por lo que es mucho más rápido que el método de String.Compare o de CompareInfo.Compare .

Consideraciones sobre el rendimiento

Al realizar una comparación de cadenas, Compare y los métodos de CompareInfo.Compare generan los mismos resultados, pero los diferentes escenarios de destino.

En efecto, el método de CompareInfo.Compare genera el criterio de ordenación para cada cadena, realiza la comparación, y a continuación descarta el criterio de ordenación y devuelve el resultado de la comparación. Sin embargo, el método de CompareInfo.Compare no genera un criterio de ordenación completo para realizar la comparación. En su lugar, el método genera los datos clave para cada elemento de texto (es decir, carácter base, un par suplente, o combinar secuencia de caracteres) en cada cadena. Después el método compara los datos de clave de los elementos de texto correspondientes. La operación finaliza en cuanto se determina el resultado final de la comparación. Se procesa la información de los criterios de ordenación, pero no se crea ningún objeto SortKey. Esta estrategia es económica en lo que se refiere a rendimiento si las cadenas sólo se comparan una vez, pero consume muchos recursos si se comparan las mismas cadenas varias veces.

El método Compare necesita la generación de un objeto SortKey por cada cadena antes de realizar la comparación. Esta estrategia es cara en términos de rendimiento para la primera comparación debido al tiempo y la memoria invertidos en la generación de los objetos SortKey. Sin embargo, se convierte en barata si los mismos criterios de ordenación se comparan muchas veces.

Por ejemplo, suponga que escribe una aplicación que busca en una tabla de base de datos la fila cuya columna de índice basada en cadena coincide con una cadena de búsqueda especificada. La tabla contiene miles de filas, por lo que la comparación de la cadena de búsqueda con el índice de cada fila tardará mucho tiempo. Por tanto, cuando la aplicación almacene una fila y su columna de índice, también genera y almacena el criterio de ordenación del índice en una columna específica para mejorar el rendimiento de la búsqueda. Cuando la aplicación busque una fila de destino, comparará el criterio de ordenación de la cadena de búsqueda con el criterio de ordenación de la cadena del índice, en lugar de comparar la cadena de búsqueda con la de índice.

Consideraciones de seguridad

El método CompareInfo.GetSortKey(String, CompareOptions) devuelve un objeto SortKey cuyo valor se basa en una cadena especificada y el valor CompareOptions y la referencia cultural asociada al objeto CompareInfo subyacente. Si una decisión de seguridad depende de una comparación de cadenas o cambio de caso, debe utilizar el método de CompareInfo.GetSortKey(String, CompareOptions) de la referencia cultural invariable para garantizar que el comportamiento de la operación es coherente, independientemente de la configuración de la referencia cultural del sistema operativo.

Realice los pasos siguientes para obtener un criterio de ordenación:

  1. Recupere la referencia cultural invariable de la propiedad de CultureInfo.InvariantCulture .

  2. Recupera un objeto de CompareInfo para la referencia cultural invariable de la propiedad de CultureInfo.CompareInfo .

  3. Llame al método CompareInfo.GetSortKey(String, CompareOptions).

Trabajar con el valor de un objeto de SortKey equivale a llamar al método de Windows LCMapString con el valor de LCMAP_SORTKEY especificado. No obstante, para el objeto SortKey, los criterios de ordenación de los caracteres ingleses se anteponen a los criterios de ordenación de los caracteres coreanos.

Se pueden serializar los objetos SortKey, pero solo para que puedan cruzar objetos AppDomain. Si una aplicación serializa un objeto de SortKey , la aplicación debe volver a generar todos los criterios de ordenación cuando hay una nueva versión de .NET Framework.

Para obtener más información sobre los criterios de ordenación, vea el estándar #10 Unicode Técnico, “algoritmo de intercalación Unicode” en Sitio Web de Unicode Consortium.

El ejemplo siguiente se compara la cadena “llamada” utilizando “en-us” y referencias culturales “es- ES”, y “en-us” y referencias culturales tradicionales “es- ES”.


using System;
using System.Globalization;

public class SamplesSortKey  {

   public static void Main()  {

      // Creates a SortKey using the en-US culture.
      CompareInfo myComp_enUS = new CultureInfo("en-US",false).CompareInfo;
      SortKey mySK1 = myComp_enUS.GetSortKey( "llama" );

      // Creates a SortKey using the es-ES culture with international sort.
      CompareInfo myComp_esES = new CultureInfo("es-ES",false).CompareInfo;
      SortKey mySK2 = myComp_esES.GetSortKey( "llama" );

      // Creates a SortKey using the es-ES culture with traditional sort.
      CompareInfo myComp_es   = new CultureInfo(0x040A,false).CompareInfo;
      SortKey mySK3 = myComp_es.GetSortKey( "llama" );

      // Compares the en-US SortKey with each of the es-ES SortKey objects.
      Console.WriteLine( "Comparing \"llama\" in en-US and in es-ES with international sort : {0}", SortKey.Compare( mySK1, mySK2 ) );
      Console.WriteLine( "Comparing \"llama\" in en-US and in es-ES with traditional sort   : {0}", SortKey.Compare( mySK1, mySK3 ) );

   }

}

/*
This code produces the following output.

Comparing "llama" in en-US and in es-ES with international sort : 0
Comparing "llama" in en-US and in es-ES with traditional sort   : -1
*/



El ejemplo siguiente muestra cómo utilizar la clase de SortKey para mejorar el rendimiento en una aplicación que confíe ampliamente en la ordenación y buscar una matriz grande. El ejemplo crea una matriz desordenado de nombres, que en este caso tiene 13 elementos. A continuación almacena el criterio de ordenación de cada nombre de una matriz paralelo, que pasa a Array.Sort(Array, Array) el método. El resultado es un matriz ordenada. En el ejemplo se busca la matriz de tres cadenas. Para cada cadena de búsqueda, llama al método de CompareInfo.GetSortKey(String, CompareOptions) para recuperar el criterio de ordenación de la cadena, y después llamar al método de Array.FindIndex para recuperar el índice de ese criterio de ordenación en la matriz de criterios de ordenación. Dado que las matrices de nombre y criterio de ordenación son paralelas, el índice devuelto también es el índice del nombre de la matriz de names .


using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      // Define names.
      String[] names= { "Adam", "Ignatius", "Batholomew", "Gregory", 
                        "Clement", "Frances", "Harold", "Dalmatius", 
                        "Edgar", "John", "Benedict", "Paul", "George" }; 
      SortKey[] sortKeys = new SortKey[names.Length];
      CompareInfo ci = CultureInfo.CurrentCulture.CompareInfo;

      for (int ctr = 0; ctr < names.Length; ctr++)
         sortKeys[ctr] = ci.GetSortKey(names[ctr], CompareOptions.IgnoreCase);         

      // Sort array based on value of sort keys.
      Array.Sort(names, sortKeys);

      Console.WriteLine("Sorted array: ");
      foreach (var name in names)
         Console.WriteLine(name);

      Console.WriteLine();

      String[] namesToFind = { "Paul", "PAUL", "Wilberforce" };

      Console.WriteLine("Searching an array:");
      foreach (var nameToFind in namesToFind) {
         SortKey searchKey = ci.GetSortKey(nameToFind, CompareOptions.IgnoreCase);
         int index = Array.FindIndex(sortKeys, (x) => x.Equals(searchKey)); 
         if (index >= 0)
            Console.WriteLine("{0} found at index {1}: {2}", nameToFind,
                              index, names[index]);
         else
            Console.WriteLine("{0} not found", nameToFind);
      } 
   }
}
// The example displays the following output:
//       Sorted array:
//       Adam
//       Batholomew
//       Benedict
//       Clement
//       Dalmatius
//       Edgar
//       Frances
//       George
//       Gregory
//       Harold
//       Ignatius
//       John
//       Paul
//       
//       Searching an array:
//       Paul found at index 12: Paul
//       PAUL found at index 12: Paul
//       Wilberforce not found


.NET Framework

Compatible con: 4.5.2, 4.5.1, 4.5, 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Compatible con: 4, 3.5 SP1

Windows Phone 8.1, Windows Phone 8, Windows 8.1, Windows Server 2012 R2, Windows 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (no se admite el rol Server Core), Windows Server 2008 R2 (se admite el rol Server Core con SP1 o versiones posteriores; no se admite Itanium)

.NET Framework no admite todas las versiones de todas las plataformas. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

Todos los miembros static (Shared en Visual Basic) públicos de este tipo son seguros para la ejecución de subprocesos. No se garantiza que los miembros de instancias sean seguros para la ejecución de subprocesos.

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft