SortKey Classe

Définition

Représente le résultat du mappage d'une chaîne à sa clé de tri.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
Héritage
SortKey
Attributs

Exemples

L’exemple suivant compare la chaîne « llama » à l’aide des cultures « en-US » et « es-ES », ainsi que les cultures traditionnelles « en-US » et « 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

L’exemple suivant montre comment vous pouvez utiliser la classe SortKey pour améliorer les performances d’une application qui s’appuie largement sur le tri et la recherche dans un tableau volumineux.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. L’exemple crée un tableau non ordonné de noms, qui, dans ce cas, contient 13 éléments.The example creates an unordered array of names, which in this case has 13 elements. Il stocke ensuite la clé de tri de chaque nom dans un tableau parallèle, qu’il transmet à la méthode 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. Le résultat est un tableau trié.The result is a sorted array. L’exemple recherche ensuite trois chaînes dans le tableau.The example then searches the array for three strings. Pour chaque chaîne recherchée, elle appelle la méthode CompareInfo.GetSortKey(String, CompareOptions) pour récupérer la clé de tri de la chaîne, puis appelle la méthode Array.FindIndex pour récupérer l’index de cette clé de tri dans le tableau de clés de tri.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. Étant donné que les tableaux de noms et de clés de tri sont parallèles, l’index retourné est également l’index du nom dans le tableau de 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

Remarques

Une comparaison dépendante de la culture de deux chaînes dépend de chaque caractère des chaînes ayant plusieurs catégories de pondérations de tri, y compris les pondérations de script, alphabétique, de casse et diacritiques.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. Une clé de tri sert de référentiel de ces pondérations pour une chaîne particulière.A sort key serves as the repository of these weights for a particular string.

La méthode CompareInfo.GetSortKey retourne une instance de la classe SortKey qui reflète le mappage de caractères dépendants de la culture dans une chaîne spécifiée.The CompareInfo.GetSortKey method returns an instance of the SortKey class that reflects the culture-sensitive mapping of characters in a specified string. La valeur d’un objet SortKey est ses données de clé, qui sont retournées par la propriété KeyData.The value of a SortKey object is its key data, which is returned by the KeyData property. Ces données de clé se composent d’une série d’octets qui encodent la chaîne, des règles de tri spécifiques à la culture et des options de comparaison spécifiées par l’utilisateur.This key data consists of a series of bytes that encode the string, culture-specific sorting rules, and user-specified comparison options. Une comparaison à l’aide de clés de tri se compose d’une comparaison au niveau du bit des données de clé correspondantes dans chaque clé de tri.A comparison using sort keys consists of a bitwise comparison of the corresponding key data in each sort key. Par exemple, si vous créez une clé de tri en appelant la méthode GetSortKey(String, CompareOptions) avec une valeur de CompareOptions.IgnoreCase, une opération de comparaison de chaînes qui utilise la clé de tri ne respecte pas la casse.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.

Une fois que vous avez créé une clé de tri pour une chaîne, vous comparez les clés de tri en appelant la méthode statique SortKey.Compare.After you create a sort key for a string, you compare sort keys by calling the static SortKey.Compare method. Cette méthode effectue une comparaison octet par octet simple. elle est donc beaucoup plus rapide que la méthode String.Compare ou CompareInfo.Compare.This method performs a simple byte-by-byte comparison, so it is much faster than the String.Compare or CompareInfo.Compare method.

Notes

Vous pouvez télécharger les tables de pondération de tri, un ensemble de fichiers texte qui contiennent des informations sur les poids des caractères utilisés dans les opérations de tri et de comparaison pour les systèmes d’exploitation Windows, la table d' éléments de classement Unicode par défaut, la table de pondération de tri pour Linux et 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.

Considérations sur les performancesPerformance considerations

Lorsque vous effectuez une comparaison de chaînes, les méthodes Compare et CompareInfo.Compare produisent les mêmes résultats, mais elles ciblent des scénarios différents.When performing a string comparison, the Compare and CompareInfo.Compare methods yield the same results, but they target different scenarios.

À un niveau élevé, la méthode CompareInfo.Compare génère la clé de tri pour chaque chaîne, effectue la comparaison, puis ignore la clé de tri et retourne le résultat de la comparaison.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. Toutefois, la méthode CompareInfo.Compare ne génère pas réellement une clé de tri entière pour effectuer la comparaison.However, the CompareInfo.Compare method actually doesn't generate an entire sort key to perform the comparison. Au lieu de cela, la méthode génère les données de clé pour chaque élément de texte (autrement dit, le caractère de base, la paire de substitution ou la combinaison de séquences de caractères) dans chaque chaîne.Instead, the method generates the key data for each text element (that is, base character, surrogate pair, or combining character sequence) in each string. La méthode compare ensuite les données de clé pour les éléments de texte correspondants.The method then compares the key data for the corresponding text elements. L’opération se termine dès que le résultat final de la comparaison est déterminé.The operation terminates as soon as the ultimate result of the comparison is determined. Les informations sur la clé de tri sont calculées, mais aucun objet SortKey n’est créé.Sort key information is computed, but no SortKey object is created. Cette stratégie est économique en termes de performances si les deux chaînes sont comparées une fois, mais devient coûteuse si les mêmes chaînes sont comparées de nombreuses fois.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.

La méthode Compare nécessite la génération d’un objet SortKey pour chaque chaîne avant d’effectuer la comparaison.The Compare method requires generation of a SortKey object for each string before performing the comparison. Cette stratégie est coûteuse en termes de performances pour la première comparaison en raison du temps et de la mémoire investis pour générer les objets SortKey.This strategy is expensive in terms of performance for the first comparison because of the time and memory invested to generate the SortKey objects. Toutefois, il devient économique si les mêmes clés de tri sont comparées de nombreuses fois.However, it becomes economical if the same sort keys are compared many times.

Par exemple, supposons que vous écrivez une application qui recherche dans une table de base de données la ligne dans laquelle la colonne d’index basée sur chaîne correspond à une chaîne de recherche spécifiée.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 table contient des milliers de lignes et la comparaison de la chaîne recherchée à l’index de chaque ligne prend beaucoup de temps.The table contains thousands of rows, and comparing the search string to the index in each row will take a long time. Par conséquent, lorsque l’application stocke une ligne et sa colonne d’index, elle génère et stocke également la clé de tri de l’index dans une colonne dédiée à l’amélioration des performances de recherche.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. Lorsque l’application recherche une ligne cible, elle compare la clé de tri de la chaîne de recherche à la clé de tri de la chaîne d’index, au lieu de comparer la chaîne recherchée à la chaîne d’index.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.

Considérations relatives à la sécuritéSecurity considerations

La méthode CompareInfo.GetSortKey(String, CompareOptions) retourne un objet SortKey avec la valeur basée sur une chaîne et une valeur de CompareOptions spécifiées, ainsi que la culture associée à l’objet CompareInfo sous-jacent.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. Si une décision de sécurité dépend d’une comparaison de chaînes ou d’un changement de casse, vous devez utiliser la méthode CompareInfo.GetSortKey(String, CompareOptions) de la culture dite indifférente pour garantir la cohérence du comportement de l’opération, quels que soient les paramètres de culture du système d’exploitation.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.

Pour obtenir une clé de tri, procédez comme suit :Use the following steps to obtain a sort key:

  1. Récupérez la culture dite indifférente de la propriété CultureInfo.InvariantCulture.Retrieve the invariant culture from the CultureInfo.InvariantCulture property.

  2. Récupérez un objet CompareInfo pour la culture dite indifférente à partir de la propriété CultureInfo.CompareInfo.Retrieve a CompareInfo object for the invariant culture from the CultureInfo.CompareInfo property.

  3. Appelez la méthode CompareInfo.GetSortKey(String, CompareOptions).Call the CompareInfo.GetSortKey(String, CompareOptions) method.

L’utilisation de la valeur d’un objet SortKey équivaut à appeler la méthode Windows LCMapString avec la valeur LCMAP_SORTKEY spécifiée.Working with the value of a SortKey object is equivalent to calling the Windows LCMapString method with the LCMAP_SORTKEY value specified. Toutefois, pour l’objet SortKey, les clés de tri pour les caractères anglais précèdent les clés de tri pour les caractères coréens.However, for the SortKey object, the sort keys for English characters precede the sort keys for Korean characters.

les objets SortKey peuvent être sérialisés, mais uniquement afin de pouvoir traverser AppDomain objets.SortKey objects can be serialized, but only so that they can cross AppDomain objects. Si une application sérialise un objet SortKey, l’application doit régénérer toutes les clés de tri lorsqu’il existe une nouvelle version du .NET Framework.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.

Pour plus d’informations sur les clés de tri, consultez Unicode Technical standard #10, « algorithme de classement Unicode » sur le site Web du consortium Unicode.For more information about sort keys, see Unicode Technical Standard #10, "Unicode Collation Algorithm" on the Unicode Consortium website.

Propriétés

KeyData

Obtient le tableau d’octets qui représente l’objet SortKey actuel.Gets the byte array representing the current SortKey object.

OriginalString

Obtient la chaîne d’origine utilisée pour créer l’objet SortKey actuel.Gets the original string used to create the current SortKey object.

Méthodes

Compare(SortKey, SortKey)

Compare deux clés de tri.Compares two sort keys.

Equals(Object)

Détermine si l'objet spécifié est identique à l'objet SortKey actuel.Determines whether the specified object is equal to the current SortKey object.

GetHashCode()

Est utilisé comme fonction de hachage pour l’objet SortKey actuel et convient aux algorithmes de hachage et aux structures de données, comme une table de hachage.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()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Hérité de Object)
MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ToString()

Retourne une chaîne qui représente l'objet SortKey actuel.Returns a string that represents the current SortKey object.

S’applique à

Voir aussi