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

Question

L'utilisation de string.IsNullOrEmpty(string) lors de la vérification d'une chaîne de caractères considérée comme une mauvaise pratique lorsqu'il y a string.IsNullOrWhiteSpace(string) dans .NET 4.0 et plus ?

Answer 1

La meilleure pratique consiste à choisir la plus appropriée.

Le .Net Framework 4.0 Beta 2 comporte une nouvelle méthode IsNullOrWhiteSpace() pour les chaînes de caractères. chaînes de caractères, qui généralise la méthode IsNullOrEmpty() afin d'inclure d'autres espaces blancs en plus des espace blanc en plus de la chaîne vide.

Le terme "espace blanc" comprend tous les caractères qui ne sont pas visibles à l'écran. l'écran. Par exemple, l'espace, le saut de ligne, la tabulation et la chaîne vide sont des caractères d'espace blanc*. 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 légère pénalité de performance. De plus, la méthode IsWhiteSpace elle-même comporte des indirections qui peuvent être supprimées si vous n'utilisez pas de données Unicode. Comme toujours, l'optimisation prématurée prématurée peut être maléfique, mais elle est aussi amusante.

Référence : Ici

Vérifier le code source (Source de référence .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

Answer 2

Les différences dans la 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

Answer 3

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

Je ne considère pas l'utilisation de l'un d'entre eux comme une mauvaise pratique. La plupart du temps IsNullOrEmpty() est suffisant. Mais vous avez le choix :)

Answer 4

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

Answer 5

Tout est dit IsNullOrEmpty() ne comprend pas d'espacement blanc alors que IsNullOrWhiteSpace() fait !

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

IsNullOrWhiteSpace() Si la chaîne est :
-Null
-Empty
-Contenant uniquement des espaces blancs