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

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?

10 Answers

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)

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; } 

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 

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 

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

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; } 

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

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

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.

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.

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 

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.