SortKey SortKey SortKey SortKey Class

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
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class SortKey
type SortKey = class
Public Class SortKey
Herencia
SortKeySortKeySortKeySortKey
Atributos

Ejemplos

El ejemplo siguiente compara la cadena "llama" utilizando "en-US" y referencias culturales "es-es" y las culturas 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
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 'Main 

End Class 'SamplesSortKey


'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 puede usar el SortKey clase para mejorar el rendimiento en una aplicación que depende en gran parte de una matriz grande de búsqueda y ordenación.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. El ejemplo crea una matriz no ordenada de nombres, 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 la clave de ordenación de cada nombre en una matriz paralela, que pasa a la Array.Sort(Array, Array) método.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. En el ejemplo, a continuación, busca en la matriz de tres cadenas.The example then searches the array for three strings. Para cada cadena de búsqueda, llama a la CompareInfo.GetSortKey(String, CompareOptions) método para recuperar la cadena clave de ordenación y, a continuación, llama a la Array.FindIndex método para recuperar el índice de esa clave de ordenación de 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 clave de nombre y la ordenación son paralelas, el índice devuelto también es el índice del nombre de la names matriz.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 de referencias culturales de dos cadenas depende de cada carácter en las cadenas de varias categorías de prioridad de ordenación, incluidos scripts, es un carácter alfabético, mayúsculas, 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. Un criterio de ordenación sirve como repositorio de estas categorías para una cadena determinada.A sort key serves as the repository of these weights for a particular string.

El CompareInfo.GetSortKey método devuelve una instancia de la SortKey clase que refleja la asignación de referencias culturales de caracteres en 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 SortKey objeto es sus datos clave, que es devuelto por la KeyData propiedad.The value of a SortKey object is its key data, which is returned by the KeyData property. Estos datos de claves constan de una serie de bytes que codificar la cadena, las reglas de ordenación específicas de referencias culturales y las opciones de comparación especificada 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 consta 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 una clave de ordenación mediante una llamada a la GetSortKey(String, CompareOptions) método con un valor de CompareOptions.IgnoreCase, una operación de comparación de cadenas que utiliza la clave de ordenación que distingue mayúsculas de 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 un criterio de ordenación para una cadena, comparar las claves de ordenación mediante una llamada a estático SortKey.Compare método.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 String.Compare o CompareInfo.Compare método.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 el tablas ordenación de peso, un conjunto de archivos de texto que contienen información acerca de las ponderaciones de caracteres utilizado en las operaciones de ordenación y comparación para los sistemas operativos de Windows, el Unicode predeterminado Tabla de elemento de intercalación, la tabla de peso 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, la Compare y CompareInfo.Compare métodos producen los mismos resultados, pero se dirigen a distintos escenarios.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 CompareInfo.Compare método genera la clave 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.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 CompareInfo.Compare método realmente no genera un criterio de ordenación completo 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 combinables) 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, a continuación, compara 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 de clave de ordenación, pero no SortKey se crea el objeto.Sort key information is computed, but no SortKey object is created. Esta estrategia es económica en términos de rendimiento si se comparan dos cadenas una vez, pero puede resultar caro si las cadenas se comparan muchas veces.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 Compare método requiere la generación de un SortKey objeto 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 memoria invertido para generar el SortKey objetos.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, resulta económico si las mismas claves de ordenación se comparan muchas veces.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 para la fila en la que la columna de índice basada en cadena coincide con una cadena de búsqueda especificado.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 comparar la cadena de búsqueda en 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 la clave de ordenación para el índice en una columna específica para mejorar el 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 para la cadena de búsqueda a la clave de ordenación para la cadena del índice, en lugar de comparar la cadena de búsqueda en 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 CompareInfo.GetSortKey(String, CompareOptions) método devuelve un SortKey objeto con el valor basado en una cadena especificada y CompareOptions valor y la referencia cultural asociada subyacente CompareInfo objeto.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 cambio de mayúsculas, debe usar el CompareInfo.GetSortKey(String, CompareOptions) método de la referencia cultural 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.

Para obtener una clave de ordenación, siga estos pasos:Use the following steps to obtain a sort key:

  1. Recuperar la referencia cultural de la CultureInfo.InvariantCulture propiedad.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Recuperar un CompareInfo objeto para la referencia cultural de la CultureInfo.CompareInfo propiedad.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 SortKey objeto es equivalente a llamar a la Windows LCMapString método con el valor 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 SortKey de objetos, las claves de ordenación para caracteres ingleses preceder 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 pueden ser serializado, pero solo por lo que pueden cruzar AppDomain objetos.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Si una aplicación serializa un SortKey de objeto, la aplicación debe volver a generar todas las claves de ordenación cuando hay una nueva versión de .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, vea Unicode Technical Standard #10, "Unicode Collation Algorithm" 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 KeyData KeyData KeyData

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

OriginalString OriginalString OriginalString 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) Compare(SortKey, SortKey) Compare(SortKey, SortKey) Compare(SortKey, SortKey)

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

Equals(Object) Equals(Object) Equals(Object) 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() GetHashCode() GetHashCode() 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() GetType() GetType() GetType()

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

(Inherited from Object)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
ToString() ToString() ToString() 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: