Opérateurs d’égalité (référence C#)Equality operators (C# reference)

Les opérateurs == (égalité) et != (inégalité) vérifient si leurs opérandes sont égaux ou non.The == (equality) and != (inequality) operators check if their operands are equal or not.

Opérateur d’égalité ==Equality operator ==

L’opérateur d’égalité == retourne true si ses opérandes sont égaux, false dans le cas contraire.The equality operator == returns true if its operands are equal, false otherwise.

Égalité de types valeurValue types equality

Les opérandes des types valeur intégrés sont égaux si leurs valeurs sont égales :Operands of the built-in value types are equal if their values are equal:

int a = 1 + 2 + 3;
int b = 6;
Console.WriteLine(a == b);  // output: True

char c1 = 'a';
char c2 = 'A';
Console.WriteLine(c1 == c2);  // output: False
Console.WriteLine(c1 == char.ToLower(c2));  // output: True

Notes

Pour les opérateurs ==, <, >, <= et >=, si un des opérandes n’est pas un nombre (Double.NaN ou Single.NaN), le résultat de l’opération est false.For the ==, <, >, <=, and >= operators, if any of the operands is not a number (Double.NaN or Single.NaN), the result of operation is false. Cela signifie que la valeur NaN n’est ni supérieure à, ni inférieure à, ni égale à n’importe quelle autre valeur double (ou float), y compris NaN.That means that the NaN value is neither greater than, less than, nor equal to any other double (or float) value, including NaN. Pour plus d’informations et des exemples, consultez l’article de référence Double.NaN ou Single.NaN.For more information and examples, see the Double.NaN or Single.NaN reference article.

Deux opérandes du même type enum sont égaux si les valeurs correspondantes du type intégral sous-jacent sont égales.Two operands of the same enum type are equal if the corresponding values of the underlying integral type are equal.

Par défaut, les types struct définis par l’utilisateur ne prennent pas en charge l’opérateur ==.User-defined struct types don't support the == operator by default. Pour prendre en charge l’opérateur ==, un struct défini par l’utilisateur doit le surcharger.To support the == operator, a user-defined struct must overload it.

À compter de C# 7.3, les opérateurs == et != sont pris en charge par les tuples C#.Beginning with C# 7.3, the == and != operators are supported by C# tuples. Pour plus d’informations, consultez la section Égalité et tuples de l’article Types de tuple C#.For more information, see the Equality and tuples section of the C# tuple types article.

Égalité de types référenceReference types equality

Par défaut, deux opérandes de type référence sont égaux s’ils font référence au même objet :By default, two reference-type operands are equal if they refer to the same object:

public class ReferenceTypesEquality
{
    public class MyClass
    {
        private int id;

        public MyClass(int id) => this.id = id;
    }

    public static void Main()
    {
        var a = new MyClass(1);
        var b = new MyClass(1);
        var c = a;
        Console.WriteLine(a == b);  // output: False
        Console.WriteLine(a == c);  // output: True
    }
}

Comme le montre l’exemple, les types référence définis par l’utilisateur prennent en charge l’opérateur == par défaut.As the example shows, user-defined reference types support the == operator by default. Un type référence peut toutefois surcharger l’opérateur ==.However, a reference type can overload the == operator. Si un type référence surcharge l’opérateur ==, utilisez la méthode Object.ReferenceEquals pour vérifier si deux références de ce type font référence au même objet.If a reference type overloads the == operator, use the Object.ReferenceEquals method to check if two references of that type refer to the same object.

Égalité de chaîneString equality

Deux opérandes string sont égaux lorsque les deux sont null ou lorsque les deux instances de chaîne sont de même longueur et ont des caractères identiques dans chaque position de caractère :Two string operands are equal when both of them are null or both string instances are of the same length and have identical characters in each character position:

string s1 = "hello!";
string s2 = "HeLLo!";
Console.WriteLine(s1 == s2.ToLower());  // output: True

string s3 = "Hello!";
Console.WriteLine(s1 == s3);  // output: False

Il s’agit d’une comparaison ordinale respectant la casse.That is a case-sensitive ordinal comparison. Pour plus d’informations sur la comparaison de chaînes, consultez Comment comparer des chaînes en C#.For more information about string comparison, see How to compare strings in C#.

Égalité de déléguéDelegate equality

Deux opérandes de délégué du même type de runtime sont égaux si les deux sont null ou si leurs listes d’appel sont de même longueur et ont des entrées égales dans chaque position :Two delegate operands of the same runtime type are equal when both of them are null or their invocation lists are of the same length and have equal entries in each position:

Action a = () => Console.WriteLine("a");

Action b = a + a;
Action c = a + a;
Console.WriteLine(object.ReferenceEquals(b, c));  // output: False
Console.WriteLine(b == c);  // output: True

Pour plus d’informations, consultez la section Opérateurs d’égalité de délégué de la spécification du langage C#.For more information, see the Delegate equality operators section of the C# language specification.

Les délégués qui sont produits à partir de l’évaluation d’expressions lambda identiques sémantiquement ne sont pas égaux, comme l’indique l’exemple suivant :Delegates that are produced from evaluation of semantically identical lambda expressions are not equal, as the following example shows:

Action a = () => Console.WriteLine("a");
Action b = () => Console.WriteLine("a");

Console.WriteLine(a == b);  // output: False
Console.WriteLine(a + b == a + b);  // output: True
Console.WriteLine(b + a == a + b);  // output: False

Opérateur d’inégalité !=Inequality operator !=

L’opérateur d’inégalité != retourne true si ses opérandes ne sont pas égaux, false dans le cas contraire.The inequality operator != returns true if its operands are not equal, false otherwise. Pour les opérandes des types intégrés, l’expression x != y produit le même résultat que l’expression !(x == y).For the operands of the built-in types, the expression x != y produces the same result as the expression !(x == y). Pour plus d’informations sur l’égalité des types, consultez la section Opérateur d’égalité.For more information about type equality, see the Equality operator section.

L’exemple suivant illustre l’utilisation de l’opérateur != :The following example demonstrates the usage of the != operator:

int a = 1 + 1 + 2 + 3;
int b = 6;
Console.WriteLine(a != b);  // output: True

string s1 = "Hello";
string s2 = "Hello";
Console.WriteLine(s1 != s2);  // output: False

object o1 = 1;
object o2 = 1;
Console.WriteLine(o1 != o2);  // output: True

Capacité de surcharge de l’opérateurOperator overloadability

Un type défini par l’utilisateur peut surcharger les opérateurs == et !=.A user-defined type can overload the == and != operators. Si un type surcharge un des deux opérateurs, il doit aussi en surcharger un autre.If a type overloads one of the two operators, it must also overload another one.

spécification du langage C#C# language specification

Pour plus d’informations, consultez la section Opérateurs relationnels et de test de type de la spécification du langage C#.For more information, see the Relational and type-testing operators section of the C# language specification.

Voir aussiSee also