CompareOptions Énumération

Définition

Définit les options de comparaison de chaînes à utiliser avec CompareInfo.Defines the string comparison options to use with CompareInfo.

Cette énumération a un attribut FlagsAttribute qui permet une combinaison au niveau du bit de ses valeurs membres.

public enum class CompareOptions
[System.Flags]
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum CompareOptions
type CompareOptions = 
Public Enum CompareOptions
Héritage
CompareOptions
Attributs

Champs

IgnoreCase 1

Indique si la casse doit être ignorée durant la comparaison des chaînes.Indicates that the string comparison must ignore case.

IgnoreKanaType 8

Indique que le type Kana doit être ignoré durant la comparaison des chaînes.Indicates that the string comparison must ignore the Kana type. Le type Kana fait référence aux caractères japonais hiragana et katakana représentant des sons phonétiques de la langue japonaise.Kana type refers to Japanese hiragana and katakana characters, which represent phonetic sounds in the Japanese language. Le caractère hiragana est utilisé pour des expressions et des mots natifs japonais, tandis que le caractère katakana est utilisé pour des mots empruntés à d’autres langues, par exemple « computer » ou « Internet ».Hiragana is used for native Japanese expressions and words, while katakana is used for words borrowed from other languages, such as "computer" or "Internet". Un son phonétique peut être exprimé à la fois avec un caractère hiragana et katakana.A phonetic sound can be expressed in both hiragana and katakana. Quand cette valeur est sélectionnée, le caractère hiragana représentant un son est considéré comme identique au caractère katakana correspondant à ce même son.If this value is selected, the hiragana character for one sound is considered equal to the katakana character for the same sound.

IgnoreNonSpace 2

Indique que les comparaisons de chaînes doivent ignorer les caractères d’association sans espace, par exemple les signes diacritiques.Indicates that the string comparison must ignore nonspacing combining characters, such as diacritics. La norme Unicode définit les caractères d’association comme des caractères combinés à des caractères de base pour produire un nouveau caractère.The Unicode Standard defines combining characters as characters that are combined with base characters to produce a new character. Au moment du rendu, les caractères d’association sans espace n’occupent pas un espace proprement dit.Nonspacing combining characters do not occupy a spacing position by themselves when rendered.

IgnoreSymbols 4

Indique que la comparaison de chaînes doit ignorer les symboles, tels que les espaces blancs, les signes de ponctuation, les symboles monétaires, le symbole de pourcentage, les symboles mathématiques et l’esperluette.Indicates that the string comparison must ignore symbols, such as white-space characters, punctuation, currency symbols, the percent sign, mathematical symbols, the ampersand, and so on.

IgnoreWidth 16

Indique que la largeur des caractères doit être ignorée durant la comparaison des chaînes.Indicates that the string comparison must ignore the character width. Par exemple, les caractères katakana japonais peuvent être écrits sous la forme de caractères à demi-chasse ou à pleine chasse.For example, Japanese katakana characters can be written as full-width or half-width. Quand cette valeur est sélectionnée, les caractères katakana à pleine chasse sont considérés comme identiques aux mêmes caractères à demi-chasse.If this value is selected, the katakana characters written as full-width are considered equal to the same characters written as half-width.

None 0

Indique les valeurs des options par défaut utilisées pour la comparaison de chaînes.Indicates the default option settings for string comparisons.

Ordinal 1073741824

Indique que la comparaison de chaînes doit utiliser les valeurs successives encodées en Unicode UTF-16 de la chaîne (comparaison unité de code par unité de code), permettant ainsi une comparaison rapide mais indépendante de la culture.Indicates that the string comparison must use successive Unicode UTF-16 encoded values of the string (code unit by code unit comparison), leading to a fast comparison but one that is culture-insensitive. Une chaîne qui commence par une unité de code XXXX16 vient avant une chaîne commençant par YYYY16, si XXXX16 est inférieur à YYYY16.A string starting with a code unit XXXX16 comes before a string starting with YYYY16, if XXXX16 is less than YYYY16. Cette valeur ne peut pas être combinée avec d’autres valeurs CompareOptions et doit être utilisée seule.This value cannot be combined with other CompareOptions values and must be used alone.

OrdinalIgnoreCase 268435456

La comparaison de chaînes doit ignorer la casse, puis effectuer une comparaison ordinale.String comparison must ignore case, then perform an ordinal comparison. Cette technique équivaut à convertir la chaîne en majuscules à l’aide de la culture indifférente et à effectuer ensuite une comparaison ordinale du résultat.This technique is equivalent to converting the string to uppercase using the invariant culture and then performing an ordinal comparison on the result.

StringSort 536870912

Indique que la comparaison des chaînes doit utiliser l’algorithme de triage de chaînes.Indicates that the string comparison must use the string sort algorithm. Dans un triage de chaînes, le trait d’union et l’apostrophe, de même que d’autres symboles non alphanumériques, ont priorité sur les caractères alphanumériques.In a string sort, the hyphen and the apostrophe, as well as other nonalphanumeric symbols, come before alphanumeric characters.

Exemples

L’exemple de code suivant montre comment le tri avec StringSort diffère du tri sans StringSort.The following code example shows how sorting with StringSort differs from sorting without StringSort.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

// __gc public class SamplesCompareOptions {
ref class MyStringComparer: public IComparer
{
public:

   // Constructs a comparer using the specified CompareOptions.
   CompareInfo^ myComp;
   CompareOptions myOptions;
   MyStringComparer( CompareInfo^ cmpi, CompareOptions options )
      : myComp( cmpi ), myOptions( options )
   {}

   // Compares strings with the CompareOptions specified in the constructor.
   virtual int Compare( Object^ a, Object^ b )
   {
      if ( a == b )
            return 0;

      if ( a == nullptr )
            return  -1;

      if ( b == nullptr )
            return 1;

      String^ sa = dynamic_cast<String^>(a);
      String^ sb = dynamic_cast<String^>(b);
      if ( sa != nullptr && sb != nullptr )
            return myComp->Compare( sa, sb, myOptions );

      throw gcnew ArgumentException( "a and b should be strings." );
   }
};

int main()
{
   
   // Creates and initializes an array of strings to sort.
   array<String^>^myArr = {"cant","bill's","coop","cannot","billet","can't","con","bills","co-op"};
   Console::WriteLine( "\nInitially, " );
   IEnumerator^ myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }

   
   // Creates and initializes a Comparer to use.
   //CultureInfo* myCI = new CultureInfo(S"en-US", false);
   MyStringComparer^ myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::None );
   
   // Sorts the array without StringSort.
   Array::Sort( myArr, myComp );
   Console::WriteLine( "\nAfter sorting without CompareOptions::StringSort:" );
   myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }

   
   // Sorts the array with StringSort.
   myComp = gcnew MyStringComparer( CompareInfo::GetCompareInfo( "en-US" ),CompareOptions::StringSort );
   Array::Sort( myArr, myComp );
   Console::WriteLine( "\nAfter sorting with CompareOptions::StringSort:" );
   myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      String^ myStr = safe_cast<String^>(myEnum->Current);
      Console::WriteLine( myStr );
   }
}

/*
This code produces the following output.

Initially,
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting without CompareOptions::StringSort:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions::StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop
*/
using System;
using System.Collections;
using System.Globalization;


public class SamplesCompareOptions  {

   private class MyStringComparer: IComparer {
      private CompareInfo myComp;   
      private CompareOptions myOptions = CompareOptions.None;

      // Constructs a comparer using the specified CompareOptions.
      public MyStringComparer( CompareInfo cmpi, CompareOptions options )  {
         myComp = cmpi;
         this.myOptions = options;
      }

      // Compares strings with the CompareOptions specified in the constructor.
      public int Compare(Object a, Object b) {
         if (a == b) return 0;
         if (a == null) return -1;
         if (b == null) return 1;

         String sa = a as String;
         String sb = b as String;
         if (sa != null && sb != null)
            return myComp.Compare(sa, sb, myOptions);
         throw new ArgumentException("a and b should be strings.");

      }
   }
   
   public static void Main()  {

      // Creates and initializes an array of strings to sort.
      String[] myArr = new String[9] { "cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op" };
      Console.WriteLine( "\nInitially," );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

      // Creates and initializes a Comparer to use.
      //CultureInfo myCI = new CultureInfo( "en-US", false );
      MyStringComparer myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None);

      // Sorts the array without StringSort.
      Array.Sort( myArr, myComp );
      Console.WriteLine( "\nAfter sorting without CompareOptions.StringSort:" );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

      // Sorts the array with StringSort.
      myComp = new MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort);
      Array.Sort( myArr, myComp );
      Console.WriteLine( "\nAfter sorting with CompareOptions.StringSort:" );
      foreach ( String myStr in myArr )
         Console.WriteLine( myStr );

   }

}

/*
This code produces the following output.

Initially,
cant
bill's
coop
cannot
billet
can't
con
bills
co-op

After sorting without CompareOptions.StringSort:
billet
bills
bill's
cannot
cant
can't
con
coop
co-op

After sorting with CompareOptions.StringSort:
bill's
billet
bills
can't
cannot
cant
co-op
con
coop

*/
Imports System.Collections
Imports System.Globalization

Public Class SamplesCompareOptions

   Private Class MyStringComparer
      Implements IComparer

      Private myComp As CompareInfo
      Private myOptions As CompareOptions = CompareOptions.None
      
      ' Constructs a comparer using the specified CompareOptions.
      Public Sub New(cmpi As CompareInfo, options As CompareOptions)
         myComp = cmpi
         Me.myOptions = options
      End Sub
      
      ' Compares strings with the CompareOptions specified in the constructor.
      Public Function Compare(a As [Object], b As [Object]) As Integer Implements IComparer.Compare
         If a = b Then
            Return 0
         End If
         If a Is Nothing Then
            Return - 1
         End If
         If b Is Nothing Then
            Return 1
         End If 

         Dim sa As [String] = a
         Dim sb As [String] = b
         If Not (sa Is Nothing) And Not (sb Is Nothing) Then
            Return myComp.Compare(sa, sb, myOptions)
         End If
         Throw New ArgumentException("a and b should be strings.")

      End Function 'Compare 

   End Class


   Public Shared Sub Main()
      
      ' Creates and initializes an array of strings to sort.
      Dim myArr() As [String] = {"cant", "bill's", "coop", "cannot", "billet", "can't", "con", "bills", "co-op"}
      Console.WriteLine()
      Console.WriteLine("Initially,")
      Dim myStr As [String]
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

      ' Creates and initializes a Comparer to use.
      'CultureInfo myCI = new CultureInfo( "en-US", false );
      Dim myComp As New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.None)
      
      ' Sorts the array without StringSort.
      Array.Sort(myArr, myComp)
      Console.WriteLine()
      Console.WriteLine("After sorting without CompareOptions.StringSort:")
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

      ' Sorts the array with StringSort.
      myComp = New MyStringComparer(CompareInfo.GetCompareInfo("en-US"), CompareOptions.StringSort)
      Array.Sort(myArr, myComp)
      Console.WriteLine()
      Console.WriteLine("After sorting with CompareOptions.StringSort:")
      For Each myStr In  myArr
         Console.WriteLine(myStr)
      Next myStr 

   End Sub

End Class


'This code produces the following output.
'
'Initially,
'cant
'bill's
'coop
'cannot
'billet
'can't
'con
'bills
'co-op
'
'After sorting without CompareOptions.StringSort:
'billet
'bills
'bill's
'cannot
'cant
'can't
'con
'coop
'co-op
'
'After sorting with CompareOptions.StringSort:
'bill's
'billet
'bills
'can't
'cannot
'cant
'co-op
'con
'coop

Remarques

Ces options indiquent le respect de la casse ou la nécessité d’ignorer les types de caractères.These options denote case sensitivity or necessity to ignore types of characters.

.NET utilise trois méthodes distinctes de tri: tri de mot, tri de chaîne et tri ordinal..NET uses three distinct ways of sorting: word sort, string sort, and ordinal sort. Tri de mot effectue une comparaison de chaînes dépendante de la culture.Word sort performs a culture-sensitive comparison of strings. Certains caractères non alphanumériques peuvent avoir des pondérations spéciales qui leur sont affectées.Certain nonalphanumeric characters might have special weights assigned to them. Par exemple, le trait d’Union («-») peut avoir un très petit poids affecté, de sorte que «Coop» et «co-op» s’affichent à côté les uns des autres dans une liste triée.For example, the hyphen ("-") might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Le tri par chaîne est similaire au tri par mot, à ceci près qu’il n’y a aucun cas particulier.String sort is similar to word sort, except that there are no special cases. Par conséquent, tous les symboles non alphanumériques sont placés avant tous les caractères alphanumériques.Therefore, all nonalphanumeric symbols come before all alphanumeric characters. Le tri ordinal compare les chaînes en fonction des valeurs Unicode de chaque élément de la chaîne.Ordinal sort compares strings based on the Unicode values of each element of the string. Pour obtenir un ensemble téléchargeable 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, consultez Trier les tables en pondération.For a downloadable set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, see Sorting Weight Tables. Pour la table de pondération de tri pour Linux et macOS, consultez la table d’éléments de classement Unicode par défaut.For the sort weight table for Linux and macOS, see the Default Unicode Collation Element Table. La version spécifique de la table de pondération de tri sur Linux et macOS varie selon la version des bibliothèques International Components for Unicode installées sur le système.The specific version of the sort weight table on Linux and macOS depends on the version of the International Components for Unicode libraries installed on the system. Pour plus d’informations sur les versions ICU et les versions Unicode qu’elles implémentent, consultez Téléchargement d’ICU.For information on ICU versions and the Unicode versions that they implement, see Downloading ICU.

La StringSort valeur ne peut être utilisée qu' CompareInfo.Compare avec CompareInfo.GetSortKeyet.The StringSort value can only be used with CompareInfo.Compare and CompareInfo.GetSortKey. ArgumentExceptionest levé si la valeur StringSort est utilisée avec CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOfou CompareInfo.LastIndexOf.ArgumentException is thrown if the StringSort value is used with CompareInfo.IsPrefix, CompareInfo.IsSuffix, CompareInfo.IndexOf, or CompareInfo.LastIndexOf.

Notes

Lorsque cela est possible, vous devez utiliser des méthodes de comparaison CompareOptions de chaînes qui acceptent une valeur pour spécifier le type de comparaison attendu.When possible, you should use string comparison methods that accept a CompareOptions value to specify the kind of comparison expected. En règle générale, les comparaisons accessibles à l’utilisateur sont mieux servies par l’utilisation d’options linguistiques (à l’aide de la culture actuelle), tandis OrdinalIgnoreCaseque les comparaisons de sécurité doivent spécifier Ordinal ou.As a general rule, user-facing comparisons are best served by the use of linguistic options (using the current culture), while security comparisons should specify Ordinal or OrdinalIgnoreCase.

Remarques sur les tris dépendants de la cultureNotes on culture-sensitive sorts

Notes

.NET Core s’exécutant sur les systèmes Linux et macOS uniquement : Le comportement de classement pour les cultures C et Posix respecte toujours la casse, car ces cultures n’utilisent pas l’ordre de classement Unicode attendu..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. Nous vous recommandons d’utiliser une culture autre que C ou Posix pour effectuer des opérations de tri respectant la culture, mais ne respectant pas la casse.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

S’applique à

Voir aussi