c# - practice - ArgumentException o ArgumentNullException para los parámetros de cadena?

throw c# ejemplo

Question

En lo que respecta a las mejores prácticas, ¿cuál es mejor?

public void SomeMethod(string str) 
{
    if(string.IsNullOrEmpty(str))
    {
        throw new ArgumentException("str cannot be null or empty.");
    }

    // do other stuff
}

o

public void SomeMethod(string str) 
{
    if(str == null) 
    {
        throw new ArgumentNullException("str");
    }

    if(str == string.Empty)
    {
        throw new ArgumentException("str cannot be empty.");
    }

    // do other stuff
}

La segunda versión parece más precisa, pero también más engorrosa que la primera. Usualmente voy con el n. ° 1, pero pensé que verificaría si hay un argumento para el n. ° 2.

Answer 1

Sugeriría usar el primero. Si su método no espera una cadena nula o vacía, realmente no importa si se pasó nulo o vacío: importante informar y error, y eso es lo que hace la primera variante.

Answer 2

Diría que la segunda forma es más precisa, sí, es más engorrosa, pero siempre puedes envolverla en un método para evitar tener que hacerlo todo el tiempo. Incluso podría ser un método de extensión:

str.ThrowIfNullOrEmpty("str");


public static void ThrowIfNullOrEmpty(this string value, string name)
{
    if (value == null)
    {
        throw new ArgumentNullException(name);
    }
    if (value == "")
    {
        throw new ArgumentException("Argument must not be the empty string.",
                                    name);
    }
}

Otra forma que es potencialmente útil es aquella que devuelve la cadena original si todo está bien. Podrías escribir algo como esto:

public Person(string name)
{
    this.name = name.CheckNotEmpty();
}

Otra opción a considerar es usar contratos de código como alternativa a lanzar sus propias excepciones.

Answer 3

Otra posibilidad es la excepción ArgumentOutOfRange :

La excepción que se produce cuando el valor de un argumento está fuera del rango permitido de valores según lo definido por el método invocado.