web-dev-qa-db-fra.com

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

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 y a string.IsNullOrWhiteSpace(string) dans .NET 4.0 et versions ultérieures?

c#.netstring
194
eomeroff

La meilleure pratique consiste à choisir le plus approprié.

.Net Framework 4.0 Beta 2 a une nouvelle méthode IsNullOrWhiteSpace () pour chaînes qui généralise la méthode IsNullOrEmpty () pour inclure également un autre espace blanc en plus de la chaîne vide.

Le terme "espace blanc" inclut tous les caractères non visibles à l'écran. Par exemple, espace, saut de ligne, tabulation et chaîne vide sont des caractères blancs * .

Référence: Here

Pour les performances, IsNullOrWhiteSpace n'est pas idéal mais bon. Les appels de méthode entraîneront une petite pénalité de performance. En outre, 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, une optimisation prématurée peut être néfaste, mais c'est aussi amusant.

Référence: Here

Vérifiez 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
309
CharithJ

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
150
Mohammad Dayyan

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

Je n'envisage pas de les utiliser comme une mauvaise pratique. La plupart du temps, IsNullOrEmpty() suffit. Mais tu as le choix :)

37
Ivan Danilov

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

Tout est dit IsNullOrEmpty() n'inclut pas l'espacement des blancs tandis que IsNullOrWhiteSpace() le fait!

IsNullOrEmpty() Si string est:
-Nul
-Vide

IsNullOrWhiteSpace() Si string est:
-Nul
-Vide
- Ne contient que des espaces blancs

6
Hk Shambesh

Qu'en est-il de cette attrape tous ...

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

Cela supprimera tous les espaces, le cas échéant, en évitant la pénalité de performance imposée par IsWhiteSpace, ce qui permettra à la chaîne de remplir la condition "vide" si sa valeur n'est pas nulle.

Je pense aussi que cela est plus clair et que c'est généralement une bonne pratique de couper les chaînes, surtout si vous les mettez dans une base de données ou quelque chose du genre.

3
Remotec

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: /

2
Kabindas

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

string.IsNullOrWhiteSpace (str) - En gros, il s'agit déjà d'une sorte d'implémentation de logique métier (pourquoi "" n'est pas bon, mais quelque chose comme "~~" est bon).

Mon conseil: ne mélangez pas la logique métier aux 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.

1
beloblotskiy

Dans le standard .Net 2.0:

string.IsNullOrEmpty(): Indique si la chaîne spécifiée est null 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 consiste uniquement en 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
0
Sina Lotfi