IEnumberable to something that I can get a Count from?

Question

I've got this:

private IEnumerable _myList;

I need to get a count off of that object. I was previously typing _myList to an array and getting the length, but now we are using this same bit of code with a different kind of object. It's still a Collection type (it's a strongly typed Subsonic Collection object), and everything works great, except for the bit that we need to get the total number of items in the object.

I've tried typing it to CollectionBase, and many many other types, but nothing works that will let me get a .Count or .Length or anything like that.

Can anyone point me in the right direction?

EDIT: I'm not using 3.5, I'm using 2. So, anything dealing with Linq won't work. Sorry for not posting this earlier.

Answer 1

What about calling .ToList()?

Answer 2

The System.Linq.Enumerable.Count extension method does this for a typed IEnumerable<T>. For an untyped IEnumerable try making your own extension:

    public static int Count(this IEnumerable source)
    {
        if (source == null)
        {
            throw new ArgumentNullException("source");
        }

        ICollection collectionSource = source as ICollection;
        if (collectionSource != null)
        {
            return collectionSource.Count;
        }

        int num = 0;
        IEnumerator enumerator = source.GetEnumerator();
        //try-finally block to ensure Enumerator gets disposed if disposable
        try
        {
            while (enumerator.MoveNext())
            {
                num++;
            }
        }
        finally
        {
            // check for disposal
            IDisposable disposableEnumerator = enumerator as IDisposable;
            if(disposableEnumerator != null)
            {
                disposableEnumerator.Dispose();
            }
        }
        return num;
    }

Answer 3

LINQ provides a Count() extension method.

using System.Linq;

...

var count = _myList.Count();

Answer 4

If you're using .NET 3.5, you can use Enumerable.Count() to get the count from any IEnumerable<T>.

This will not work off a non-generic IEnumerable, though - it requires IEnumerable<T>.

This should work, though, since Subsonic's collection classes implement the appropriate interfaces for you. You'll need to change your definition from IEnumerable to IEnumerable<MyClass>.

Answer 5

If you include the System.Linq namespace, IEnumerable<T> has a Count() extension method available. You can write your own extension method to get it on the non-generic version. Note this method will box value types, so if that might end up being a performance concern for you, go with Jon Skeet's solution. This is just simpler.

public static int Count(this IEnumerable enumerable)
{
    int count = 0;
    foreach(object item in enumerable)
    {
        count++;
    }
    return count;
}

Answer 6

Is this actually IEnumerable instead of IEnumerable<T>? If so, LINQ won't help you directly. (You can use Cast<T>() as suggested elsewhere, but that will be relatively slow - in particular, it won't be optimised for IList/IList<T> implementations.)

I suggest you write:

public static int Count(this IEnumerable sequence)
{
    if (sequence == null)
    {
        throw new ArgumentNullException("sequence");
    }

    // Optimisation: won't optimise for collections which
    // implement ICollection<T> but not ICollection, admittedly.
    ICollection collection = sequence as ICollection;
    if (collection != null)
    {
        return collection.Count;
    }

    IEnumerator iterator = sequence.GetEnumerator();
    try
    {
        int count = 0;
        while (iterator.MoveNext())
        {
            // Don't bother accessing Current - that might box
            // a value, and we don't need it anyway
            count++;
        }
        return count;
    }
    finally
    {
        IDisposable disposable = iterator as IDisposable;
        if (disposable != null)
        {
            disposable.Dispose();
        }
    }
}

Answer 7

The type you use is IEnumerable, which doesn't have a Count property. But the generic equivalent, IEnumerable(T), has a Count property.

The obvious solution is to use IEnumerable(T), but if you can't, you could do something like this:

_myList.Cast<MyListItemType>().Count()

The cast is an easy way to convert a IEnumerable to an IEnumerable(SomeType) but obviously is not the best way to get the count performance-wise.

If performance is a factor, I'd just loop through the values to get the count, unless you know the underlying collection has a Count property (see Jon Skeet's answer...).

Answer 8

If the underlying object implements ICollection, then you can use the .Count() property.

Answer 9

I needed the same and I created IEnumerableList. The reason was that I didnt like to evaluate every time I need the count through whole enumerable object as it's done with the extension method Count().

More about it here: http://fknet.wordpress.com/2010/08/11/string-formatwith-extension/