String.Equals Méthode

Définition

Espace de noms:

System

Assembly:

System.Runtime.dll

Détermine si deux objets String ont la même valeur.

Surcharges

Equals(Object)	Détermine si cette instance et un objet spécifié, qui doit aussi être un objet String, ont la même valeur.
Equals(String)	Détermine si cette instance et un autre objet String spécifié ont la même valeur.
Equals(String, String)	Détermine si deux objets String spécifiés ont la même valeur.
Equals(String, StringComparison)	Détermine si cette chaîne et un objet String spécifié ont la même valeur. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.
Equals(String, String, StringComparison)	Détermine si deux objets String spécifiés ont la même valeur. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.

Equals(Object)

Source:

String.Comparison.cs

Détermine si cette instance et un objet spécifié, qui doit aussi être un objet String, ont la même valeur.

C#

public override bool Equals (object? obj);

Paramètres

obj

Object

Chaîne à comparer à cette instance.

Retours

Boolean

true si obj est String et possède la même valeur que cette instance ; sinon, false. Si obj est null, la méthode retourne false.

Exemples

L’exemple suivant illustre la Equals méthode.

C#

// Sample for String.Equals(Object)
//            String.Equals(String)
//            String.Equals(String, String)
using System;
using System.Text;

class Sample1
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder("abcd");
        String str1 = "abcd";
        String str2 = null;
        Object o2 = null;

        Console.WriteLine();
        Console.WriteLine(" *  The value of String str1 is '{0}'.", str1);
        Console.WriteLine(" *  The value of StringBuilder sb is '{0}'.", sb.ToString());

        Console.WriteLine();
        Console.WriteLine("1a) String.Equals(Object). Object is a StringBuilder, not a String.");
        Console.WriteLine("    Is str1 equal to sb?: {0}", str1.Equals(sb));

        Console.WriteLine();
        Console.WriteLine("1b) String.Equals(Object). Object is a String.");
        str2 = sb.ToString();
        o2 = str2;
        Console.WriteLine(" *  The value of Object o2 is '{0}'.", o2);
        Console.WriteLine("    Is str1 equal to o2?: {0}", str1.Equals(o2));

        Console.WriteLine();
        Console.WriteLine(" 2) String.Equals(String)");
        Console.WriteLine(" *  The value of String str2 is '{0}'.", str2);
        Console.WriteLine("    Is str1 equal to str2?: {0}", str1.Equals(str2));

        Console.WriteLine();
        Console.WriteLine(" 3) String.Equals(String, String)");
        Console.WriteLine("    Is str1 equal to str2?: {0}", String.Equals(str1, str2));
    }
}
/*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String.Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String.Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String.Equals(String, String)
    Is str1 equal to str2?: True
*/

Remarques

Cette méthode effectue une comparaison ordinale (respectant la casse et ne respectant pas la culture).

Voir aussi

• Object
• CompareOrdinal(String, String)

Equals(String)

Source:

String.Comparison.cs

Détermine si cette instance et un autre objet String spécifié ont la même valeur.

C#

public bool Equals (string? value);

Paramètres

value

String

Chaîne à comparer à cette instance.

Retours

Boolean

true si la valeur du paramètre value est la même que celle de cette instance ; sinon, false. Si value est null, la méthode retourne false.

Implémente

Equals(T)

Exemples

L’exemple suivant illustre la Equals méthode. Il compare le mot de titre « File » à un mot équivalent, son équivalent en minuscules, son équivalent majuscule et un mot qui contient LATIN SMALL LETTER DOTLESS I (U+0131) au lieu de LATIN SMALL LETTER I (U+0069). Étant donné que la Equals(String) méthode effectue une comparaison ordinale, seule la comparaison avec un mot identique retourne true.

C#

using System;

public class Example
{
    public static void Main()
    {
        Console.OutputEncoding = System.Text.Encoding.UTF8;
        string word = "File";
        string[] others = { word.ToLower(), word, word.ToUpper(), "Fıle" };
        foreach (string other in others)
        {
            if (word.Equals(other))
                Console.WriteLine("{0} = {1}", word, other);
            else
                Console.WriteLine("{0} {1} {2}", word, '\u2260', other);
        }
    }
}
// The example displays the following output:
//       File ≠ file
//       File = File
//       File ≠ FILE
//       File ≠ Fıle

Remarques

Cette méthode effectue une comparaison ordinale (respectant la casse et ne respectant pas la culture).

Voir aussi

• CompareOrdinal(String, String)

Equals(String, String)

Source:

String.Comparison.cs

Détermine si deux objets String spécifiés ont la même valeur.

C#

public static bool Equals (string? a, string? b);

Paramètres

a

String

Première chaîne à comparer, ou null.

b

String

Deuxième chaîne à comparer, ou null.

Retours

Boolean

true si la valeur de a est égale à la valeur de b ; sinon false. Si a et b ont la valeur null, la méthode retourne true.

Exemples

L’exemple suivant illustre la Equals méthode.

C#

// Sample for String.Equals(Object)
//            String.Equals(String)
//            String.Equals(String, String)
using System;
using System.Text;

class Sample1
{
    public static void Main()
    {
        StringBuilder sb = new StringBuilder("abcd");
        String str1 = "abcd";
        String str2 = null;
        Object o2 = null;

        Console.WriteLine();
        Console.WriteLine(" *  The value of String str1 is '{0}'.", str1);
        Console.WriteLine(" *  The value of StringBuilder sb is '{0}'.", sb.ToString());

        Console.WriteLine();
        Console.WriteLine("1a) String.Equals(Object). Object is a StringBuilder, not a String.");
        Console.WriteLine("    Is str1 equal to sb?: {0}", str1.Equals(sb));

        Console.WriteLine();
        Console.WriteLine("1b) String.Equals(Object). Object is a String.");
        str2 = sb.ToString();
        o2 = str2;
        Console.WriteLine(" *  The value of Object o2 is '{0}'.", o2);
        Console.WriteLine("    Is str1 equal to o2?: {0}", str1.Equals(o2));

        Console.WriteLine();
        Console.WriteLine(" 2) String.Equals(String)");
        Console.WriteLine(" *  The value of String str2 is '{0}'.", str2);
        Console.WriteLine("    Is str1 equal to str2?: {0}", str1.Equals(str2));

        Console.WriteLine();
        Console.WriteLine(" 3) String.Equals(String, String)");
        Console.WriteLine("    Is str1 equal to str2?: {0}", String.Equals(str1, str2));
    }
}
/*
This example produces the following results:

 *  The value of String str1 is 'abcd'.
 *  The value of StringBuilder sb is 'abcd'.

1a) String.Equals(Object). Object is a StringBuilder, not a String.
    Is str1 equal to sb?: False

1b) String.Equals(Object). Object is a String.
 *  The value of Object o2 is 'abcd'.
    Is str1 equal to o2?: True

 2) String.Equals(String)
 *  The value of String str2 is 'abcd'.
    Is str1 equal to str2?: True

 3) String.Equals(String, String)
    Is str1 equal to str2?: True
*/

Remarques

Cette méthode effectue une comparaison ordinale (respectant la casse et ne respectant pas la culture).

Voir aussi

• CompareOrdinal(String, String)

Equals(String, StringComparison)

Source:

String.Comparison.cs

Détermine si cette chaîne et un objet String spécifié ont la même valeur. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.

C#

public bool Equals (string? value, StringComparison comparisonType);

Paramètres

value

String

Chaîne à comparer à cette instance.

comparisonType

StringComparison

Une des valeurs d'énumération qui spécifie le mode de comparaison des chaînes.

Retours

Boolean

true si la valeur du paramètre value est la même que cette chaîne ; sinon, false.

Exceptions

ArgumentException

comparisonType n’est pas une valeur StringComparison.

Exemples

L’exemple suivant crée un tableau de chaînes qui se compose d’un « I » majuscule, d’un « i » minuscule et d’un « ı » sans point. Il appelle ensuite la Equals(String, StringComparison) méthode pour les comparer à l’aide de chaque valeur d’énumération possible StringComparison .

C#

using System;

class Sample 
{
   public static void Main() 
   {
      // Define a string array with the following three "I" characters:
      //      U+0069, U+0131, and U+0049.  
      string[] threeIs = { "i", "ı", "I" };
      // Define Type object representing StringComparison type.
      Type scType = typeof(StringComparison);  
      
      // Show the current culture (for culture-sensitive string comparisons).
      Console.WriteLine("The current culture is {0}.\n", 
                        System.Globalization.CultureInfo.CurrentCulture.Name);
        
      // Perform comparisons using each StringComparison member. 
      foreach (string scName in Enum.GetNames(scType))
      {
         StringComparison sc = (StringComparison) Enum.Parse(scType, scName);
         Console.WriteLine("Comparisons using {0}:", sc);
         // Compare each character in character array.
         for (int ctr = 0; ctr <= 1; ctr++)
         {
            string instanceChar = threeIs[ctr];
            for (int innerCtr = ctr + 1; innerCtr <= threeIs.GetUpperBound(0); innerCtr++)
            {
               string otherChar = threeIs[innerCtr];
               Console.WriteLine("{0} (U+{1}) = {2} (U+{3}): {4}", 
                                 instanceChar, Convert.ToInt16(Char.Parse(instanceChar)).ToString("X4"), 
                                 otherChar, Convert.ToInt16(Char.Parse(otherChar)).ToString("X4"), 
                                 instanceChar.Equals(otherChar, sc));
            }
            Console.WriteLine();
         }
      }   
   }
}
// The example displays the following output:
//       The current culture is en-US.
//       
//       Comparisons using CurrentCulture:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using CurrentCultureIgnoreCase:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using InvariantCulture:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using InvariantCultureIgnoreCase:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using Ordinal:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): False
//       
//       ı (U+0131) = I (U+0049): False
//       
//       Comparisons using OrdinalIgnoreCase:
//       i (U+0069) = ı (U+0131): False
//       i (U+0069) = I (U+0049): True
//       
//       ı (U+0131) = I (U+0049): False

Remarques

Le comparisonType paramètre indique si la comparaison doit utiliser la culture actuelle ou invariante, respecter ou ignorer la casse des deux chaînes comparées, ou utiliser des règles de tri de mot ou ordinal.

Voir aussi

• CompareOrdinal(String, String)

Equals(String, String, StringComparison)

Source:

String.Comparison.cs

Détermine si deux objets String spécifiés ont la même valeur. Un paramètre spécifie la culture, la casse et les règles de tri utilisées dans la comparaison.

C#

public static bool Equals (string? a, string? b, StringComparison comparisonType);

Paramètres

a

String

Première chaîne à comparer, ou null.

b

String

Deuxième chaîne à comparer, ou null.

comparisonType

StringComparison

Une des valeurs d'énumération qui spécifie les règles de la comparaison.

Retours

Boolean

true si la valeur du paramètre a est égale à la valeur du paramètre b ; sinon, false.

Exceptions

ArgumentException

comparisonType n’est pas une valeur StringComparison.

Exemples

L’exemple suivant compare trois ensembles de chaînes à l’aide de chaque membre de l’énumération StringComparison . Les comparaisons utilisent les conventions des cultures anglaise (États-Unis), thaïlandaise (Thaïlande) et turque (Turquie). Notez que les chaînes « a » et « a- » sont considérées comme équivalentes dans la culture « th-TH », mais pas dans les autres, tandis que « i » et « İ » sont considérés comme équivalents dans la culture « tr-TR » lorsque la casse est ignorée, mais pas dans les autres cultures.

C#

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

public class Example3
{
    public static void Main()
    {
        String[] cultureNames = { "en-US", "th-TH", "tr-TR" };
        String[] strings1 = { "a", "i", "case", };
        String[] strings2 = { "a-", "\u0130", "Case" };
        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
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: th-TH
//       a = a- (CurrentCulture): True
//       a = a- (CurrentCultureIgnoreCase): True
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): False
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True
//
//
//    Current Culture: tr-TR
//       a = a- (CurrentCulture): False
//       a = a- (CurrentCultureIgnoreCase): False
//       a = a- (InvariantCulture): False
//       a = a- (InvariantCultureIgnoreCase): False
//       a = a- (Ordinal): False
//       a = a- (OrdinalIgnoreCase): False
//
//       i = İ (CurrentCulture): False
//       i = İ (CurrentCultureIgnoreCase): True
//       i = İ (InvariantCulture): False
//       i = İ (InvariantCultureIgnoreCase): False
//       i = İ (Ordinal): False
//       i = İ (OrdinalIgnoreCase): False
//
//       case = Case (CurrentCulture): False
//       case = Case (CurrentCultureIgnoreCase): True
//       case = Case (InvariantCulture): False
//       case = Case (InvariantCultureIgnoreCase): True
//       case = Case (Ordinal): False
//       case = Case (OrdinalIgnoreCase): True

Remarques

Le comparisonType paramètre indique si la comparaison doit utiliser la culture actuelle ou invariante, respecter ou ignorer la casse des deux chaînes comparées, ou utiliser des règles de tri de mot ou ordinal.

Voir aussi

• CompareOrdinal(String, String)