SortKey Classe

Definição

public ref class SortKey sealed

public ref class SortKey

public sealed class SortKey

public class SortKey

[System.Serializable]
public class SortKey

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class SortKey

type SortKey = class

[<System.Serializable>]
type SortKey = class

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type SortKey = class

Public NotInheritable Class SortKey

Public Class SortKey

Herança

Object

SortKey

Atributos

SerializableAttribute ComVisibleAttribute

Exemplos

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

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

O exemplo a seguir mostra como você pode usar a classe para melhorar o SortKey desempenho em um aplicativo que depende extensivamente da classificação e pesquisa de uma grande matriz. O exemplo cria uma matriz não ordenada de nomes, que nesse caso tem 13 elementos. Em seguida, armazena a chave de classificação de cada nome em uma matriz paralela, que passa para o Sort(Array, Array) método. O resultado é uma matriz classificada. Em seguida, o exemplo pesquisa a matriz em busca de três cadeias de caracteres. Para cada cadeia de caracteres de pesquisa, ele chama o GetSortKey(String, CompareOptions) método para recuperar a chave de classificação da cadeia de caracteres e, em seguida, chama o Array.FindIndex método para recuperar o índice dessa chave de classificação na matriz de chaves de classificação. Como as matrizes de nome e de chave de classificação são paralelas, o índice retornado também é o índice do nome na names matriz.

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 nas cadeias de caracteres com várias categorias de pesos de classificação, incluindo pesos de script, alfabéticos, maiúsculas e minúsculas e diacríticos. Uma chave de classificação serve como repositório desses pesos para uma cadeia de caracteres específica.

O método CompareInfo.GetSortKey retorna uma instância da classe SortKey que reflete o mapeamento de caracteres sensível à cultura em uma string especificada. O valor de um SortKey objeto são seus dados de chave, que são retornados pela KeyData propriedade. Esses dados principais consistem em uma série de bytes que codificam a cadeia de caracteres, regras de classificação específicas da cultura e opções de comparação especificadas pelo usuário. Uma comparação usando chaves de classificação consiste em uma comparação bit a bit dos dados de chave correspondentes em cada chave de classificação. Por exemplo, se você criar uma chave de classificação chamando o método GetSortKey(String, CompareOptions) com um valor de CompareOptions.IgnoreCase, uma operação de comparação de cadeia de caracteres que usa a chave de classificação não diferencia maiúsculas de minúsculas.

Depois de criar uma chave de classificação para uma cadeia de caracteres, você compara as chaves de classificação chamando o método estático SortKey.Compare . Esse método executa uma comparação simples byte a byte, portanto, é muito mais rápido do que o método String.Compare ou CompareInfo.Compare.

Considerações sobre desempenho

Ao executar uma comparação de cadeia de caracteres, os métodos Compare e CompareInfo.Compare produzem os mesmos resultados, mas eles visam cenários diferentes.

Em um nível alto, 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. No entanto, o CompareInfo.Compare método realmente não gera uma chave de classificação inteira para executar a comparação. 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. Em seguida, o método compara os dados de chave para os elementos de texto correspondentes. A operação é encerrada assim que o resultado final da comparação é determinado. As informações de chave de classificação são computadas, mas nenhum SortKey objeto é criado. Essa estratégia é econômica em termos de desempenho se ambas as cadeias de caracteres forem comparadas uma vez, mas se tornar caro se as mesmas cadeias de caracteres forem comparadas muitas vezes.

O Compare método requer a geração de um SortKey objeto para cada cadeia de caracteres antes de executar a comparação. Essa estratégia é cara em termos de desempenho para a primeira comparação devido ao tempo e à memória investidas para gerar os SortKey objetos. No entanto, ele se tornará econômico se as mesmas chaves de classificação forem comparadas muitas vezes.

Por exemplo, suponha que você escreva um aplicativo que pesquisa uma tabela de banco de dados para a linha na qual a coluna de índice baseada em cadeia de caracteres corresponde a uma cadeia de caracteres de pesquisa especificada. A tabela contém milhares de linhas e comparar a cadeia de caracteres de pesquisa com o índice em cada linha levará muito tempo. Portanto, quando o aplicativo armazena uma linha e sua coluna de índice, ele também gera e armazena a chave de classificação do índice em uma coluna dedicada a melhorar o desempenho da pesquisa. Quando o aplicativo procura uma linha de destino, ele compara a chave de classificação da cadeia de caracteres de pesquisa com a chave de classificação da cadeia de caracteres de índice, em vez de comparar a cadeia de caracteres de pesquisa com a cadeia de caracteres de índice.

Considerações de segurança

O método CompareInfo.GetSortKey(String, CompareOptions) retorna um objeto SortKey com o valor baseado em uma cadeia de caracteres especificada e o valor CompareOptions, e na cultura associada ao objeto subjacente CompareInfo. Se uma decisão de segurança depender de uma comparação de cadeia de caracteres ou alteração de caso, você deverá usar o CompareInfo.GetSortKey(String, CompareOptions) método da cultura invariável para garantir que o comportamento da operação seja consistente, independentemente das configurações de cultura do sistema operacional.

Use as seguintes etapas para obter uma chave de classificação:

1. Recupere a cultura invariável da propriedade CultureInfo.InvariantCulture.

2. Recupere um objeto CompareInfo para a cultura invariável da propriedade CultureInfo.CompareInfo.

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

Trabalhar com o valor de um SortKey objeto é equivalente a chamar o método Windows LCMapString com o valor LCMAP_SORTKEY especificado. No entanto, para o SortKey objeto, as chaves de classificação para caracteres em inglês precedem as chaves de classificação para caracteres coreanos.

SortKey objetos podem ser serializados, mas somente para que possam atravessar objetos AppDomain. Se um aplicativo serializar um SortKey objeto, o aplicativo deverá regenerar todas as chaves de classificação quando houver uma nova versão do .NET.

Para obter mais informações sobre chaves de classificação, consulte Unicode Technical Standard #10, "Algoritmo de ordenação Unicode" no site do Consórcio Unicode.

Confira também

• GetSortKey(String, CompareOptions)
• KeyData