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迭代器。它使用list的迭代器迭代列表并应用谓词和选择器。这是一个MoveNext方法实现：

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

正如您所看到的，它不会保留与谓词匹配的项目数量的信息，因此它不知道过滤序列中的项目数。

List上的Select（）是否会丢失集合的大小？

3 个答案: