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

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

Answer 2

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

Answer 3

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 4

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 5

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 6

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 7

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

Answer 8

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

Answer 9

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 10

That is the most common usage I have seen.

Answer 11

"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 12

I had the same question before I realized all I had to do to flip the question was to put the Not operator in front of the conditional. I think it cleande up my code some.

 // need to check if tBx_PTNum.Text is empty
        /*
        if (string.IsNullOrWhiteSpace(tBx_PTNum.Text))
        {
            // no pt number yet
        }
        else
        {
            ptNum = Convert.ToInt32(tBx_PTNum.Text);
        }
        */
        
        if(!string.IsNullOrEmpty(tBx_PTNum.Text))
        {
            ptNum = Convert.ToInt32(tBx_PTNum.Text);
        }

Answer 13

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 14

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.