Merge pull request #2120 from stephentoub/select_toarray

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

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;
         }

src/System.Linq/tests/ReverseTests.cs

@@ -0,0 +1,39 @@
+using System.Linq.Tests.Helpers;
+using Xunit;
+
+namespace System.Linq.Tests
+{
+    public class ReverseTests
+    {
+        [Fact]
+        public void InvalidArguments()
+        {
+            Assert.Throws<ArgumentNullException>(() => Enumerable.Reverse<string>(null));
+        }
+
+        [Theory]
+        [InlineData(new int[] { })]
+        [InlineData(new int[] { 1 })]
+        [InlineData(new int[] { 1, 3, 5 })]
+        [InlineData(new int[] { 2, 4, 6, 8 })]
+        public void ReverseMatches(int[] input)
+        {
+            int[] expectedResults = new int[input.Length];
+            for (int i = 0; i < input.Length; i++)
+            {
+                expectedResults[i] = input[input.Length - 1 - i];
+            }
+
+            Assert.NotSame(input, Enumerable.Reverse(input));
+
+            Assert.Equal(expectedResults, input.Reverse());
+            Assert.Equal(expectedResults, new TestCollection<int>(input).Reverse());
+            Assert.Equal(expectedResults, new TestEnumerable<int>(input).Reverse());
+            Assert.Equal(expectedResults, new TestReadOnlyCollection<int>(input).Reverse());
+
+            Assert.Equal(expectedResults.Select(i => i * 2), input.Select(i => i * 2).Reverse());
+            Assert.Equal(expectedResults.Where(i => true).Select(i => i * 2), input.Where(i => true).Select(i => i * 2).Reverse());
+            Assert.Equal(expectedResults.Where(i => false).Select(i => i * 2), input.Where(i => false).Select(i => i * 2).Reverse());
+        }
+    }
+}

src/System.Linq/tests/System.Linq.Tests.csproj

@@ -35,6 +35,7 @@
     <Compile Include="RangeTests.cs" />
     <Compile Include="RepeatTests.cs" />
     <Compile Include="SumTests.cs" />
+    <Compile Include="ReverseTests.cs" />
     <Compile Include="WhereTests.cs" />
     <Compile Include="ToArrayTests.cs" />
     <Compile Include="ToDictionaryTests.cs" />
@@ -49,4 +50,4 @@
     </ProjectReference>
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />
-</Project>
+</Project>

src/System.Linq/tests/ToArrayTests.cs

@@ -52,6 +52,10 @@ public void ToArray_AlwaysCreateACopy()
 
             Assert.NotSame(sourceArray, resultArray);
             Assert.Equal(sourceArray, resultArray);
+
+            int[] emptySourceArray = Array.Empty<int>();
+            Assert.NotSame(emptySourceArray.ToArray(), emptySourceArray.ToArray());
+            Assert.NotSame(emptySourceArray.Select(i => i).ToArray(), emptySourceArray.Select(i => i).ToArray());
         }
 
 
@@ -153,5 +157,44 @@ public void ToArray_FailOnExtremelyLargeCollection()
             var thrownException = Assert.ThrowsAny<Exception>(() => { largeSeq.ToArray(); });
             Assert.True(thrownException.GetType() == typeof(OverflowException) || thrownException.GetType() == typeof(OutOfMemoryException));
         }
+
+        [Theory]
+        [InlineData(new int[] { }, new string[] { })]
+        [InlineData(new int[] { 1 }, new string[] { "1" })]
+        [InlineData(new int[] { 1, 2, 3 }, new string[] { "1", "2", "3" })]
+        public void ToArray_ArrayWhereSelect(int[] sourceIntegers, string[] convertedStrings)
+        {
+            Assert.Equal(convertedStrings, sourceIntegers.Select(i => i.ToString()).ToArray());
+
+            Assert.Equal(sourceIntegers, sourceIntegers.Where(i => true).ToArray());
+            Assert.Equal(Array.Empty<int>(), sourceIntegers.Where(i => false).ToArray());
+
+            Assert.Equal(convertedStrings, sourceIntegers.Where(i => true).Select(i => i.ToString()).ToArray());
+            Assert.Equal(Array.Empty<string>(), sourceIntegers.Where(i => false).Select(i => i.ToString()).ToArray());
+
+            Assert.Equal(convertedStrings, sourceIntegers.Select(i => i.ToString()).Where(s => s != null).ToArray());
+            Assert.Equal(Array.Empty<string>(), sourceIntegers.Select(i => i.ToString()).Where(s => s == null).ToArray());
+        }
+
+        [Theory]
+        [InlineData(new int[] { }, new string[] { })]
+        [InlineData(new int[] { 1 }, new string[] { "1" })]
+        [InlineData(new int[] { 1, 2, 3 }, new string[] { "1", "2", "3" })]
+        public void ToArray_ListWhereSelect(int[] sourceIntegers, string[] convertedStrings)
+        {
+            var sourceList = new List<int>(sourceIntegers);
+
+            Assert.Equal(convertedStrings, sourceList.Select(i => i.ToString()).ToArray());
+            
+            Assert.Equal(sourceList, sourceList.Where(i => true).ToArray());
+            Assert.Equal(Array.Empty<int>(), sourceList.Where(i => false).ToArray());
+
+            Assert.Equal(convertedStrings, sourceList.Where(i => true).Select(i => i.ToString()).ToArray());
+            Assert.Equal(Array.Empty<string>(), sourceList.Where(i => false).Select(i => i.ToString()).ToArray());
+
+            Assert.Equal(convertedStrings, sourceList.Select(i => i.ToString()).Where(s => s != null).ToArray());
+            Assert.Equal(Array.Empty<string>(), sourceList.Select(i => i.ToString()).Where(s => s == null).ToArray());
+        }
+
     }
 }