Jak sprawdzić wartości null w przeciążeniu operatora „==” bez nieskończonej rekursji?

Poniższe działania spowodują nieskończoną rekursję w metodzie przeciążenia operatora ==

    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);
    }

Jak sprawdzić wartości null?

Zastosowanie 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);
}

Rzutowanie na obiekt w metodzie przeciążenia:

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

Użyj ReferenceEquals. Z forów 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;
}

Próbować Object.ReferenceEquals(foo1, null)

W każdym razie nie polecałbym przeciążania ==operatora; Powinien być używany do porównywania odniesień i Equalsdo porównań „semantycznych”.

Jeśli nadpisałem bool Equals(object obj)i chcę, aby operator ==i Foo.Equals(object obj)zwracał tę samą wartość, zwykle implementuję !=operator w ten sposób:

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);
}

Operator ==po wykonaniu wszystkich sprawdzeń zerowych zakończy się dla mnie wywołaniem foo1.Equals(foo2), że przesłoniłem, aby wykonać faktyczne sprawdzenie, czy oba są równe.

Jeśli używasz języka C # 7 lub nowszego, możesz użyć stałego dopasowania wzorca o wartości null:

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

Daje to nieco schludniejszy kod niż ten wywołujący obiekt.ReferenceEquals (foo1, null)

W nulltym przypadku istnieje prostszy sposób sprawdzenia :

if (foo is null)

Otóż ​​to!

Ta funkcja została wprowadzona w języku C # 7

Moje podejście jest do zrobienia

(object)item == null

na którym polegam na objectwłasnym operatorze równości, który nie może się nie udać. Lub niestandardowa metoda rozszerzenia (i przeciążenie):

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;
}

lub aby obsłużyć więcej spraw, może być:

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

Ograniczenie zapobiega IsNulltypom wartości. Teraz jest tak słodki jak dzwonienie

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

co oznacza, że ​​mam jeden spójny / nie podatny na błędy styl sprawdzania wartości null w całym tekście. Stwierdziłem również, że (object)item == nulljest bardzo, bardzo, trochę szybszy niżObject.ReferenceEquals(item, null) , ale tylko wtedy, gdy ma to znaczenie (obecnie pracuję nad czymś, w którym muszę wszystko mikro-optymalizować!).

Aby zobaczyć kompletny przewodnik dotyczący wdrażania sprawdzania równości, zobacz „ Co to jest„ Najlepsza praktyka ”porównywania dwóch wystąpień typu odwołania?

Statyczne Equals(Object, Object)metody wskazuje, czy dwa obiekty, objAa objBsą równe. Umożliwia także testowanie obiektów, których wartość dotyczy nullrówności. Porównuje objAi objBdla równości w następujący sposób:

• Określa, czy te dwa obiekty reprezentują to samo odniesienie do obiektu. Jeśli tak, metoda zwraca true. Ten test jest równoważny wywołaniu ReferenceEqualsmetody. Ponadto, jeśli oba objAi objBsą null, metoda zwraca true.
• Określa, czy jest albo objAczy objBjest null. Jeśli tak, to wraca false. Jeśli te dwa obiekty nie reprezentują tego samego odwołania do obiektu i żadna z nich nie jest null, wywołuje objA.Equals(objB)i zwraca wynik. Oznacza to, że jeśli objAprzesłania Object.Equals(Object)metodę, to zastąpienie jest wywoływane.

.

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

odpowiadanie bardziej na przesłanianie operatora, jak porównać z null, który przekierowuje tutaj jako duplikat.

W przypadkach, w których robi się to w celu obsługi obiektów wartości, uważam, że nowa notacja jest przydatna i lubię upewnić się, że jest tylko jedno miejsce, w którym dokonuje się porównania. Wykorzystanie również Object.Equals (A, B) upraszcza sprawdzanie wartości null.

Spowoduje to przeciążenie ==,! =, Equals i 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();

W przypadku bardziej skomplikowanych obiektów dodaj dodatkowe porównania w Equals i bogatszym GetHashCode.

Aby uzyskać nowoczesną i skondensowaną składnię:

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);
}

Częstym błędem w przeciążeń operatora == jest użycie (a == b), (a ==null)lub (b == null)w celu sprawdzenia równości odniesienia. Zamiast tego powoduje wywołanie przeciążonego operatora ==, powodując błąd infinite loop. Użyj ReferenceEqualslub rzuć typ na Object, aby uniknąć pętli.

Sprawdź to

// 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;
}

odniesienia Wytyczne dotyczące przeciążania równa się () i operator ==

Możesz spróbować użyć właściwości obiektu i przechwycić wynikowy wyjątek NullReferenceException. Jeśli próbowana właściwość jest dziedziczona lub zastępowana przez Object, to działa to dla każdej klasy.

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;
}