c# - List 上的 Select() 是否会丢失集合的大小？

Question

在下面的代码中，该Select()方法是否足够聪明，可以在内部保持列表的大小以使该ToArray()方法变得便宜？

List<Thing> bigList = someBigList;
var bigArray = bigList.Select(t => t.SomeField).ToArray();

Answer 1

这很容易检查，无需查看实现。只需创建一个实现 的类IList<T>，并在Count属性中添加跟踪：

    class MyList<T> : IList<T>
    {
        private readonly IList<T> _list = new List<T>();
        public IEnumerator<T> GetEnumerator()
        {
            return _list.GetEnumerator();
        }

        public void Add(T item)
        {
            _list.Add(item);
        }

        public void Clear()
        {
            _list.Clear();
        }

        public bool Contains(T item)
        {
            return _list.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            _list.CopyTo(array, arrayIndex);
        }

        public bool Remove(T item)
        {
            return _list.Remove(item);
        }

        public int Count
        {
            get
            {
                Console.WriteLine ("Count accessed");
                return _list.Count;
            }
        }

        public bool IsReadOnly
        {
            get { return _list.IsReadOnly; }
        }

        public int IndexOf(T item)
        {
            return _list.IndexOf(item);
        }

        public void Insert(int index, T item)
        {
            _list.Insert(index, item);
        }

        public void RemoveAt(int index)
        {
            _list.RemoveAt(index);
        }

        public T this[int index]
        {
            get { return _list[index]; }
            set { _list[index] = value; }
        }

        #region Implementation of IEnumerable

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion
    }

如果Count访问该属性，则此代码应打印“访问计数”：

var list = new MyList<int> { 1, 2, 3 };
var array = list.Select(x => x).ToArray();

但它不打印任何东西，所以不，它不跟踪计数。当然，可能会有特定于 的优化List<T>，但似乎不太可能......

Answer 2

不，现在它没有（至少是 .NET 实现）。从 MS 参考源，Enumerable.ToArray实现为

public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source) {
    if (source == null) throw Error.ArgumentNull("source"); 
    return new Buffer<TSource>(source).ToArray();
}

Buffer<TSource>通过根据需要进行迭代和调整大小，在构造时创建源序列的副本（以数组形式）；source如果是一个，它有一个特殊的“快速路径” ICollection<TSource>，但结果Enumerable.Select不出所料地没有实现那个接口。

尽管如此，除了纯粹的好奇之外，我认为这个结果没有任何意义。一方面，实施可能在未来的任何时候发生变化（即使快速的成本效益分析不会发现这种可能性）。在任何情况下，您最多会遭受 O(logN) 重新分配。对于小 N，重新分配不会很明显。对于较大的 N，迭代集合所花费的时间将是 O(N)，因此很容易占主导地位。

Answer 3

当您将Select运算符应用于可枚举序列时，它会创建以下迭代器之一：

• WhereSelectArrayIterator
• WhereSelectListIterator
• WhereSelectEnumerableIterator

在 的情况下List<T>，WhereSelectListIterator创建迭代器。它使用列表的迭代器来迭代列表并应用谓词和选择器。这是一个MoveNext方法实现：

while (this.enumerator.MoveNext())
{
    TSource current = this.enumerator.Current;
    if ((this.predicate == null) || this.predicate(current))
    {
        base.current = this.selector(current);
        return true;
    }
}

如您所见，它不保留有关匹配 predicate 的项目数的信息，因此它不知道过滤序列中的项目数。