¿Cómo verifico valores nulos en una sobrecarga de operador '==' sin recursividad infinita?

Lo siguiente causará una recursividad infinita en el método de sobrecarga del operador ==

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

¿Cómo verifico si hay nulos?

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

Transmitir a objeto en el método de sobrecarga:

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

Utilice ReferenceEquals. Desde los foros de 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;
}

Tratar Object.ReferenceEquals(foo1, null)

De todos modos, no recomendaría sobrecargar al ==operador; debe usarse para comparar referencias y usarse Equalspara comparaciones "semánticas".

Si he anulado bool Equals(object obj)y quiero que el operador ==y Foo.Equals(object obj)devuelva el mismo valor, generalmente implemento el !=operador de esta manera:

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

==Luego, el operador , después de hacer todas las comprobaciones nulas, terminará llamando foo1.Equals(foo2)que he anulado para hacer la verificación real si los dos son iguales.

Si está utilizando C # 7 o posterior, puede utilizar la coincidencia de patrones constantes nulos:

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

Esto le da un código un poco más ordenado que el que llama al objeto. ReferenceEquals (foo1, null)

En realidad, existe una forma más sencilla de verificar nullen este caso:

if (foo is null)

¡Eso es!

Esta característica se introdujo en C # 7

Mi enfoque es hacer

(object)item == null

en el que confío en objectel propio operador de igualdad que no puede fallar. O un método de extensión personalizado (y una sobrecarga):

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

o para manejar más casos, puede ser:

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

La restricción impide los IsNulltipos de valor. Ahora es tan dulce como llamar

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

lo que significa que tengo un estilo consistente / no propenso a errores de verificación de nulos en todo momento. También he descubierto que (object)item == nulles muy, muy ligeramente más rápido queObject.ReferenceEquals(item, null) , pero solo si importa (¡actualmente estoy trabajando en algo en lo que tengo que micro-optimizar todo!).

Para ver una guía completa sobre la implementación de verificaciones de igualdad, consulte ¿Cuál es la "práctica recomendada" para comparar dos instancias de un tipo de referencia?

El Equals(Object, Object)método estático indica si dos objetos, objAy objB, son iguales. También le permite probar objetos cuyo valor es nullde igualdad. Compara objAy objBpor igualdad de la siguiente manera:

• Determina si los dos objetos representan la misma referencia de objeto. Si lo hacen, el método regresa true. Esta prueba es equivalente a llamar al ReferenceEqualsmétodo. Además, si ambos objAy objBson null, el método regresa true.
• Determina si es objAo objBes null. Si es así, vuelve false. Si los dos objetos no representan la misma referencia de objeto y ninguno lo es null, llama objA.Equals(objB)y devuelve el resultado. Esto significa que si objAanula el Object.Equals(Object)método, se llama a esta anulación.

.

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

respondiendo más al operador anulante cómo comparar con nulo que redirige aquí como un duplicado.

En los casos en que esto se hace para admitir objetos de valor, encuentro que la nueva notación es útil y me gusta asegurarme de que solo haya un lugar donde se realice la comparación. Además, aprovechar Object.Equals (A, B) simplifica las comprobaciones nulas.

Esto sobrecargará ==,! =, Equals y 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();

Para objetos más complicados, agregue comparaciones adicionales en Equals y un GetHashCode más rico.

Para una sintaxis moderna y condensada:

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

Un error común en las sobrecargas de operador == es utilizar (a == b), (a ==null)o (b == null)para comprobar la igualdad de referencia. En cambio, esto da como resultado una llamada al operador sobrecargado ==, lo que provoca un infinite loop. Utilice ReferenceEqualso convierta el tipo en Objeto para evitar el bucle.

mira esto

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

Directrices de referencia para sobrecargar Equals () y Operador ==

Puede intentar usar una propiedad de objeto y capturar la NullReferenceException resultante. Si la propiedad que prueba se hereda o se anula de Object, esto funciona para cualquier clase.

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