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

O uso de string.IsNullOrEmpty(string)ao verificar uma string é considerado uma má prática quando existe string.IsNullOrWhiteSpace(string)no .NET 4.0 e superior?

A melhor prática é selecionar a mais apropriada.

O .NET Framework 4.0 Beta 2 possui um novo método IsNullOrWhiteSpace () para seqüências de caracteres que generaliza o método IsNullOrEmpty () para incluir também outro espaço em branco, além da seqüência vazia.

O termo "espaço em branco" inclui todos os caracteres que não são visíveis na tela. Por exemplo, espaço, quebra de linha, tabulação e sequência vazia são caracteres de espaço em branco * .

Referência: Aqui

Para desempenho, IsNullOrWhiteSpace não é ideal, mas é bom. As chamadas de método resultarão em uma pequena penalidade de desempenho. Além disso, o próprio método IsWhiteSpace possui alguns indiretos que podem ser removidos se você não estiver usando dados Unicode. Como sempre, a otimização prematura pode ser ruim, mas também é divertida.

Referência: Aqui

Verifique o código-fonte (Fonte de Referência .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;
}

Exemplos

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

As diferenças na prática:

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

São funções diferentes. Você deve decidir para sua situação o que precisa.

Não considero usar nenhum deles como uma má prática. Na maioria das vezes IsNullOrEmpty()é suficiente. Mas você tem a escolha :)

Aqui está a implementação real dos dois métodos (descompilada 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;
    }

Diz que tudo IsNullOrEmpty()não inclui espaçamento em branco, enquanto IsNullOrWhiteSpace()inclui!

IsNullOrEmpty()Se a string é:
-Null
-Empty

IsNullOrWhiteSpace()Se a string é:
-Null
-Empty
espaços -Contém Branca Somente

Verifique isso com 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();

Você verá que IsNullOrWhiteSpace é muito mais lento: /

string.IsNullOrEmpty (str) - se você deseja verificar se o valor da string foi fornecido

string.IsNullOrWhiteSpace (str) - basicamente, esse já é um tipo de implementação de lógica de negócios (ou seja, por que "" é ruim, mas algo como "~~" é bom).

Meu conselho - não misture lógica de negócios com verificações técnicas. Portanto, por exemplo, string.IsNullOrEmpty é o melhor a ser usado no início dos métodos para verificar seus parâmetros de entrada.

Que tal isso para pegar tudo ...

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

Isso cortará todos os espaços, se houver, evitando a penalidade de desempenho de IsWhiteSpace, que permitirá que a sequência atenda à condição "vazia" se não for nula.

Eu também acho que isso é mais claro e geralmente é uma boa prática cortar seqüências de qualquer maneira, especialmente se você as estiver colocando em um banco de dados ou algo assim.

No padrão .Net 2.0:

string.IsNullOrEmpty(): Indica se a sequência especificada é nula ou vazia.

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

string.IsNullOrWhiteSpace(): Indica se uma sequência especificada é nula, vazia ou consiste apenas em caracteres de espaço em branco.

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