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 seguinte compara a cadeia "llama" 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 seguinte mostra como pode usar a SortKey classe para melhorar o desempenho numa aplicação que depende extensivamente de ordenar e pesquisar um grande array. O exemplo cria um array não ordenado de nomes, que neste caso tem 13 elementos. Depois, armazena a chave de ordenação de cada nome num array paralelo, que passa para o Sort(Array, Array) método. O resultado é um array ordenado. O exemplo procura então três cadeias no array. Para cada cadeia de pesquisa, chama o GetSortKey(String, CompareOptions) método para recuperar a chave de ordenação da cadeia e depois chama o Array.FindIndex método para recuperar o índice dessa chave de ordenação no array de chaves de ordenação. Como os arrays de nomes e chaves de ordenação são paralelos, o índice devolvido é também o índice do nome no 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

Observações

Uma comparação sensível à cultura de duas cadeias de caracteres depende de cada caractere ter várias categorias de pesos de classificação, incluindo pesos de escrita, alfabéticos, de maiúsculas e minúsculas e de diacríticos. Uma chave de classificação serve como o 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 sensível à cultura de caracteres numa string especificada. O valor de um SortKey objeto é os seus dados-chave, que são retornados pela propriedade KeyData. Esses dados de chave 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 criar uma chave de ordenação chamando o método GetSortKey(String, CompareOptions) com um valor de CompareOptions.IgnoreCase, uma operação de comparação que usa a chave de ordenação é insensível a maiúsculas e 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 . Este método executa uma comparação simples byte-a-byte, por isso é 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 Compare métodos e CompareInfo.Compare produzem os mesmos resultados, mas 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 sequência de caracteres combinada) em cada cadeia de caracteres. Em seguida, o método compara os dados de chave para os elementos de texto correspondentes. A operação termina assim que o resultado final da comparação é determinado. As informações da chave de classificação são calculadas, mas nenhum SortKey objeto é criado. Essa estratégia é econômica em termos de desempenho se ambas as strings forem comparadas uma vez, mas se torna cara se as mesmas strings 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. Esta estratégia é cara em termos de desempenho para a primeira comparação devido ao tempo e memória investidos para gerar os SortKey objetos. No entanto, torna-se 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 pesquisa especificada. A tabela contém milhares de linhas, e comparar a cadeia 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 para o í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 para a cadeia de caracteres de pesquisa com a chave de classificação para a 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 string especificada e no 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 maiúsculas e minúsculas, você deverá usar o CompareInfo.GetSortKey(String, CompareOptions) método da cultura invariante 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 invariante da propriedade CultureInfo.InvariantCulture.

2. Recupere um objeto da cultura invariante da propriedade CompareInfo a partir de 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 ingleses precedem as chaves de classificação para caracteres coreanos.

SortKey Os objetos podem ser serializados, mas apenas para que possam cruzar AppDomain objetos. Se um aplicativo serializa um SortKey objeto, o aplicativo deve 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, "Unicode Collation Algorithm" no site do Unicode Consortium.

Ver também

• GetSortKey(String, CompareOptions)
• KeyData