¿Por qué lanzar a objeto al comparar con nulo?

Question

Mientras navegaba por las documentaciones de MSDN sobre anulaciones de Igualdad, un punto me llamó la atención.

En los ejemplos de this specific page, algunos cheques nulos están hechos, y los objetos están fundidas con el tipo System.Object al hacer la comparación:

public override bool Equals(System.Object obj) 
{ 
    // If parameter is null return false. 
    if (obj == null) 
    { 
     return false; 
    } 

    // If parameter cannot be cast to Point return false. 
    TwoDPoint p = obj as TwoDPoint; 
    if ((System.Object)p == null) 
    { 
     return false; 
    } 

    // Return true if the fields match: 
    return (x == p.x) && (y == p.y); 
} 

¿Hay alguna razón específica para utilizar este molde, o ¿Es solo un código "inútil" olvidado en este ejemplo?

Answer 1

Es posible que un tipo sobrecargue el operador ==. La conversión a objeto garantiza que se use la definición original.

Answer 2

Creo que la conversión a System.Object lo llevaría a cualquier sobrecarga de operador que pudiera tener TwoDPoint.

Answer 3

Esto podría haber sido parte de una muestra más grande donde el operador == estaba sobrecargado. En ese caso, usar obj == null podría haber resultado en StackOverflow si se invoca TwoDPoint.Equals (object) como parte de la definición ==.

Answer 4

Como han dicho otros, el tipo puede anular el operador ==. Por lo tanto, la conversión a Object es equivalente a if (Object.ReferenceEquals(p, null)) { ... }.

Answer 5

Probablemente existe para evitar confusiones con un operador == sobrecargado. Imagine si el elenco no existía y el operador == estaba sobrecargado. Ahora la línea p == null se uniría potencialmente al operador ==. Muchas implementaciones de operator == simplemente difieren al método Equals reemplazado. Esto podría causar fácilmente una situación de desbordamiento de pila

public static bool operator==(TwoDPoint left, TwoDPoint right) { 
    return left.Equals(right); 
} 

public override bool Equals(System.Object obj) { 
    ... 
    TwoDPoint p = obj as TwoDPoint; 
    if (p == null) { // Stack overflow!!! 
     return false; 
    } 

    ... 
} 

Echando a Object el autor asegura una verificación de referencia simple para ocurrirá null (que es lo que se pretende).