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

What for an discussion. All source code is available and so you know that: If you are using instances which have the property Length or Count then you have always O(1). The value is a member of your instance and you can directly compare against any other value. It is only a compare operation between two values.

The extension method Any(), creates always as first a new iterator and the tries to get the first element. It is also O(1), but because of creating a new iterator a small amount of memory is allocated for this iterator, each time you call Any(). Inside implementation of MoveNext() which is used by the iterator there are 2 compare operations and one index based access to the list, because MoveNext saves also the current value for the iteration inside a member (see implementation for enumerator of List) And that's why you should prefer usage of the properties Count or Length if you can use it.

Answer 2

.Length iterates through the collection and returns the number of elements. Complexity is O(n)

.Any checks whether the collection has at least one item. Complexity is O(1).

Answer 3

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 4

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.

Answer 5

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 6

Sounds quite similar to this Stackoverflow question about difference between .Count and .Any for checking for existence of a result: Check for Existence of a Result in Linq-to-xml

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

Answer 7

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

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 9

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