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也会为您节省新List<T>个实例的分配 - 而不是过于昂贵，但在可能的情况下，最好避免不必要的分配。

Answer 2

任何一个版本都要求（在一般情况下）您完全迭代IEnumerable<string>。

在某些情况下，支持类型提供了一种直接确定可用于O（1）性能的计数的机制。有关详细信息，请参阅@ Marcin的答案。

调用ToList（）的版本将产生额外的CPU开销，尽管非常小且可能难以测量。它还将分配原本无法分配的内存。如果你的数量很高，那将是更大的担忧。

Answer 3

一个非常基本的LinqPad测试表明，调用IEnumerable<string>.Count()比创建列表集合并获取计数更快，更不用说更高效的内存（如其他答案中所述），并且在重新访问已经枚举的集合时仍然更快

我有一个平均约4个滴答用于调用IEnumerable的Count（）和~10k来创建一个新列表以获得Count。

void Main()
{
    IEnumerable<string> ienumerable = GetStrings();
    var test1 = new Stopwatch();
    test1.Start();
    var count1 = ienumerable.Count();
    test1.Stop();
    test1.ElapsedTicks.Dump();

    var test2 = new Stopwatch();
    test2.Start();
    var count2 = ienumerable.ToList().Count;
    test2.Stop();
    test2.ElapsedTicks.Dump();

    var test3 = new Stopwatch();
    test3.Start();
    var count3 = ienumerable.Count();
    test3.Stop();
    test3.ElapsedTicks.Dump();
}

public IEnumerable<string> GetStrings()
{
    var testString = "test";
    var strings = new List<string>();
    for (int i = 0; i < 500000; i++)
    {
        strings.Add(testString);
    }

    return strings;
}

在后一种情况下，您需要从现有集合（引擎盖必须迭代集合）中创建新集合所需的周期，然后将Count属性从集合中拉出。因此，Enumerable优化获胜并更快地返回计数值。

在第三次试运行中，平均价格下降至约2，因为它立即返回先前看到的计数（如下所示）。

IColllection<TSource> collectionoft = source as ICollection<TSource>;
if (collectionoft != null) return collectionoft.Count;
ICollection collection = source as ICollection;
if (collection != null) return collection.Count;

然而，这里的实际成本不是CPU周期，而是内存消耗。这就是你应该更关心的事情。

最后，作为警告，小心不要在集合的枚举中使用Count（）。这样做会重新枚举集合，从而导致可能的冲突。如果您需要在迭代集合时使用count来处理某些事情，那么正确的方法是使用.ToList()创建一个新列表并迭代该列表，引用Count

Linq计数vs IList计数

3 个答案: