cadena.IsNullOrEmpty(string) en comparación con la cadena.IsNullOrWhiteSpace (cadena)

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 funciones diferentes. Usted debe decidir para su situación lo que necesita.

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

Aquí está la implementación real de ambos métodos ( descompilados 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;
    }

Lo dice todo IsNullOrEmpty() no incluye el espaciado en blanco mientras que IsNullOrWhiteSpace() lo hace!

IsNullOrEmpty() Si la cadena es:
- Null
- Vacío

IsNullOrWhiteSpace() Si la cadena es:
- Null
- Empty
- Contiene Solo Espacios En Blanco

¿Qué hay de esto para un catch all...

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 null.

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á poniendo en una base de datos o algo así.

Compruebe esto con IsNullOrEmpty e 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 : /

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

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

Mi consejo - no mezcle la lógica de negocios con comprobaciones técnicas. Así, por ejemplo, cadena.IsNullOrEmpty es el mejor para usar al principio de los métodos para verificar sus parámetros de entrada.