SortKey Klasse

Definition

Stellt das Ergebnis der Zuordnung einer Zeichenfolge zum zugehörigen Sortierschlüssel dar.

public ref class SortKey sealed
public ref class SortKey
public sealed class SortKey
public class SortKey
[System.Serializable]
public class SortKey
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class SortKey
type SortKey = class
[<System.Serializable>]
type SortKey = class
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type SortKey = class
Public NotInheritable Class SortKey
Public Class SortKey
Vererbung
SortKey
Attribute

Beispiele

Im folgenden Beispiel wird die Zeichenfolge "llama" mithilfe der Kulturen "en-US" und "es-ES" sowie der herkömmlichen Kulturen "en-US" und "es-ES" verglichen.

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

Das folgende Beispiel zeigt, wie Sie die -Klasse verwenden können, um die SortKey Leistung in einer Anwendung zu verbessern, die sich umfassend auf das Sortieren und Durchsuchen eines großen Arrays stützt. Im Beispiel wird ein ungeordnetes Array von Namen erstellt, das in diesem Fall 13 Elemente enthält. Anschließend wird der Sortierschlüssel jedes Namens in einem parallelen Array gespeichert, das an die -Methode übergeben Array.Sort(Array, Array) wird. Das Ergebnis ist ein sortiertes Array. Im Beispiel wird dann das Array nach drei Zeichenfolgen durchsucht. Für jede Suchzeichenfolge ruft sie die CompareInfo.GetSortKey(String, CompareOptions) -Methode auf, um den Sortierschlüssel der Zeichenfolge abzurufen, und ruft dann die Array.FindIndex -Methode auf, um den Index dieses Sortierschlüssels im Array von Sortierschlüsseln abzurufen. Da die Arrays name und sort key parallel sind, ist der zurückgegebene Index auch der Index des Namens im 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 hängt davon ab, ob jedes Zeichen in den Zeichenfolgen mehrere Kategorien von Sortiergewichtungen aufweist, einschließlich Skript-, Alphabet-, Groß- und Kleinschreibung sowie diakritische Gewichtungen. Ein Sortierschlüssel dient als Repository dieser Gewichtungen für eine bestimmte Zeichenfolge.

Die CompareInfo.GetSortKey -Methode gibt eine Instanz der SortKey -Klasse zurück, die die kulturabhängige Zuordnung von Zeichen in einer angegebenen Zeichenfolge widerspiegelt. Der Wert eines SortKey -Objekts ist seine Schlüsseldaten, die von der -Eigenschaft zurückgegeben KeyData werden. Diese Schlüsseldaten bestehen aus einer Reihe von Bytes, die die Zeichenfolge codieren, kulturspezifischen Sortierregeln und benutzerdefinierten Vergleichsoptionen. Ein Vergleich mit Sortierschlüsseln besteht aus einem bitweisen Vergleich der entsprechenden Schlüsseldaten in jedem Sortierschlüssel. Wenn Sie beispielsweise einen Sortierschlüssel erstellen, indem Sie die GetSortKey(String, CompareOptions) -Methode mit dem Wert CompareOptions.IgnoreCase aufrufen, wird bei einem Zeichenfolgenvergleichsvorgang, der den Sortierschlüssel verwendet, die Groß-/Kleinschreibung nicht beachtet.

Nachdem Sie einen Sortierschlüssel für eine Zeichenfolge erstellt haben, vergleichen Sie Sortierschlüssel, indem Sie die statische SortKey.Compare Methode aufrufen. Diese Methode führt einen einfachen Byte-by-Byte-Vergleich durch, sodass sie viel schneller ist als die String.Compare - oder CompareInfo.Compare -Methode.

Hinweis

Sie können die Sortiergewichtungstabellenherunterladen, eine Reihe von Textdateien, die Informationen zu den Zeichengewichtungen enthalten, die bei Sortier- und Vergleichsvorgängen für Windows Betriebssysteme verwendet werden, die Standardmäßige Unicode-Sortierungselementtabelle, die Sortiergewichtungstabelle für Linux und macOS.

Überlegungen zur Leistung

Beim Durchführen eines Zeichenfolgenvergleichs liefern die Compare Methoden und CompareInfo.Compare dieselben Ergebnisse, aber sie sind auf verschiedene Szenarien ausgerichtet.

Auf hoher Ebene generiert die CompareInfo.Compare -Methode den Sortierschlüssel für jede Zeichenfolge, führt den Vergleich aus, verwirft dann den Sortierschlüssel und gibt das Ergebnis des Vergleichs zurück. Die -Methode generiert jedoch CompareInfo.Compare nicht den gesamten Sortierschlüssel, um den Vergleich durchzuführen. Stattdessen generiert die -Methode die Schlüsseldaten für jedes Textelement (d. h. Basiszeichen, Ersatzzeichenpaar oder Kombinationszeichenfolge) in jeder Zeichenfolge. Die -Methode vergleicht dann die Schlüsseldaten für die entsprechenden Textelemente. Der Vorgang wird beendet, sobald das endgültige Ergebnis des Vergleichs bestimmt wird. Sortierschlüsselinformationen werden berechnet, aber es wird kein SortKey Objekt erstellt. Diese Strategie ist im Hinblick auf die Leistung wirtschaftlich, wenn beide Zeichenfolgen einmal verglichen werden, wird jedoch teuer, wenn dieselben Zeichenfolgen mehrmals verglichen werden.

Die Compare -Methode erfordert die Generierung eines SortKey -Objekts für jede Zeichenfolge, bevor der Vergleich durchgeführt wird. Diese Strategie ist im Hinblick auf die Leistung beim ersten Vergleich aufgrund der Zeit und des Arbeitsspeichers, die zum Generieren der Objekte erforderlich sind, SortKey teuer. Es wird jedoch wirtschaftlich, wenn dieselben Sortierschlüssel mehrmals verglichen werden.

Angenommen, Sie schreiben eine Anwendung, die eine Datenbanktabelle nach der Zeile durchsucht, in der die zeichenfolgenbasierte Indexspalte mit einer angegebenen Suchzeichenfolge übereinstimmt. Die Tabelle enthält Tausende von Zeilen, und der Vergleich der Suchzeichenfolge mit dem Index in jeder Zeile dauert sehr lange. Wenn die Anwendung daher eine Zeile und ihre Indexspalte speichert, generiert und speichert sie auch den Sortierschlüssel für den Index in einer Spalte, die der Verbesserung der Suchleistung dient. Wenn die Anwendung nach einer Zielzeile sucht, vergleicht sie den Sortierschlüssel für die Suchzeichenfolge mit dem Sortierschlüssel für die Indexzeichenfolge, anstatt die Suchzeichenfolge mit der Indexzeichenfolge zu vergleichen.

Sicherheitshinweise

Die CompareInfo.GetSortKey(String, CompareOptions) -Methode gibt ein SortKey -Objekt mit dem Wert basierend auf einer angegebenen Zeichenfolge und einem angegebenen CompareOptions Wert sowie der kultur, die dem zugrunde liegenden Objekt zugeordnet ist, CompareInfo zurück. Wenn eine Sicherheitsentscheidung von einem Zeichenfolgenvergleich oder einer Falländerung abhängt, sollten Sie die CompareInfo.GetSortKey(String, CompareOptions) -Methode der invarianten Kultur verwenden, um sicherzustellen, dass das Verhalten des Vorgangs konsistent ist, unabhängig von den Kultureinstellungen des Betriebssystems.

Verwenden Sie die folgenden Schritte, um einen Sortierschlüssel abzurufen:

  1. Rufen Sie die invariante Kultur aus der CultureInfo.InvariantCulture -Eigenschaft ab.

  2. Rufen Sie ein CompareInfo -Objekt für die invariante Kultur aus der CultureInfo.CompareInfo -Eigenschaft ab.

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

Das Arbeiten mit dem Wert eines SortKey -Objekts entspricht dem Aufrufen der LCMapString Windows-Methode mit dem angegebenen LCMAP_SORTKEY Wert. Für das SortKey -Objekt sind jedoch die Sortierschlüssel für englische Zeichen den Sortierschlüsseln für koreanische Zeichen vorangestellt.

SortKey -Objekte können serialisiert werden, aber nur so, dass sie Objekte kreuzen AppDomain können. Wenn eine Anwendung ein SortKey -Objekt serialisiert, muss die Anwendung alle Sortierschlüssel neu generieren, wenn eine neue Version des .NET Framework vorhanden ist.

Weitere Informationen zu Sortierschlüsseln finden Sie unter Unicode Technical Standard #10, "Unicode Collation Algorithm" (Unicode-Sortierungsalgorithmus) auf der Website des Unicode-Konsortiums.

Eigenschaften

KeyData

Ruft das Bytearray ab, das das aktuelle SortKey-Objekt darstellt.

OriginalString

Ruft die ursprüngliche Zeichenfolge ab, mit der das aktuelle SortKey-Objekt erstellt wurde.

Methoden

Compare(SortKey, SortKey)

Vergleicht zwei Sortierschlüssel.

Equals(Object)

Bestimmt, ob das angegebene Objekt und das aktuelle SortKey-Objekt gleich sind.

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.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle SortKey-Objekt darstellt.

Gilt für

Siehe auch