Throwing ArgumentNullException

Question

Supongamos que tengo un método que toma un objeto de algún tipo como argumento. Ahora diga que si a este método se le pasa un argumento nulo, es un error fatal y se debe lanzar una excepción. ¿Vale la pena para mí para codificar algo como esto (teniendo en cuenta que es un ejemplo trivial):

void someMethod(SomeClass x) 
{ 
    if (x == null){ 
     throw new ArgumentNullException("someMethod received a null argument!"); 
    } 

    x.doSomething(); 
} 

O es seguro para mí sólo se basan en él lanzando NullException cuando llama x.doSomething() ?

En segundo lugar, supongamos que someMethod es un constructor y x no se usará hasta que se llame a otro método. ¿Debería lanzar la excepción inmediatamente o esperar hasta que se necesite x y arrojar la excepción, entonces?

Answer 1

Prefiero el ArgumentNullException sobre el NullReferenceException que no verificaría el argumento. En general, mi preferencia es verificar siempre la nulidad antes de intentar invocar un método en un objeto potencialmente nulo.

Si el método es un constructor, dependerá de un par de factores diferentes: ¿existe también un organismo público para la propiedad y qué tan probable es que el objeto se use realmente? Si hay un organismo público, entonces no proporcionar una instancia válida a través del constructor sería razonable y no debería dar lugar a una excepción.

Si no hay un organismo público y es posible usar el objeto contenedor sin referencia al objeto inyectado, es posible que desee diferir la comprobación/excepción hasta que se intente su uso. Sin embargo, creo que el caso general sería que el objeto inyectado es esencial para el funcionamiento de la instancia y, por lo tanto, una excepción ArgumentNull es perfectamente razonable ya que la instancia no puede funcionar sin ella.

Answer 2

Siempre sigo la práctica de fail fast. Si su método depende de X y entiende que X podría pasarse en nulo, nírelo e inicie la excepción de inmediato en lugar de prolongar el punto de falla.

2016 actualización:

ejemplo del mundo real. Recomiendo encarecidamente el uso de Jetbrains Annotations.

[Pure] 
public static object Call([NotNull] Type declaringType, 
          [NotNull] string methodName, 
          [CanBeNull] object instance) 
{ 
    if (declaringType == null) throw new ArgumentNullException(nameof(declaringType)); 
    if (methodName == null) throw new ArgumentNullException(nameof(methodName)); 

declaraciones Guardia se han mejorado enormemente con C# 6 proporciona al operador nameof.

Answer 3

prefiero la excepción explícita, por estas razones:

• Si el método tiene más de un argumento SomeClass le da la oportunidad de decir cuál es (todo lo demás está disponible en la pila de llamadas) .
• ¿Qué sucede si hace algo que pueda tener un efecto secundario antes de hacer referencia a x?

Answer 4

Si programa a la defensiva, debe fallar rápidamente. Así que revisa tus entradas y error al principio de tu código. Debe ser amable con su interlocutor y darles el mensaje de error más descriptivo que pueda.

Answer 5

Es mejor lanzar ArgumentNullException más pronto que tarde. Si lo arroja, puede proporcionar más información útil sobre el problema que una NullReferenceException.

Answer 6

1- Hazlo explícitamente si no quieres valor nulo. De lo contrario, cuando otra persona busque su código, ellos creerán que se acepta pasar un valor nulo.

2- Hazlo lo más rápido que puedas. De esta forma, no se propaga el comportamiento "incorrecto" de tener un valor nulo cuando no se supone.

Answer 7

Debería lanzar explícitamente una ArgumentNullException si está esperando que la entrada no sea nula. Es posible que desee escribir una clase llamada Guard que proporciona métodos de ayuda para esto. Por lo que su código será:

void someMethod(SomeClass x, SomeClass y) 
{ 
    Guard.NotNull(x,"x","someMethod received a null x argument!"); 
    Guard.NotNull(y,"y","someMethod received a null y argument!"); 


    x.doSomething(); 
    y.doSomething(); 
} 

El método no nulo haría la verificación de nulidad y lanzar una NullArgumentException con el mensaje de error especificado en la llamada.

Answer 8

Preferiría la verificación de parámetros con la explícita ArgumentNullException, también.

En cuanto a los metadatos:

// 
    // Summary: 
    //  Initializes a new instance of the System.ArgumentNullException class with 
    //  the name of the parameter that causes this exception. 
    // 
    // Parameters: 
    // paramName: 
    //  The name of the parameter that caused the exception. 
    public ArgumentNullException(string paramName); 

Se puede ver, que la cadena debe ser el nombre del parámetro, que es nulo, y así darle al desarrollador una pista sobre lo que va mal.

Answer 9

Estoy de acuerdo con la idea de fallar rápido, sin embargo, es conveniente saber por qué fallar rápido es práctico. Considere este ejemplo:

void someMethod(SomeClass x) 
{  
    x.Property.doSomething(); 
} 

Si depende de la NullReferenceException para decirle que algo estaba mal, ¿cómo vas a saber lo que era nulo? La traza de la pila solo le dará un número de línea, no la referencia fue nula. En este ejemplo, x o x.Property podrían haber sido nulos y sin fallar rápidamente con una verificación agresiva de antemano, no sabrá cuál es.

Answer 10

Probablemente estaré desilusionada por esto, pero creo que es completamente diferente.

¿Qué hay de seguir una buena práctica llamada "never pass null" y eliminar la fea excepción de comprobación?

Si el parámetro es un objeto, NO PASA NULO. Además, NO DEVUELVA NULL. Incluso puede usar el patrón de objeto nulo para ayudar con eso.

Si es opcional, use los valores predeterminados (si su idioma los admite) o cree una sobrecarga.

Mucho más limpio que desagradables excepciones.

Answer 11

Puede utilizar la sintaxis como la siguiente para no solo arrojar un ArgumentNullException, sino que tenga esa excepción para nombrar el parámetro como parte de su texto de error también. P.ej.;

void SomeMethod(SomeObject someObject) 
{ 
    Throw.IfArgNull(() => someObject); 
    //... do more stuff 
} 

La clase utilizada para levantar la excepción es;

public static class Throw 
{ 
    public static void IfArgNull<T>(Expression<Func<T>> arg) 
    { 
     if (arg == null) 
     { 
      throw new ArgumentNullException(nameof(arg), "There is no expression with which to test the object's value."); 
     } 

     // get the variable name of the argument 
     MemberExpression metaData = arg.Body as MemberExpression; 
     if (metaData == null) 
     { 
      throw new ArgumentException("Unable to retrieve the name of the object being tested.", nameof(arg)); 
     } 

     // can the data type be null at all 
     string argName = metaData.Member.Name; 
     Type type = typeof(T); 
     if (type.IsValueType && Nullable.GetUnderlyingType(type) == null) 
     { 
      throw new ArgumentException("The expression does not specify a nullible type.", argName); 
     } 

     // get the value and check for null 
     if (arg.Compile()() == null) 
     { 
      throw new ArgumentNullException(argName); 
     } 
    } 
}