Return zero for Count() on null IEnumerables.

Question

I'm getting tired of using code like this:

var count = 0;
if (myEnumerable != null)
{
    count = myEnumerable.Count();
}

And this is a bit pedantic:

var count = (myEnumerable ?? new string[0]).Count();

Is there any tidier way of doing this? I once had a (badly named) PhantomCount extension method on IEnumerable<> that used my first code example, but it had something of a smell about it (besides the name).

Answer 1

How about

count = myEnumerable == null? 0 : myEnumerable.Count()

Answer 2

The problem is really in whatever is creating these enumerables. Unless you have a really good reason, anything that generates an iterable collection should return an empty collection instead of null. This would align with the Null-Object-Pattern, hence the benefits are the same.

My suggestion would be to fix whatever produces myEnumerable, or if you can't do this, add a check way earlier to see if it's null and react appropriately.

Answer 3

I don't think using extension method is a bad idea.

public static int NullableCount<T>(this IEnumerable<T> collection)
{
   return collection == null ? 0 : collection.Count();
}

Answer 4

Just create your own extension method that handles null enumerables as you wish.

public int CountOrNull<T>(this IEnumerable<T> source)
{
    return source == null ? 0 : source.Count();
}

You can then simply use:

var list1 = new int[] { 1, 2, 3, 4 };
var list2 = (int[])null;

var count1 = list1.CountOrNull(); // 4
var count2 = list2.CountOrNull(); // 0

That's the great thing about extension methods. They still work fine even if the object on which (you appear to be) calling the method is null.

Answer 5

I would also write my own extension method CountOrZeroForNull, as shown in other answers.

Besides... Instead of:

var count = (myEnumerable ?? new string[0]).Count();
                          // ^^^^^^^^^^^^^

you could write:

var count = (myEnumerable ?? Enumerable.Empty<string>()).Count();
                          // ^^^^^^^^^^^^^^^^^^^^^^^^^^

This doesn't alleviate your specific problem, but it circumvents allocation of an unused array. (Enumerable.Empty<T> is most likely implemented as a simple yield break statement.)

Answer 6

var count = 0; 

if (myEnumerable != null) 
    count = myEnumerable.Count(); 

While it's not as technical as the other answers, it's far the most readable.

Answer 7

What actions are you taking if the value returned is 0?

If that's what's interesting, maybe you should use Haack's IsNullOrEmpty extension method for IEnumerable like so:

public static bool IsNullOrEmpty<T>(this IEnumerable<T> items) 
{
    return items == null || !items.Any();
}

The link is http://haacked.com/archive/2010/06/10/checking-for-empty-enumerations.aspx

Posted as a comment on the blog, you'll also find an Exception class I wrote to go with that:

public class ArgumentNullOrEmptyException : ArgumentNullException
{
    public ArgumentNullOrEmptyException( string paramName ) : base( paramName )
    {}

    public ArgumentNullOrEmptyException( string paramName, string message ) : base( paramName, message )
    {}

    public override string Message
    {
        get
        {
            return "Value cannot be null nor empty.{0}Parameter name: {1}".FormatWith( Environment.NewLine, ParamName );
        }
    }
}

Answer 8

I use a custom extension method:

public static IEnumerable<T> EmptyIfNull<T>(this IEnumerable<T> source)
{
    return source ?? Enumerable.Empty<T>();
}

...

int count = myEnumerable.EmptyIfNull().Count();