c# - Linq 计数与 IList 计数

Question

如果我有以下来自某个存储库的 IEnumerable 列表。

IEnumerable<SomeObject> items = _someRepo.GetAll();

什么更快:

items.Count(); // Using Linq on the IEnumerable interface.

或

List<SomeObject> temp = items.ToList<SomeObject>(); // Cast as a List

temp.Count(); // Do a count on a list

Linq Count() 比将 IEnumerable 转换为 List 然后执行更快还是更慢Count()?

更新:将问题稍微改进为更现实的场景。

Answer 1

调用 Count直接是更好的选择。

Enumerable.Count内置了一些性能改进，可以让它在不枚举整个集合的情况下返回:

public static int Count<TSource>(this IEnumerable<TSource> source) {
    if (source == null) throw Error.ArgumentNull("source");
    ICollection<TSource> collectionoft = source as ICollection<TSource>;
    if (collectionoft != null) return collectionoft.Count;
    ICollection collection = source as ICollection;
    if (collection != null) return collection.Count;
    int count = 0;
    using (IEnumerator<TSource> e = source.GetEnumerator()) {
        checked {
            while (e.MoveNext()) count++;
        }
    }
    return count;
}

ToList()使用类似的优化，融入 List<T>(IEnumerable<T> source)构造函数:

public List(IEnumerable<T> collection) {
    if (collection==null)
        ThrowHelper.ThrowArgumentNullException(ExceptionArgument.collection);
    Contract.EndContractBlock();

    ICollection<T> c = collection as ICollection<T>;
    if( c != null) {
        int count = c.Count;
        if (count == 0)
        {
            _items = _emptyArray;
        }
        else {
            _items = new T[count];
            c.CopyTo(_items, 0);
            _size = count;
        }
    }    
    else {                
        _size = 0;
        _items = _emptyArray;
        // This enumerable could be empty.  Let Add allocate a new array, if needed.
        // Note it will also go to _defaultCapacity first, not 1, then 2, etc.

        using(IEnumerator<T> en = collection.GetEnumerator()) {
            while(en.MoveNext()) {
                Add(en.Current);                                    
            }
        }
    }
}

但如您所见，它只使用通用的 ICollection<T> , 所以如果你的收藏实现了 ICollection但不是它的通用版本调用 Count()直接会快很多。

不打电话 ToList first 还为您节省了新的分配 List<T> instance - 不是太昂贵的东西，但最好尽可能避免不必要的分配。