SortKey SortKey SortKey SortKey Class

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
SortKeySortKeySortKeySortKey
Attribute

Beispiele

Im folgenden Beispiel wird die Zeichenfolge "Llama" mit "En-US" und "es-ES" Kulturen und herkömmlichen Kulturen "En-US" und "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
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 'Main 

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

Das folgende Beispiel zeigt Informationen zur Verwendung der SortKey Klasse zur Verbesserung der Leistung in einer Anwendung, die umfassend sortieren und suchen ein großes Array benötigen.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. Das Beispiel erstellt ein nicht geordnete Array von Namen, die 13 Elementen in diesem Fall hat.The example creates an unordered array of names, which in this case has 13 elements. Speichert dann den Schlüssel für die Sortierung des jeweiligen Namens in ein paralleles Array, das er an übergibt die Array.Sort(Array, Array) Methode.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. Das Beispiel sucht dann das Array für drei Zeichenfolgen.The example then searches the array for three strings. Für jede Suchzeichenfolge, ruft der CompareInfo.GetSortKey(String, CompareOptions) Methode zum Abrufen der Zeichenfolge Sortierschlüssel, und ruft dann die Array.FindIndex Methode, um den Index des Sort-Schlüssel, das Array von Sortierschlü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 und die Sortierreihenfolge-Arrays parallel sind, der zurückgegebene Index ist auch der Index mit dem Namen in der 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 kulturabhängiger Vergleich von zwei Zeichenfolgen abhängig jedes Zeichens in die Zeichenfolge mehrere Sortiergewichtungskategorien zugeordnet, z. B. Skript, alphabetischer, Groß-/Kleinschreibung und diakritische Gewichtungen ist.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. Ein Sortierschlüssel dient als Repository für diese 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 der SortKey -Klasse, die kulturabhängige-Zuordnung für Zeichen in einer angegebenen Zeichenfolge angibt.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 des einem SortKey Objekt ist, die wichtigen Daten, die von zurückgegeben wird die KeyData Eigenschaft.The value of a SortKey object is its key data, which is returned by the KeyData property. Diese wichtigen Daten besteht aus einer Reihe von Bytes, die die Zeichenfolge, die kulturabhängigen Sortierregeln und die Benutzer angegebenen Vergleichsoptionen zu 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 Sortierschlüsseln besteht aus einen 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. Beispielsweise wird bei der Erstellung eines Sortierschlüssels durch Aufrufen der GetSortKey(String, CompareOptions) Methode mit einem Wert von CompareOptions.IgnoreCase, einem Zeichenfolgenvergleich, der den Sortierschlüssel verwendet wird Groß-/Kleinschreibung.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.

Nach der Erstellung eines Sortierschlüssels für eine Zeichenfolge, vergleichen Sie Sortierschlüssel durch Aufrufen der statischen SortKey.Compare Methode.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-pro-Byte-Vergleich, daher ist es wesentlich schneller als die String.Compare oder CompareInfo.Compare 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 sortieren Gewichtung Tabellen, einen Satz von Textdateien, die Informationen auf der Zeichen Gewichtung verwendet bei Sortier- und Vergleichsregeln für Windows-Betriebssysteme enthalten die Unicode Standard Sortierung-Elementtabelle, die Gewichtung Sortiertabelle 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 Zeichenfolgenvergleich durch die Compare und CompareInfo.Compare Methoden führen die gleichen Ergebnisse, aber sie Zielen auf andere Szenarien.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

Auf einer hohen Ebene der CompareInfo.Compare Methode den Sortierschlüssel für jede Zeichenfolge generiert, führt der Vergleich durch, und klicken Sie dann verwirft 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. Allerdings die CompareInfo.Compare Methode nicht tatsächlich einen gesamte Sortierung-Schlüssel zum Ausführen des Vergleichs generieren.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. Die Methode generiert stattdessen die Schlüsseldaten für jeden Text-Element (d. h. Basiszeichen, Surrogate-Paar oder Zeichenfolge kombinieren) in jeder 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 endgültige Ergebnis des Vergleichs bestimmt wird.The operation terminates as soon as the ultimate result of the comparison is determined. Die Sortierschlüssel wird berechnet, aber kein SortKey Objekt erstellt wird.Sort key information is computed, but no SortKey object is created. Diese Strategie ist effizient, wenn beide Zeichenfolgen einmal verglichen werden, aber es ist teuer, wenn die gleichen Zeichenfolgen oft 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 einer SortKey Objekt für jede Zeichenfolge vor dem Vergleich.The Compare method requires generation of a SortKey object for each string before performing the comparison. Diese Strategie ist aufgrund der Zeit und Arbeitsspeicher, die zum Generieren von investiert Leistung für den ersten Vergleich der SortKey Objekte.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. Allerdings wird es wirtschaftlicher, wenn die gleichen Sortierschlüssel oft verglichen werden.However, it becomes economical if the same sort keys are compared many times.

Nehmen wir beispielsweise an, dass Sie eine Anwendung schreiben, die in einer Datenbanktabelle für die Zeile sucht, in der Zeichenfolge-basierte Indexspalte mit einer angegebenen 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 vergleichen die Suchzeichenfolge für den Index in jeder Zeile wird sehr lange dauern.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. Aus diesem Grund bei die Anwendung eine Zeile und die Indexspalte gespeichert werden, außerdem generiert und speichert den Sortierschlüssel für den Index in einer Spalte, die speziell für die Verbesserung der Leistung der Suche.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 bestimmten Zeile sucht, vergleicht er den Sortierschlüssel für die Suchzeichenfolge für den Sortierschlüssel für die Indexzeichenfolge, anstatt zu vergleichen die Suchzeichenfolge für die Indexzeichenfolge.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 eine SortKey Objekt mit dem Wert auf Grundlage einer angegebenen Zeichenfolge und CompareOptions Wert und die zugeordnete, zugrunde liegenden Kultur CompareInfo Objekt.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 sicherheitsentscheidung auf einem Zeichenfolgenvergleich oder Änderung abhängig ist, verwenden Sie die CompareInfo.GetSortKey(String, CompareOptions) -Methode der invarianten Kultur, um sicherzustellen, dass das Verhalten des Vorgangs, unabhängig von den kultureinstellungen des Betriebssystems übereinstimmt.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 aus, um den Schlüssel für die Sortierung zu erhalten:Use the following steps to obtain a sort key:

  1. Abrufen die invariante Kultur aus der CultureInfo.InvariantCulture Eigenschaft.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Abrufen einer CompareInfo Objekt für die invariante Kultur aus der CultureInfo.CompareInfo Eigenschaft.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.

Arbeiten mit dem Wert von einem SortKey Objekt 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. Beachten Sie jedoch bei der SortKey Objekt, das Sortierschlüssel für englische Zeichen die Sortierschlüssel für die koreanische Zeichen vorangestellt.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKey Objekte können serialisiert werden, aber nur, damit sie überschreiten AppDomain Objekte.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Wenn eine Anwendung serialisiert eine SortKey Objekt ist, wird die Anwendung muss die Sortierschlüssel erneut generieren, wenn eine neue Version von .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 Sortierschlüsseln finden Sie unter Unicode Technical Standard #10, "Unicode Collation Algorithm" in 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 KeyData KeyData KeyData

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

OriginalString OriginalString OriginalString 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) Compare(SortKey, SortKey) Compare(SortKey, SortKey) Compare(SortKey, SortKey)

Vergleicht zwei Sortierschlüssel.Compares two sort keys.

Equals(Object) Equals(Object) Equals(Object) 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() GetHashCode() GetHashCode() 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() GetType() GetType() GetType()

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

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

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

(Inherited from Object)
ToString() ToString() ToString() 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