SortKey Třída

Definice

Představuje výsledek mapování řetězce na klíč řazení.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
Dědičnost
SortKey
Atributy

Příklady

Následující příklad porovnává řetězec "Llama" pomocí kultur "en-US" a "ES-ES" a tradiční jazykové verze "en-US" a "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.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 lze použít SortKey třídu pro zlepšení výkonu v aplikaci, která se při třídění a hledání velkého pole spoléhá na značné množství.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. Příklad vytvoří neuspořádané pole názvů, které v tomto případě má 13 prvků.The example creates an unordered array of names, which in this case has 13 elements. Pak uloží klíč řazení každého názvu v paralelním poli, které předává Array.Sort(Array, Array) metodě.It then stores the sort key of each name in a parallel array, which it passes to the Array.Sort(Array, Array) method. Výsledkem je seřazené pole.The result is a sorted array. Příklad následně vyhledá pole pro tři řetězce.The example then searches the array for three strings. U každého hledaného řetězce volá CompareInfo.GetSortKey(String, CompareOptions) metodu pro načtení klíče řazení řetězce a potom Array.FindIndex zavolá metodu pro načtení indexu tohoto třídicího klíče v poli klíčů řazení.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. Vzhledem k tomu, že pole název a řazení klíčů jsou paralelní, vrácený index je také indexem názvu v names poli.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

Poznámky

Porovnání dvou řetězců závislé na jazykové verzi závisí na každém znaku v řetězcích s několika kategoriemi vah řazení, včetně znaků skriptu, abecedy, písmen a diakritiky.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. Klíč řazení slouží jako úložiště těchto vah pro určitý řetězec.A sort key serves as the repository of these weights for a particular string.

Metoda vrátí instanci SortKey třídy, která odráží mapování znaků závislých na jazykové verzi v zadaném řetězci. CompareInfo.GetSortKeyThe CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. Hodnota SortKey objektu je jeho klíčová data, která jsou vrácena KeyData vlastností.The value of a SortKey object is its key data, which is returned by the KeyData property. Tato klíčová data se skládají z řady bajtů, které kódují řetězec, pravidla pro řazení specifická pro jazykovou verzi a uživatelsky definované možnosti porovnání.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. Porovnání pomocí klíčů řazení se skládá z bitového porovnání odpovídajících klíčových dat v jednotlivých klíčích řazení.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. Například pokud vytvoříte klíč řazení voláním GetSortKey(String, CompareOptions) metody s CompareOptions.IgnoreCasehodnotou, operace porovnání řetězců, která používá klíč řazení, rozlišuje malá a velká písmena.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.

Po vytvoření klíče řazení pro řetězec porovnáte klíče řazení voláním statické SortKey.Compare metody.After you create a sort key for a string, you compare sort keys by calling the static SortKey.Compare method. Tato metoda provádí jednoduché porovnání po bajtech, takže je mnohem rychlejší než String.Compare metoda nebo. CompareInfo.CompareThis method performs a simple byte-by-byte comparison, so it is much faster than the String.Compare or CompareInfo.Compare method.

Poznámka

Můžete stáhnout tabulky váhy řazení, sadu textových souborů, které obsahují informace o znakových závaží používaných při operacích řazení a porovnávání pro operační systémy Windows, výchozí tabulka prvků kolace sady Unicode, řazení Tabulka váhy pro Linux a 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.

Důležité informace o výkonuPerformance considerations

Při provádění porovnání Compare řetězců poskytují metody a CompareInfo.Compare stejné výsledky, ale cílí na různé scénáře.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

Na vysoké úrovni CompareInfo.Compare Metoda generuje klíč řazení pro každý řetězec, provede porovnání a pak zahodí klíč řazení a vrátí výsledek porovná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. CompareInfo.Compare Metoda ale ve skutečnosti negeneruje celý klíč řazení pro provedení porovnání.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. Místo toho Metoda generuje klíčová data pro každý textový prvek (tj. Základní znak, náhradní pár nebo kombinování znakových sekvencí) v každém řetězci.Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. Metoda pak porovná klíčová data pro odpovídající textové prvky.The method then compares the key data for the corresponding text elements. Operace se ukončí, jakmile se určí konečný výsledek porovnání.The operation terminates as soon as the ultimate result of the comparison is determined. Informace klíče řazení jsou vypočítány, SortKey ale není vytvořen žádný objekt.Sort key information is computed, but no SortKey object is created. Tato strategie je ekonomicky náročná na výkon, pokud jsou oba řetězce porovnány, ale jsou nákladné, pokud jsou stejné řetězce porovnány mnohokrát.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.

Metoda vyžaduje generování SortKey objektu pro každý řetězec před provedením porovnání. CompareThe Compare method requires generation of a SortKey object for each string before performing the comparison. Tato strategie je pro první porovnání náročná na výkon, a to z důvodu času a paměti, kterou investovalo k SortKey vygenerování objektů.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. To se ale bude ekonomicky přecházet, pokud se stejné klíče řazení budou porovnávat mnohokrát.However, it becomes economical if the same sort keys are compared many times.

Předpokládejme například, že píšete aplikaci, která vyhledává tabulku databáze pro řádek, ve kterém sloupec indexu založený na řetězci odpovídá zadanému hledanému řetězci.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. Tabulka obsahuje tisíce řádků a porovnávání vyhledávaného řetězce na index v jednotlivých řádcích bude trvat dlouhou dobu.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. Proto když aplikace uloží řádek a jeho indexový sloupec, vygeneruje a uloží také klíč řazení pro index ve sloupci vyhrazeném pro zlepšení výkonu hledání.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. Když aplikace vyhledá cílový řádek, porovná klíč řazení pro hledaný řetězec s klíčem řazení pro řetězec indexu místo porovnání hledaného řetězce s řetězcem indexu.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.

Důležité informace o zabezpečeníSecurity considerations

Metoda vrátí objekt s hodnotou založenou na zadaném řetězci a CompareOptions hodnotě a jazykové verzi přidružené k základnímu CompareInfo objektu. SortKey CompareInfo.GetSortKey(String, CompareOptions)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. Pokud rozhodnutí o zabezpečení závisí na porovnání řetězců nebo změně velikosti písmen, 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.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.

Klíč řazení můžete získat pomocí následujících kroků:Use the following steps to obtain a sort key:

  1. Načtěte od CultureInfo.InvariantCulture vlastnosti invariantní jazykovou verzi.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Načtěte CultureInfo.CompareInfo objekt pro invariantní jazykovou verzi z vlastnosti. CompareInfoRetrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

  3. Volání CompareInfo.GetSortKey(String, CompareOptions) metody.Call the CompareInfo.GetSortKey(String, CompareOptions) method.

Práce s hodnotou SortKey objektu je ekvivalentní volání metody Windows LCMapString se zadanou hodnotou LCMAP_SORTKEY.Working with the value of a SortKey object is equivalent to calling the Windows LCMapString method with the LCMAP_SORTKEY value specified. Pro SortKey objekt ale klíče řazení pro anglické znaky předcházejí klíčům řazení pro korejské znaky.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKeyobjekty mohou být serializovány, ale pouze tak, aby mohly AppDomain více objektů.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Pokud aplikace serializace SortKey objektu, musí aplikace znovu vygenerovat všechny klíče řazení, pokud je k dispozici nová verze .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.

Další informace o klíčích pro řazení najdete v části Unicode Technical Standard #10, "algoritmus kolace Unicode" na webu Unicode Consortium.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

Vlastnosti

KeyData

Získá pole bajtů představující aktuální SortKey objekt.Gets the byte array representing the current SortKey object.

OriginalString

Získá původní řetězec použitý k vytvoření aktuálního SortKey objektu.Gets the original string used to create the current SortKey object.

Metody

Compare(SortKey, SortKey)

Porovná dva klíče řazení.Compares two sort keys.

Equals(Object)

Určuje, zda je zadaný objekt stejný jako aktuální SortKey objekt.Determines whether the specified object is equal to the current SortKey object.

GetHashCode()

Slouží jako funkce hash pro aktuální SortKey objekt, který je vhodný pro algoritmy hash a datové struktury, jako je zatřiďovací tabulka.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()

Type Získá aktuální instanci.Gets the Type of the current instance.

(Zděděno od Object)
MemberwiseClone()

Vytvoří kopii aktuálního Objectseznamu.Creates a shallow copy of the current Object.

(Zděděno od Object)
ToString()

Vrátí řetězec, který představuje aktuální SortKey objekt.Returns a string that represents the current SortKey object.

Platí pro

Viz také