.net - ¿Debo tirar ArgumentNullException si una cadena está en blanco?

Question

Estoy trabajando en un método que hace algo dado un parámetro de cadena. Un valor válido para el parámetro de cadena es cualquier cosa que no sea nulo o cadena. Vacío. Entonces mi código se ve así.

private void SomeMethod(string someArgument) { if(string.IsNullOrEmpty(someArgument)) throw new ArgumentNullException("someArgument"); // do some work }

Nada muy emocionante allí. Mi pregunta es, ¿está bien tirar una ArgumentNullException incluso si la cadena es igual a string.Empty? Porque técnicamente no es nulo. Si crees que no debería lanzar ArgumentNullException, ¿qué excepción debería arrojarse?

Answer 1

¿Por qué no usas este código?

private void SomeMethod(string someArgument)
{
//chek only NULL
if(ReferenceEquals(someArgument,null))
    throw new ArgumentNullException("someArgument");

// and after trim and check
if (someArgument.Trim() == String.Empty)
    throw new ArgumentException("Input cannot be empty", "someArgument");

// do some work
}

Answer 2

ArgumentNullException a veces se usa en .NET Framework para el caso String.IsNullOrEmpty; un ejemplo es System.Windows.Forms.Clipboard.SetText .

Por lo tanto, creo que es razonable hacer lo mismo en su código, a menos que haya algún valor real para distinguir los dos casos.

Tenga en cuenta que esta y otras excepciones derivadas de ArgumentException generalmente indican un error de programación y, por lo tanto, deben proporcionar la información necesaria para ayudar al desarrollador a diagnosticar el problema. Personalmente, creo que es poco probable que un desarrollador lo encuentre confuso si usa ArgumentNullException para un argumento de cadena vacío, especialmente si documenta este comportamiento como en el siguiente ejemplo.

/// <summary>
/// ... description of method ...
/// </summary>
/// <param name="someArgument">... description ...</param>
/// <exception cref="ArgumentNullException">someArgument is a null reference or Empty.</exception>
public void SomeMethod(string someArgument)
{
   ...
}

Answer 3

Debería lanzar una ArgumentException si una cadena vacía no es una entrada aceptada para su método. Puede ser muy confuso para los clientes si lanza una ArgumentNullException mientras no proporcionan un argumento null .

Es simplemente otro caso de uso. También puede tener métodos que no acepten valores de entrada nulos pero que acepten cadenas vacías. Es importante ser coherente en toda su aplicación.

Answer 4

Esto depende de las circunstancias realmente.

La pregunta se reduce a si realmente es un error. Con eso quiero decir ¿ siempre esperas un valor? Si lo haces, entonces probablemente tu mejor opción aquí sea crear tu propia Exception , quizás así:

class StringEmptyOrNullException : Exception
{
}

Donde también puede agregar sus propios constructores e información adicional, etc.

Sin embargo, si no es un evento "excepcional" en su programa, probablemente sería una mejor idea devolver nulo el método y manejarlo desde allí. Solo recuerde, las Exception son para condiciones excepcionales.

Espero que esto ayude,

Kyle

Answer 5

Tomando todas las cosas en cuenta que se han dicho (Joe / Ahmad Mageed), crearía una excepción para ese caso.

class ArgumentNullOrEmptyException : ArgumentNullException

Answer 6

ArgumentException debe lanzarse para el caso String.Empty . Esto indicaría un problema que no sea nulo. Para evitar una NullReferenceException , compruebo primero null, luego recorte y verifico la caja vacía para evitar que pase espacio en blanco.

private void SomeMethod(string someArgument)
{
    if(someArgument == null)
        throw new ArgumentNullException("someArgument");

    if (someArgument.Trim() == String.Empty)
        throw new ArgumentException("Input cannot be empty", "someArgument");

    // do some work
}

A partir de .NET 4.0, puede utilizar el método String.IsNullOrWhiteSpace para realizar estas comprobaciones de una vez. Al hacerlo, renuncia a la posibilidad de especificar un tipo de excepción granular, por lo que optaría por ArgumentException y actualizaría el mensaje en consecuencia.