Comparaisons d’égalité (Guide de programmation C#)

Il est parfois nécessaire de comparer l’égalité de deux valeurs. Dans certains cas, vous testez l’égalité de valeur, également appelée équivalence, qui signifie que les valeurs contenues dans les deux variables sont égales. Dans d’autres cas, vous devez déterminer si deux variables référencent le même objet sous-jacent en mémoire. Ce type d’égalité est appelée l’égalité de référence ou identité. Cette rubrique décrit ces deux genres d’égalité et fournit des liens vers d’autres rubriques pour obtenir plus d’informations.

Égalité des références

L’égalité de références signifie que deux références d’objets référencent le même objet sous-jacent. Cela peut se produire par simple assignation, comme illustré dans l’exemple suivant.

using System;
class Test
{
    public int Num { get; set; }
    public string Str { get; set; }

    public static void Main()
    {
        Test a = new Test() { Num = 1, Str = "Hi" };
        Test b = new Test() { Num = 1, Str = "Hi" };

        bool areEqual = System.Object.ReferenceEquals(a, b);
        // False:
        System.Console.WriteLine("ReferenceEquals(a, b) = {0}", areEqual);

        // Assign b to a.
        b = a;

        // Repeat calls with different results.
        areEqual = System.Object.ReferenceEquals(a, b);
        // True:
        System.Console.WriteLine("ReferenceEquals(a, b) = {0}", areEqual);
    }
}

Dans ce code, deux objets sont créés, mais après l’instruction d’assignation, les deux références référencent le même objet. Elles présentent donc une égalité de référence. Utilisez la méthode ReferenceEquals pour déterminer si deux références référencent le même objet.

Le concept d’égalité de référence s’applique uniquement aux types référence. Les objets de type valeur ne peuvent pas avoir une égalité de référence, car quand une instance d’un type valeur est assignée à une variable, une copie de la valeur est effectuée. Ainsi, vous ne pouvez jamais avoir deux structs unboxed qui référencent le même emplacement en mémoire. De plus, si vous utilisez ReferenceEquals pour comparer deux types valeur, le résultat est toujours false, même si les valeurs contenues dans les objets sont toutes identiques. Cela est dû au fait que chaque variable est convertie en une instance d’objet distincte. Pour plus d’informations, consultez Guide pratique pour tester l’égalité des références (Identité).

Égalité des valeurs

L’égalité de valeur signifie que deux objets contiennent les mêmes valeurs. Pour les types valeur primitifs tels que int ou bool, les tests d’égalité de valeur sont simples. Vous pouvez utiliser l’opérateur ==, comme indiqué dans l’exemple suivant.

int a = GetOriginalValue();  
int b = GetCurrentValue();  
  
// Test for value equality.
if (b == a)
{  
    // The two integers are equal.  
}  

Pour la plupart des autres types, les tests d’égalité de valeur sont plus complexes parce qu’ils vous demandent de comprendre comment le type la définit. Pour les classes et structs qui ont plusieurs champs ou propriétés, l’égalité de valeur signifie souvent que tous les champs ou propriétés ont la même valeur. Par exemple, deux objets Point peuvent être définis comme équivalents si pointA.X est égal à pointB.X et que pointA.Y est égal à pointB.Y. Pour les enregistrements, l’égalité des valeurs signifie que deux variables d’un type d’enregistrement sont égales si les types correspondent et que toutes les valeurs de propriété et de champ correspondent.

Toutefois, il n’est pas obligatoire que l’équivalence soit basée sur tous les champs dans un type. Elle peut être basée sur une partie. Quand vous comparez des types dont vous n’êtes pas propriétaire, vous devez bien comprendre comment l’équivalence est définie pour ce type. Pour plus d’informations sur la façon de définir l’égalité des valeurs dans vos propres classes et structs, consultez Guide pratique pour définir une égalité de valeurs pour un type.

Égalité des valeurs à virgule flottante

Les comparaisons d’égalité des valeurs à virgule flottante (double et float) sont problématiques en raison de l’imprécision de l’arithmétique à virgule flottante sur les ordinateurs binaires. Pour plus d’informations, consultez les notes dans la rubrique System.Double.

Rubriques connexes

Intitulé	Description
Guide pratique pour tester l’égalité des références (Identité)	Décrit comment déterminer si deux variables présentent une égalité de référence.
Comment définir une égalité de valeurs pour un type	Décrit comment fournir une définition personnalisée de l’égalité de valeur pour un type.
Types	Fournit des informations sur le système de typeC# et des liens vers des informations supplémentaires.
Enregistrements	Fournit des informations sur les types d’enregistrements, qui testent par défaut l’égalité des valeurs.