chaîne.IsNullOrEmpty(string) par rapport à la chaîne.IsNullOrWhiteSpace (string)
est-ce que l'utilisation de string.IsNullOrEmpty(string) lors de la vérification d'une chaîne de caractères est considérée comme une mauvaise pratique quand il y a string.IsNullOrWhiteSpace(string) dans .NET 4.0 et au-dessus?
8 réponses
la meilleure pratique consiste à choisir celle qui convient le mieux.
.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 aussi d'autres blancs espace d'ailleurs chaîne vide.
l'expression "espace blanc" comprend tous les caractères qui ne sont pas visibles écran. Par exemple, l'espace, saut de ligne, tabulation et la chaîne vide sont blancs espace caractères* .
Référence: Ici
pour la performance, IsNullOrWhiteSpace n'est pas idéal mais est bon. Les appels de méthode donneront lieu à une petite pénalité de rendement. De plus, la méthode IsWhiteSpace elle-même comporte certaines être supprimé si vous n'utilisez pas les données Unicode. Comme toujours, prématuré l'optimisation peut être mal, mais c'est aussi un plaisir.
Référence: Ici
Vérifier le code source (source de référence. NET Framework 4.6.2)
[Pure]
public static bool IsNullOrEmpty(String value) {
return (value == null || value.Length == 0);
}
[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 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
ce sont des fonctions différentes. Vous devez décider pour votre situation ce dont vous avez besoin.
Je ne considère pas leur utilisation comme une mauvaise pratique. La plupart du temps IsNullOrEmpty() est suffisant. Mais vous avez le choix :)
Voici la mise en œuvre effective des deux méthodes (décomposé en utilisant 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 tout IsNullOrEmpty() ne comprend pas le blanc de l'espacement alors que IsNullOrWhiteSpace() ne!
IsNullOrEmpty() si la chaîne est:
- Null
- Vide
IsNullOrWhiteSpace() si la chaîne est:
- Null
- Vide
- Ne Contient Que Des Espaces Blancs
ce pour un fourre-tout...
if (string.IsNullOrEmpty(x.Trim())
{
}
cela va couper tous les espaces s'ils sont là en évitant la pénalité de performance D'IsWhiteSpace, ce qui permettra à la chaîne de répondre à la condition" vide " si son pas nul.
je pense aussi que c'est plus clair et 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.
Check this out with IsNullOrEmpty and 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 : /
de la chaîne.IsNullOrEmpty (str) - si vous souhaitez vérifier que la valeur de la chaîne de caractères a été fournie
de la chaîne.IsNullOrWhiteSpace (str) - fondamentalement, il s'agit déjà d'une sorte de mise en œuvre de la logique d'entreprise (i.e. pourquoi ""est mauvais, mais quelque chose comme" ~ " est bon).
mon conseil - Ne mélangez pas la logique commerciale avec les contrôles techniques. Ainsi, par exemple, de la chaîne.IsNullOrEmpty est le meilleur à utiliser au début de méthodes pour vérifier leurs paramètres d'entrée.