如何计算IEnumerable的项目？

Question

Given an instance IEnumerable o how can I get the item Count ? (without enumerating through all the items )

For example, if the instance is of ICollection , ICollection<T> and IReadOnlyCollection<T> , each of these interfaces have their own Count method.

Is getting the Count property by reflection the only way?

Instead, can I check and cast o to ICollection<T> for example, so I can then call Count ?

Answer 1

Ienumerable doesn't promise a count . What if it was a random sequence or a real time data feed from a sensor? It is entirely possible for the collection to be infinitely sized. The only way to count them is to start at zero and increment for each element that the enumerator provides. Which is exactly what LINQ does, so don't reinvent the wheel. LINQ is smart enough to use .Count properties of collections that support this.

Answer 2

The only way to really cover all your possible types for a collection is to use the generic interface and call the Count - method . This also covers other types such as streams or just iterators. Furthermore it will use the Count - property as of Count property vs Count() method? to avoid unneccessary overhead.

If you however have a non-generic collection you´d have to use reflection to use the correct property. However this is cumbersome and may fail if your collection doesn´t even have the property (eg an endless stream or just an iterator). On the other hand IEnumerable<T>.Count() will handle those types with the optimization mentioned above. Only if neccessary it will iterate the entire collection.

Answer 3

It depends how badly you want to avoid enumerating the items if the count is not available otherwise.

If you can enumerate the items, you can use the LINQ method Enumerable.Count . It will look for a quick way to get the item count by casting into one of the interfaces. If it can't, it will enumerate.

If you want to avoid enumeration at any cost, you will have to perform a type cast. In a real life scenario you often will not have to consider all the interfaces you have named, since you usually use one of them ( IReadOnlyCollection is rare and ICollection only used in legacy code). If you have to consider all of the interfaces, try them all in a separate method, which can be an extension:

static class CountExtensions {
    public static int? TryCount<T>(this IEnumerable<T> items) {
        switch (items) {
            case ICollection<T> genCollection:
                return genCollection.Count;
            case ICollection legacyCollection:
                return legacyCollection.Count;
            case IReadOnlyCollection<T> roCollection:
                return roCollection.Count;
            default:
                return null;
        }
    }
}

Access the extension method with:

int? count = myEnumerable.TryCount();