Як перевірити наявність нульових значень при перевантаженні оператора '==' без нескінченної рекурсії?

Нижче наведено нескінченну рекурсію методу перевантаження оператора ==

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

Оператор ==потім, виконавши всі нульові перевірки для мене, в кінцевому підсумку зателефонує, 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) спрощує нульові перевірки.

Це перевантажить ==,! =, Дорівнює та 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();

Для більш складних об'єктів додайте додаткові порівняння в рівних та багатший 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;
}

довідкові вказівки щодо перевантаження рівних () та оператора ==

Ви можете спробувати скористатися властивістю об'єкта і зафіксувати отриманий 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;
}