string.IsNullOrEmpty (string) vs. string.IsNullOrWhiteSpace (string)

¿El uso de string.IsNullOrEmpty(string)cuando se verifica una cadena se considera una mala práctica cuando existe string.IsNullOrWhiteSpace(string)en .NET 4.0 y superior?

La mejor práctica es seleccionar la más adecuada.

.Net Framework 4.0 Beta 2 tiene un nuevo método IsNullOrWhiteSpace () para cadenas que generaliza el método IsNullOrEmpty () para incluir también otros espacios en blanco además de la cadena vacía.

El término "espacio en blanco" incluye todos los caracteres que no son visibles en la pantalla. Por ejemplo, espacio, salto de línea, tabulación y cadena vacía son espacios en blanco * .

Referencia: aquí

Para el rendimiento, IsNullOrWhiteSpace no es ideal pero es bueno. Las llamadas al método generarán una pequeña penalización de rendimiento. Además, el método IsWhiteSpace en sí tiene algunas indirecciones que pueden eliminarse si no está utilizando datos Unicode. Como siempre, la optimización prematura puede ser mala, pero también es divertida.

Referencia: aquí

Verifique el código fuente (Reference Source .NET Framework 4.6.2)

IsNullorEmpty

[Pure]
public static bool IsNullOrEmpty(String value) {
    return (value == null || value.Length == 0);
}

IsNullOrWhiteSpace

[Pure]
public static bool IsNullOrWhiteSpace(String value) {
    if (value == null) return true;

    for(int i = 0; i < value.Length; i++) {
        if(!Char.IsWhiteSpace(value[i])) return false;
    }

    return true;
}

Ejemplos

string nullString = null;
string emptyString = "";
string whitespaceString = "    ";
string nonEmptyString = "abc123";

bool result;

result = String.IsNullOrEmpty(nullString);            // true
result = String.IsNullOrEmpty(emptyString);           // true
result = String.IsNullOrEmpty(whitespaceString);      // false
result = String.IsNullOrEmpty(nonEmptyString);        // false

result = String.IsNullOrWhiteSpace(nullString);       // true
result = String.IsNullOrWhiteSpace(emptyString);      // true
result = String.IsNullOrWhiteSpace(whitespaceString); // true
result = String.IsNullOrWhiteSpace(nonEmptyString);   // false

Las diferencias en la práctica:

string testString = "";
Console.WriteLine(string.Format("IsNullOrEmpty : {0}", string.IsNullOrEmpty(testString)));
Console.WriteLine(string.Format("IsNullOrWhiteSpace : {0}", string.IsNullOrWhiteSpace(testString)));
Console.ReadKey();

Result :
IsNullOrEmpty : True
IsNullOrWhiteSpace : True

**************************************************************
string testString = " MDS   ";

IsNullOrEmpty : False
IsNullOrWhiteSpace : False

**************************************************************
string testString = "   ";

IsNullOrEmpty : False
IsNullOrWhiteSpace : True

**************************************************************
string testString = string.Empty;

IsNullOrEmpty : True
IsNullOrWhiteSpace : True

**************************************************************
string testString = null;

IsNullOrEmpty : True
IsNullOrWhiteSpace : True

Son diferentes funciones. Debe decidir para su situación qué necesita.

No considero usar ninguno de ellos como una mala práctica. La mayor parte del tiempo IsNullOrEmpty()es suficiente. Pero tienes la opción :)

Aquí está la implementación real de ambos métodos (descompilado usando dotPeek)

[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
    public static bool IsNullOrEmpty(string value)
    {
      if (value != null)
        return value.Length == 0;
      else
        return true;
    }

    /// <summary>
    /// Indicates whether a specified string is null, empty, or consists only of white-space characters.
    /// </summary>
    /// 
    /// <returns>
    /// true if the <paramref name="value"/> parameter is null or <see cref="F:System.String.Empty"/>, or if <paramref name="value"/> consists exclusively of white-space characters.
    /// </returns>
    /// <param name="value">The string to test.</param>
    public static bool IsNullOrWhiteSpace(string value)
    {
      if (value == null)
        return true;
      for (int index = 0; index < value.Length; ++index)
      {
        if (!char.IsWhiteSpace(value[index]))
          return false;
      }
      return true;
    }

¡Dice que todo IsNullOrEmpty()no incluye espacios en blanco mientras que IsNullOrWhiteSpace()sí!

IsNullOrEmpty()Si la cadena es:
-Null
-Empty

IsNullOrWhiteSpace()Si la cadena es:
-Null
-Empty -Contains
White Spaces Only

Mira esto con IsNullOrEmpty y IsNullOrwhiteSpace

string sTestes = "I like sweat peaches";
    Stopwatch stopWatch = new Stopwatch();
    stopWatch.Start();
    for (int i = 0; i < 5000000; i++)
    {
        for (int z = 0; z < 500; z++)
        {
            var x = string.IsNullOrEmpty(sTestes);// OR string.IsNullOrWhiteSpace
        }
    }

    stopWatch.Stop();
    // Get the elapsed time as a TimeSpan value.
    TimeSpan ts = stopWatch.Elapsed;
    // Format and display the TimeSpan value. 
    string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
        ts.Hours, ts.Minutes, ts.Seconds,
        ts.Milliseconds / 10);
    Console.WriteLine("RunTime " + elapsedTime);
    Console.ReadLine();

Verás que IsNullOrWhiteSpace es mucho más lento: /

string.IsNullOrEmpty (str): si desea comprobar si se ha proporcionado el valor de la cadena

string.IsNullOrWhiteSpace (str): básicamente, esto ya es una especie de implementación de lógica de negocios (es decir, por qué "" es malo, pero algo como "~~" es bueno).

Mi consejo: no mezcle la lógica empresarial con las verificaciones técnicas. Entonces, por ejemplo, string.IsNullOrEmpty es el mejor para usar al comienzo de los métodos para verificar sus parámetros de entrada.

¿Qué pasa con esto para atrapar a todos ...

if (string.IsNullOrEmpty(x.Trim())
{
}

Esto recortará todos los espacios si están allí, evitando la penalización de rendimiento de IsWhiteSpace, lo que permitirá que la cadena cumpla con la condición "vacía" si no es nula.

También creo que esto es más claro y generalmente es una buena práctica recortar cadenas de todos modos, especialmente si las está colocando en una base de datos o algo así.

En el estándar .Net 2.0:

string.IsNullOrEmpty(): Indica si la cadena especificada es nula o una cadena vacía.

Console.WriteLine(string.IsNullOrEmpty(null));           // True
Console.WriteLine(string.IsNullOrEmpty(""));             // True
Console.WriteLine(string.IsNullOrEmpty(" "));            // False
Console.WriteLine(string.IsNullOrEmpty("  "));           // False

string.IsNullOrWhiteSpace(): Indica si una cadena especificada es nula, está vacía o si solo consta de caracteres de espacio en blanco.

Console.WriteLine(string.IsNullOrWhiteSpace(null));     // True
Console.WriteLine(string.IsNullOrWhiteSpace(""));       // True
Console.WriteLine(string.IsNullOrWhiteSpace(" "));      // True
Console.WriteLine(string.IsNullOrWhiteSpace("  "));     // True