Add AsValueEnumerable() to replace the bindings

NetFabric · Feb 22, 2021 · 0e0a52d · 0e0a52d
1 parent 7ff1272
commit 0e0a52d
Show file tree

Hide file tree

Showing 150 changed files with 2,821 additions and 5,073 deletions.
diff --git a/NetFabric.Hyperlinq.Benchmarks/Benchmarks/SelectManyBenchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Benchmarks/SelectManyBenchmarks.cs
@@ -150,10 +150,7 @@ public int Hyperlinq_List_Value()
             var sum = 0;
             foreach (var item in listValue
                 .AsValueEnumerable()
-                .SelectMany<
-                    ReadOnlyListExtensions.ValueEnumerableWrapper<int>, int, 
-                    ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(
-                        item => ValueEnumerable.Return(item)))
+                .SelectMany(item => ValueEnumerable.Return(item)))
                 sum += item;
             return sum;
         }
@@ -165,9 +162,7 @@ public int Hyperlinq_Enumerable_Reference()
             var sum = 0;
             foreach (var item in enumerableReference
                 .AsValueEnumerable()
-                .SelectMany<
-                    EnumerableExtensions.ValueEnumerable<int>, EnumerableExtensions.ValueEnumerable<int>.Enumerator, int,
-                    ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(item => ValueEnumerable.Return(item)))
+                .SelectMany(item => ValueEnumerable.Return(item)))
                 sum += item;
             return sum;
         }
@@ -179,9 +174,7 @@ public int Hyperlinq_Collection_Reference()
             var sum = 0;
             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)))
+                .SelectMany(item => ValueEnumerable.Return(item)))
                 sum += item;
             return sum;
         }
@@ -193,10 +186,7 @@ public int Hyperlinq_List_Reference()
             var sum = 0;
             foreach (var item in listReference
                 .AsValueEnumerable()
-                .SelectMany<
-                    ReadOnlyListExtensions.ValueEnumerableWrapper<int>, int, 
-                    ValueEnumerable.ReturnEnumerable<int>, ValueEnumerable.ReturnEnumerable<int>.DisposableEnumerator, int>(
-                        item => ValueEnumerable.Return(item)))
+                .SelectMany(item => ValueEnumerable.Return(item)))
                 sum += item;
             return sum;
         }

diff --git a/NetFabric.Hyperlinq.Benchmarks/Benchmarks/SkipTakeBenchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Benchmarks/SkipTakeBenchmarks.cs
@@ -180,10 +180,14 @@ public int StructLinq_List_Reference()
         [Benchmark]
         public int Hyperlinq_Array_For()
         {
-            var source = array.AsValueEnumerable().Skip(Skip).Take(Count).Array;
+            var source = array.AsValueEnumerable().Skip(Skip).Take(Count);
             var sum = 0;
-            for (var index = 0; index < Count; index++)
-                sum += source[index];
+            for (var index = 0; index < source.Count; index++)
+            {
+                var item = source[index];
+                sum += item;
+            }
+
             return sum;
         }
 
@@ -193,7 +197,7 @@ public int Hyperlinq_Array_For()
         public int Hyperlinq_Array_Foreach()
         {
             var sum = 0;
-            foreach (var item in array.Skip(Skip).Take(Count))
+            foreach (var item in array.AsValueEnumerable().Skip(Skip).Take(Count))
                 sum += item;
             return sum;
         }
@@ -205,8 +209,11 @@ public int Hyperlinq_Span_For()
         {
             var source = array.AsSpan().Skip(Skip).Take(Count);
             var sum = 0;
-            for (var index = 0; index < Count; index++)
-                sum += source[index];
+            for (var index = 0; index < source.Length; index++)
+            {
+                var item = source[index];
+                sum += item;
+            }
             return sum;
         }
 
@@ -226,10 +233,13 @@ public int Hyperlinq_Span_Foreach()
         [Benchmark]
         public int Hyperlinq_Memory_For()
         {
-            var source = memory.Skip(Skip).Take(Count).Span;
+            var source = memory.AsValueEnumerable().Skip(Skip).Take(Count);
             var sum = 0;
-            for (var index = 0; index < Count; index++)
-                sum += source[index];
+            for (var index = 0; index < source.Count; index++)
+            {
+                var item = source[index];
+                sum += item;
+            }
             return sum;
         }
 
@@ -239,7 +249,7 @@ public int Hyperlinq_Memory_For()
         public int Hyperlinq_Memory_Foreach()
         {
             var sum = 0;
-            foreach (var item in memory.Skip(Skip).Take(Count).Span)
+            foreach (var item in memory.AsValueEnumerable().Skip(Skip).Take(Count))
                 sum += item;
             return sum;
         }

diff --git a/NetFabric.Hyperlinq.Benchmarks/Utils/TestCollection.cs b/NetFabric.Hyperlinq.Benchmarks/Utils/TestCollection.cs
@@ -28,7 +28,7 @@ public Enumerable(int[] array)
             public void Clear() => throw new NotImplementedException();
 
             public bool Contains(int item)
-                => array.Contains(item);
+                => ((IList<int>)array).Contains(item);
 
             public void CopyTo(int[] array, int arrayIndex)
                 => this.array.CopyTo(array, arrayIndex);
@@ -80,7 +80,7 @@ public EnumerableReferenceType(int[] array)
             public void Clear() => throw new NotImplementedException();
 
             public bool Contains(int item)
-                => array.Contains(item);
+                => ((IList<int>)array).Contains(item);
 
             public void CopyTo(int[] array, int arrayIndex)
                 => this.array.CopyTo(array, arrayIndex);

diff --git a/NetFabric.Hyperlinq.Benchmarks/Utils/TestList.cs b/NetFabric.Hyperlinq.Benchmarks/Utils/TestList.cs
@@ -39,7 +39,7 @@ public Enumerable(int[] array)
             public void RemoveAt(int index) => throw new NotImplementedException();
 
             public bool Contains(int item)
-                => array.Contains(item);
+                => ((IList<int>)array).Contains(item);
 
             public void CopyTo(int[] array, int arrayIndex)
                 => this.array.CopyTo(array, arrayIndex);
@@ -102,7 +102,7 @@ public EnumerableReferenceType(int[] array)
             public void RemoveAt(int index) => throw new NotImplementedException();
 
             public bool Contains(int item)
-                => array.Contains(item);
+                => ((IList<int>)array).Contains(item);
 
             public void CopyTo(int[] array, int arrayIndex)
                 => this.array.CopyTo(array, arrayIndex);

diff --git a/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ReadOnlyList.cs b/NetFabric.Hyperlinq.SourceGenerator.UnitTests/TestData/Source/Any.ReadOnlyList.cs
@@ -9,18 +9,18 @@ public static partial class ReadOnlyListExtensions
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool Any<TList, TSource>(this TList source)
-            where TList : IReadOnlyList<TSource>
+            where TList : struct, IReadOnlyList<TSource>
             => source.Count is not 0;
 
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool Any<TList, TSource>(this TList source, Func<TSource, bool> predicate)
-            where TList : IReadOnlyList<TSource>
+            where TList : struct, IReadOnlyList<TSource>
             => source.Any<TList, TSource, FunctionWrapper<TSource, bool>>(new FunctionWrapper<TSource, bool>(predicate));
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static bool Any<TList, TSource, TPredicate>(this TList source, TPredicate predicate = default)
-            where TList : IReadOnlyList<TSource>
+            where TList : struct, IReadOnlyList<TSource>
             where TPredicate : struct, IFunction<TSource, bool>
             => default;
     }

diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.Array.Tests.cs b/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.Array.Tests.cs
@@ -14,8 +14,8 @@ public class ArrayTests
         public void Count_With_ValidData_Must_Succeed(int[] source)
         {
             // Arrange
-            var expected = Enumerable
-                .Count(source);
+            var expected = source
+                .Count();
 
             // Act
             var result = source.AsValueEnumerable()

diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ArraySegment.Tests.cs b/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ArraySegment.Tests.cs
@@ -14,8 +14,8 @@ public void Count_With_NullArray_Must_Succeed()
             var source = default(ArraySegment<int>);
 
             // Act
-            var result = ArrayExtensions
-                .Count(source);
+            var result = source.AsValueEnumerable()
+                .Count();
 
             // Assert
             _ = result.Must()
@@ -35,8 +35,8 @@ public void Count_With_ValidData_Must_Succeed(int[] source, int skip, int take)
                 .Count(wrapped);
 
             // Act
-            var result = ArrayExtensions
-                .Count(wrapped);
+            var result = wrapped.AsValueEnumerable()
+                .Count();
 
             // Assert
             _ = result.Must()
@@ -57,8 +57,8 @@ public void Count_Predicate_With_ValidData_Must_Succeed(int[] source, int skip,
                 .Count(predicate);
 
             // Act
-            var result = ArrayExtensions
-                .Skip(wrapped, skip)
+            var result = wrapped.AsValueEnumerable()
+                .Skip(skip)
                 .Take(take)
                 .Where(predicate)
                 .Count();
@@ -83,8 +83,8 @@ public void Count_PredicateAt_With_ValidData_Must_Succeed(int[] source, int skip
                 .Count();
 
             // Act
-            var result = ArrayExtensions
-                .Skip(wrapped, skip)
+            var result = wrapped.AsValueEnumerable()
+                .Skip(skip)
                 .Take(take)
                 .Where(predicate)
                 .Count();

diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.UnitTests/Aggregation/Count/Count.ReadOnlyList.Tests.cs
@@ -20,8 +20,8 @@ public void Count_With_ValidData_Must_Succeed(int[] source)
                 .Count(source);
 
             // Act
-            var result = ReadOnlyListExtensions
-                .Count<Wrap.ReadOnlyListWrapper<int>, int>(wrapped);
+            var result = wrapped
+                .Count();
 
             // Assert
             _ = result.Must()
@@ -43,8 +43,8 @@ public void Count_Predicate_With_ValidData_Must_Succeed(int[] source, int skip,
                 .Count(predicate);
 
             // Act
-            var result = ReadOnlyListExtensions
-                .Skip<Wrap.ReadOnlyListWrapper<int>, int>(wrapped, skip)
+            var result = wrapped
+                .Skip(skip)
                 .Take(take)
                 .Where(predicate)
                 .Count();
@@ -70,8 +70,8 @@ public void Count_PredicateAt_With_ValidData_Must_Succeed(int[] source, int skip
                 .Count();
 
             // Act
-            var result = ReadOnlyListExtensions
-                .Skip<Wrap.ReadOnlyListWrapper<int>, int>(wrapped, skip)
+            var result = wrapped
+                .Skip(skip)
                 .Take(take)
                 .Where(predicate)
                 .Count();

diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ReadOnlyList.Tests.cs b/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ReadOnlyList.Tests.cs
@@ -0,0 +1,68 @@
+using NetFabric.Assertive;
+using System;
+using System.Linq;
+using Xunit;
+
+namespace NetFabric.Hyperlinq.UnitTests.Aggregation.Sum
+{
+    public class ReadOnlyListTests
+    {
+        public static TheoryData<int[]> Sum =>
+            new TheoryData<int[]>
+            {
+                { new int[] { 1, 2, 3, 4, 5, 6, 7 } },
+                { new int[] { 1, 2, 3, 4, 5, 6, 7, 8 } },
+                { new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 } },
+                { new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 } },
+            };
+
+
+        [Theory]
+        [MemberData(nameof(TestData.Empty), MemberType = typeof(TestData))]
+        [MemberData(nameof(TestData.Single), MemberType = typeof(TestData))]
+        [MemberData(nameof(TestData.Multiple), MemberType = typeof(TestData))]
+        [MemberData(nameof(Sum))]
+        public void Sum_With_ValidData_Must_Succeed(int[] source)
+        {
+            // Arrange
+            var wrapped = Wrap.AsList(source);
+            var expected = Enumerable
+                .Sum(source);
+
+            // Act
+            var result = wrapped.AsValueEnumerable()
+                .Sum();
+
+            // Assert
+            _ = result.Must()
+                .BeEqualTo(expected);
+        }
+
+        public static TheoryData<int?[]> NullableSum =>
+            new TheoryData<int?[]>
+            {
+                { new int?[] { null } },
+                { new int?[] { null, null, null } },
+                { new int?[] { null, 2, 3, 4, null } },
+                { new int?[] { 1, 2, null, 4, 5 } },
+            };
+
+        [Theory]
+        [MemberData(nameof(NullableSum))]
+        public void Sum_With_Nullable_ValidData_Must_Succeed(int?[] source)
+        {
+            // Arrange
+            var wrapped = Wrap.AsList(source);
+            var expected = Enumerable
+                .Sum(source);
+
+            // Act
+            var result = wrapped.AsValueEnumerable()
+                .Sum();
+
+            // Assert
+            _ = result.Must()
+                .BeEqualTo(expected.Value);
+        }
+    }
+}
diff --git a/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ValueEnumerable.Tests.cs b/NetFabric.Hyperlinq.UnitTests/Aggregation/Sum/Sum.ValueEnumerable.Tests.cs
@@ -0,0 +1,68 @@
+using NetFabric.Assertive;
+using System;
+using System.Linq;
+using Xunit;
+
+namespace NetFabric.Hyperlinq.UnitTests.Aggregation.Sum
+{
+    public class ValueEnumerableTests
+    {
+        public static TheoryData<int[]> Sum =>
+            new TheoryData<int[]>
+            {
+                { new int[] { 1, 2, 3, 4, 5, 6, 7 } },
+                { new int[] { 1, 2, 3, 4, 5, 6, 7, 8 } },
+                { new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 } },
+                { new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 } },
+            };
+
+
+        [Theory]
+        [MemberData(nameof(TestData.Empty), MemberType = typeof(TestData))]
+        [MemberData(nameof(TestData.Single), MemberType = typeof(TestData))]
+        [MemberData(nameof(TestData.Multiple), MemberType = typeof(TestData))]
+        [MemberData(nameof(Sum))]
+        public void Sum_With_ValidData_Must_Succeed(int[] source)
+        {
+            // Arrange
+            var wrapped = Wrap.AsValueEnumerable(source);
+            var expected = Enumerable
+                .Sum(source);
+
+            // Act
+            var result = wrapped.AsValueEnumerable()
+                .Sum();
+
+            // Assert
+            _ = result.Must()
+                .BeEqualTo(expected);
+        }
+
+        public static TheoryData<int?[]> NullableSum =>
+            new TheoryData<int?[]>
+            {
+                { new int?[] { null } },
+                { new int?[] { null, null, null } },
+                { new int?[] { null, 2, 3, 4, null } },
+                { new int?[] { 1, 2, null, 4, 5 } },
+            };
+
+        [Theory]
+        [MemberData(nameof(NullableSum))]
+        public void Sum_With_Nullable_ValidData_Must_Succeed(int?[] source)
+        {
+            // Arrange
+            var wrapped = Wrap.AsList(source);
+            var expected = Enumerable
+                .Sum(source);
+
+            // Act
+            var result = wrapped.AsValueEnumerable()
+                .Sum();
+
+            // Assert
+            _ = result.Must()
+                .BeEqualTo(expected.Value);
+        }
+    }
+}