¿Por qué arrojar nulo antes de verificar si el objeto es igual a nulo?

Question

Estaba mirando el proyecto "Domain Oriented N-Layered .NET 4.0 Sample App" y encontré un código que no entiendo. En este proyecto que a menudo utilizan la siguiente sintaxis para comprobar los argumentos de nulo:

public GenericRepository(IQueryableContext context,ITraceManager traceManager) 
{ 
    if (context == (IQueryableContext)null) 
      throw new ArgumentNullException("context", Resources.Messages.exception_ContainerCannotBeNull); 

¿por qué te fundido nula con el tipo de objeto que está mirando para nula?

Answer 1

No tiene sentido en el ejemplo dado.

Aunque no es aplicable en este caso, a veces hay una necesidad de echar nula (o al menos no había antes del incumplimiento (T) se añadió en cuenta lo siguiente:.

void DoSomething(string x) { 
    ... 
} 

void DoSomething(object x) { 
    ... 
} 

DoSomething(null);   // compiler can't infer the type 
DoSomething((string)null); // string type is now explicit 
DoSomething(default(string)); // same as previous 

EDITAR

Acabo de pensar en otro caso en el que tendrías que hacer el yeso al probar la igualdad. Si tuvieras un objeto que tuviera un operador == sobrecargado que permitiera la comparación con dos tipos de referencia, la comparación con el nulo sería ambigua. Sin embargo, porque IQueryableContext es más Probablemente una interfaz e interfaces no pueden overlo y el operador ==, todavía no veo ninguna razón válida para hacerlo en el ejemplo que proporcionó.

class CustomObject { 

    private string _id; 

    public CustomObject(string id) { 
     _id=id; 
    } 

    public static bool operator ==(CustomObject lhs, CustomObject rhs) { 
     if (ReferenceEquals(lhs, rhs)) { return true; } 
     if (ReferenceEquals(lhs, null)) { return false; } 
     if (ReferenceEquals(rhs, null)) { return false; } 
     return lhs._id == rhs._id; 
    } 

    public static bool operator !=(CustomObject lhs, CustomObject rhs) { 
     return !(lhs == rhs); 
    } 

    public static bool operator ==(CustomObject lhs, string rhs) { 
     if (ReferenceEquals(lhs, rhs)) { return true; } 
     if (ReferenceEquals(lhs, null)) { return false; } 
     if (ReferenceEquals(rhs, null)) { return false; } 
     return lhs._id == rhs; 
    } 

    public static bool operator !=(CustomObject lhs, string rhs) { 
     return !(lhs==rhs); 
    } 

} 

CustomObject o = null; 
if (o == null) { 
    Console.WriteLine("I don't compile."); 
} 

Answer 2

No haria un yeso. No hay razón para eso en este caso.

Answer 3

No hay ninguna razón para emitir nulo en el ejemplo dado. Puede ser por legibilidad ... No sé, no haría esto = P

En algunos casos [que no incluye el caso cubierto en este tema] tiene que convertir a INullable antes que usted puede verificar si una variable es nula. De lo contrario, debe usar object == default (TypeOfObject) ...