SortKey SortKey SortKey SortKey Class

Definição

Representa o resultado do mapeamento de uma cadeia de caracteres pela sua chave de classificação.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
Herança
SortKeySortKeySortKeySortKey
Atributos

Exemplos

O exemplo a seguir compara a cadeia de caracteres "llama" usando o "en-US" e culturas "es-ES" e as culturas tradicionais "en-US" e "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

O exemplo a seguir mostra como você pode usar o SortKey classe para melhorar o desempenho em um aplicativo que depende amplamente de classificação e pesquisa uma 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. O exemplo cria uma matriz não ordenada de nomes, que nesse caso, tem 13 elementos.The example creates an unordered array of names, which in this case has 13 elements. Em seguida, armazena a chave de classificação de cada nome em uma matriz paralela, que é passada para o 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. O resultado é uma matriz classificada.The result is a sorted array. O exemplo, em seguida, procura a matriz de três cadeias de caracteres.The example then searches the array for three strings. Para cada cadeia de caracteres de pesquisa, ele chama o CompareInfo.GetSortKey(String, CompareOptions) método para recuperar a cadeia de caracteres chave de classificação e, em seguida, chama o Array.FindIndex método para recuperar o índice dessa chave de classificação da matriz das chaves de classificação.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. Como as matrizes de chave de classificação e o nome são paralelas, o índice retornado também é o índice do nome no 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

Comentários

Uma comparação sensível à cultura de duas cadeias de caracteres depende de cada caractere em cadeias de caracteres tendo várias categorias de pesos de classificação, incluindo o script, em ordem alfabética, os pesos de maiusculas e minúsculas e 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. Uma chave de classificação funciona como repositório desses pesos para uma determinada cadeia de caracteres.A sort key serves as the repository of these weights for a particular string.

O CompareInfo.GetSortKey método retorna uma instância da SortKey classe que reflete o mapeamento de cultura de caracteres em uma cadeia de caracteres especificada.The CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. O valor de uma SortKey seus dados de chave, que são retornados do objeto é o KeyData propriedade.The value of a SortKey object is its key data, which is returned by the KeyData property. Esses dados de chave consistem em uma série de bytes que codificar a cadeia de caracteres, as regras de classificação específicas da cultura e opções de comparação especificada pelo usuário.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. Uma comparação usando chaves de classificação consiste em uma comparação bit a bit dos dados da chave correspondentes em cada chave de classificação.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. Por exemplo, se você criar uma chave de classificação, chamando o GetSortKey(String, CompareOptions) método com um valor de CompareOptions.IgnoreCase, uma operação de comparação de cadeia de caracteres que usa a chave de classificação diferencia maiusculas 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.

Depois de criar uma chave de classificação para uma cadeia de caracteres, comparar chaves de classificação chamando 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. Esse método executa uma comparação byte por byte simples, portanto, é muito mais rápido que o String.Compare ou 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.

Observação

Você pode baixar o tabelas de peso de classificação, um conjunto de arquivos de texto que contêm informações sobre os pesos de caractere usado em operações de classificação e comparação para os sistemas operacionais Windows, o padrão Unicode Tabela do elemento de agrupamento, a tabela de peso de classificação para Linux e 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.

Considerações sobre desempenhoPerformance considerations

Ao executar uma comparação de cadeia de caracteres, o Compare e CompareInfo.Compare métodos geram os mesmos resultados, mas eles se destinam a cenários diferentes.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

Em um alto nível, o CompareInfo.Compare método gera a chave de classificação para cada cadeia de caracteres, executa a comparação e, em seguida, descarta a chave de classificação e retorna o resultado da comparação.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. No entanto, o CompareInfo.Compare método, na verdade, não gera uma chave de classificação de inteiro para executar a comparação.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. Em vez disso, o método gera os dados de chave para cada elemento de texto (ou seja, caractere base, par substituto ou combinação de sequência de caracteres) em cada cadeia de caracteres.Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. O método, em seguida, compara os dados de chave para os elementos de texto correspondentes.The method then compares the key data for the corresponding text elements. A operação termina assim que o resultado final da comparação é determinado.The operation terminates as soon as the ultimate result of the comparison is determined. Informações de chave de classificação são computadas, mas nenhum SortKey objeto é criado.Sort key information is computed, but no SortKey object is created. Essa estratégia é econômica em termos de desempenho se ambas as cadeias de caracteres são comparadas de uma vez, mas se torna cara, se as mesmas cadeias de caracteres são comparadas muitas vezes.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.

O Compare método requer a geração de um SortKey objeto para cada cadeia de caracteres antes de executar a comparação.The Compare method requires generation of a SortKey object for each string before performing the comparison. Essa estratégia é cara em termos de desempenho para a comparação primeiro devido ao tempo e memória investido para gerar o 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. No entanto, ele se torna econômico se as mesmas chaves de classificação são comparadas muitas vezes.However, it becomes economical if the same sort keys are compared many times.

Por exemplo, suponha que você escreve um aplicativo que pesquisa uma tabela de banco de dados para a linha na qual a coluna de índice com base em cadeia de caracteres corresponde a uma cadeia de caracteres de pesquisa 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. A tabela contém milhares de linhas e comparar a cadeia de caracteres de pesquisa para o índice em cada linha levará um longo tempo.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. Portanto, quando o aplicativo armazena uma linha e sua coluna de índice, ele também gera e armazena a chave de classificação para o índice em uma coluna dedicada ao aprimoramento de desempenho da pesquisa.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. Quando o aplicativo procura por uma linha de destino, ele compara a chave de classificação para a cadeia de caracteres de pesquisa para a chave de classificação para a cadeia de caracteres de índice, em vez de comparar a cadeia de caracteres de pesquisa para a cadeia de caracteres do í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.

Considerações sobre segurançaSecurity considerations

O CompareInfo.GetSortKey(String, CompareOptions) método retorna um SortKey objeto com o valor com base em uma cadeia de caracteres especificada e CompareOptions valor e a cultura associada com subjacente 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. Se uma decisão de segurança depende de uma comparação de cadeia de caracteres ou a alteração de caso, você deve usar o CompareInfo.GetSortKey(String, CompareOptions) método da cultura invariável para garantir que o comportamento da operação é consistente, independentemente das configurações de cultura do sistema operacional.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.

Use as etapas a seguir para obter uma chave de classificação:Use the following steps to obtain a sort key:

  1. Recuperar a cultura invariável do CultureInfo.InvariantCulture propriedade.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Recuperar um CompareInfo objeto para a cultura invariável do CultureInfo.CompareInfo propriedade.Retrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

  3. Chame o método CompareInfo.GetSortKey(String, CompareOptions).Call the CompareInfo.GetSortKey(String, CompareOptions) method.

Trabalhando com o valor de uma SortKey objeto é equivalente a chamar o Windows LCMapString método com o 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. No entanto, para o SortKey do objeto, as chaves de classificação de caracteres em inglês precedem as chaves de classificação para caracteres coreanos.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKey objetos podem ser serializados, mas somente para que eles podem cruzar AppDomain objetos.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Se um aplicativo serializa um SortKey do objeto, o aplicativo deve gerar novamente as chaves de classificação quando há uma nova versão do .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 obter mais informações sobre chaves de classificação, consulte Unicode Technical Standard #10, "Algoritmo de agrupamento de Unicode" sobre o site do consórcio Unicode.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

Propriedades

KeyData KeyData KeyData KeyData

Obtém a matriz de bytes que representa o objeto SortKey atual.Gets the byte array representing the current SortKey object.

OriginalString OriginalString OriginalString OriginalString

Obtém a cadeia de caracteres original usada para criar o objeto SortKey atual.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 duas chaves de classificação.Compares two sort keys.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se o objeto especificado é igual ao objeto SortKey atual.Determines whether the specified object is equal to the current SortKey object.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funciona como uma função de hash para o objeto SortKey atual, adequada para algoritmos de hash e estruturas de dados, como uma tabela de 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()

Obtém o Type da instância atual.Gets the Type of the current instance.

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

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Inherited from Object)
ToString() ToString() ToString() ToString()

Retorna uma cadeia de caracteres que representa o objeto SortKey atual.Returns a string that represents the current SortKey object.

Aplica-se a

Veja também