SortKey Clase

Definición

Representa el resultado de asignar una cadena a su criterio de ordenación.Represents the result of mapping a string to its sort key.

public ref class SortKey
public class SortKey
[System.Serializable]
public class SortKey
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class SortKey
type SortKey = class
Public Class SortKey
Herencia
SortKey
Atributos

Ejemplos

En el ejemplo siguiente se compara la cadena "llamar" con las referencias culturales "en-US" y "es-ES", y las referencias culturales tradicionales "en-US" y "es-ES".The following example compares the string "llama" using the "en-US" and "es-ES" cultures, and the "en-US" and "es-ES" traditional cultures.

using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Creates a SortKey using the en-US culture.
   CultureInfo^ MyCI = gcnew CultureInfo( "en-US",false );
   CompareInfo^ myComp_enUS = MyCI->CompareInfo;
   SortKey^ mySK1 = myComp_enUS->GetSortKey( "llama" );
   
   // Creates a SortKey using the es-ES culture with international sort.
   MyCI = gcnew CultureInfo( "es-ES",false );
   CompareInfo^ myComp_esES = MyCI->CompareInfo;
   SortKey^ mySK2 = myComp_esES->GetSortKey( "llama" );
   
   // Creates a SortKey using the es-ES culture with traditional sort.
   MyCI = gcnew CultureInfo( 0x040A,false );
   CompareInfo^ myComp_es = MyCI->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 S"llama" in en-US and in es-ES with international sort : 0
Comparing S"llama" in en-US and in es-ES with traditional sort   : -1
*/
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
*/

Imports System.Globalization

Public Class SamplesSortKey

   Public Shared Sub Main()

      ' Creates a SortKey using the en-US culture.
      Dim myComp_enUS As CompareInfo = New CultureInfo("en-US", False).CompareInfo
      Dim mySK1 As SortKey = myComp_enUS.GetSortKey("llama")

      ' Creates a SortKey using the es-ES culture with international sort.
      Dim myComp_esES As CompareInfo = New CultureInfo("es-ES", False).CompareInfo
      Dim mySK2 As SortKey = myComp_esES.GetSortKey("llama")

      ' Creates a SortKey using the es-ES culture with traditional sort.
      Dim myComp_es As CompareInfo = New CultureInfo(&H40A, False).CompareInfo
      Dim mySK3 As SortKey = 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))

   End Sub

End Class


'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

En el ejemplo siguiente se muestra cómo puede utilizar la clase SortKey para mejorar el rendimiento en una aplicación que se basa en gran medida en la ordenación y búsqueda de una matriz grande.The following example shows how you can use the SortKey class to improve performance in an application that relies extensively on sorting and searching a large array. En el ejemplo se crea una matriz de nombres sin ordenar, que en este caso tiene 13 elementos.The example creates an unordered array of names, which in this case has 13 elements. A continuación, almacena el criterio de ordenación de cada nombre en una matriz paralela, que pasa al método Array.Sort(Array, Array).It then stores the sort key of each name in a parallel array, which it passes to the Array.Sort(Array, Array) method. El resultado es una matriz ordenada.The result is a sorted array. A continuación, el ejemplo busca tres cadenas en la matriz.The example then searches the array for three strings. Para cada cadena de búsqueda, llama al método CompareInfo.GetSortKey(String, CompareOptions) para recuperar la clave de ordenación de la cadena y, a continuación, llama al método Array.FindIndex para recuperar el índice de esa clave de ordenación en la matriz de claves de ordenación.For each search string, it calls the CompareInfo.GetSortKey(String, CompareOptions) method to retrieve the string's sort key, and then calls the Array.FindIndex method to retrieve the index of that sort key in the array of sort keys. Dado que las matrices de nombre y de criterio de ordenación son paralelas, el índice devuelto también es el índice del nombre de la matriz names.Because the name and sort key arrays are parallel, the returned index is also the index of the name in the names array.

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
Imports System.Globalization

Module Example
   Public Sub Main()
      ' Define names.
      Dim names() As String = { "Adam", "Ignatius", "Batholomew", 
                                "Gregory", "Clement", "Frances",  
                                "Harold", "Dalmatius", "Edgar",    
                                "John", "Benedict", "Paul", "George" } 
      Dim sortKeys(names.Length - 1) As SortKey
      Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo

      For ctr As Integer = 0 To names.Length - 1
         sortKeys(ctr) = ci.GetSortKey(names(ctr), CompareOptions.IgnoreCase)         
      Next   
      
      ' Sort array based on value of sort keys.
      Array.Sort(names, sortKeys)
      
      Console.WriteLine("Sorted array: ")
      For Each name In names
         Console.WriteLine(name)
      Next          
      Console.WriteLine()
      
      Dim namesToFind() As String = { "Paul", "PAUL", "Wilberforce" }
      
      Console.WriteLine("Searching an array:")
      For Each nameToFind In namesToFind
         Dim searchKey As SortKey = ci.GetSortKey(nameToFind, CompareOptions.IgnoreCase)
         Dim index As Integer = Array.FindIndex(sortKeys, 
                                                Function(x) x.Equals(searchKey)) 
         If index >= 0 Then
            Console.WriteLine("{0} found at index {1}: {2}", nameToFind,
                              index, names(index))
         Else
            Console.WriteLine("{0} not found", nameToFind)
         End If                     
      Next                     
   End Sub
End Module
' 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

Comentarios

Una comparación dependiente de la referencia cultural de dos cadenas depende de cada carácter de las cadenas que tienen varias categorías de pesos de ordenación, incluidos los pesos de scripts, alfabéticos, de mayúsculas y minúsculas, y diacríticos.A culture-sensitive comparison of two strings depends on each character in the strings having several categories of sort weights, including script, alphabetic, case, and diacritic weights. Una clave de ordenación actúa como repositorio de estas ponderaciones para una cadena determinada.A sort key serves as the repository of these weights for a particular string.

El método CompareInfo.GetSortKey devuelve una instancia de la clase SortKey que refleja la asignación que tiene en cuenta la referencia cultural de los caracteres de una cadena especificada.The CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. El valor de un objeto SortKey son sus datos clave, devueltos por la propiedad KeyData.The value of a SortKey object is its key data, which is returned by the KeyData property. Estos datos clave se componen de una serie de bytes que codifican la cadena, las reglas de ordenación específicas de la referencia cultural y las opciones de comparación especificadas por el usuario.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. Una comparación con las claves de ordenación se compone de una comparación bit a bit de los datos de clave correspondientes en cada criterio de ordenación.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. Por ejemplo, si crea un criterio de ordenación llamando al método GetSortKey(String, CompareOptions) con un valor de CompareOptions.IgnoreCase, una operación de comparación de cadenas que utiliza la clave de ordenación no distingue entre mayúsculas y minúsculas.For example, if you create a sort key by calling the GetSortKey(String, CompareOptions) method with a value of CompareOptions.IgnoreCase, a string comparison operation that uses the sort key is case-insensitive.

Después de crear una clave de ordenación para una cadena, se comparan las claves de ordenación mediante una llamada al método estático de SortKey.Compare.After you create a sort key for a string, you compare sort keys by calling the static SortKey.Compare method. Este método realiza una comparación byte a byte simple, por lo que es mucho más rápido que el método String.Compare o CompareInfo.Compare.This method performs a simple byte-by-byte comparison, so it is much faster than the String.Compare or CompareInfo.Compare method.

Nota

Puede descargar las tablas de peso de ordenación, un conjunto de archivos de texto que contienen información sobre los pesos de caracteres utilizados en las operaciones de ordenación y comparación de los sistemas operativos Windows, la tabla del elemento de intercalación Unicode predeterminada, la tabla de peso de ordenación para Linux y MacOS.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

Consideraciones sobre el rendimientoPerformance considerations

Al realizar una comparación de cadenas, los métodos Compare y CompareInfo.Compare producen los mismos resultados, pero se destinan a escenarios diferentes.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

En un nivel alto, el método CompareInfo.Compare genera la clave de ordenación para cada cadena, realiza la comparación y, a continuación, descarta la clave de ordenación y devuelve el resultado de la comparación.At a high level, the CompareInfo.Compare method generates the sort key for each string, performs the comparison, and then discards the sort key and returns the result of the comparison. Sin embargo, el método CompareInfo.Compare realmente no genera una clave de ordenación completa para realizar la comparación.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. En su lugar, el método genera los datos de clave para cada elemento de texto (es decir, carácter base, par suplente o secuencia de caracteres de combinación) en cada cadena.Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. El método compara a continuación los datos de clave para los elementos de texto correspondientes.The method then compares the key data for the corresponding text elements. La operación finaliza en cuanto se determina el resultado final de la comparación.The operation terminates as soon as the ultimate result of the comparison is determined. Se calcula la información del criterio de ordenación, pero no se crea ningún objeto de SortKey.Sort key information is computed, but no SortKey object is created. Esta estrategia es económica en términos de rendimiento si ambas cadenas se comparan una vez, pero se vuelve costosa si se comparan muchas veces las mismas cadenas.This strategy is economical in terms of performance if both strings are compared once, but becomes expensive if the same strings are compared many times.

El método Compare requiere la generación de un objeto SortKey para cada cadena antes de realizar la comparación.The Compare method requires generation of a SortKey object for each string before performing the comparison. Esta estrategia es costosa en términos de rendimiento para la primera comparación debido al tiempo y la memoria invertidos en generar los objetos de SortKey.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. Sin embargo, es económico si se comparan muchas veces los mismos criterios de ordenación.However, it becomes economical if the same sort keys are compared many times.

Por ejemplo, supongamos que escribe una aplicación que busca en una tabla de base de datos la fila en la que la columna de índice basada en cadena coincide con una cadena de búsqueda especificada.For example, suppose you write an application that searches a database table for the row in which the string-based index column matches a specified search string. La tabla contiene miles de filas y la comparación de la cadena de búsqueda con el índice de cada fila tardará mucho tiempo.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. Por lo tanto, cuando la aplicación almacena una fila y su columna de índice, también genera y almacena el criterio de ordenación para el índice en una columna dedicada a la mejora del rendimiento de la búsqueda.Therefore, when the application stores a row and its index column, it also generates and stores the sort key for the index in a column dedicated to improving search performance. Cuando la aplicación busca una fila de destino, compara la clave de ordenación de la cadena de búsqueda con la clave de ordenación de la cadena de índice, en lugar de comparar la cadena de búsqueda con la cadena de índice.When the application searches for a target row, it compares the sort key for the search string to the sort key for the index string, instead of comparing the search string to the index string.

Consideraciones de seguridadSecurity considerations

El método CompareInfo.GetSortKey(String, CompareOptions) devuelve un objeto SortKey con el valor basado en una cadena y un valor CompareOptions especificados, y la referencia cultural asociada al objeto CompareInfo subyacente.The CompareInfo.GetSortKey(String, CompareOptions) method returns a SortKey object with the value based on a specified string and CompareOptions value, and the culture associated with the underlying CompareInfo object. Si una decisión de seguridad depende de una comparación de cadenas o de un cambio de mayúsculas y minúsculas, debe usar el método CompareInfo.GetSortKey(String, CompareOptions) de la referencia cultural de todos los idiomas para asegurarse de que el comportamiento de la operación es coherente, independientemente de la configuración de la referencia cultural del sistema operativo.If a security decision depends on a string comparison or case change, you should use the CompareInfo.GetSortKey(String, CompareOptions) method of the invariant culture to ensure that the behavior of the operation is consistent, regardless of the culture settings of the operating system.

Siga estos pasos para obtener una clave de ordenación:Use the following steps to obtain a sort key:

  1. Recupere la referencia cultural de todos los idiomas de la propiedad CultureInfo.InvariantCulture.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Recupere un objeto CompareInfo para la referencia cultural de todos los idiomas de la propiedad CultureInfo.CompareInfo.Retrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

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

Trabajar con el valor de un objeto SortKey es equivalente a llamar al método de LCMapString de Windows con el valor de LCMAP_SORTKEY especificado.Working with the value of a SortKey object is equivalent to calling the Windows LCMapString method with the LCMAP_SORTKEY value specified. Sin embargo, para el objeto SortKey, las teclas de ordenación para caracteres ingleses preceden a las claves de ordenación de los caracteres coreanos.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKey objetos se pueden serializar, pero solo para que puedan cruzar objetos AppDomain.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Si una aplicación serializa un objeto de SortKey, la aplicación debe volver a generar todas las claves de ordenación cuando haya una nueva versión de la .NET Framework.If an application serializes a SortKey object, the application must regenerate all the sort keys when there is a new version of the .NET Framework.

Para obtener más información acerca de las claves de ordenación, consulte Unicode Technical Standard #10, "algoritmo de intercalación Unicode" en el sitio web de Unicode Consortium.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

Propiedades

KeyData

Obtiene la matriz de bytes que representa el objeto SortKey actual.Gets the byte array representing the current SortKey object.

OriginalString

Obtiene la cadena original utilizada para crear el objeto SortKey actual.Gets the original string used to create the current SortKey object.

Métodos

Compare(SortKey, SortKey)

Compara dos claves de ordenación.Compares two sort keys.

Equals(Object)

Determina si el objeto especificado es igual al objeto SortKey actual.Determines whether the specified object is equal to the current SortKey object.

GetHashCode()

Sirve 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.Serves as a hash function for the current SortKey object that is suitable for hashing algorithms and data structures such as a hash table.

GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
ToString()

Devuelve una cadena que representa el actual objeto SortKey.Returns a string that represents the current SortKey object.

Se aplica a

Consulte también: