String.IsNullOrEmpty(myString) Vs myString != null

Question

Which one is better among these three?

string myString = ""; 
String.IsNullOrEmpty(myString);

vs

string myString = "";
if(myString.Length > 0 || myString != null)

vs 

string myString = "";
if (m.Length > 0 | m != null)

Former is clearer but is there any performance difference among these? What if, in case a string is never empty, like if taken from a Text Box, which could be empty but not null ?

score 19 · Accepted Answer · answered Jan 23 '10 at 23:28

19

Well, the version in the question:

if(myString.Length > 0 || myString != null)

would definitely be worse, as you should test for null first (not second) - ideally short-circuiting on null so you don't attempt to call .Length. But generally I'd just use string.IsNullOrEmpty. You could always write an extension method to make it less verbose if you want (you can call extension methods on null values).

static bool HasValue(this string s) {
    return !string.IsNullOrEmpty(s);
}

answered Jan 23 '10 at 23:28

Marc Gravell

1,026,079
266
2,566
2,900

Yeah, nice tip that last one. I am a bit of a sucker for string.Format extension methods :) – Skurmedel Jan 23 '10 at 23:30
Great one always, never thought about it. – Asad Jan 23 '10 at 23:33
4

@Marc Gravell: I realize the method is static, but when calling it on an instance variable not everyone may be able to tell if such call will throw a null reference exception or not. – Esteban Araya Jan 23 '10 at 23:44
@Esteban - the compiler / runtime can tell, though ;-p – Marc Gravell Jan 24 '10 at 00:09
1

I agree with Esteban, the syntax is not 100% clear to the uninitiated. In an attempt to make this clearer, instead of naming the extension method 'HasValue' I would instead name it exactly the same as the static method: 'IsNullOrEmpty', which is allowed: public static bool IsNullOrEmpty(this string s) { return string.IsNullOrEmpty(s); } – Mike Rosenblum Jan 24 '10 at 00:23
The extension method should start with `if (s == null) throw new NullReferenceException()` (not `ArgumentNullException`). If it looks like an instance method, it behaves like an instance method. If you want it to allow a `null` argument, then call it statically. – Sam Harwell Jan 24 '10 at 00:27
1

@Z280Z28: No, that's not right. You should never throw a 'NullReferenceException' in your own code. Extension methods are static methods and therefore should throw an 'ArgumentNullException' (if you are going to throw one -- the examples here should return true or false and not throw). For more on this see: http://stackoverflow.com/questions/463302/argumentnullexception-or-nullreferenceexception-from-extension-method. – Mike Rosenblum Jan 24 '10 at 17:13
I've often wondered why this method doesn't already exist for `String`. If I had a dollar for every time I've had to write `if(!String.IsNullOrEmpty(someString))` I'd be a rich man. – Christian Hagelid Apr 12 '13 at 03:26
performance tests are here: http://www.jstawski.com/archive/2006/12/08/string.empty-null-length-or-string.isemptyornull.aspx – ruffrey Jul 09 '13 at 19:21
@MarcGravell The name of the method is wrong - HasValue. Empty string is also a value. – anar khalilov Nov 15 '13 at 11:00
@anario that depends on the context. If I showed you a birth certificate with a name that was zero characters long, and asked you whether that person had a name: would you say "yes"? But indeed, the name could be less ambiguous. But I'll let you into a secret: *the above works just fine for us* (the exact usage is described in the intellisense comments, etc) – Marc Gravell Nov 15 '13 at 11:14

score 4 · Answer 2 · answered Jan 23 '10 at 23:27

Go with string.IsNullOrEmpty(str). It's clearer and more succinct. It will not be a bottle-neck in your application.

If you only need to check for string "emptiness", then I would go with a check against string.Empty since it expresses your intent better.

score 2 · Answer 3 · answered Jan 23 '10 at 23:50

2

I'd use the IsNullOrEmpty.

It will be easier to parse when you are looking through the code later on.

Here's another - slightly bizarre - reason. Some later programmer is bound to come along later, scratch his beard and say "I think that myString.trim().Length != 0 is better" and change it.

As others have pointed out: checking for null second is a potential null access error waiting to happen - the library routine is guaranteed to be ok.

answered Jan 23 '10 at 23:50

Fortyrunner

12,702
4
31
54

4

Hence the creation of `IsNullOrWhitespace`: http://msdn.microsoft.com/en-us/library/system.string.isnullorwhitespace(VS.100).aspx – Sam Harwell Jan 24 '10 at 00:28

score 2 · Answer 4 · answered Jan 24 '10 at 07:39

As others have said, IsNullOrEmpty() is superior to the manual checks for purposes of maintainability and isn't likely to suffer in performance thanks to the JIT compiler's runtime decisions about inlining (see Eric Gunnerson's comments).

In case anyone else is wondering what the actual .NET implementation looks like, here is the .NET 4 code:

[TargetedPatchingOptOut("Performance critical to inline across NGen image boundaries")]
public static bool IsNullOrEmpty(string value)
{
    if (value != null)
    {
        return (value.Length == 0);
    }
    return true;
}

That attribute indicates the method will also be inlined in NGen (that is, native) images.

Interesting, **ILSpy.exe** shows that **mscorlib** -> **System** -> **String** -> **IsNullOrEmpty(string): bool** looks like this: **`return value == null || value.Length == 0;`**. — Code Maverick, Nov 25 '14 at 21:11

Guffa · Answer 5 · 2010-01-24T00:31:59.230

The String.IsNullOrEmpty is the better choise if you are unsecure about how to test the different states of the string reference (which you obviously are, as you got it wrong... ;).

Using the IsNullOrEmpty method:

if (String.IsNullOrEmpty(s)) ...

is equivalent to using a short circuit test for null and zero length:

if (s == null || s.Length == 0) ...

If you know that the referene can't be null, you can skip that check and just check the length:

if (s.Length == 0) ...

The IsNullOrEmpty method would also work for normal situations, but in the case where something went wrong and the reference is actually null, the IsNullOrEmpty method would silently accept it, while you would normally want to be made aware of the error.

score 0 · Answer 6 · answered Jan 24 '10 at 00:36

0

I believe the String.IsNullOrEmpty(String s) is implemented as:

if (s == null || s.Length == 0) ...

in the API.

answered Jan 24 '10 at 00:36

Blade3

4,140
13
41
57

... which means as far as IL code goes, the same IL is generated. Neither is faster than the other. – Blade3 Jan 24 '10 at 00:39
3

I am not sure if this ok to put it here, but using Disassembler, this is what is in the API for String.IsNullOrEmptr(value) { if (value != null) { return (value.Length == 0); } return true;} – Asad Jan 24 '10 at 01:00
That's probably an artefact of disassembling rather than how the code actually looks. – ICR Jan 24 '10 at 04:03

score -4 · Answer 7 · answered Mar 22 '12 at 14:26

-4

I believe the String.IsNullOrEmpty(String s) is implemented as: if (s == null || s.Length == 0) ... in the API.

That's wrong. Try it and you will get an exception as the two statement will be tried. If s is null, then s.Length will throw an execption.

answered Mar 22 '12 at 14:26

Inacss

1

3

`||` short-circuits, so no, the second expression won't be evaluated if `s` is `null`. Also, not an answer. – Ry- Mar 22 '12 at 22:16

String.IsNullOrEmpty(myString) Vs myString != null

7 Answers7