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

L'uso di string.IsNullOrEmpty(string)quando si controlla una stringa è considerato una cattiva pratica string.IsNullOrWhiteSpace(string)in .NET 4.0 e versioni successive?

La migliore pratica è selezionare quella più appropriata.

.Net Framework 4.0 Beta 2 ha un nuovo metodo IsNullOrWhiteSpace () per le stringhe che generalizza il metodo IsNullOrEmpty () per includere anche altri spazi bianchi oltre alla stringa vuota.

Il termine "spazio bianco" include tutti i caratteri che non sono visibili sullo schermo. Ad esempio, spazio, interruzione di riga, tabulazione e stringa vuota sono caratteri di spazi bianchi * .

Riferimento: qui

Per prestazioni, IsNullOrWhiteSpace non è l'ideale ma è buono. Le chiamate al metodo comporteranno una piccola penalità per le prestazioni. Inoltre, il metodo IsWhiteSpace stesso ha alcune indicazioni indirette che possono essere rimosse se non si utilizzano i dati Unicode. Come sempre, l'ottimizzazione prematura può essere malvagia, ma è anche divertente.

Riferimento: qui

Controlla il codice sorgente (Riferimento 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;
}

Esempi

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

Le differenze nella pratica:

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

Sono funzioni diverse. Dovresti decidere per la tua situazione di cosa hai bisogno.

Non considero l'utilizzo di nessuno di questi come una cattiva pratica. Il più delle volte IsNullOrEmpty()è abbastanza. Ma hai la scelta :)

Ecco l'implementazione effettiva di entrambi i metodi (decompilati 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 che tutto IsNullOrEmpty()non include la spaziatura bianca mentre lo IsNullOrWhiteSpace()fa!

IsNullOrEmpty()Se stringa è:
-null
-Vuoto

IsNullOrWhiteSpace()Se stringa è:
-null
-Vuoto
gli ambienti, -Contiene solo Bianco

Dai un'occhiata a 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();

Vedrai che IsNullOrWhiteSpace è molto più lento: /

string.IsNullOrEmpty (str) - se si desidera verificare che sia stato fornito il valore della stringa

string.IsNullOrWhiteSpace (str) - fondamentalmente questa è già una sorta di implementazione della logica di business (cioè perché "" è male, ma qualcosa come "~~" è buono).

Il mio consiglio: non mescolare la logica aziendale con i controlli tecnici. Quindi, ad esempio, string.IsNullOrEmpty è il migliore da utilizzare all'inizio dei metodi per controllare i loro parametri di input.

Che dire di questo per una cattura tutto ...

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

Ciò eliminerà tutti gli spazi se presenti evitando la penalità di prestazione di IsWhiteSpace, che consentirà alla stringa di soddisfare la condizione "vuota" se non è nulla.

Penso anche che sia più chiaro e che sia generalmente buona norma tagliare le stringhe, specialmente se le si inserisce in un database o qualcosa del genere.

Nello standard .Net 2.0:

string.IsNullOrEmpty(): Indica se la stringa specificata è nulla o vuota.

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 una stringa specificata è null, vuota o è composta solo da spazi bianchi.

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