Opérateurs d’égalité : testent si deux objets sont égaux ou non

  • Article

Les opérateurs == (égalité) et != (inégalité) vérifient si leurs opérandes sont égaux ou non. Les types de valeurs sont égaux lorsque leur contenu est égal. Les types de référence sont égaux lorsque les deux variables font référence au même stockage.

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

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

É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

Les types d’enregistrements prennent en charge les opérateurs == et != qui fournissent par défaut une sémantique d’égalité des valeurs. Autrement dit, deux opérandes d’enregistrement sont égaux quand les deux sont null ou de valeurs correspondantes pour tous les champs et que 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, pour les 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

Les comparaisons d’égalité de chaîne sont des comparaisons ordinales 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 à l’exécution 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 :

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 un des deux opérateurs, il doit aussi en surcharger un autre.

Un type d’enregistrement ne peut pas surcharger explicitement les opérateurs == et !=. Si vous devez modifier le comportement des opérateurs == et != pour le type d’enregistrement T, implémentez la méthode IEquatable<T>.Equals 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 note de proposition de fonctionnalité d’enregistrement.

Voir aussi