SortKey SortKey SortKey SortKey Class

Definicja

Reprezentuje wynik mapowania ciągu do jego klucza sortowania.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
Dziedziczenie
SortKeySortKeySortKeySortKey
Atrybuty

Przykłady

Poniższy przykład porównuje ciąg "Llama" przy użyciu kultur "en-US" i "es-ES" oraz kultur "pl-US" i "es-ES" tradycyjnych kultury.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 '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

Poniższy przykład pokazuje, SortKey jak można użyć klasy w celu zwiększenia wydajności w aplikacji, która opiera się na sortowaniu i przeszukiwaniu dużej tablicy.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. Przykład tworzy tablicę nieuporządkowaną nazw, która w tym przypadku zawiera 13 elementów.The example creates an unordered array of names, which in this case has 13 elements. Następnie przechowuje klucz sortowania każdej nazwy w tablicy równoległej, który przechodzi do Array.Sort(Array, Array) metody.It then stores the sort key of each name in a parallel array, which it passes to the Array.Sort(Array, Array) method. Wynikiem jest posortowana tablica.The result is a sorted array. Przykład następnie przeszukuje tablicę pod kątem trzech ciągów.The example then searches the array for three strings. Dla każdego ciągu wyszukiwania wywołuje CompareInfo.GetSortKey(String, CompareOptions) metodę w celu pobrania klucza sortowania ciągu, a następnie Array.FindIndex wywołuje metodę, aby pobrać indeks tego klucza sortowania w tablicy kluczy sortowania.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. Ponieważ tablice Name i Sort Key są równoległe, zwracany indeks jest również indeksem nazwy w names tablicy.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

Uwagi

Porównanie wrażliwe na kulturę dwóch ciągów zależy od każdego znaku w ciągach z kilkoma kategoriami sortowania, w tym skryptu, litery, wielkości liter i znaków diakrytycznych.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. Klucz sortowania służy jako repozytorium tych wag dla określonego ciągu.A sort key serves as the repository of these weights for a particular string.

Metoda zwraca wystąpienie SortKey klasy odzwierciedlające zależne od kultury mapowanie znaków w określonym ciągu. CompareInfo.GetSortKeyThe CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. Wartość SortKey obiektu to jego kluczowe dane, które są zwracane KeyData przez właściwość.The value of a SortKey object is its key data, which is returned by the KeyData property. Te kluczowe dane składają się z serii bajtów, które kodują ciągi, reguły sortowania specyficzne dla kultury i opcje porównania określone przez użytkownika.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. Porównanie przy użyciu kluczy sortowania składa się z bitowego porównania odpowiednich danych klucza w każdym kluczu sortowania.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. Na przykład jeśli utworzysz klucz sortowania przez wywołanie GetSortKey(String, CompareOptions) metody z CompareOptions.IgnoreCasewartością, operacja porównywania ciągów, która używa klucza sortowania, nie uwzględnia wielkości liter.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 utworzeniu klucza sortowania dla ciągu należy porównać klucze sortowania przez wywołanie metody statycznej SortKey.Compare .After you create a sort key for a string, you compare sort keys by calling the static SortKey.Compare method. Ta metoda wykonuje proste porównanie bajtów po bajcie, więc jest znacznie szybsze niż w przypadku String.Compare metody lub. CompareInfo.CompareThis method performs a simple byte-by-byte comparison, so it is much faster than the String.Compare or CompareInfo.Compare method.

Uwaga

Można pobrać tabele wagi sortowania, zestaw plików tekstowych, które zawierają informacje o wagach znaków używanych w operacjach sortowania i porównywania dla systemów operacyjnych Windows, domyślną tabelę elementów sortowania Unicode, sortowanie tabela wag dla systemów Linux i 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.

Zagadnienia dotyczące wydajnościPerformance considerations

Podczas porównywania Compare ciągów metody i CompareInfo.Compare dają te same wyniki, ale są one ukierunkowane na różne scenariusze.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

Na wysokim poziomie CompareInfo.Compare Metoda generuje klucz sortowania dla każdego ciągu, wykonuje porównanie, a następnie odrzuca klucz sortowania i zwraca wynik porównania.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 Jednak Metoda faktycznie nie generuje całego klucza sortowania do przeprowadzenia porównania.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. Zamiast tego Metoda generuje dane klucza dla każdego elementu tekstowego (to jest, znak podstawowy, para zastępcza lub łącząc sekwencję znaków) w każdym ciągu.Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. Następnie metoda porównuje kluczowe dane dla odpowiadających im elementów tekstowych.The method then compares the key data for the corresponding text elements. Operacja kończy się zaraz po ustaleniu ostatecznego wyniku porównania.The operation terminates as soon as the ultimate result of the comparison is determined. Obliczane są informacje o kluczu sortowania, SortKey ale nie jest tworzony żaden obiekt.Sort key information is computed, but no SortKey object is created. Ta strategia jest ekonomiczna w zakresie wydajności, jeśli oba ciągi są porównywane jednokrotnie, ale staną się kosztowne, jeśli te same ciągi są porównywane wiele razy.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 wymaga wygenerowania SortKey obiektu dla każdego ciągu przed przeprowadzeniem porównania. CompareThe Compare method requires generation of a SortKey object for each string before performing the comparison. Ta strategia jest kosztowna pod względem wydajności podczas pierwszego porównania ze względu na czas i ilość pamięci zainwestowaną w SortKey celu wygenerowania obiektów.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. Jest jednak ekonomiczny, jeśli te same klucze sortowania są porównywane wiele razy.However, it becomes economical if the same sort keys are compared many times.

Załóżmy na przykład, że napiszesz aplikację, która przeszukuje tabelę bazy danych dla wiersza, w którym kolumna indeksu oparta na ciągach pasuje do określonego ciągu wyszukiwania.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. Tabela zawiera tysiące wierszy i porównanie ciągu wyszukiwania do indeksu w każdym wierszu zajmuje dużo czasu.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. W związku z tym, gdy aplikacja przechowuje wiersz i jego kolumnę indeksu, generuje i przechowuje klucz sortowania dla indeksu w kolumnie przeznaczonej do poprawiania wydajności wyszukiwania.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. Gdy aplikacja wyszukuje wiersz docelowy, porównuje klucz sortowania ciągu wyszukiwania z kluczem sortowania dla ciągu indeksu, zamiast porównywać ciąg wyszukiwania z ciągiem indeksu.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.

Zagadnienia dotyczące bezpieczeństwaSecurity considerations

Metoda zwraca obiekt z wartością na podstawie określonego ciągu i CompareOptions wartości oraz kulturę skojarzoną z obiektem źródłowym CompareInfo. CompareInfo.GetSortKey(String, CompareOptions) SortKeyThe 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. Jeśli decyzja dotycząca zabezpieczeń zależy od porównania ciągów lub zmiany wielkości liter, należy użyć CompareInfo.GetSortKey(String, CompareOptions) metody niezmiennej kultury, aby upewnić się, że zachowanie operacji jest spójne, niezależnie od ustawień kultury systemu operacyjnego.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.

Aby uzyskać klucz sortowania, wykonaj następujące kroki:Use the following steps to obtain a sort key:

  1. Pobierz niezmienną kulturę z CultureInfo.InvariantCulture właściwości.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Pobierz obiekt dla niezmiennej kultury CultureInfo.CompareInfo z właściwości. CompareInfoRetrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

  3. Wywołaj CompareInfo.GetSortKey(String, CompareOptions) metody.Call the CompareInfo.GetSortKey(String, CompareOptions) method.

Praca z wartością SortKey obiektu jest równoważna wywołaniu metody systemu Windows LCMapString z określoną wartością LCMAP_SORTKEY.Working with the value of a SortKey object is equivalent to calling the Windows LCMapString method with the LCMAP_SORTKEY value specified. Jednak dla SortKey obiektu klucze sortowania dla znaków w języku angielskim poprzedzają klucze sortowania dla znaków koreańskich.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKeyobiekty mogą być serializowane, ale tylko wtedy, gdy mogą AppDomain one zawierać wiele obiektów.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Jeśli aplikacja serializować SortKey obiekt, aplikacja musi ponownie wygenerować wszystkie klucze sortowania, gdy istnieje nowa wersja .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.

Aby uzyskać więcej informacji na temat kluczy sortowania, zobacz Standard Unicode Technical #10, "algorytmu sortowania Unicode" w witrynie internetowej konsorcjum Unicode.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

Właściwości

KeyData KeyData KeyData KeyData

Pobiera tablicę bajtową reprezentującą SortKey bieżący obiekt.Gets the byte array representing the current SortKey object.

OriginalString OriginalString OriginalString OriginalString

Pobiera oryginalny ciąg używany do tworzenia bieżącego SortKey obiektu.Gets the original string used to create the current SortKey object.

Metody

Compare(SortKey, SortKey) Compare(SortKey, SortKey) Compare(SortKey, SortKey) Compare(SortKey, SortKey)

Porównuje dwa klucze sortowania.Compares two sort keys.

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

Określa, czy określony obiekt jest równy bieżącemu SortKey obiektowi.Determines whether the specified object is equal to the current SortKey object.

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

Służy jako funkcja skrótu dla bieżącego SortKey obiektu, który jest odpowiedni dla algorytmów wyznaczania wartości skrótu i struktur danych, takich jak tabela skrótów.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()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

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

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

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

Zwraca ciąg, który reprezentuje bieżący SortKey obiekt.Returns a string that represents the current SortKey object.

Dotyczy

Zobacz też