SortKey Osztály

Definíció

Névtér:

System.Globalization

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

SortKey.cs

Egy sztring rendezési kulcshoz való leképezésének eredményét jelöli.

public ref class SortKey sealed

public sealed class SortKey

type SortKey = class

Public NotInheritable Class SortKey

Öröklődés

Object

SortKey

Példák

Az alábbi példa a "láma" sztringet hasonlítja össze a "en-US" és a "es-ES" kultúrák, valamint a "en-US" és a "es-ES" hagyományos kultúrák használatával.

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

Az alábbi példa bemutatja, hogyan javíthatja az SortKey osztály teljesítményét egy olyan alkalmazásban, amely nagy tömbök rendezésére és keresésére támaszkodik. A példa egy rendezetlen névtömböt hoz létre, amely ebben az esetben 13 elemből áll. Ezután az egyes nevek rendezési kulcsát egy párhuzamos tömbben tárolja, amelyet átad a Sort(Array, Array) metódusnak. Az eredmény egy rendezett tömb. A példa ezután három sztringet keres a tömbben. Minden keresési sztring esetében meghívja a metódust a GetSortKey(String, CompareOptions) sztring rendezési kulcsának lekéréséhez, majd meghívja a Array.FindIndex metódust, hogy a rendezési kulcsok tömbjében kérje le a rendezési kulcs indexét. Mivel a név- és rendezési kulcstömbök párhuzamosak, a visszaadott index a tömbben lévő names név indexe is.

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

Megjegyzések

A két karakterlánc kulturálisan érzékeny összehasonlítása attól függ, hogy a karakterláncok egyes karakterei több rendezési súly kategóriával rendelkeznek, beleértve a szkriptet, betűrendet, kis- és nagybetűket, és diakritikus jelek súlyait. A rendezési kulcs a súlyok tárhelyeként szolgál egy adott karakterlánchoz.

A CompareInfo.GetSortKey metódus az SortKey osztály egy olyan példányát adja vissza, amely egy adott sztringben lévő karakterek kultúraérzékeny leképezését tükrözi. Az SortKey objektum értéke a kulcsadat, amelyet a KeyData tulajdonság ad vissza. Ezek a kulcsadatok egy bájtsorozatból állnak, amely kódolja a karaktersorozatot, a kultúraspecifikus rendezési szabályokat és a felhasználó által meghatározott összehasonlítási lehetőségeket. A rendezési kulcsokat használó összehasonlítás az egyes rendezési kulcsok megfelelő kulcsadatainak bitenkénti összehasonlításából áll. Ha például rendezési kulcsot hoz létre úgy, hogy meghívja a GetSortKey(String, CompareOptions) metódust egy CompareOptions.IgnoreCase értékkel, akkor a rendezési kulcsot használó sztring-összehasonlító művelet esetérzéketlen.

Miután létrehozott egy rendezési kulcsot egy sztringhez, a rendezési kulcsokat a statikus SortKey.Compare metódus meghívásával hasonlíthatja össze. Ez a módszer egyszerű bájtonkénti összehasonlítást végez, így sokkal gyorsabb, mint a String.Compare vagy a CompareInfo.Compare metódus.

Note

Letöltheti a rendezési súlytáblákat, amelyek a Windows operációs rendszerek rendezési és összehasonlító műveleteihez használt karaktervastagságokról, az alapértelmezett Unicode rendezési elemtábláról, a Linux és macOS rendszerhez készült rendezési súlyozási táblázatról tartalmaznak információkat.

Teljesítménnyel kapcsolatos szempontok

Sztring-összehasonlítás során a Compare és a CompareInfo.Compare metódusok ugyanazokat az eredményeket adják, de különböző forgatókönyveket céloznak meg.

Magas szinten a CompareInfo.Compare metódus létrehozza az egyes sztringekhez tartozó rendezési kulcsot, végrehajtja az összehasonlítást, majd elveti a rendezési kulcsot, és visszaadja az összehasonlítás eredményét. A CompareInfo.Compare metódus azonban valójában nem generál teljes rendezési kulcsot az összehasonlítás elvégzéséhez. A metódus ehelyett minden egyes sztringben létrehozza az egyes szövegelemek (azaz alap karakter, helyettesítő pár vagy egyesítő karaktersorozat) kulcsadatait. A metódus ezután összehasonlítja a megfelelő szövegelemek kulcsadatait. A művelet az összehasonlítás végső eredményének meghatározása után azonnal leáll. A rendezési kulcs adatai kiszámításra kerülnek, de nem jön létre SortKey objektum. Ez a stratégia a teljesítmény szempontjából gazdaságos, ha mindkét sztringet egyszer hasonlítják össze, de költségessé válik, ha ugyanazokat a sztringeket sokszor hasonlítják össze.

A Compare metódushoz minden sztringhez létre kell hozatnia egy SortKey objektumot az összehasonlítás végrehajtása előtt. Ez a stratégia teljesítmény szempontjából költséges az első összehasonlításnál, mert jelentős időt és memóriát igényel az SortKey objektumok létrehozása. Azonban gazdaságossá válik, ha ugyanazokat a rendezési kulcsokat sokszor hasonlítják össze.

Tegyük fel például, hogy egy olyan alkalmazást ír, amely egy adatbázistáblában keres arra a sorra, amelyben a sztringalapú indexoszlop egy adott keresési sztringgel egyezik. A táblázat több ezer sort tartalmaz, és a keresési sztring és az egyes sorok indexének összehasonlítása hosszú időt vesz igénybe. Ezért amikor az alkalmazás egy sort és annak indexoszlopát tárolja, az is létrehozza és tárolja az index rendezési kulcsát egy olyan oszlopban, amelynek célja a keresési teljesítmény javítása. Amikor az alkalmazás egy célsort keres, összehasonlítja a keresési sztring rendezési kulcsát az indexsztring rendezési kulcsával ahelyett, hogy összehasonlítja a keresési sztringet az indexsztringgel.

Biztonsági megfontolások

A CompareInfo.GetSortKey(String, CompareOptions) metódus visszaad egy SortKey objektumot, amelynek értéke egy adott sztring és CompareOptions érték alapján van meghatározva, valamint az, az alapul szolgáló CompareInfo objektumhoz kapcsolódó kultúrához társított. Ha egy biztonsági döntés a sztringek összehasonlításától vagy az esetek változásától függ, az CompareInfo.GetSortKey(String, CompareOptions) invariáns kultúra módszerével biztosíthatja, hogy a művelet viselkedése konzisztens legyen, függetlenül az operációs rendszer kulturális beállításaitól.

A rendezési kulcs beszerzéséhez kövesse az alábbi lépéseket:

1. Kérje le az invariáns kultúrát a CultureInfo.InvariantCulture tulajdonságból.

2. CompareInfo Az invariáns kultúra objektumának lekérése a CultureInfo.CompareInfo tulajdonságból.

3. Hívja meg a CompareInfo.GetSortKey(String, CompareOptions) metódust.

Az SortKey objektum értékének használata egyenértékű a Windows LCMapString metódus meghívásával a megadott LCMAP_SORTKEY értékkel. Az objektum esetében azonban az SortKey angol karakterek rendezési kulcsai megelőzik a koreai karakterek rendezési kulcsait.

SortKey objektumok szerializálhatók, de csak azért, hogy átjutjanak AppDomain objektumokon. Ha egy alkalmazás szerializál egy SortKey objektumot, az alkalmazásnak újra kell létrehoznia az összes rendezési kulcsot, ha a .NET új verziója van.

A rendezési kulcsokkal kapcsolatos további információkért tekintse meg a Unicode Consortium webhelyén található Unicode Technical Standard #10,"Unicode Collation Algorithm" (Unicode-rendezési algoritmus) című témakört.

Tulajdonságok

Name	Description
KeyData	Lekéri az aktuális SortKey objektumot képviselő bájttömböt.
OriginalString	Lekéri az aktuális SortKey objektum létrehozásához használt eredeti sztringet.

Metódusok

Name	Description
Compare(SortKey, SortKey)	Két rendezési kulcsot hasonlít össze.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális SortKey objektummal.
GetHashCode()	Az aktuális SortKey objektum kivonatfüggvénye, amely alkalmas algoritmusok és adatstruktúrák, például kivonattáblák kivonatolására.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
ToString()	Az aktuális SortKey objektumot jelképező sztringet ad vissza.

Lásd még

• GetSortKey(String, CompareOptions)
• KeyData