SortKey Třída

Definice

Obor názvů:

System.Globalization

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

SortKey.cs

Představuje výsledek mapování řetězce na jeho klíč řazení.

public ref class SortKey sealed

public sealed class SortKey

type SortKey = class

Public NotInheritable Class SortKey

Dědičnost

Object

SortKey

Příklady

Následující příklad porovnává řetězec "llama" pomocí "en-US" a "es-ES" jazykové verze a "en-US" a "es-ES" tradiční jazykové verze.

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

Následující příklad ukazuje, jak můžete pomocí SortKey třídy zlepšit výkon v aplikaci, která spoléhá na rozsáhlé řazení a vyhledávání ve velkém poli. Příklad vytvoří neseřazené pole názvů, které v tomto případě obsahuje 13 prvků. Potom uloží klíč řazení každého názvu do paralelního pole, které předává metodě Sort(Array, Array) . Výsledkem je seřazené pole. Příklad pak prohledá pole pro tři řetězce. Pro každý hledaný řetězec volá metodu GetSortKey(String, CompareOptions) pro načtení klíče řazení řetězce a potom volá metodu Array.FindIndex pro načtení indexu tohoto klíče řazení v poli klíčů řazení. Vzhledem k tomu, že pole názvů a klíčů řazení jsou paralelní, vrácený index je také index názvu v names poli.

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

Poznámky

Porovnání dvou řetězců citlivé na kulturní kontext závisí na tom, že každý znak v řetězcích má několik kategorií váh pro třídění, včetně skriptů, abecedních, případových a diakritických vah. Klíč řazení slouží jako úložiště těchto vah pro určitý řetězec.

Metoda CompareInfo.GetSortKey vrátí instanci SortKey třídy, která odráží jazykově závislé mapování znaků v zadaném řetězci. Hodnota objektu SortKey je jeho klíčová data, která je vrácena KeyData vlastností. Tato klíčová data se skládají z řady bajtů, které kódují řetězec, pravidla řazení specifická pro jazykovou verzi a možnosti porovnání zadané uživatelem. Porovnání pomocí klíčů řazení se skládá z bitového porovnání odpovídajících dat klíče v každém klíči řazení. Pokud například vytvoříte klíč řazení voláním GetSortKey(String, CompareOptions) metody s hodnotou CompareOptions.IgnoreCase, operace porovnání řetězců, která používá klíč řazení, nerozlišuje malá a velká písmena.

Po vytvoření klíče řazení pro řetězec porovnáte klíče řazení voláním statické SortKey.Compare metody. Tato metoda provádí jednoduché porovnání bajt po bajtu, takže je mnohem rychlejší než metoda String.Compare nebo CompareInfo.Compare.

Note

Můžete si stáhnout tabulky hmotnosti řazení, sadu textových souborů, které obsahují informace o váhách znaků používaných při řazení a porovnávání operací pro operační systémy Windows, výchozí tabulka prvků kolace Unicode, tabulka hmotnosti řazení pro Linux a macOS.

Důležité informace o výkonu

Při porovnávání řetězců poskytují metody Compare a CompareInfo.Compare stejné výsledky, ale cílí na různé scénáře.

Na vysoké úrovni CompareInfo.Compare metoda vygeneruje klíč řazení pro každý řetězec, provede porovnání a potom zahodí klíč řazení a vrátí výsledek porovnání. CompareInfo.Compare Metoda ale ve skutečnosti negeneruje celý klíč řazení k provedení porovnání. Místo toho metoda vygeneruje klíčová data pro každý textový prvek (tj. základní znak, náhradní dvojici nebo kombinování sekvence znaků) v každém řetězci. Metoda pak porovná klíčová data pro odpovídající textové prvky. Operace se ukončí, jakmile se určí konečný výsledek porovnání. Informace o klíči řazení se počítají, ale nevytvoří se žádný SortKey objekt. Tato strategie je z hlediska výkonu úsporná, pokud jsou oba řetězce porovnány jednou, ale stává se nákladnou, pokud jsou stejné řetězce porovnávány mnohokrát.

Metoda Compare vyžaduje generování objektu SortKey pro každý řetězec před provedením porovnání. Tato strategie je nákladná z hlediska výkonu při prvním porovnání z důvodu času a paměti investovaného do generování SortKey objektů. Nicméně, stává se ekonomické, pokud jsou stejné klíče řazení porovnávány mnohokrát.

Předpokládejme například, že napíšete aplikaci, která hledá v databázové tabulce řádek, ve kterém sloupec indexu založený na řetězci odpovídá zadanému vyhledávacímu řetězci. Tabulka obsahuje tisíce řádků a porovnání vyhledávacího řetězce s indexem v každém řádku bude trvat dlouhou dobu. Proto když aplikace uloží řádek a sloupec indexu, vygeneruje a uloží klíč řazení pro index ve sloupci vyhrazeném pro zlepšení výkonu vyhledávání. Když aplikace hledá cílový řádek, porovná klíč řazení pro hledaný řetězec s klíčem řazení pro indexový řetězec, místo aby porovnával hledaný řetězec s indexovým řetězcem.

Bezpečnostní aspekty

Metoda CompareInfo.GetSortKey(String, CompareOptions) vrátí SortKey objekt s hodnotou podle zadaného řetězce a CompareOptions hodnoty, a kultury spojené s podkladovým CompareInfo objektem. Pokud rozhodnutí o zabezpečení závisí na porovnání řetězců nebo změně případu, měli byste použít CompareInfo.GetSortKey(String, CompareOptions) metodu invariantní jazykové verze, abyste zajistili, že chování operace je konzistentní bez ohledu na nastavení jazykové verze operačního systému.

Pomocí následujícího postupu získejte klíč řazení:

1. Načtěte invariantní jazykovou verzi z vlastnosti CultureInfo.InvariantCulture.

2. CompareInfo Načtěte objekt pro invariantní jazykovou verzi z CultureInfo.CompareInfo vlastnosti.

3. Zavolejte metodu CompareInfo.GetSortKey(String, CompareOptions) .

Práce s hodnotou objektu SortKey je ekvivalentní volání metody Windows LCMapString se zadanou hodnotou LCMAP_SORTKEY. V případě objektu SortKey však klíče řazení pro anglické znaky předchází klíčům řazení pro korejské znaky.

SortKey objekty lze serializovat, ale pouze tak, aby mohly přecházet AppDomain mezi objekty. Pokud aplikace serializuje objekt SortKey, musí znovu vygenerovat všechny klíče řazení, pokud je k dispozici nová verze .NET.

Další informace o klíčích řazení naleznete v tématu Unicode Technical Standard #10, "Unicode Collation Algorithm" na webu Unicode Consortium.

Vlastnosti

Name	Description
KeyData	Získá bajt pole představující aktuální SortKey objekt.
OriginalString	Získá původní řetězec použitý k vytvoření aktuálního SortKey objektu.

Metody

Name	Description
Compare(SortKey, SortKey)	Porovná dva klíče řazení.
Equals(Object)	Určuje, zda je zadaný objekt roven aktuálnímu SortKey objektu.
GetHashCode()	Slouží jako hashovací funkce pro aktuální SortKey objekt, který je vhodný pro hashovací algoritmy a datové struktury, jako je například hashovací tabulka.
GetType()	Získá Type aktuální instance. (Zděděno od Object)
MemberwiseClone()	Vytvoří mělkou kopii aktuálního Object. (Zděděno od Object)
ToString()	Vrátí řetězec, který představuje aktuální SortKey objekt.

Viz také

• GetSortKey(String, CompareOptions)
• KeyData