SortKey Klasse

Definition

Stellt das Ergebnis der Zuordnung einer Zeichenfolge zum zugehörigen Sortierschlüssel dar.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
Vererbung
SortKey
Attribute

Beispiele

Im folgenden Beispiel wird die Zeichenfolge "Llama" mithilfe der Kulturen "en-US" und "es-es" und der herkömmlichen Kulturen "en-US" und "es-es" verglichen.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

Im folgenden Beispiel wird gezeigt, wie Sie die SortKey -Klasse verwenden können, um die Leistung in einer Anwendung zu verbessern, die häufig beim Sortieren und Durchsuchen eines großen Arrays basiert.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. Im Beispiel wird ein ungeordneter Array von Namen erstellt, das in diesem Fall 13 Elemente enthält.The example creates an unordered array of names, which in this case has 13 elements. Anschließend wird der Sortierschlüssel jedes namens in einem parallelen Array gespeichert, das an die Array.Sort(Array, Array) Methode weitergeleitet wird.It then stores the sort key of each name in a parallel array, which it passes to the Array.Sort(Array, Array) method. Das Ergebnis ist ein sortiertes Array.The result is a sorted array. Im Beispiel wird dann das Array nach drei Zeichen folgen durchsucht.The example then searches the array for three strings. Für jede Such Zeichenfolge ruft Sie CompareInfo.GetSortKey(String, CompareOptions) die-Methode auf, um den Sortierschlüssel der Zeichenfolge abzurufen Array.FindIndex , und ruft dann die-Methode auf, um den Index dieses Sortier Schlüssels im Array von Sortier Schlüsseln abzurufen.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. Da die Schlüssel Arrays Name und Sort parallel sind, ist der zurückgegebene Index auch der Index des Namens im names Array.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

Hinweise

Ein Kultur abhängiger Vergleich von zwei Zeichen folgen ist von jedem Zeichen in den Zeichen folgen abhängig, das über mehrere Kategorien von Sortierungs Gewichtungen verfügt, einschließlich Skript-, alphabe tischer, Groß-/Kleinschreibung und diakritischer GewichtungA 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. Ein Sortierschlüssel dient als Repository dieser Gewichtungen für eine bestimmte Zeichenfolge.A sort key serves as the repository of these weights for a particular string.

Die CompareInfo.GetSortKey -Methode gibt eine Instanz SortKey der-Klasse zurück, die die Kultur abhängige Zuordnung von Zeichen in einer angegebenen Zeichenfolge widerspiegelt.The CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. Der Wert eines SortKey -Objekts ist die Schlüsseldaten, die von der KeyData -Eigenschaft zurückgegeben werden.The value of a SortKey object is its key data, which is returned by the KeyData property. Diese Schlüsseldaten bestehen aus einer Reihe von Bytes, die die Zeichenfolge, kulturspezifische Sortierregeln und benutzerdefinierte Vergleichs Optionen codieren.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. Ein Vergleich mit Sortier Schlüsseln besteht aus einem bitweisen Vergleich der entsprechenden Schlüsseldaten in jedem Sortierschlüssel.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. Wenn Sie z. b. einen Sortierschlüssel erstellen, indem GetSortKey(String, CompareOptions) Sie die-Methode mit CompareOptions.IgnoreCasedem Wert aufrufen, wird bei einer Zeichen folgen Vergleichsoperation, die den Sortierschlüssel verwendet, die Groß-/Kleinschreibung nicht beachtetFor 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.

Nachdem Sie einen Sortierschlüssel für eine Zeichenfolge erstellt haben, vergleichen Sie Sortierschlüssel, indem SortKey.Compare Sie die statische-Methode aufrufen.After you create a sort key for a string, you compare sort keys by calling the static SortKey.Compare method. Diese Methode führt einen einfachen Byte weisen Vergleich durch, sodass Sie viel schneller ist als die-Methode String.Compare oder CompareInfo.Compare die-Methode.This method performs a simple byte-by-byte comparison, so it is much faster than the String.Compare or CompareInfo.Compare method.

Hinweis

Sie können die Sortierungs Gewichtungs Tabellenherunterladen, eine Reihe von Textdateien, die Informationen zu den in Sortier-und Vergleichs Vorgängen für Windows-Betriebssysteme verwendeten Zeichen Gewichtungen enthalten, die standardmäßige Unicode- Sortierungs Element Tabelle, die Sortierung. Gewichtungs Tabelle für Linux und 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.

Überlegungen zur LeistungPerformance considerations

Wenn Sie einen Zeichen folgen Vergleich durch Compare führen CompareInfo.Compare , erzielen die-Methode und die-Methode dieselben Ergebnisse, aber Sie zielen auf andere Szenarien ab.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

Auf hoher Ebene generiert die CompareInfo.Compare -Methode den Sortierschlüssel für jede Zeichenfolge, führt den Vergleich aus und verwirft dann den Sortierschlüssel und gibt das Ergebnis des Vergleichs zurück.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. Die CompareInfo.Compare -Methode generiert jedoch tatsächlich keinen kompletten Sortierschlüssel, um den Vergleich durchzuführen.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. Stattdessen generiert die-Methode in jeder Zeichenfolge die Schlüsseldaten für jedes Textelement (d. h. Basiszeichen, Ersatz Zeichenpaar oder kombinierte Zeichenfolge).Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. Die-Methode vergleicht dann die Schlüsseldaten für die entsprechenden Textelemente.The method then compares the key data for the corresponding text elements. Der Vorgang wird beendet, sobald das Endergebnis des Vergleichs bestimmt wird.The operation terminates as soon as the ultimate result of the comparison is determined. Sortierschlüssel Informationen werden berechnet, aber es SortKey wird kein Objekt erstellt.Sort key information is computed, but no SortKey object is created. Diese Strategie ist in Bezug auf die Leistung wirtschaftlich, wenn beide Zeichen folgen einmal verglichen werden. Dies wird jedoch teuer, wenn die gleichen Zeichen folgen mehrmals verglichen werden.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.

Die Compare -Methode erfordert die Generierung SortKey eines-Objekts für jede Zeichenfolge, bevor der Vergleich durchgeführt wird.The Compare method requires generation of a SortKey object for each string before performing the comparison. Diese Strategie ist im Hinblick auf die Leistung für den ersten Vergleich aufgrund der Zeit und des Arbeitsspeichers, die zum SortKey generieren der Objekte investiert wurden, aufwändig.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. Dies wird jedoch wirtschaftlich, wenn die gleichen Sortierschlüssel mehrmals verglichen werden.However, it becomes economical if the same sort keys are compared many times.

Nehmen Sie beispielsweise an, Sie schreiben eine Anwendung, die eine Datenbanktabelle nach der Zeile durchsucht, in der die Zeichen folgen basierte Index Spalte mit einer angegebenen Such Zeichenfolge übereinstimmt.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. Die Tabelle enthält Tausende von Zeilen, und das Vergleichen der Such Zeichenfolge mit dem Index in den einzelnen Zeilen nimmt einige Zeit in Anspruch.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. Wenn die Anwendung also eine Zeile und Ihre Index Spalte speichert, generiert und speichert Sie auch den Sortierschlüssel für den Index in einer Spalte, die für die Verbesserung der Suchleistung reserviert ist.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. Wenn die Anwendung nach einer Zielzeile sucht, vergleicht Sie den Sortierschlüssel für die Such Zeichenfolge mit dem Sortierschlüssel für die Index Zeichenfolge, anstatt die Such Zeichenfolge mit der Index Zeichenfolge zu vergleichen.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.

SicherheitsüberlegungenSecurity considerations

Die CompareInfo.GetSortKey(String, CompareOptions) Methode gibt ein SortKey -Objekt mit dem-Wert zurück, der auf CompareOptions einer angegebenen Zeichenfolge und einem angegebenen Wert basiert CompareInfo , sowie die dem zugrunde liegenden Objekt zugeordnete Kultur.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. Wenn eine Sicherheits Entscheidung von einem Zeichen folgen Vergleich oder einer Änderung der Groß-/Kleinschreibung abhängt, sollten Sie die CompareInfo.GetSortKey(String, CompareOptions) -Methode der invarianten Kultur verwenden, um sicherzustellen, dass das Verhalten des Vorgangs unabhängig von den Kultur Einstellungen des Betriebssystems konsistent ist.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.

Verwenden Sie die folgenden Schritte zum Abrufen eines Sortier Schlüssels:Use the following steps to obtain a sort key:

  1. Rufen Sie die invariante Kultur aus CultureInfo.InvariantCulture der-Eigenschaft ab.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Rufen Sie CompareInfo ein-Objekt für die invariante Kultur CultureInfo.CompareInfo aus der-Eigenschaft ab.Retrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

  3. Rufen Sie die CompareInfo.GetSortKey(String, CompareOptions)-Methode auf.Call the CompareInfo.GetSortKey(String, CompareOptions) method.

Das Arbeiten mit dem Wert eines SortKey -Objekts entspricht dem Aufrufen der Windows LCMapString -Methode mit dem angegebenen LCMAP_SORTKEY-Wert.Working with the value of a SortKey object is equivalent to calling the Windows LCMapString method with the LCMAP_SORTKEY value specified. Für das SortKey -Objekt werden die Sortierschlüssel für englische Zeichen jedoch den Sortier Schlüsseln für koreanische Zeichen vorangestellt.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKeyObjekte können serialisiert werden, jedoch nur, damit Sie Objekte über AppDomain schreiten können.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Wenn eine Anwendung ein SortKey -Objekt serialisiert, muss die Anwendung alle Sortierschlüssel erneut generieren, wenn eine neue Version der .NET Framework vorhanden ist.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.

Weitere Informationen zu Sortier Schlüsseln finden Sie unter Unicode Technical Standard #10 "Unicode COLLATIONS Algorithmus" auf der Website des Unicode-Consortium.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

Eigenschaften

KeyData

Ruft das Bytearray ab, das das aktuelle SortKey-Objekt darstellt.Gets the byte array representing the current SortKey object.

OriginalString

Ruft die ursprüngliche Zeichenfolge ab, mit der das aktuelle SortKey-Objekt erstellt wurde.Gets the original string used to create the current SortKey object.

Methoden

Compare(SortKey, SortKey)

Vergleicht zwei Sortierschlüssel.Compares two sort keys.

Equals(Object)

Bestimmt, ob das angegebene Objekt und das aktuelle SortKey-Objekt gleich sind.Determines whether the specified object is equal to the current SortKey object.

GetHashCode()

Fungiert als Hashfunktion für das aktuelle SortKey-Objekt, die sich für die Verwendung in Hashalgorithmen und -datenstrukturen eignet, z. B. in einer Hashtabelle.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()

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

(Geerbt von Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle SortKey-Objekt darstellt.Returns a string that represents the current SortKey object.

Gilt für:

Siehe auch