Как проверить наличие нулей в перегрузке оператора '==' без бесконечной рекурсии?

Следующее вызовет бесконечную рекурсию в методе перегрузки оператора ==.

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

Как проверить наличие нулей?

Использование 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);
}

Привести к объекту в методе перегрузки:

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

Используйте ReferenceEquals. На форумах 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;
}

Пытаться Object.ReferenceEquals(foo1, null)

В любом случае я бы не рекомендовал перегружать ==оператора; его следует использовать для сравнения ссылок и использовать Equalsдля «семантических» сравнений.

Если я переопределил bool Equals(object obj)и хочу, чтобы оператор ==и Foo.Equals(object obj)возвращал одно и то же значение, я обычно реализую !=оператор следующим образом:

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

Затем оператор ==после выполнения всех проверок на null для меня в конечном итоге вызовет то, foo1.Equals(foo2)что я переопределил, чтобы выполнить фактическую проверку, равны ли они.

Если вы используете C # 7 или новее, вы можете использовать сопоставление с нулевым постоянным шаблоном:

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

Это дает вам немного более аккуратный код, чем один вызывающий объект .ReferenceEquals (foo1, null)

В этом случае есть более простой способ проверки null:

if (foo is null)

Это оно!

Эта функция была представлена ​​в C # 7

Мой подход - делать

(object)item == null

на что я полагаюсь на objectсобственный оператор равенства, который не может ошибиться. Или собственный метод расширения (и перегрузка):

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

или для обработки большего количества дел может быть:

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

Ограничение предотвращает использование IsNullтипов значений. Теперь это так же мило, как звонить

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

Это означает, что у меня есть один последовательный / не подверженный ошибкам стиль проверки на нули повсюду. Я также обнаружил, что (object)item == nullэто очень-очень-очень немного быстрееObject.ReferenceEquals(item, null) , но только если это имеет значение (в настоящее время я работаю над чем-то, где я должен все микро-оптимизировать!).

Чтобы увидеть полное руководство по внедрению проверок равенства, см. Что такое «лучшая практика» для сравнения двух экземпляров ссылочного типа?

Статический Equals(Object, Object)метод указывает, равны ли два объекта, objAи objB. Это также позволяет вам тестировать объекты, значение которых соответствует nullравенству. Он сравнивает objAи objBна равенство следующим образом:

• Он определяет, представляют ли два объекта одну и ту же ссылку на объект. Если они это сделают, метод вернется true. Этот тест эквивалентен вызову ReferenceEqualsметода. Кроме того, если оба objAи objBесть null, метод возвращает true.
• Он определяет, есть ли objAили objBесть null. Если так, он возвращается false. Если два объекта не представляют одну и ту же ссылку на объект, и ни один из них не является null, он вызывает objA.Equals(objB)и возвращает результат. Это означает, что при objAпереопределении Object.Equals(Object)метода вызывается это переопределение.

.

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

больше отвечая на переопределяющий оператор, как сравнить с null, который перенаправляется здесь как дубликат.

В тех случаях, когда это делается для поддержки объектов-значений, я считаю новую нотацию удобной и хочу убедиться, что есть только одно место, где производится сравнение. Также использование Object.Equals (A, B) упрощает нулевые проверки.

Это приведет к перегрузке ==,! =, Equals и 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();

Для более сложных объектов добавьте дополнительные сравнения в Equals и более богатый GetHashCode.

Для современного сжатого синтаксиса:

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

Распространенная ошибка в перегруженных операторе == является использование (a == b), (a ==null)или (b == null)для проверки равенства ссылок. Вместо этого это приводит к вызову перегруженного оператора ==, вызывая infinite loop. Используйте ReferenceEqualsили приведите тип к Object, чтобы избежать цикла.

проверь это

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

справочные руководства по перегрузке Equals () и Operator ==

Вы можете попробовать использовать свойство объекта и поймать результирующее исключение NullReferenceException. Если свойство, которое вы пробуете, унаследовано или переопределено от Object, то это работает для любого класса.

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