string.IsNullOrEmpty(string) vs. string.IsNullOrWhiteSpace(string)
C#.NetStringC# Problem Overview
Is use of string.IsNullOrEmpty(string)
when checking a string considered as bad practice when there is string.IsNullOrWhiteSpace(string)
in .NET 4.0 and above?
C# Solutions
Solution 1 - C#
The best practice is selecting the most appropriate one.
> .Net Framework 4.0 Beta 2 has a new IsNullOrWhiteSpace() method for > strings which generalizes the IsNullOrEmpty() method to also include other white > space besides empty string. > > The term “white space” includes all characters that are not visible on > screen. For example, space, line break, tab and empty string are white > space characters*.
Reference : Here
> For performance, IsNullOrWhiteSpace is not ideal but is > good. The method calls will result in a small performance penalty. > Further, the IsWhiteSpace method itself has some indirections that can > be removed if you are not using Unicode data. As always, premature > optimization may be evil, but it is also fun.
Reference : Here
Check the source code (Reference Source .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;
}
Examples
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
Solution 2 - C#
The differences in practice :
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
Solution 3 - C#
They are different functions. You should decide for your situation what do you need.
I don't consider using any of them as a bad practice. Most of the time IsNullOrEmpty()
is enough. But you have the choice :)
Solution 4 - C#
Here is the actual implementation of both methods ( decompiled using 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;
}
Solution 5 - C#
It says it all IsNullOrEmpty()
does not include white spacing while IsNullOrWhiteSpace()
does!
IsNullOrEmpty()
If string is:
-Null
-Empty
IsNullOrWhiteSpace()
If string is:
-Null
-Empty
-Contains White Spaces Only
Solution 6 - C#
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();
You'll see that IsNullOrWhiteSpace is much slower :/
Solution 7 - C#
Be careful of escaped characters:
String.IsNullOrEmpty(""); //True
String.IsNullOrEmpty(null); //True
String.IsNullOrEmpty(" "); //False
String.IsNullOrEmpty("\n"); //False
String.IsNullOrEmpty("\t"); //False
String.IsNullOrEmpty("hello"); //False
and here:
String.IsNullOrWhiteSpace("");//True
String.IsNullOrWhiteSpace(null);//True
String.IsNullOrWhiteSpace(" ");//True
String.IsNullOrWhiteSpace("\n");//True
String.IsNullOrWhiteSpace("\t");//True
String.IsNullOrWhiteSpace("hello");//False
If you apply Trim to the values passed to IsNullOrEmpty(), the results for the two methods will be the same.
As a matter of performance, IsNullOrWhiteSpace() would be faster.
Solution 8 - C#
string.IsNullOrEmpty(str) - if you'd like to check string value has been provided
string.IsNullOrWhiteSpace(str) - basically this is already a sort of business logic implementation (i.e. why " " is bad, but something like "~~" is good).
My advice - do not mix business logic with technical checks. So, for example, string.IsNullOrEmpty is the best to use at the beginning of methods to check their input parameters.
Solution 9 - C#
What about this for a catch all...
if (string.IsNullOrEmpty(x.Trim())
{
}
This will trim all the spaces if they are there avoiding the performance penalty of IsWhiteSpace, which will enable the string to meet the "empty" condition if its not null.
I also think this is clearer and its generally good practise to trim strings anyway especially if you are putting them into a database or something.
Solution 10 - C#
In the .Net standard 2.0:
> string.IsNullOrEmpty()
: Indicates whether the specified string is null or an Empty string.
Console.WriteLine(string.IsNullOrEmpty(null)); // True
Console.WriteLine(string.IsNullOrEmpty("")); // True
Console.WriteLine(string.IsNullOrEmpty(" ")); // False
Console.WriteLine(string.IsNullOrEmpty(" ")); // False
> string.IsNullOrWhiteSpace()
: Indicates whether a specified string is null, empty, or consists only of white-space characters.
Console.WriteLine(string.IsNullOrWhiteSpace(null)); // True
Console.WriteLine(string.IsNullOrWhiteSpace("")); // True
Console.WriteLine(string.IsNullOrWhiteSpace(" ")); // True
Console.WriteLine(string.IsNullOrWhiteSpace(" ")); // True