Interview Question: .Any() vs if (.Length > 0) for testing if a collection has elements

Question

In a recent interview I was asked what the difference between .Any() and .Length > 0 was and why I would use either when testing to see if a collection had elements.

This threw me a little as it seems a little obvious but feel I may be missing something.

I suggested that you use .Length when you simply need to know that a collection has elements and .Any() when you wish to filter the results.

Presumably .Any() takes a performance hit too as it has to do a loop / query internally.

Answer 1

Length only exists for some collection types such as Array.

Any is an extension method that can be used with any collection that implements IEnumerable<T>.

If Length is present then you can use it, otherwise use Any.

---

Presumably .Any() takes a performance hit too as it has to do a loop / query internally.

Enumerable.Any does not loop. It fetches an iterator and checks if MoveNext returns true. Here is the source code from .NET Reflector.

public static bool Any<TSource>(this IEnumerable<TSource> source)
{
    if (source == null)
    {
        throw Error.ArgumentNull("source");
    }
    using (IEnumerator<TSource> enumerator = source.GetEnumerator())
    {
        if (enumerator.MoveNext())
        {
            return true;
        }
    }
    return false;
}

Answer 2

Length is a property of array types, while Any() is an extension method of Enumerable. Therefore, you can use Length only when working with arrays. When working with more abstract types (IEnumerable<T>), you can use Any().

Answer 3

I think this is a more general question of what to choose if we have 2 way to express something. In does situation I would suggest the statement: "Be specific" quote from Peter Norvig in his book PAIP

Be specific mean use what best describe what your are doing. Thus what you want to say is something like:

collection.isEmpty()

If you don't have such construct I will choose the common idiom that the communities used. For me .Length > 0 is not the best one since it impose that you can size the object. Suppose your implement infinite list. .Lenght would obviously not work.

Answer 4

.Length... System.Array .Any ... IEnumerable (extension method).

I would prefer using "length" whenever i can find it. Property is anyhow light-weight than any method call.

Though, implementation of "Any" won't be doing anything more than the below mentioned code.

 private static bool Any<T>(this IEnumerable<T> items)
        {
            return items!=null && items.GetEnumerator().MoveNext();
        }

Also, A better question could have been a difference beterrn ".Count" and ".Length", what say :).

Answer 5

Sounds quite similar to this Stackoverflow question about difference between .Count and .Any for checking for existence of a result: http://stackoverflow.com/questions/2540220/check-for-existence-of-a-result-in-linq-to-xml/2540302#2540302

In that case it is better to use Any then Count, as Count will iterate all elements of an IEnumerable

Answer 6

We know that .Length is only used for Arrays and .Any() is used for collections of IEnumerable.

You can swap .Count for .Length and you have the same question for working with collections of IEnumberable

Both .Any() and .Count perform a null check before beginning an enumerator. So with regards to performance they are the same.

As for the array lets assume we have the following line:

int[] foo = new int[10];

Here foo.Length is 10. While this is correct it may not be the answer your looking for because we haven't added anything to the array yet. If foo is null it will throw an exception.

Answer 7

I'm guessing the interviewer may have meant to ask about checking Any() versus Count() > 0 (as opposed to Length > 0).

Basically, here's the deal.

Any() will effectively try to determine if a collection has any members by enumerating over a single item. (There is an overload to check for a given criterion using a Func<T, bool>, but I'm guessing the interviewer was referring to the version of Any() that takes no arguments.) This makes it O(1).

Count() will check for a Length or Count property (from a T[] or an ICollection or ICollection<T>) first. This would generally be O(1). If that isn't available, however, it will count the items in a collection by enumerating over the entire thing. This would be O(n).

A Count or Length property, if available, would most likely be O(1) just like Any(), and would probably perform better as it would require no enumerating at all. But the Count() extension method does not ensure this. Therefore it is sometimes O(1), sometimes O(n).

Presumably, if you're dealing with a nondescript IEnumerable<T> and you don't know whether it implements ICollection<T> or not, you are much better off using Any() than Count() > 0 if your intention is simply to ensure the collection is not empty.