Comment puis-je vérifier les valeurs nulles dans une surcharge d'opérateur '==' sans récursivité infinie?

Ce qui suit provoquera une récursion infinie sur la méthode de surcharge de l'opérateur ==

    Foo foo1 = null;
    Foo foo2 = new Foo();
    Assert.IsFalse(foo1 == foo2);

    public static bool operator ==(Foo foo1, Foo foo2) {
        if (foo1 == null) return foo2 == null;
        return foo1.Equals(foo2);
    }

Comment vérifier les valeurs nulles?

Utilisez ReferenceEquals:

Foo foo1 = null;
Foo foo2 = new Foo();
Assert.IsFalse(foo1 == foo2);

public static bool operator ==(Foo foo1, Foo foo2) {
    if (object.ReferenceEquals(null, foo1))
        return object.ReferenceEquals(null, foo2);
    return foo1.Equals(foo2);
}

Cast en objet dans la méthode de surcharge:

public static bool operator ==(Foo foo1, Foo foo2) {
    if ((object) foo1 == null) return (object) foo2 == null;
    return foo1.Equals(foo2);
}

Utilisez ReferenceEquals. Depuis les forums MSDN :

public static bool operator ==(Foo foo1, Foo foo2) {
    if (ReferenceEquals(foo1, null)) return ReferenceEquals(foo2, null);
    if (ReferenceEquals(foo2, null)) return false;
    return foo1.field1 == foo2.field2;
}

Essayer Object.ReferenceEquals(foo1, null)

Quoi qu'il en soit, je ne recommanderais pas de surcharger l' ==opérateur; il doit être utilisé pour comparer des références et Equalspour des comparaisons «sémantiques».

Si je l' ai substituée bool Equals(object obj)et je veux l'opérateur ==et Foo.Equals(object obj)de retourner la même valeur, je mets en œuvre habituellement l' !=opérateur comme celui - ci:

public static bool operator ==(Foo foo1, Foo foo2) {
  return object.Equals(foo1, foo2);
}
public static bool operator !=(Foo foo1, Foo foo2) {
  return !object.Equals(foo1, foo2);
}

L'opérateur ==, après avoir effectué toutes les vérifications nulles pour moi, finira par appeler foo1.Equals(foo2)que j'ai remplacé pour faire la vérification réelle si les deux sont égaux.

Si vous utilisez C # 7 ou une version ultérieure, vous pouvez utiliser la correspondance de modèle à constante nulle:

public static bool operator==(Foo foo1, Foo foo2)
{
    if (foo1 is null)
        return foo2 is null;
    return foo1.Equals(foo2);
}

Cela vous donne un code légèrement plus net que celui de l'objet appelant.ReferenceEquals (foo1, null)

Il existe en fait un moyen plus simple de vérifier nulldans ce cas:

if (foo is null)

C'est tout!

Cette fonctionnalité a été introduite en C # 7

Mon approche est de faire

(object)item == null

sur lequel je me fie à son objectpropre opérateur d'égalité qui ne peut pas aller mal. Ou une méthode d'extension personnalisée (et une surcharge):

public static bool IsNull<T>(this T obj) where T : class
{
    return (object)obj == null;
}

public static bool IsNull<T>(this T? obj) where T : struct
{
    return !obj.HasValue;
}

ou pour traiter plus de cas, peut être:

public static bool IsNull<T>(this T obj) where T : class
{
    return (object)obj == null || obj == DBNull.Value;
}

La contrainte empêche IsNullles types valeur. Maintenant c'est aussi doux que d'appeler

object obj = new object();
Guid? guid = null; 
bool b = obj.IsNull(); // false
b = guid.IsNull(); // true
2.IsNull(); // error

ce qui signifie que j'ai un style cohérent / non sujet aux erreurs de vérification des valeurs nulles partout. J'ai aussi trouvé que (object)item == nullc'est très très très légèrement plus rapide queObject.ReferenceEquals(item, null) , mais seulement si cela compte (je travaille actuellement sur quelque chose où je dois tout micro-optimiser!).

Pour consulter un guide complet sur la mise en œuvre des vérifications d'égalité, consultez Qu'est - ce que la «meilleure pratique» pour comparer deux instances d'un type de référence?

La Equals(Object, Object)méthode statique indique si deux objets, objAet objB, sont égaux. Il vous permet également de tester des objets dont la valeur est nullpour l'égalité. Il compare objAet objBpour l'égalité comme suit:

• Il détermine si les deux objets représentent la même référence d'objet. Si c'est le cas, la méthode retourne true. Ce test équivaut à appeler la ReferenceEqualsméthode. De plus, si les deux objAet objBsont null, la méthode retournetrue .
• Il détermine si l'un objAou l' autre objBest null. Si tel est le cas, il revient false. Si les deux objets ne représentent pas la même référence d'objet et que ni l'un ni l'autre ne l'est null, il appelle objA.Equals(objB)et renvoie le résultat. Cela signifie que s'il objAremplace la Object.Equals(Object)méthode, ce remplacement est appelé.

.

public static bool operator ==(Foo objA, Foo objB) {
    return Object.Equals(objA, objB);
}

répondre plus à opérateur de remplacement comment comparer à null qui redirige ici comme un doublon.

Dans les cas où cela est fait pour prendre en charge les objets de valeur, je trouve la nouvelle notation pratique et j'aime m'assurer qu'il n'y a qu'un seul endroit où la comparaison est faite. Exploiter également Object.Equals (A, B) simplifie les vérifications nulles.

Cela surchargera ==,! =, Equals et GetHashCode

    public static bool operator !=(ValueObject self, ValueObject other) => !Equals(self, other);
    public static bool operator ==(ValueObject self, ValueObject other) => Equals(self, other);
    public override bool Equals(object other) => Equals(other as ValueObject );
    public bool Equals(ValueObject other) {
        return !(other is null) && 
               // Value comparisons
               _value == other._value;
    }
    public override int GetHashCode() => _value.GetHashCode();

Pour les objets plus compliqués, ajoutez des comparaisons supplémentaires dans Equals et un GetHashCode plus riche.

Pour une syntaxe moderne et condensée:

public static bool operator ==(Foo x, Foo y)
{
    return x is null ? y is null : x.Equals(y);
}

public static bool operator !=(Foo x, Foo y)
{
    return x is null ? !(y is null) : !x.Equals(y);
}

Une erreur commune de l' opérateur == surcharge est d'utiliser (a == b), (a ==null)ou (b == null)pour vérifier l'égalité de référence. Cela entraîne à la place un appel à l'opérateur surchargé ==, provoquant un infinite loop. Utilisez ReferenceEqualsou transtypez le type en Object pour éviter la boucle.

Regarde ça

// If both are null, or both are same instance, return true.
if (System.Object.ReferenceEquals(a, b))// using ReferenceEquals
{
    return true;
}

// If one is null, but not both, return false.
if (((object)a == null) || ((object)b == null))// using casting the type to Object
{
    return false;
}

Reference Guidelines for Overloading Equals () et Operator ==

Vous pouvez essayer d'utiliser une propriété d'objet et intercepter l'exception NullReferenceException résultante. Si la propriété que vous essayez est héritée ou remplacée par Object, cela fonctionne pour n'importe quelle classe.

public static bool operator ==(Foo foo1, Foo foo2)
{
    //  check if the left parameter is null
    bool LeftNull = false;
    try { Type temp = a_left.GetType(); }
    catch { LeftNull = true; }

    //  check if the right parameter is null
    bool RightNull = false;
    try { Type temp = a_right.GetType(); }
    catch { RightNull = true; }

    //  null checking results
    if (LeftNull && RightNull) return true;
    else if (LeftNull || RightNull) return false;
    else return foo1.field1 == foo2.field2;
}