SortKey Classe

Définition

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

Héritage

Object

SortKey

Attributs

SerializableAttribute ComVisibleAttribute

Exemples

L’exemple suivant compare la chaîne « llama » à l’aide des cultures «en-US» et «es-ES», et des cultures traditionnelles «en-US» et «es-ES».

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 utiliser la classe pour améliorer les performances dans une application qui s’appuie largement sur le SortKey tri et la recherche d’un grand tableau. L’exemple crée un tableau de noms non ordonné, qui, dans ce cas, comporte 13 éléments. Il stocke ensuite la clé de tri de chaque nom dans un tableau parallèle, qu’il passe à la Sort(Array, Array) méthode. Le résultat est un tableau trié. L’exemple recherche ensuite le tableau pour trois chaînes. Pour chaque chaîne de recherche, elle appelle la GetSortKey(String, CompareOptions) méthode pour récupérer la clé de tri de la chaîne, puis appelle la Array.FindIndex méthode pour récupérer l’index de cette clé de tri dans le tableau de clés de tri. Étant donné que les tableaux de clés de nom et de tri sont parallèles, l’index retourné est également l’index du nom dans le names tableau.

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 sensible à la culture de deux chaînes dépend de chaque caractère dans les chaînes ayant plusieurs catégories de pondérations de tri, y compris le système d'écriture, l’ordre alphabétique, la casse et les accents diacritiques. Une clé de tri sert de référentiel de ces pondérations pour une chaîne particulière.

La CompareInfo.GetSortKey méthode retourne une instance de la SortKey classe qui reflète le mappage sensible à la culture des caractères dans une chaîne spécifiée. La valeur d’un SortKey objet est ses données clés, qui sont retournées par la KeyData propriété. Ces données clés se composent d’une série d’octets qui encodent les règles de tri spécifiques à la culture et les options de comparaison spécifiées par l’utilisateur. 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. 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 est insensible à la casse.

Après avoir créé une clé de tri pour une chaîne, vous comparez les clés de tri en appelant la méthode statique SortKey.Compare . Cette méthode effectue une comparaison simple octet par octet, de sorte qu’elle est beaucoup plus rapide que la méthode String.Compare ou CompareInfo.Compare.

Considérations relatives aux performances

Lors de l’exécution d’une comparaison de chaînes, les méthodes Compare et CompareInfo.Compare produisent les mêmes résultats, mais elles ciblent différents scénarios.

À un niveau élevé, la CompareInfo.Compare méthode 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. Toutefois, la CompareInfo.Compare méthode ne génère pas de clé de tri entière pour effectuer la comparaison. Au lieu de cela, la méthode génère les données clés de chaque élément de texte (c’est-à-dire, caractère de base, paire de substitution ou séquence de caractères combinée) dans chaque chaîne. La méthode compare ensuite les données clés des éléments de texte correspondants. L’opération se termine dès que le résultat final de la comparaison est déterminé. Les informations de clé de tri sont calculées, mais aucun objet `SortKey` n’est créé. 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 plusieurs fois.

La Compare méthode nécessite la génération d’un SortKey objet pour chaque chaîne avant d’effectuer la comparaison. 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 SortKey objets. Toutefois, il devient économique si les mêmes clés de tri sont comparées plusieurs fois.

Par exemple, supposons que vous écriviez une application qui recherche une table de base de données pour la ligne dans laquelle la colonne d’index basée sur des chaînes correspond à une chaîne de recherche spécifiée. La table contient des milliers de lignes et la comparaison de la chaîne de recherche à l’index dans chaque ligne prend beaucoup de temps. 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. 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 de recherche à la chaîne d’index.

Considérations relatives à la sécurité

La méthode CompareInfo.GetSortKey(String, CompareOptions) renvoie un objet SortKey avec la valeur basée sur une chaîne spécifiée et une valeur CompareOptions, ainsi que la culture associée à l'objet sous-jacent CompareInfo. Si une décision de sécurité dépend d’une comparaison de chaînes ou d’une modification de cas, vous devez utiliser la CompareInfo.GetSortKey(String, CompareOptions) méthode de la culture invariante pour vous assurer que le comportement de l’opération est cohérent, quels que soient les paramètres de culture du système d’exploitation.

Pour obtenir une clé de tri, procédez comme suit :

1. Récupérez la culture invariante de la propriété CultureInfo.InvariantCulture.

2. Récupérez un objet CompareInfo pour la culture invariante depuis la propriété CultureInfo.CompareInfo.

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

L’utilisation de la valeur d’un SortKey objet équivaut à appeler la méthode Windows LCMapString avec la valeur LCMAP_SORTKEY spécifiée. 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.

SortKey les objets peuvent être sérialisés, mais uniquement pour qu'ils puissent passer entre AppDomain objets. Si une application sérialise un SortKey objet, l’application doit régénérer toutes les clés de tri lorsqu’il existe une nouvelle version de .NET.

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.

Voir aussi

• GetSortKey(String, CompareOptions)
• KeyData