Review use of AsValueEnumerable in benchmarks (#235)

NetFabric · Aug 17, 2020 · 81bb2e2 · 81bb2e2
1 parent ab52282
commit 81bb2e2
Show file tree

Hide file tree

Showing 31 changed files with 145 additions and 82 deletions.
diff --git a/NetFabric.Hyperlinq.Benchmarks/All.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/All.Benchmarks.cs
@@ -75,7 +75,8 @@ public class AllBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public bool Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .All(item => (item & 0x01) == 0);
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Any.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Any.Benchmarks.cs
@@ -75,7 +75,8 @@ public class AnyBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public bool Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .Any();
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Any.Predicate.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Any.Predicate.Benchmarks.cs
@@ -75,7 +75,8 @@ public class AnyPredicateBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public bool Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .Any(item => (item & 0x01) == 0);
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Contains.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Contains.Benchmarks.cs
@@ -81,18 +81,21 @@ public class ContainsBenchmarks : BenchmarksBase
         [BenchmarkCategory("Enumerable_Reference")]
         [Benchmark]
         public bool Hyperlinq_Enumerable_Reference() => 
-            EnumerableExtensions.AsValueEnumerable(enumerableReference)
+            enumerableReference
+            .AsValueEnumerable()
             .Contains(Count - 1);
 
         [BenchmarkCategory("Collection_Reference")]
         [Benchmark]
         public bool Hyperlinq_Collection_Reference() => 
-            ReadOnlyCollectionExtensions.AsValueEnumerable(collectionReference)
+            collectionReference
+            .AsValueEnumerable()
             .Contains(Count - 1);
 
         [BenchmarkCategory("List_Reference")]
         [Benchmark]
         public bool Hyperlinq_List_Reference() => 
-            ReadOnlyListExtensions.Contains(listReference, Count - 1);
+            listReference
+            .Contains(Count - 1);
     }
 }
diff --git a/NetFabric.Hyperlinq.Benchmarks/Contains.Comparer.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Contains.Comparer.Benchmarks.cs
@@ -96,7 +96,7 @@ public class ContainsComparerBenchmarks : BenchmarksBase, IEqualityComparer<int>
         [BenchmarkCategory("List_Reference")]
         [Benchmark]
         public bool Hyperlinq_List_Reference() =>
-            ReadOnlyListExtensions.Contains(listReference, Count - 1, this);
+            listReference.Contains(Count - 1, this);
 
         public bool Equals(int x, int y) 
             => EqualityComparer<int>.Default.Equals(x, y);

diff --git a/NetFabric.Hyperlinq.Benchmarks/Contains.DefaultComparer.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Contains.DefaultComparer.Benchmarks.cs
@@ -77,7 +77,7 @@ public class ContainsDefaultComparerBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public bool Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.Contains(listValue, Count - 1, EqualityComparer<int>.Default);
+            listValue.Contains(Count - 1, EqualityComparer<int>.Default);
 
         [BenchmarkCategory("Enumerable_Reference")]
         [Benchmark]
@@ -96,6 +96,7 @@ public class ContainsDefaultComparerBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Reference")]
         [Benchmark]
         public bool Hyperlinq_List_Reference() =>
-            ReadOnlyListExtensions.Contains(listReference, Count - 1, EqualityComparer<int>.Default);
+            listReference
+            .Contains(Count - 1, EqualityComparer<int>.Default);
     }
 }
diff --git a/NetFabric.Hyperlinq.Benchmarks/Count.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Count.Benchmarks.cs
@@ -92,7 +92,8 @@ public class CountBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public int Hyperlinq_List_Value() =>
-            listValue.AsValueEnumerable()
+            listValue
+            .AsValueEnumerable()
             .Count();
 
         [BenchmarkCategory("AsyncEnumerable_Value")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Distinct.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Distinct.Benchmarks.cs
@@ -135,7 +135,7 @@ public int Hyperlinq_Collection_Value()
         public int Hyperlinq_List_Value()
         {
             var sum = 0;
-            foreach (var item in EnumerableExtensions.AsValueEnumerable<TestList.Enumerable, TestList.Enumerable.Enumerator, int>(listValue, enumerable => enumerable.GetEnumerator()).Distinct())
+            foreach (var item in listValue.AsValueEnumerable().Distinct())
                 sum += item;
             return sum;
         }

diff --git a/NetFabric.Hyperlinq.Benchmarks/ElementAt.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/ElementAt.Benchmarks.cs
@@ -75,7 +75,8 @@ public class ElementAtBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public Option<int> Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .ElementAt(Count - 1);
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/First.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/First.Benchmarks.cs
@@ -75,8 +75,9 @@ public class FirstBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public Option<int> Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
-                .First();
+            listValue
+            .AsValueEnumerable()
+            .First();
 
         [BenchmarkCategory("Enumerable_Reference")]
         [Benchmark]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Indexer.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Indexer.Benchmarks.cs
@@ -46,7 +46,7 @@ public void GlobalSetup()
 
         [Benchmark]
         public bool Hyperlinq_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue).All(item => (item & 0x01) == 0);
+            listValue.AsValueEnumerable().All(item => (item & 0x01) == 0);
 
         static bool AllEnumerable(TestEnumerable.Enumerable source, Predicate<int> predicate)
         {

diff --git a/NetFabric.Hyperlinq.Benchmarks/Select.Count.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Select.Count.Benchmarks.cs
@@ -75,7 +75,8 @@ public class SelectCountBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public int Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .Select(item => item).Count();
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Select.ToArray.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Select.ToArray.Benchmarks.cs
@@ -75,7 +75,8 @@ public class SelectToArrayBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public int[] Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .Select(item => item).ToArray();
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Select.ToList.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Select.ToList.Benchmarks.cs
@@ -76,7 +76,8 @@ public class SelectToListBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public List<int> Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .Select(item => item).ToList();
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/SelectMany.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/SelectMany.Benchmarks.cs
@@ -132,10 +132,12 @@ public int Hyperlinq_Collection_Value()
         public int Hyperlinq_List_Value()
         {
             var sum = 0;
-            foreach (var item in EnumerableExtensions.AsValueEnumerable<TestList.Enumerable, TestList.Enumerable.Enumerator, int>(listValue, enumerable => enumerable.GetEnumerator())
+            foreach (var item in listValue
+                .AsValueEnumerable()
                 .SelectMany<
-                    EnumerableExtensions.ValueEnumerableWrapper<TestList.Enumerable, TestList.Enumerable.Enumerator, int>, TestList.Enumerable.Enumerator, int,
-                    ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(item => ValueEnumerable.Return(item)))
+                    ReadOnlyListExtensions.ValueEnumerableWrapper<int>, int, 
+                    ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(
+                        item => ValueEnumerable.Return(item)))
                 sum += item;
             return sum;
         }
@@ -145,7 +147,8 @@ public int Hyperlinq_List_Value()
         public int Hyperlinq_Enumerable_Reference()
         {
             var sum = 0;
-            foreach (var item in enumerableReference.AsValueEnumerable()
+            foreach (var item in enumerableReference
+                .AsValueEnumerable()
                 .SelectMany<
                     EnumerableExtensions.ValueEnumerableWrapper<int>, EnumerableExtensions.ValueEnumerableWrapper<int>.Enumerator, int,
                     ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(item => ValueEnumerable.Return(item)))
@@ -158,7 +161,8 @@ public int Hyperlinq_Enumerable_Reference()
         public int Hyperlinq_Collection_Reference()
         {
             var sum = 0;
-            foreach (var item in collectionReference.AsValueEnumerable()
+            foreach (var item in collectionReference
+                .AsValueEnumerable()
                 .SelectMany<
                     ReadOnlyCollectionExtensions.ValueEnumerableWrapper<int>, ReadOnlyCollectionExtensions.ValueEnumerableWrapper<int>.Enumerator, int,
                     ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(item => ValueEnumerable.Return(item)))
@@ -171,10 +175,12 @@ public int Hyperlinq_Collection_Reference()
         public int Hyperlinq_List_Reference()
         {
             var sum = 0;
-            foreach (var item in ReadOnlyListExtensions.SelectMany<
+            foreach (var item in listReference
+                .AsValueEnumerable()
+                .SelectMany<
                     ReadOnlyListExtensions.ValueEnumerableWrapper<int>, int, 
                     ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(
-                        ReadOnlyListExtensions.AsValueEnumerable<int>(listReference), item => ValueEnumerable.Return(item)))
+                        item => ValueEnumerable.Return(item)))
                 sum += item;
             return sum;
         }

diff --git a/NetFabric.Hyperlinq.Benchmarks/Single.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Single.Benchmarks.cs
@@ -106,7 +106,8 @@ public void GlobalSetup()
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public Option<int> Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .Single();
 
         [BenchmarkCategory("Enumerable_Reference")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/ToArray.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/ToArray.Benchmarks.cs
@@ -91,7 +91,8 @@ public class ToArrayBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public int[] Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .ToArray();
 
         [BenchmarkCategory("AsyncEnumerable_Value")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/ToArray.MemoryPool.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/ToArray.MemoryPool.Benchmarks.cs
@@ -106,8 +106,9 @@ public int Hyperlinq_Collection_Value()
         [Benchmark]
         public int Hyperlinq_List_Value()
         {
-            using var memoryOwner = ReadOnlyListExtensions
-                .AsValueEnumerable<int>(listValue)
+            using var memoryOwner = 
+                listValue
+                .AsValueEnumerable()
                 .ToArray(memoryPool);
             return memoryOwner.Memory.Span[0];
         }

diff --git a/NetFabric.Hyperlinq.Benchmarks/ToList.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/ToList.Benchmarks.cs
@@ -87,7 +87,8 @@ public class ToListBenchmarks : BenchmarksBase
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public List<int> Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
+            listValue
+            .AsValueEnumerable()
             .ToList();
 
         [BenchmarkCategory("AsyncEnumerable_Value")]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Where.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Where.Benchmarks.cs
@@ -233,7 +233,7 @@ public int Hyperlinq_Collection_Value()
         public int Hyperlinq_List_Value()
         {
             var sum = 0;
-            foreach (var item in EnumerableExtensions.AsValueEnumerable<TestList.Enumerable, TestList.Enumerable.Enumerator, int>(listValue, enumerable => enumerable.GetEnumerator()).Where(item => (item & 0x01) == 0))
+            foreach (var item in listValue.AsValueEnumerable().Where(item => (item & 0x01) == 0))
                 sum += item;
             return sum;
         }

diff --git a/NetFabric.Hyperlinq.Benchmarks/Where.Count.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Where.Count.Benchmarks.cs
@@ -53,70 +53,86 @@ public class WhereCountBenchmarks : BenchmarksBase
         [BenchmarkCategory("Array")]
         [Benchmark]
         public int StructLinq_Count() =>
-            array.ToStructEnumerable().Where(item => (item & 0x01) == 0, x => x).Count(x => x);
+            array.ToStructEnumerable()
+            .Where(item => (item & 0x01) == 0, x => x)
+            .Count(x => x);
 
         [BenchmarkCategory("Array")]
         [Benchmark]
         public int StructLinq_Count_IFunction()
         {
             var predicate = new IsEven();
-            var count = array.ToStructEnumerable().Where(ref predicate, x => x).Count(x => x);
-            return count;
+            return array.ToStructEnumerable()
+                .Where(ref predicate, x => x)
+                .Count(x => x);
         }
 
         [BenchmarkCategory("Array")]
         [Benchmark]
         public int Hyperlinq_Array() =>
-            array.Where(item => (item & 0x01) == 0).Count();
+            array
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
         [BenchmarkCategory("Array")]
         [Benchmark]
         public int Hyperlinq_Span() =>
-            array.AsSpan().Where(item => (item & 0x01) == 0).Count();
+            array.AsSpan()
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
         [BenchmarkCategory("Array")]
         [Benchmark]
         public int Hyperlinq_Memory() =>
-            memory.Where(item => (item & 0x01) == 0).Count();
+            memory
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
         [BenchmarkCategory("Enumerable_Value")]
         [Benchmark]
         public int Hyperlinq_Enumerable_Value() =>
             EnumerableExtensions.AsValueEnumerable<TestEnumerable.Enumerable, TestEnumerable.Enumerable.Enumerator, int>(enumerableValue, enumerable => enumerable.GetEnumerator())
-            .Where(item => (item & 0x01) == 0).Count();
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
         [BenchmarkCategory("Collection_Value")]
         [Benchmark]
         public int Hyperlinq_Collection_Value() =>
             ReadOnlyCollectionExtensions.AsValueEnumerable<TestCollection.Enumerable, TestCollection.Enumerable.Enumerator, int>(collectionValue, enumerable => enumerable.GetEnumerator())
-            .Where(item => (item & 0x01) == 0).Count();
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
         [BenchmarkCategory("List_Value")]
         [Benchmark]
         public int Hyperlinq_List_Value() =>
-            ReadOnlyListExtensions.AsValueEnumerable<int>(listValue)
-            .Where(item => (item & 0x01) == 0).Count();
+            listValue
+            .AsValueEnumerable()
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
 
         [BenchmarkCategory("Enumerable_Reference")]
         [Benchmark]
         public int Hyperlinq_Enumerable_Reference() =>
             enumerableReference
             .AsValueEnumerable()
-            .Where(item => (item & 0x01) == 0).Count();
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
         [BenchmarkCategory("Collection_Reference")]
         [Benchmark]
         public int Hyperlinq_Collection_Reference() =>
             collectionReference
             .AsValueEnumerable()
-            .Where(item => (item & 0x01) == 0).Count();
+            .Where(item => (item & 0x01) == 0)
+            .Count();
 
         [BenchmarkCategory("List_Reference")]
         [Benchmark]
         public int Hyperlinq_List_Reference() =>
             listReference
             .AsValueEnumerable()
-            .Where(item => (item & 0x01) == 0).Count();
+            .Where(item => (item & 0x01) == 0)
+            .Count();
     }
 }