Optimize array/list.Select(...).ToArray()

LINQ already special-cases the very common case of using Select on input T[]s and List<T>s, but it doesn't take this to the next step of optimizing the case where that's then turned back into an array, a common pattern in its own right, e.g.

var names = people.Select(p => p.Name).ToArray();

This commit does so, modifying the internal Iterator type to support customization of ToArray, and updating the internal Buffer type to use it.  Changing Buffer not only helps ToArray but also Reverse and OrderBy, both of which convert the input sequence into an array internally.

Author: stephentoub

src/System.Linq/src/System/Linq/Enumerable.cs

@@ -144,6 +144,11 @@ public IEnumerable<TResult> Select<TResult>(Func<TSource, TResult> selector)
 
             public abstract IEnumerable<TSource> Where(Func<TSource, bool> predicate);
 
+            public virtual TSource[] ToArray()
+            {
+                return new Buffer<TSource>(this, queryInterfaces: false).ToArray();
+            }
+
             object IEnumerator.Current
             {
                 get { return Current; }
@@ -431,6 +436,21 @@ public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
             {
                 return new WhereEnumerableIterator<TResult>(this, predicate);
             }
+
+            public override TResult[] ToArray()
+            {
+                if (_predicate != null)
+                {
+                    return base.ToArray();
+                }
+
+                var results = new TResult[_source.Length];
+                for (int i = 0; i < results.Length; i++)
+                {
+                    results[i] = _selector(_source[i]);
+                }
+                return results;
+            }
         }
 
         internal class WhereSelectListIterator<TSource, TResult> : Iterator<TResult>
@@ -486,6 +506,21 @@ public override IEnumerable<TResult> Where(Func<TResult, bool> predicate)
             {
                 return new WhereEnumerableIterator<TResult>(this, predicate);
             }
+
+            public override TResult[] ToArray()
+            {
+                if (_predicate != null)
+                {
+                    return base.ToArray();
+                }
+
+                var results = new TResult[_source.Count];
+                for (int i = 0; i < results.Length; i++)
+                {
+                    results[i] = _selector(_source[i]);
+                }
+                return results;
+            }
         }
 
         //public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate) {
@@ -3079,21 +3114,35 @@ internal struct Buffer<TElement>
         internal TElement[] items;
         internal int count;
 
-        internal Buffer(IEnumerable<TElement> source)
+        internal Buffer(IEnumerable<TElement> source, bool queryInterfaces = true)
         {
             TElement[] items = null;
             int count = 0;
-            ICollection<TElement> collection = source as ICollection<TElement>;
-            if (collection != null)
+
+            if (queryInterfaces)
             {
-                count = collection.Count;
-                if (count > 0)
+                Enumerable.Iterator<TElement> iterator = source as Enumerable.Iterator<TElement>;
+                if (iterator != null)
                 {
-                    items = new TElement[count];
-                    collection.CopyTo(items, 0);
+                    items = iterator.ToArray();
+                    count = items.Length;
+                }
+                else
+                {
+                    ICollection<TElement> collection = source as ICollection<TElement>;
+                    if (collection != null)
+                    {
+                        count = collection.Count;
+                        if (count > 0)
+                        {
+                            items = new TElement[count];
+                            collection.CopyTo(items, 0);
+                        }
+                    }
                 }
             }
-            else
+
+            if (items == null)
             {
                 foreach (TElement item in source)
                 {
@@ -3109,6 +3158,7 @@ internal Buffer(IEnumerable<TElement> source)
                     count++;
                 }
             }
+
             this.items = items;
             this.count = count;
         }