CODEWITHSUNDEEP
c#.netstring
Chris S
Chris S

Reputation: 65456

string.IsNullOrEmpty() vs string.NotNullOrEmpty()

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?

Upvotes: 34

Views: 70675

Answers (14)

Greg
Greg

Reputation: 1

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

Upvotes: 0

Brian Genisio
Brian Genisio

Reputation: 48157

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

Upvotes: 7

Kent Boogaart
Kent Boogaart

Reputation: 178790

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

Upvotes: 64

Binoj Antony
Binoj Antony

Reputation: 16204

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

Upvotes: 2

sethjeffery
sethjeffery

Reputation: 81

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

Upvotes: 8

Dan Tao
Dan Tao

Reputation: 128417

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.

Upvotes: 1

Mehrdad Afshari
Mehrdad Afshari

Reputation: 422222

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

Upvotes: 38

Wedge
Wedge

Reputation: 19875

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

Upvotes: 1

tvanfosson
tvanfosson

Reputation: 532665

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.

Upvotes: 12

stevehipwell
stevehipwell

Reputation: 57558

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.

Upvotes: 0

Guffa
Guffa

Reputation: 700730

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

Upvotes: 4

uriDium
uriDium

Reputation: 13440

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.

Upvotes: 0

Erich Mirabal
Erich Mirabal

Reputation: 10048

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

Upvotes: 7

John Kraft
John Kraft

Reputation: 6840

That is the most common usage I have seen.

Upvotes: 1

Related Questions