SortKey Classe

Definizione

Rappresenta il risultato del mapping di una stringa alla chiave di ordinamento.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
Ereditarietà
SortKey
Attributi

Esempi

Nell'esempio seguente viene confrontata la stringa "llama" utilizzando le impostazioni cultura "en-US" ed "es-ES" e le impostazioni cultura tradizionali "en-US" ed "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.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

Nell'esempio seguente viene illustrato come utilizzare la classe SortKey per migliorare le prestazioni in un'applicazione basata ampiamente sull'ordinamento e la ricerca di una matrice di grandi dimensioni.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. Nell'esempio viene creata una matrice non ordinata di nomi, che in questo caso contiene 13 elementi.The example creates an unordered array of names, which in this case has 13 elements. Viene quindi archiviata la chiave di ordinamento di ogni nome in una matrice parallela, che viene passata al metodo Array.Sort(Array, Array).It then stores the sort key of each name in a parallel array, which it passes to the Array.Sort(Array, Array) method. Il risultato è una matrice ordinata.The result is a sorted array. Nell'esempio viene quindi eseguita la ricerca delle tre stringhe nella matrice.The example then searches the array for three strings. Per ogni stringa di ricerca viene chiamato il metodo CompareInfo.GetSortKey(String, CompareOptions) per recuperare la chiave di ordinamento delle stringhe, quindi il metodo Array.FindIndex per recuperare l'indice di tale chiave di ordinamento nella matrice delle chiavi di ordinamento.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. Poiché le matrici dei nomi e delle chiave di ordinamento sono parallele, l'indice restituito è anche l'indice del nome nella matrice names.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

Commenti

Un confronto con distinzione delle impostazioni cultura di due stringhe dipende da ogni carattere nelle stringhe con diverse categorie di pesi di ordinamento, tra cui i pesi di script, alfabetici, maiuscole e minuscole.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. Una chiave di ordinamento funge da repository di questi pesi per una determinata stringa.A sort key serves as the repository of these weights for a particular string.

Il metodo CompareInfo.GetSortKey restituisce un'istanza della classe SortKey che riflette il mapping dei caratteri dipendente dalle impostazioni cultura in una stringa specificata.The CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. Il valore di un SortKey oggetto è costituito KeyData dai dati chiave restituiti dalla proprietà.The value of a SortKey object is its key data, which is returned by the KeyData property. Questi dati chiave sono costituiti da una serie di byte che codificano la stringa, le regole di ordinamento specifiche delle impostazioni cultura e le opzioni di confronto specificate dall'utente.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. Un confronto con chiavi di ordinamento è costituito da un confronto bit per bit dei dati chiave corrispondenti in ogni chiave di ordinamento.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. Ad esempio, se si crea una chiave di ordinamento chiamando il metodo GetSortKey(String, CompareOptions) con un valore di CompareOptions.IgnoreCase, un'operazione di confronto tra stringhe che utilizza la chiave di ordinamento prevede la distinzione tra maiuscole e minuscole.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.

Dopo aver creato una chiave di ordinamento per una stringa, è possibile confrontare le chiavi di ordinamento chiamando il metodo statico SortKey.Compare.After you create a sort key for a string, you compare sort keys by calling the static SortKey.Compare method. Questo metodo rappresenta una soluzione molto più rapida rispetto a String.Compare o CompareInfo.Compare, poiché esegue un semplice confronto byte per byte.This method performs a simple byte-by-byte comparison, so it is much faster than the String.Compare or CompareInfo.Compare method.

Nota

È possibile scaricare le tabelle di ordinamento ponderato, un set di file di testo che contiene informazioni sui pesi dei caratteri utilizzati nelle operazioni di ordinamento e confronto per i sistemi operativi Windows, la tabella degli elementi delle regole di confronto Unicode predefinita, l'ordinamento tabella Weight per Linux e 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.

Considerazioni sulle prestazioniPerformance considerations

Quando si esegue un confronto tra stringhe, i metodi Compare e CompareInfo.Compare restituiscono gli stessi risultati, ma destinati a scenari diversi.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

A un livello elevato, il CompareInfo.Compare metodo genera la chiave di ordinamento per ogni stringa, esegue il confronto, quindi Elimina la chiave di ordinamento e restituisce il risultato del confronto.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. Tuttavia, il CompareInfo.Compare metodo in realtà non genera un'intera chiave di ordinamento per eseguire il confronto.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. Genera invece i dati di chiave per ciascun elemento di testo, ovvero carattere di base, coppia di surrogati o sequenza di caratteri di combinazione, in ciascuna stringa.Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. Il metodo confronta quindi i dati della chiave per gli elementi di testo corrispondenti.The method then compares the key data for the corresponding text elements. L'operazione viene terminata non appena viene determinato il risultato finale del confronto.The operation terminates as soon as the ultimate result of the comparison is determined. Le informazioni sulla chiave di ordinamento vengono calcolate SortKey , ma non viene creato alcun oggetto.Sort key information is computed, but no SortKey object is created. Questa strategia è economica in termini di prestazioni se entrambe le stringhe vengono confrontate una volta, ma diventa costosa se le stesse stringhe vengono confrontate molte volte.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.

Il Compare metodo richiede la generazione di SortKey un oggetto per ogni stringa prima di eseguire il confronto.The Compare method requires generation of a SortKey object for each string before performing the comparison. Questa strategia è dispendiosa in termini di prestazioni per il primo confronto a causa del tempo e della memoria investito per la generazione degli SortKey oggetti.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. Tuttavia, diventa economico se le stesse chiavi di ordinamento vengono confrontate molte volte.However, it becomes economical if the same sort keys are compared many times.

Si supponga, ad esempio, di scrivere un'applicazione che esegue la ricerca di una tabella di database per la riga in cui la colonna dell'indice basata su stringa corrisponde a una stringa di ricerca specificata.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. La tabella contiene migliaia di righe e il confronto tra la stringa di ricerca e l'indice in ogni riga richiede molto tempo.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. Pertanto, quando nell'applicazione vengono archiviate una riga e la relativa colonna dell'indice, viene inoltre generata e archiviata la chiave di ordinamento per l'indice in una colonna dedicata al miglioramento delle prestazioni di ricerca.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. Quando l'applicazione cerca una riga di destinazione, confronta la chiave di ordinamento per la stringa di ricerca con la chiave di ordinamento per la stringa di indice, anziché confrontare la stringa di ricerca con la stringa di indice.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.

Considerazioni sulla sicurezzaSecurity considerations

Il CompareInfo.GetSortKey(String, CompareOptions) metodo restituisce un SortKey oggetto con il valore basato su una stringa e CompareOptions un valore specificati e le impostazioni cultura associate all'oggetto CompareInfo sottostante.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. Se una decisione relativa alla sicurezza è basata sul risultato di un confronto di stringhe o di un'operazione di modifica delle lettere maiuscole e minuscole, è necessario utilizzare il metodo CompareInfo.GetSortKey(String, CompareOptions) della lingua inglese per garantire la coerenza del comportamento dell'operazione, indipendentemente dalle impostazioni cultura del sistema operativo.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.

Utilizzare i passaggi indicati di seguito per ottenere una chiave di ordinamento:Use the following steps to obtain a sort key:

  1. Recuperare la lingua inglese dalla proprietà CultureInfo.InvariantCulture.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Recuperare un oggetto CompareInfo della lingua inglese dalla proprietà CultureInfo.CompareInfo.Retrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

  3. Chiamare il metodo CompareInfo.GetSortKey(String, CompareOptions).Call the CompareInfo.GetSortKey(String, CompareOptions) method.

L'utilizzo del valore di un oggetto SortKey equivale alla chiamata al metodo LCMapString di Windows con specificato il valore LCMAP_SORTKEY.Working with the value of a SortKey object is equivalent to calling the Windows LCMapString method with the LCMAP_SORTKEY value specified. Tuttavia, per l' SortKey oggetto, le chiavi di ordinamento per i caratteri inglesi precedono le chiavi di ordinamento per i caratteri coreani.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

SortKeygli oggetti possono essere serializzati, ma solo in modo che possano AppDomain attraversare oggetti.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Se un'applicazione serializza un oggetto SortKey, quando è disponibile una nuova versione di Framework .NET, l'applicazione deve rigenerare tutte le chiavi di ordinamento.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.

Per ulteriori informazioni sulle chiavi di ordinamento, vedere Unicode Technical Standard #10, "Unicode Collation Algorithm" nel sito Web Unicode Consortium.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

Proprietà

KeyData

Ottiene la matrice di byte che rappresenta l'oggetto SortKey corrente.Gets the byte array representing the current SortKey object.

OriginalString

Ottiene la stringa originale utilizzata per creare l'oggetto SortKey corrente.Gets the original string used to create the current SortKey object.

Metodi

Compare(SortKey, SortKey)

Confronta due chiavi di ordinamento.Compares two sort keys.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto SortKey corrente.Determines whether the specified object is equal to the current SortKey object.

GetHashCode()

Viene utilizzato come funzione hash per l'oggetto SortKey corrente adatto per algoritmi di hash e strutture di dati, ad esempio una tabella hash.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()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Ereditato da Object)
MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Ereditato da Object)
ToString()

Restituisce una stringa che rappresenta l'oggetto SortKey corrente.Returns a string that represents the current SortKey object.

Si applica a

Vedi anche