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

Les opérateurs == (égalité) et != (inégalité) vérifient si leurs opérandes sont égaux ou non.

Opérateur d’égalité ==

L’opérateur d’égalité == retourne true si ses opérandes sont égaux, false dans le cas contraire.

Égalité de types valeur

Les opérandes des types valeur intégrés sont égaux si leurs valeurs sont égales :

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 l’un des opérandes n’est pas un nombre ( Double.NaN ou Single.NaN ), le résultat de l’opération est 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. Pour plus d’informations et des exemples, consultez l’article de référence Double.NaN ou Single.NaN.

Deux opérandes du même type enum sont égaux si les valeurs correspondantes du type intégral sous-jacent sont égales.

Par défaut, les types struct définis par l’utilisateur ne prennent pas en charge l’opérateur ==. Pour prendre en charge l’opérateur ==, un struct défini par l’utilisateur doit le surcharger.

À compter de C# 7.3, les opérateurs == et != sont pris en charge par les tuples C#. Pour plus d’informations, consultez la section égalité des tuples de l’article types de tuple .

Égalité de types référence

Par défaut, deux opérandes de type référence non-enregistrement sont égaux s’ils font référence au même objet :

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. Un type référence peut toutefois surcharger l’opérateur ==. 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.

Égalité des types d’enregistrements

Disponible en C# 9,0 et versions ultérieures, les types d’enregistrements prennent en charge les == != opérateurs et qui, par défaut, fournissent une sémantique d’égalité des valeurs. Autrement dit, deux opérandes d’enregistrement sont égaux lorsqu’ils sont ou que les null valeurs correspondantes de tous les champs et les propriétés implémentées automatiquement sont égales.

public class RecordTypesEquality
{
    public record Point(int X, int Y, string Name);
    public record TaggedNumber(int Number, List<string> Tags);

    public static void Main()
    {
        var p1 = new Point(2, 3, "A");
        var p2 = new Point(1, 3, "B");
        var p3 = new Point(2, 3, "A");

        Console.WriteLine(p1 == p2);  // output: False
        Console.WriteLine(p1 == p3);  // output: True

        var n1 = new TaggedNumber(2, new List<string>() { "A" });
        var n2 = new TaggedNumber(2, new List<string>() { "A" });
        Console.WriteLine(n1 == n2);  // output: False
    }
}

Comme le montre l’exemple précédent, dans le cas de membres de type référence non-enregistrement, leurs valeurs de référence sont comparées, et non les instances référencées.

Égalité de chaîne

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 :

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. Pour plus d’informations sur la comparaison de chaînes, consultez Comment comparer des chaînes en C#.

Égalité de délégué

Deux opérandes délégués du même type au moment de l’exécution sont égaux lorsqu’ils sont null ou que leurs listes d’appel sont de la même longueur et ont des entrées égales à chaque 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#.

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 :

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é !=

L’opérateur d’inégalité != retourne true si ses opérandes ne sont pas égaux, false dans le cas contraire. Pour les opérandes des types intégrés, l’expression x != y produit le même résultat que l’expression !(x == y). Pour plus d’informations sur l’égalité des types, consultez la section Opérateur d’égalité.

L’exemple suivant illustre l’utilisation de l’opérateur != :

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érateur

Un type défini par l’utilisateur peut surcharger les opérateurs == et !=. Si un type surcharge l’un des deux opérateurs, il doit également surcharger l’autre.

Un type d’enregistrement ne peut pas surcharger explicitement les == != opérateurs et. Si vous avez besoin de modifier le comportement des == != opérateurs et pour le type d’enregistrement T , implémentez la IEquatable<T>.Equals méthode avec la signature suivante :

public virtual bool Equals(T? other);

spécification du langage C#

Pour plus d’informations, consultez la section Opérateurs relationnels et de test de type de la spécification du langage C#.

Pour plus d’informations sur l’égalité des types d’enregistrements, consultez la section membres d’égalité de la remarque relative à la proposition de la fonctionnalité enregistrements.

Voir aussi