String.IsNullOrEmpty() vs string.NotNullOrEmpty()

Question

Tengo curiosidad por si algún desarrolladores utilizan String.IsNullOrEmpty() más a menudo con una negativa que positiva con un

por ejemplo,

if (!string.IsNullOrEmpty()) 

Así es como utilizo el método el 99% del tiempo. ¿Cuál fue la decisión de diseño para esto?

Answer 1

Porque "IsNullOrEmpty" es más fácil de entender que "NotNullOrEmpty". Este último podría interpretarse como:

1. No es nulo y no está vacío
2. No es nulo o está vacío

Answer 2

Ese es el uso más común que he visto.

Answer 3

convenciones de nomenclatura C# dictan que sus expresiones deben ser en el sentido positivo como "Is ..." y no "IsNot ..."

EDIT: Por lo general, lo uso cuando se hace la comprobación de errores y validación de entrada al comienzo de un método y genera una excepción si el parámetro es nulo o está vacío.

if (string.IsNullOrEmpty(myParameter))
{
throw new ....
}


Answer 4

negativos dobles se desaniman por lo general en el nombramiento de las cosas. !string.NotNullOrEmpty(...) haría uno.

Answer 5

Personalmente prefiero atender el escenario no negada por primera vez. Simplemente tiene sentido para mí hacer primero la parte verdadera y luego la falsa. Se reduce al estilo personal.

Answer 6

Quizás porque entonces el nombre debería ser el largo IsNotNullAndNotEmpty para ser tan específico.

Answer 7

Así como una nota al margen, yo prefiero el método de extensión:

public static class StringExtensions 
{ 
    public static bool IsNullOrEmpty(this string value) 
    { 
     return string.IsNullOrEmpty(value); 
    } 
} 

encuentro se lee mejor decir:

if(myValue.IsNullOrEmpty()) 

o

if(!myValue.IsNullOrEmpty()) 

Answer 8

siempre he pensé que parecía ser el camino equivocado, ya que uso el negativo mucho más a menudo que el positivo.

También me gustaría que hubiera una instancia IsEmpty() o IsNotEmpty() para usar cuando la variable se declara dentro de la función. Esto no podría ser IsNullOrEmpty() o IsNotNullOrEmpty() como si la instancia fuera nula, entonces obtendría una excepción de referencia nula.

Answer 9

Para aquellos lógicos que existen,! String.IsNullOrEmpty no es equivalente a string.IsNotNullOrEmpty. @Guffa lo tiene correcto. Usando la ley de DeMorgan, tendría que ser string.IsNotNullAndNotEmpty para ser equivalente.

¬ (nulo ∨ vacío) ⇔ ¬ nula ∧ ¬ vacío

¬ (nulo ∨ vacío) ≠ ¬ nula ∨ vacío

El punto aquí, supongo, es que la forma en que se encuentra actualmente es inequívoco, donde hacer que lo contrario sea inequívoco sería engorroso.

Answer 10

"NotNullOrEmpty" es ambiguo, podría significar "(no nulo) o vacío" o podría significar "no (nulo o vacío)". Para que no quede ambiguo, deberías usar "NotNullAndNotEmpty", que es un bocazas.

Además, la denominación "IsNullOrEmpty" fomenta el uso como una cláusula de guardia, que creo que es útil. Por ejemplo:

if (String.IsNullOrEmpty(someString)) 
{ 
    // error handling 
    return; 
} 
// do stuff 

que creo que es por lo general más limpio que:

if (!String.IsNullOrEmpty(someString)) 
{ 
    // do stuff 
} 
else 
{ 
    // error handling 
    return; 
} 

Answer 11

De hecho, me inclinaría a ofrecer una respuesta diferente de la explicación "es ambigua" proporcionada por varios otros (aunque estoy de acuerdo con esa respuesta también):

Personalmente, me gusta minimizar la anidación en mi código, ya que (para mí) cuanto más código de llaves tiene, más difícil es seguirlo.

Por lo tanto me gustaría mucho prefieren este (por ejemplo):

public bool DoSomethingWithString(string s) { 
    if (string.IsNullOrEmpty(s)) 
     return false; 

    // here's the important code, not nested 
} 

a esto:

public bool DoSomethingWithString(string s) { 
    if (!string.IsNullOrEmpty(s)) { 
     // here's the important code, nested 
    } else { 
     return false; 
    } 
} 

Este es un escenario bastante específica (donde un/cadena nula vacío solicita una salida inmediata) y claramente no es la forma en que un método que usa IsNullOrEmpty siempre estaría estructurado; pero creo que en realidad es bastante común.

Answer 12

siempre se crea un método de extensión para "HasContent()" que generalmente tiene sentido, sigue las especificaciones "positivos", y lo guarda en exceso de código porque yo lo uso mucho más a menudo que su contraparte:

public static bool HasContent(this string s) { 
    return !string.IsNullOrEmpty(s); 
} 

Answer 13

Por supuesto, siempre podría usar string.IsNullOrWhiteSpace(string) ahora en lugar de string .IsNullOrEmpty(string) de .NET 4.0