Partage via

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

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.

La documentation de référence du langage C# décrit la version la plus récente du langage C#. Il contient également la documentation initiale des fonctionnalités dans les préversions publiques pour la prochaine version du langage.

La documentation identifie toute fonctionnalité introduite en premier dans les trois dernières versions de la langue ou dans les préversions publiques actuelles.

Conseil / Astuce

Pour savoir quand une fonctionnalité a été introduite en C#, consultez l’article sur l’historique des versions du langage C#.

Vous pouvez utiliser l’opérateur is de correspondance de modèle comme alternative à un == test lorsque vous testez sur une valeur constante. L’opérateur is utilise la sémantique d’égalité par défaut pour tous les types valeur et référence.

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 Cette condition signifie que la NaN valeur n’est pas supérieure, inférieure ou égale à une autre double valeur (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 tuples C# prennent en charge les opérateurs et == les != opérateurs intégrés. 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, les opérandes de type référence, à l’exception des enregistrements, 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 lorsque les deux sont null ou des valeurs correspondantes de 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 l’illustre l’exemple précédent, pour les membres de type référence, 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 d’exécution sont égaux lorsque les deux sont null ou leurs listes d’appel sont de la 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

Important

Les entrées égales dans une liste d’appels incluent tous les paramètres fixes dans l’appel, y compris le récepteur. Le récepteur est l’instance d’un objet représenté par this l’appel de l’entrée.

var o1 = new object();
var o2 = new object();
var d1 = o1.ToString;
var d2 = o2.ToString;
Console.WriteLine(object.ReferenceEquals(d1, d2));  // output: False
Console.WriteLine(d1 == d2);  // output: False (different receivers)

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 provenant de l’évaluation d’expressions lambda identiques sémantiquement ne sont pas égaux, comme l’illustre 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 et false sinon. 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 montre comment utiliser 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

Vous pouvez surcharger les opérateurs et != les == opérateurs dans un type défini par l’utilisateur. Si vous surchargez l’un de ces deux opérateurs, vous devez également surcharger l’autre opérateur.

Vous ne pouvez pas surcharger explicitement les opérateurs et != les == opérateurs dans un type d’enregistrement. Pour modifier le comportement des opérateurs et != du == type Td’enregistrement, 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 note de proposition de fonctionnalité d’enregistrement.

Voir aussi

  • Last updated on