[Array] remove UnmanagedArrayEnumerable and ArrayStructEnumerator is now a struct.

Author: reegeek

src/StructLinq.Benchmark/Array.cs

@@ -0,0 +1,65 @@
+using System.Collections.Generic;
+using System.Linq;
+using BenchmarkDotNet.Attributes;
+using StructLinq.Array;
+using StructLinq.IEnumerable;
+
+namespace StructLinq.Benchmark
+{
+    [MemoryDiagnoser]
+    public class Array
+    {
+        private readonly ITypedEnumerable<int, ArrayStructEnumerator<int>> safeArray;
+        private readonly CountAction<int>[] countActions = new CountAction<int>[1];
+        public int Count = 10000;
+        private readonly IEnumerable<int> sysEnumerable;
+        private readonly ITypedEnumerable<int, GenericEnumerator<int>> convertArray;
+        private readonly int[] array;
+        public Array()
+        {
+            array = Enumerable.Range(0, Count).ToArray();
+            sysEnumerable = array;
+            safeArray = array.ToTypedEnumerable();
+            convertArray = ((IEnumerable<int>) array).ToTypedEnumerable();
+        }
+
+        [Benchmark(Baseline = true)]
+        public int EnumArray()
+        {
+            int count = 0;
+            foreach (var i in sysEnumerable)
+            {
+                count++;
+            }
+            return count;
+        }
+
+        [Benchmark]
+        public int SysArray()
+        {
+            int count = 0;
+            foreach (var i in array)
+            {
+                count++;
+            }
+            return count;
+        }
+
+        [Benchmark]
+        public int UnsafeArray()
+        {
+            ref CountAction<int> countAction = ref countActions[0];
+            countAction.Count = 0;
+            safeArray.ForEach(ref countAction);
+            return countAction.Count;
+        }
+        [Benchmark]
+        public int ConvertArray()
+        {
+            ref CountAction<int> countAction = ref countActions[0];
+            countAction.Count = 0;
+            convertArray.ForEach(ref countAction);
+            return countAction.Count;
+        }
+    }
+}

src/StructLinq.Benchmark/ForEach.cs

@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using BenchmarkDotNet.Attributes;
-using StructLinq.ForEach;
 using StructLinq.IEnumerable;
 using StructLinq.Range;
 

src/StructLinq.Tests/ArrayTests.cs

@@ -1,16 +1,22 @@
-using System.Linq;
+using System.Collections.Generic;
+using System.Linq;
 using Xunit;
 
 namespace StructLinq.Tests
 {
-    public class ArrayTests
+    public class ArrayTests : AbstractEnumerableTests<int>
     {
         [Fact]
-        public void Test()
+        public void ShouldSameAsSystem()
         {
             var sysArray = Enumerable.Range(0, 50).ToArray();
             var structArray = Enumerable.Range(0, 50).ToArray().ToTypedEnumerable().ToArray();
             Assert.Equal(sysArray, structArray);
         }
+
+        protected override IEnumerable<int> Build(int size)
+        {
+            return Enumerable.Range(-1, size).ToArray().ToTypedEnumerable();
+        }
     }
 }

src/StructLinq/Array/ArrayEnumerable.cs

@@ -1,6 +1,9 @@
-namespace StructLinq.Array
+using System.Collections;
+using System.Collections.Generic;
+
+namespace StructLinq.Array
 {
-    class ArrayEnumerable<T> : AbstractTypedEnumerable<T, ArrayStructEnumerator<T>>
+    struct ArrayEnumerable<T> : ITypedEnumerable<T, ArrayStructEnumerator<T>>
     {
         #region private fields
         private T[] array;
@@ -9,9 +12,17 @@ public ArrayEnumerable(ref T[] array)
         {
             this.array = array;
         }
-        public override ArrayStructEnumerator<T> GetTypedEnumerator()
+        public ArrayStructEnumerator<T> GetTypedEnumerator()
         {
             return new ArrayStructEnumerator<T>(ref array);
         }
+        IEnumerator System.Collections.IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+        public IEnumerator<T> GetEnumerator()
+        {
+            return GetTypedEnumerator();
+        }
     }
 }

src/StructLinq/Array/ArrayStructEnumerable.cs

@@ -5,13 +5,9 @@ namespace StructLinq
 {
     public static partial class StructEnumerable
     {
-        public static ITypedEnumerable<T,ArrayStructEnumerator<T>> SafeToTypedEnumerable<T>(this T[] array)
+        public static ITypedEnumerable<T,ArrayStructEnumerator<T>> ToTypedEnumerable<T>(this T[] array)
         {
             return new ArrayEnumerable<T>(ref array);
         }
-        public static ITypedEnumerable<T, UnmanagedArrayEnumerator<T>> ToTypedEnumerable<T>(this T[] array) where T : unmanaged
-        {
-            return new UnmanagedArrayEnumerable<T>(ref array);
-        }
     }
 }

src/StructLinq/Array/ArrayStructEnumerator.cs

@@ -4,36 +4,46 @@
 
 namespace StructLinq.Array
 {
-    public class ArrayStructEnumerator<T> : IEnumerator<T>
+    public struct ArrayStructEnumerator<T> : IEnumerator<T>
     {
         #region private fields
         private readonly T[] array;
         private readonly int endIndex;
-        private int index = -1;
-        private T current;
+        private int index;
         #endregion
         public ArrayStructEnumerator(ref T[] array)
         {
             this.array = array;
             endIndex = array.Length;
+            index = 0;
+            Current = default;
         }
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool MoveNext()
         {
             if (index >= endIndex)
                 return false;
+            Current = array[index];
             ++index;
-            return index < endIndex;
+            return true;
         }
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Reset()
         {
-            index = -1;
+            index = 0;
+            Current = default;
         }
         object IEnumerator.Current => Current;
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public void Dispose()
         {
         }
-        public T Current => array[index];
+        public T Current
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get;
+            private set;
+        }
     }
 }