SortKey Klass

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

Arv

Object

SortKey

Attribut

SerializableAttribute ComVisibleAttribute

Exempel

I följande exempel jämförs strängen "llama" med kulturerna "en-US" och "es-ES" och "en-US" och "es-ES" traditionella kulturer.

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

I följande exempel visas hur du kan använda SortKey klassen för att förbättra prestanda i ett program som förlitar sig mycket på att sortera och söka i en stor matris. Exemplet skapar en osorterad matris med namn, som i det här fallet har 13 element. Sedan lagras sorteringsnyckeln för varje namn i en parallell matris, som den skickar till Sort(Array, Array) metoden. Resultatet är en sorterad matris. Exemplet söker sedan i matrisen efter tre strängar. För varje söksträng anropas GetSortKey(String, CompareOptions) metoden för att hämta strängens sorteringsnyckel och anropar Array.FindIndex sedan metoden för att hämta indexet för den sorteringsnyckeln i matrisen med sorteringsnycklar. Eftersom namn- och sorteringsnyckelmatriserna är parallella är det returnerade indexet också indexet för namnet i matrisen names .

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

Kommentarer

En kulturkänslig jämförelse av två strängar beror på att varje tecken i strängarna har flera kategorier av sorteringsvikter, inklusive skriftsystem, alfabetiska, versalbruk och diakritiska vikter. En sorteringsnyckel fungerar som lagringsplats för dessa vikter för en viss sträng.

Metoden CompareInfo.GetSortKey returnerar en instans av SortKey klassen som återspeglar den kulturkänsliga mappningen av tecken i en angiven sträng. Värdet för ett SortKey objekt är dess nyckeldata, som returneras av KeyData egenskapen. Dessa nyckeldata består av en serie byte som kodar strängen, kulturspecifika sorteringsregler och användardefinierade jämförelsealternativ. En jämförelse med sorteringsnycklar består av en bitvis jämförelse av motsvarande nyckeldata i varje sorteringsnyckel. Om du till exempel skapar en sorteringsnyckel genom att anropa GetSortKey(String, CompareOptions) metoden med värdet CompareOptions.IgnoreCase är en strängjämförelseåtgärd som använder sorteringsnyckeln skiftlägesokänslig.

När du har skapat en sorteringsnyckel för en sträng jämför du sorteringsnycklar genom att anropa den statiska SortKey.Compare metoden. Den här metoden utför en enkel byte-by-byte-jämförelse, så den är mycket snabbare än String.Compare metoden eller CompareInfo.Compare .

Prestandaöverväganden

När du utför en strängjämförelse ger Compare och CompareInfo.Compare-metoderna samma resultat, men de är avsedda för olika scenarier.

På hög nivå CompareInfo.Compare genererar metoden sorteringsnyckeln för varje sträng, utför jämförelsen och tar sedan bort sorteringsnyckeln och returnerar resultatet av jämförelsen. Dock genererar metoden faktiskt inte en fullständig sorteringsnyckel för att utföra jämförelsen. I stället genererar metoden nyckeldata för varje textelement (dvs. bastecken, surrogatpar eller kombination av teckensekvens) i varje sträng. Metoden jämför sedan nyckeldata för motsvarande textelement. Åtgärden avslutas så snart det slutliga resultatet av jämförelsen har fastställts. Sorteringsnyckelinformation beräknas, men inget SortKey objekt skapas. Den här strategin är ekonomisk när det gäller prestanda om båda strängarna jämförs en gång, men blir dyrt om samma strängar jämförs många gånger.

Metoden Compare kräver generering av ett SortKey objekt för varje sträng innan jämförelsen utförs. Den här strategin är dyr när det gäller prestanda för den första jämförelsen på grund av den tid och det minne som investerats för att generera objekten SortKey . Det blir dock ekonomiskt om samma sorteringsnycklar jämförs många gånger.

Anta till exempel att du skriver ett program som söker i en databastabell efter raden där den strängbaserade indexkolumnen matchar en angiven söksträng. Tabellen innehåller tusentals rader, och det tar lång tid att jämföra söksträngen med indexet på varje rad. När programmet lagrar en rad och dess indexkolumn genererar och lagrar det därför även sorteringsnyckeln för indexet i en kolumn som är dedikerad för att förbättra sökprestandan. När programmet söker efter en målrad jämförs sorteringsnyckeln för söksträngen med sorteringsnyckeln för indexsträngen i stället för att jämföra söksträngen med indexsträngen.

Säkerhetsfrågor

Metoden CompareInfo.GetSortKey(String, CompareOptions) returnerar ett SortKey objekt med värdet baserat på en angiven sträng och CompareOptions ett angivet värde samt kulturen som är associerad med det underliggande CompareInfo objektet. Om ett säkerhetsbeslut är beroende av en strängjämförelse eller skiftlägesändring bör du använda CompareInfo.GetSortKey(String, CompareOptions) metoden i den invarianta kulturen för att säkerställa att åtgärdens beteende är konsekvent, oavsett operativsystemets kulturinställningar.

Använd följande steg för att hämta en sorteringsnyckel:

1. Hämta den invarianta kulturen från egenskapen CultureInfo.InvariantCulture .

2. Hämta ett CompareInfo objekt för den invarianta kulturen från egenskapen CultureInfo.CompareInfo .

3. Anropa CompareInfo.GetSortKey(String, CompareOptions) metoden.

Att arbeta med värdet för ett SortKey objekt motsvarar att anropa Windows-metoden LCMapString med det LCMAP_SORTKEY angivna värdet. SortKey För objektet föregår dock sorteringsnycklarna för engelska tecken sorteringsnycklarna för koreanska tecken.

SortKey objekt kan serialiseras, men bara så att de kan korsa AppDomain objekt. Om ett program serialiserar ett SortKey objekt måste programmet återskapa alla sorteringsnycklar när det finns en ny version av .NET.

Mer information om sorteringsnycklar finns i Unicode Technical Standard #10, "Unicode Collation Algorithm" på Unicode Consortiums webbplats.

Se även

• GetSortKey(String, CompareOptions)
• KeyData