string.IsNullOrEmpty (chaîne) vs string.IsNullOrWhiteSpace (chaîne)

L'utilisation de string.IsNullOrEmpty(string)lors de la vérification d'une chaîne est-elle considérée comme une mauvaise pratique lorsqu'il existe string.IsNullOrWhiteSpace(string)dans .NET 4.0 et supérieur?

La meilleure pratique consiste à sélectionner la plus appropriée.

.Net Framework 4.0 Beta 2 a une nouvelle méthode IsNullOrWhiteSpace () pour les chaînes qui généralise la méthode IsNullOrEmpty () pour inclure également d'autres espaces blancs en plus de la chaîne vide.

Le terme «espace blanc» comprend tous les caractères qui ne sont pas visibles à l'écran. Par exemple, l'espace, le saut de ligne, la tabulation et la chaîne vide sont des caractères d'espace blanc * .

Référence: ici

Pour les performances, IsNullOrWhiteSpace n'est pas idéal mais est bon. Les appels de méthode entraîneront une petite pénalité de performance. En outre, la méthode IsWhiteSpace elle-même possède certaines indirections qui peuvent être supprimées si vous n'utilisez pas de données Unicode. Comme toujours, l'optimisation prématurée peut être mauvaise, mais c'est aussi amusant.

Référence: ici

Vérifiez le code source (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;
}

Exemples

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

Les différences de pratique:

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

Ce sont des fonctions différentes. Vous devez décider de votre situation ce dont vous avez besoin.

Je ne considère pas leur utilisation comme une mauvaise pratique. La plupart du temps, IsNullOrEmpty()c'est suffisant. Mais vous avez le choix :)

Voici l'implémentation réelle des deux méthodes (décompilées à l'aide de 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;
    }

Il dit que tout IsNullOrEmpty()n'inclut pas l'espacement des blancs tout en le IsNullOrWhiteSpace()fait!

IsNullOrEmpty()Si la chaîne est:
-Null
-Empty

IsNullOrWhiteSpace()Si la chaîne est:
-Null
-Empty -Contains
White Spaces Only

Vérifiez cela avec IsNullOrEmpty et 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();

Vous verrez que IsNullOrWhiteSpace est beaucoup plus lent: /

string.IsNullOrEmpty (str) - si vous souhaitez vérifier que la valeur de la chaîne a été fournie

string.IsNullOrWhiteSpace (str) - fondamentalement, c'est déjà une sorte d'implémentation de la logique métier (c'est-à-dire pourquoi "" est mauvais, mais quelque chose comme "~~" est bon).

Mon conseil - ne mélangez pas la logique métier avec les contrôles techniques. Ainsi, par exemple, string.IsNullOrEmpty est le meilleur à utiliser au début des méthodes pour vérifier leurs paramètres d'entrée.

Qu'en est-il pour un fourre-tout ...

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

Cela supprimera tous les espaces s'ils sont là en évitant la pénalité de performance de IsWhiteSpace, qui permettra à la chaîne de remplir la condition "vide" si elle n'est pas nulle.

Je pense également que c'est plus clair et que c'est généralement une bonne pratique de couper les chaînes de toute façon, surtout si vous les mettez dans une base de données ou quelque chose.

Dans la norme .Net 2.0:

string.IsNullOrEmpty(): Indique si la chaîne spécifiée est nulle ou une chaîne vide.

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

string.IsNullOrWhiteSpace(): Indique si une chaîne spécifiée est nulle, vide ou se compose uniquement de caractères d'espacement.

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