StringComparison Enum

Definition

Spécifie la culture, la casse et les règles de tri pouvant être utilisées par certaines surcharges des méthodes Compare(String, String) et Equals(Object).Specifies the culture, case, and sort rules to be used by certain overloads of the Compare(String, String) and Equals(Object) methods.

public enum class StringComparison
public enum StringComparison
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public enum StringComparison
type StringComparison = 
Public Enum StringComparison
Inheritance
StringComparison
Attributes

Fields

CurrentCulture 0

Comparez les chaînes à l’aide de règles de tri dépendantes de la culture et de la culture actuelle.Compare strings using culture-sensitive sort rules and the current culture.

CurrentCultureIgnoreCase 1

Comparez les chaînes à l’aide de règles de tri dépendantes de la culture, de la culture actuelle, et sans tenir compte de la casse des chaînes comparées.Compare strings using culture-sensitive sort rules, the current culture, and ignoring the case of the strings being compared.

InvariantCulture 2

Comparez les chaînes à l’aide de règles de tri dépendantes de la culture et de la culture indifférente.Compare strings using culture-sensitive sort rules and the invariant culture.

InvariantCultureIgnoreCase 3

Comparez les chaînes à l’aide de règles de tri dépendantes de la culture, de la culture indifférente, et sans tenir compte de la casse des chaînes comparées.Compare strings using culture-sensitive sort rules, the invariant culture, and ignoring the case of the strings being compared.

Ordinal 4

Comparez les chaînes à l’aide de règles de tri ordinal (binaire).Compare strings using ordinal (binary) sort rules.

OrdinalIgnoreCase 5

Comparez les chaînes à l’aide de règles de tri ordinal (binaire) sans tenir compte de la casse des chaînes comparées.Compare strings using ordinal (binary) sort rules and ignoring the case of the strings being compared.

Examples

L’exemple suivant compare quatre ensembles de mots à l’aide de chaque membre de l’énumération StringComparison.The following example compares four sets of words by using each member of the StringComparison enumeration. Les comparaisons utilisent les conventions des cultures anglais (États-Unis) et same du Nord (Suède).The comparisons use the conventions of the English (United States) and Sami, Northern (Sweden) cultures. Notez que les chaînes « Encyclopædia » et « Encyclopedia » sont considérées comme équivalentes dans la culture en-US, mais pas dans la culture sami, Northern (Suède).Note that the strings "encyclopædia" and "encyclopedia" are considered equivalent in the en-US culture but not in the Sami, Northern (Sweden) culture.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "en-US", "se-SE" };
      String[] strings1 = { "case",  "encyclopædia",  
                            "encyclopædia", "Archæology" };
      String[] strings2 = { "Case", "encyclopaedia", 
                            "encyclopedia" , "ARCHÆOLOGY" };
      StringComparison[] comparisons = (StringComparison[]) Enum.GetValues(typeof(StringComparison));
      
      foreach (var cultureName in cultureNames) {
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName);
         Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name);
         for (int ctr = 0; ctr <= strings1.GetUpperBound(0); ctr++) {
            foreach (var comparison in comparisons) 
               Console.WriteLine("   {0} = {1} ({2}): {3}", strings1[ctr],
                                 strings2[ctr], comparison, 
                                 String.Equals(strings1[ctr], strings2[ctr], comparison));

            Console.WriteLine();         
         }
         Console.WriteLine();
      }
   }
}
// The example displays the following output:
//    Current Culture: en-US
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): True
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
//    
//    
//    Current Culture: se-SE
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//    
//       encyclopædia = encyclopaedia (CurrentCulture): False
//       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopaedia (InvariantCulture): True
//       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
//       encyclopædia = encyclopaedia (Ordinal): False
//       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
//    
//       encyclopædia = encyclopedia (CurrentCulture): False
//       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
//       encyclopædia = encyclopedia (InvariantCulture): False
//       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
//       encyclopædia = encyclopedia (Ordinal): False
//       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
//    
//       Archæology = ARCHÆOLOGY (CurrentCulture): False
//       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (InvariantCulture): False
//       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
//       Archæology = ARCHÆOLOGY (Ordinal): False
//       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "en-US", "se-SE" }
      Dim strings1() As String = { "case",  "encyclopædia",  
                                   "encyclopædia", "Archæology" }
      Dim strings2() As String = { "Case", "encyclopaedia", 
                                   "encyclopedia" , "ARCHÆOLOGY" }
      Dim comparisons() As StringComparison = CType([Enum].GetValues(GetType(StringComparison)),
                                           StringComparison())
      
      For Each cultureName In cultureNames
         Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture(cultureName)
         Console.WriteLine("Current Culture: {0}", CultureInfo.CurrentCulture.Name)
         For ctr As Integer = 0 To strings1.GetUpperBound(0)
            For Each comparison In comparisons
               Console.WriteLine("   {0} = {1} ({2}): {3}", strings1(ctr),
                                 strings2(ctr), comparison, 
                                 String.Equals(strings1(ctr), strings2(ctr), comparison))
            Next
            Console.WriteLine()         
         Next
         Console.WriteLine()
      Next
   End Sub
End Module
' The example displays the following output:
'    Current Culture: en-US
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): True
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True
'    
'    
'    Current Culture: se-SE
'       case = Case (CurrentCulture): False
'       case = Case (CurrentCultureIgnoreCase): True
'       case = Case (InvariantCulture): False
'       case = Case (InvariantCultureIgnoreCase): True
'       case = Case (Ordinal): False
'       case = Case (OrdinalIgnoreCase): True
'    
'       encyclopædia = encyclopaedia (CurrentCulture): False
'       encyclopædia = encyclopaedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopaedia (InvariantCulture): True
'       encyclopædia = encyclopaedia (InvariantCultureIgnoreCase): True
'       encyclopædia = encyclopaedia (Ordinal): False
'       encyclopædia = encyclopaedia (OrdinalIgnoreCase): False
'    
'       encyclopædia = encyclopedia (CurrentCulture): False
'       encyclopædia = encyclopedia (CurrentCultureIgnoreCase): False
'       encyclopædia = encyclopedia (InvariantCulture): False
'       encyclopædia = encyclopedia (InvariantCultureIgnoreCase): False
'       encyclopædia = encyclopedia (Ordinal): False
'       encyclopædia = encyclopedia (OrdinalIgnoreCase): False
'    
'       Archæology = ARCHÆOLOGY (CurrentCulture): False
'       Archæology = ARCHÆOLOGY (CurrentCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (InvariantCulture): False
'       Archæology = ARCHÆOLOGY (InvariantCultureIgnoreCase): True
'       Archæology = ARCHÆOLOGY (Ordinal): False
'       Archæology = ARCHÆOLOGY (OrdinalIgnoreCase): True

Remarks

L’énumération StringComparison est utilisée pour spécifier si une comparaison de chaînes doit utiliser la culture actuelle ou la culture dite indifférente, les règles de tri par mot ou ordinal, et respectent la casse ou ne respecte pas la casse.The StringComparison enumeration is used to specify whether a string comparison should use the current culture or the invariant culture, word or ordinal sort rules, and be case-sensitive or case-insensitive.

Important

Quand vous appelez une méthode de comparaison de chaînes telle que String.Compare, String.Equalsou String.IndexOf, vous devez toujours appeler une surcharge qui comprend un paramètre de type StringComparison afin de pouvoir spécifier le type de comparaison que la méthode effectue.When you call a string comparison method such as String.Compare, String.Equals, or String.IndexOf, you should always call an overload that includes a parameter of type StringComparison so that you can specify the type of comparison that the method performs. Pour plus d’informations, consultez Bonnes pratiques l’utilisation de chaînes.For more information, see Best Practices for Using Strings.

Une opération qui utilise des règles de tri de mot effectue une comparaison dépendante de la culture dans laquelle certains caractères Unicode non alphanumériques peuvent avoir des pondérations spéciales qui leur sont affectées.An operation that uses word sort rules performs a culture-sensitive comparison wherein certain nonalphanumeric Unicode characters might have special weights assigned to them. À l’aide de règles de tri Word et des conventions d’une culture spécifique, le trait d’Union (« - ») peut avoir un poids très faible affecté, de sorte que « Coop » et « co-op » s’affichent à côté les uns des autres dans une liste triée.Using word sort rules and the conventions of a specific culture, 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.

Note

.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.

Une opération qui utilise des règles de tri ordinale effectue une comparaison basée sur la valeur numérique (point de code Unicode) de chaque Char dans la chaîne.An operation that uses ordinal sort rules performs a comparison based on the numeric value (Unicode code point) of each Char in the string. Une comparaison ordinale est rapide mais indépendante de la culture.An ordinal comparison is fast but culture-insensitive. Lorsque vous utilisez des règles de tri ordinal pour trier des chaînes qui commencent par des caractères Unicode (U +), la chaîne U + xxxx précède la chaîne U + yyyy si la valeur de xxxx est inférieure à yyyy.When you use ordinal sort rules to sort strings that start with Unicode characters (U+), the string U+xxxx comes before the string U+yyyy if the value of xxxx is numerically less than yyyy.

Pour plus d’informations sur les comparaisons, consultez les notes de la classe System.String.For more information about comparisons, see the System.String class remarks. Pour plus d’informations sur la culture, consultez les notes de la classe System.Globalization.CultureInfo.For more information about culture, see the System.Globalization.CultureInfo class remarks. Pour obtenir des instructions sur l’utilisation des règles de comparaison ordinale ou dépendante de la culture ou sur les règles de la culture dite indifférente, consultez meilleures pratiques pour l’utilisation de chaînes.For guidelines on when to use ordinal or culture-sensitive comparison rules or the rules of the invariant culture, see Best Practices for Using Strings. Pour obtenir 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, consultez Tri des tables de pondération.For a 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.

Applies to

See also