string.IsNullOrEmpty() vs string.NotNullOrEmpty()

Question

I'm curious if any developers use string.IsNullOrEmpty() more often with a negative than with a positive

e.g.

if (!string.IsNullOrEmpty())

This is how I use the method 99% of the time. What was the design decision for this?

Answer 1

That is the most common usage I have seen.

Answer 2

C# naming conventions dictate that your expressions should be in the positive such as "Is..." and not "IsNot..."

EDIT: Typically, I use it when doing error checking and input validation at the beginning of a method and raise an exception if the parameter is null or empty.

if (string.IsNullOrEmpty(myParameter))
{
throw new ....
}


Answer 3

Double negatives are usually discouraged in naming stuff. !string.NotNullOrEmpty(...) would make one.

Answer 4

Because "IsNullOrEmpty" is easier to understand than "NotNullOrEmpty". The latter could be interpreted as:

1. It's not null and it's not empty
2. It's not null or it is empty

HTH, Kent

Answer 5

Personally I prefer to cater for the non negated scenario first. It just makes sense to me to do the true part first and then the false. Comes down to personal style.

Answer 6

Perhaps because then the name would have to be the lengthy IsNotNullAndNotEmpty to be as specific.

Answer 7

Just as a side note, I prefer the extension method:

public static class StringExtensions
{
    public static bool IsNullOrEmpty(this string value)
    {
        return string.IsNullOrEmpty(value);
    }
}

I find it reads better to say:

if(myValue.IsNullOrEmpty())

or

if(!myValue.IsNullOrEmpty())

Answer 8

I've always thought it seemed the wrong way round as I use the negative much more often than the positive.

I would also like there to be an instance IsEmpty() or IsNotEmpty() for use when the variable is declared within the function. This could not be IsNullOrEmpty() or IsNotNullOrEmpty() as if the instance was null then you would get a null reference exception.

Answer 9

For those logicians out there, !string.IsNullOrEmpty is not equivalent to string.IsNotNullOrEmpty. @Guffa has it correct. Using DeMorgan's law, it would have to be string.IsNotNullAndNotEmpty to be equivalent.

¬(null ∨ empty) ⇔ ¬null ∧ ¬empty

¬(null ∨ empty) ≠ ¬null ∨ empty

The point here, I guess, is that the way it is currently is unambiguous, where as making the opposite unambiguous would be cumbersome.

Answer 10

"NotNullOrEmpty" is ambiguous, it could mean "(not null) or empty" or it could mean "not (null or empty)". To make it unambiguous you'd have to use "NotNullAndNotEmpty", which is a mouthfull.

Also, the "IsNullOrEmpty" naming encourages use as a guard clause, which I think is useful. E.g.:

if (String.IsNullOrEmpty(someString))
{
   // error handling
   return;
}
// do stuff

which I think is generally cleaner than:

if (!String.IsNullOrEmpty(someString))
{
   // do stuff
}
else
{
   // error handling
   return;
}

Answer 11

I would actually be inclined to offer a different answer from the "it's ambiguous" explanation provided by several others (though I agree with that answer as well):

Personally, I like to minimize nesting in my code, as (to me) the more curly braces code has, the harder it becomes to follow.

Therefore I'd much prefer this (for example):

public bool DoSomethingWithString(string s) {
    if (string.IsNullOrEmpty(s))
        return false;

    // here's the important code, not nested
}

to this:

public bool DoSomethingWithString(string s) {
    if (!string.IsNullOrEmpty(s)) {
        // here's the important code, nested
    } else {
        return false;
    }
}

This is a pretty specific scenario (where a null/empty string prompts an immediate exit) and clearly isn't the way a method using IsNullOrEmpty would always be structured; but I think it's actually pretty common.

Answer 12

I always create an extension method for "HasContent()" which generally makes sense, follows the "positive" specifications, and saves on code bloat because I use it much more often than its counterpart:

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

Answer 13

Of course you could always use string.IsNullOrWhiteSpace(string) now instead of string .IsNullOrEmpty(string) from .NET 4.0