SortKey Klasse

Definition

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

Object

SortKey

Attribute

SerializableAttribute ComVisibleAttribute

Beispiele

Im folgenden Beispiel wird die Zeichenfolge "Llama" mit den Kulturen "en-US" und "es-ES" und "en-US" und "es-ES" verglichen.

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 mit 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 Sort(Array, Array) Methode übergeben wird. Das Ergebnis ist ein sortiertes Array. Anschließend wird das Array nach drei Zeichenfolgen durchsucht. Für jede Suchzeichenfolge ruft sie die 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 der Sortierschlüssel abzurufen. Da der Name und die Sortierschlüsselarrays 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 kultursensitiver Vergleich von zwei Zeichenfolgen hängt davon ab, dass jedem Zeichen in den Zeichenfolgen mehrere Kategorien von Sortiergewichten zugeordnet sind, einschließlich Skript-, alphabetischen, Groß-/Kleinschreibungs- und diakritischen Gewichtungen. Ein Sortierschlüssel dient als Speicher dieser Gewichtungen für eine bestimmte Zeichenkette.

Die CompareInfo.GetSortKey Methode gibt eine Instanz der SortKey Klasse zurück, die die kultursensitive Zuordnung von Zeichen in einer angegebenen Zeichenfolge widerspiegelt. Der Wert eines SortKey Objekts ist seine Schlüsseldaten, die von der KeyData Eigenschaft zurückgegeben werden. Diese Schlüsseldaten bestehen aus einer Reihe von Bytes, die die Zeichenfolgen-, kulturspezifischen Sortierregeln und vom Benutzer angegebenen Vergleichsoptionen codieren. Ein Vergleich mit Sortierschlüsseln besteht aus einem bitweisen Vergleich der entsprechenden Schlüsseldaten in jedem Sortierschlüssel. Wenn Sie etwa einen Sortierschlüssel erstellen, indem Sie die Methode GetSortKey(String, CompareOptions) mit dem Wert CompareOptions.IgnoreCase aufrufen, wird bei einem Vorgang zum Zeichenfolgenvergleich, 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 aus, sodass sie viel schneller ist als die String.Compare- oder CompareInfo.Compare-Methode.

Leistungsüberlegungen

Beim Ausführen eines Zeichenfolgenvergleichs liefern die Methoden Compare und CompareInfo.Compare dieselben Ergebnisse, aber sie zielen auf unterschiedliche Szenarien ab.

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. CompareInfo.Compare Die Methode generiert jedoch tatsächlich keinen gesamten Sortierschlüssel, um den Vergleich auszuführen. Stattdessen generiert die Methode die Schlüsseldaten für jedes Textelement (d. h. Basiszeichen, Ersatzpaar oder kombinierende Zeichenfolge) in jeder Zeichenfolge. Die Methode vergleicht dann die Schlüsseldaten für die entsprechenden Textelemente. Der Vorgang wird beendet, sobald das endende Ergebnis des Vergleichs ermittelt wird. Sortierschlüsselinformationen werden berechnet, es wird jedoch kein SortKey Objekt erstellt. Diese Strategie ist hinsichtlich der Leistung wirtschaftlich, wenn beide Zeichenfolgen einmal verglichen werden, aber teuer werden, wenn dieselben Zeichenfolgen mehrmals verglichen werden.

Für die Compare Methode ist die Generierung eines SortKey Objekts für jede Zeichenfolge erforderlich, bevor der Vergleich ausgeführt wird. Diese Strategie ist teuer in Bezug auf die Leistung beim ersten Vergleich, da Zeit und Speicher in die Generierung der SortKey-Objekte investiert werden. 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 eine lange Zeit. Wenn die Anwendung also eine Zeile und ihre Indexspalte speichert, generiert und speichert sie auch den Sortierschlüssel für den Index in einer Spalte, die zur 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.

Sicherheitsüberlegungen

Die CompareInfo.GetSortKey(String, CompareOptions) Methode gibt ein SortKey Objekt zurück, dessen Wert auf einer angegebenen Zeichenfolge und einem angegebenen CompareOptions Wert basiert, und das mit der Kultur des zugrunde liegenden CompareInfo Objekts verbunden ist. 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.

Führen Sie die folgenden Schritte aus, um einen Sortierschlüssel abzurufen:

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

2. Abrufen eines CompareInfo-Objekts für die Invariante Kultur aus der CultureInfo.CompareInfo-Eigenschaft.

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

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

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 von .NET vorhanden ist.

Weitere Informationen zum Sortieren von Schlüsseln finden Sie unter Unicode Technical Standard #10, "Unicode Collation Algorithm" auf der Unicode Consortium-Website.

Weitere Informationen

• GetSortKey(String, CompareOptions)
• KeyData