C#: Recommended way to check if a sequence is empty

Question

A method returns a sequence, IEnumerable<T>, and you now want to check if it is empty. How do you recommend doing that? I'm looking for both good readability and good performance.

The first and most obvious way is to check that the count is greater than zero:

if(sequence.Count() == 0)

Has decent readability, but terrible performance since it has to actually go through the whole sequence.

A method that I sometimes use is the following:

if(!sequence.Any())

This doesn't (as far as I know) have to go through the whole sequence, but the readability is a bit backwards and awkward. (Reads a lot better if we are checking that the sequence is not empty though).

Another option is to use First in a try-catch, like this:

try
{
    sequence.First();
}
catch(InvalidOperationException)
{
    // Do something
}

Not a very pretty solution, and probably slower too, since it is using exceptions and stuff. Could prevent that by using FirstOrDefault of course, except you would have a big problem if the first item in the sequence actually was the default value ;)

So, any other ways to check if a sequence is empty? Which one do you usually use? Which one do you recommend to use?

Note: For optimal readability I would probably put one of the above snippets in an IsEmpty extension method, but I am still curious since I would have to do something inside that method as well :p

Answer 1

Well all these methods you're calling are LINQ extension methods, so it depends how the LINQ provider was implemented. If you want to know if a sequence is empty, either Count() == 0 or Any() == false is appropriate. I prefer Any() myself.

However, depending on what actual Type your sequence is, you might not need to use a LINQ extension method. I.e. if it's an array you can call sequence.Length. If it's a collection, you can use sequence.Count.

Answer 2

I would use !sequence.Any(), personally.

If you really need to, you could always write your own extension method:

public static void IsEmpty<T>(this IEnumerable<T> source)
{
    return !source.Any();
}

Then you can write:

if (sequence.IsEmpty())

Answer 3

You can create an Extension method, with this implementation.

public static bool IsEmpty<T>(this IEnumerable<T> items) {
            var enumerator = items.GetEnumerator();
            return !enumerator.MoveNext();
        }

Answer 4

You said:

if(sequence.Count() == 0) Has decent readability, but terrible performance since it has to actually go through the whole sequence.

Is that actually true? You are talking about dealing with an Interface, IEnumerable<T>, and yet you are making assumptions regarding its implementation which may or may not be true. In fact, many of the custom collections I've written over the years keep a private variable that stores the current count internally, which means that returning .Count is a trivial matter that does not require iterating the entire collection.

So with that said, unless you know that a specific implementation is poorly optimized for .Count, I would use .Count. Avoid premature optimization wherever possible, and stick with readability.