From 55fbf93fc2396e13f6977c24e56505a41af30c3f Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Thu, 27 May 2021 01:15:19 +1000
Subject: [PATCH 1/8] Expose public indexer and length properties on
 RefEnumerable<T> and ReadOnlyRefEnumerable<T>

---
 .../Enumerables/ReadOnlyRefEnumerable{T}.cs   | 149 ++++++++++------
 .../Enumerables/RefEnumerable{T}.cs           | 163 ++++++++++++------
 2 files changed, 207 insertions(+), 105 deletions(-)

diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
index ad5fc7e3519..65be73fe452 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
@@ -29,6 +29,11 @@ public readonly ref struct ReadOnlyRefEnumerable<T>
         /// </summary>
         /// <remarks>The <see cref="ReadOnlySpan{T}.Length"/> field maps to the total available length.</remarks>
         private readonly ReadOnlySpan<T> span;
+
+        /// <summary>
+        /// Gets the total available length for the sequence.
+        /// </summary>
+        public int Length => span.Length;
 #else
         /// <summary>
         /// The target <see cref="object"/> instance, if present.
@@ -41,9 +46,9 @@ public readonly ref struct ReadOnlyRefEnumerable<T>
         private readonly IntPtr offset;
 
         /// <summary>
-        /// The total available length for the sequence.
+        /// Gets the total available length for the sequence.
         /// </summary>
-        private readonly int length;
+        public int Length { get; }
 #endif
 
         /// <summary>
@@ -52,6 +57,40 @@ public readonly ref struct ReadOnlyRefEnumerable<T>
         /// <remarks>The distance refers to <typeparamref name="T"/> items, not byte offset.</remarks>
         private readonly int step;
 
+        /// <summary>
+        /// Gets the element at the specified zero-based index.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref readonly T this[int index]
+        {
+            get
+            {
+                if ((uint)index >= (uint)Length)
+                {
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+                }
+
+                return ref DangerousGetReferenceAt(index);
+            }
+        }
+
+#if NETSTANDARD2_1_OR_GREATER
+        /// <summary>
+        /// Gets the element at the specified zero-based index.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref readonly T this[Index index]
+        {
+            get => ref this[index.GetOffset(Length)];
+        }
+#endif
+
 #if SPAN_RUNTIME_SUPPORT
         /// <summary>
         /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
@@ -116,21 +155,52 @@ internal ReadOnlyRefEnumerable(object? instance, IntPtr offset, int length, int
         {
             this.instance = instance;
             this.offset = offset;
-            this.length = length;
+            Length = length;
             this.step = step;
         }
 #endif
 
+        /// <summary>
+        /// Returns a reference to the first element within the current instance, with no bounds check.
+        /// </summary>
+        /// <returns>A reference to the first element within the current instance.</returns>
+        internal ref readonly T DangerousGetReference()
+        {
+#if SPAN_RUNTIME_SUPPORT
+            return ref MemoryMarshal.GetReference(this.span);
+#else
+            return ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
+#endif
+        }
+
+        /// <summary>
+        /// Returns a reference to a specified element within the current instance, with no bounds check.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        internal ref readonly T DangerousGetReferenceAt(int index)
+        {
+#if SPAN_RUNTIME_SUPPORT
+            ref T r0 = ref MemoryMarshal.GetReference(this.span);
+#else
+            ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
+#endif
+            // Here we just offset by shifting down as if we were traversing a 2D array with a
+            // a single column, with the width of each row represented by the step, the height
+            // represented by the current position, and with only the first element of each row
+            // being inspected. We can perform all the indexing operations in this type as nint,
+            // as the maximum offset is guaranteed never to exceed the maximum value, since on
+            // 32 bit architectures it's not possible to allocate that much memory anyway.
+            nint offset = (nint)(uint)index * (nint)(uint)this.step;
+            ref T ri = ref Unsafe.Add(ref r0, offset);
+            return ref ri;
+        }
+
         /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Enumerator GetEnumerator()
         {
-#if SPAN_RUNTIME_SUPPORT
-            return new Enumerator(this.span, this.step);
-#else
-            return new Enumerator(this.instance, this.offset, this.length, this.step);
-#endif
+            return new Enumerator(this);
         }
 
         /// <summary>
@@ -166,7 +236,7 @@ public void CopyTo(RefEnumerable<T> destination)
             ref T sourceRef = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
             ref T destinationRef = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(destination.Instance, destination.Offset);
             int
-                sourceLength = this.length,
+                sourceLength = Length,
                 destinationLength = destination.Length;
 #endif
 
@@ -191,7 +261,7 @@ public bool TryCopyTo(RefEnumerable<T> destination)
                 destinationLength = destination.Span.Length;
 #else
             int
-                sourceLength = this.length,
+                sourceLength = Length,
                 destinationLength = destination.Length;
 #endif
 
@@ -226,7 +296,7 @@ public void CopyTo(Span<T> destination)
             int length = this.span.Length;
 #else
             ref T sourceRef = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
-            int length = this.length;
+            int length = Length;
 #endif
             if ((uint)destination.Length < (uint)length)
             {
@@ -248,7 +318,7 @@ public bool TryCopyTo(Span<T> destination)
 #if SPAN_RUNTIME_SUPPORT
             int length = this.span.Length;
 #else
-            int length = this.length;
+            int length = Length;
 #endif
 
             if (destination.Length >= length)
@@ -268,7 +338,7 @@ public T[] ToArray()
 #if SPAN_RUNTIME_SUPPORT
             int length = this.span.Length;
 #else
-            int length = this.length;
+            int length = Length;
 #endif
 
             // Empty array if no data is mapped
@@ -303,22 +373,10 @@ public static implicit operator ReadOnlyRefEnumerable<T>(RefEnumerable<T> enumer
         /// </summary>
         public ref struct Enumerator
         {
-#if SPAN_RUNTIME_SUPPORT
-            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.span"/>
-            private readonly ReadOnlySpan<T> span;
-#else
-            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.instance"/>
-            private readonly object? instance;
-
-            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.offset"/>
-            private readonly IntPtr offset;
-
-            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.length"/>
-            private readonly int length;
-#endif
-
-            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.step"/>
-            private readonly int step;
+            /// <summary>
+            /// The <see cref="ReadOnlyRefEnumerable{T}"/> used by this enumerator.
+            /// </summary>
+            private readonly ReadOnlyRefEnumerable<T> enumerable;
 
             /// <summary>
             /// The current position in the sequence.
@@ -333,10 +391,8 @@ public ref struct Enumerator
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(ReadOnlySpan<T> span, int step)
+                : this(new ReadOnlyRefEnumerable<T>(span, step))
             {
-                this.span = span;
-                this.step = step;
-                this.position = -1;
             }
 #else
             /// <summary>
@@ -348,23 +404,25 @@ internal Enumerator(ReadOnlySpan<T> span, int step)
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(object? instance, IntPtr offset, int length, int step)
+                : this(new ReadOnlyRefEnumerable<T>(instance, offset, length, step))
             {
-                this.instance = instance;
-                this.offset = offset;
-                this.length = length;
-                this.step = step;
-                this.position = -1;
             }
 #endif
 
+            internal Enumerator(ReadOnlyRefEnumerable<T> enumerable)
+            {
+                this.enumerable = enumerable;
+                this.position = -1;
+            }
+
             /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool MoveNext()
             {
 #if SPAN_RUNTIME_SUPPORT
-                return ++this.position < this.span.Length;
+                return ++this.position < this.enumerable.span.Length;
 #else
-                return ++this.position < this.length;
+                return ++this.position < this.enumerable.Length;
 #endif
             }
 
@@ -372,18 +430,7 @@ public bool MoveNext()
             public readonly ref readonly T Current
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get
-                {
-#if SPAN_RUNTIME_SUPPORT
-                    ref T r0 = ref this.span.DangerousGetReference();
-#else
-                    ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
-#endif
-                    nint offset = (nint)(uint)this.position * (nint)(uint)this.step;
-                    ref T ri = ref Unsafe.Add(ref r0, offset);
-
-                    return ref ri;
-                }
+                get => ref this.enumerable.DangerousGetReferenceAt(this.position);
             }
         }
 
diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
index 3ceee9311a9..6ce3e679a3f 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
@@ -9,9 +9,9 @@
 using System.Runtime.InteropServices;
 #endif
 using Microsoft.Toolkit.HighPerformance.Helpers.Internals;
-#if SPAN_RUNTIME_SUPPORT
 using Microsoft.Toolkit.HighPerformance.Memory.Internals;
-#else
+
+#if !SPAN_RUNTIME_SUPPORT
 using RuntimeHelpers = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
 #endif
 
@@ -29,6 +29,11 @@ public readonly ref struct RefEnumerable<T>
         /// </summary>
         /// <remarks>The <see cref="Span{T}.Length"/> field maps to the total available length.</remarks>
         internal readonly Span<T> Span;
+
+        /// <summary>
+        /// Gets the total available length for the sequence.
+        /// </summary>
+        public int Length => Span.Length;
 #else
         /// <summary>
         /// The target <see cref="object"/> instance, if present.
@@ -41,9 +46,9 @@ public readonly ref struct RefEnumerable<T>
         internal readonly IntPtr Offset;
 
         /// <summary>
-        /// The total available length for the sequence.
+        /// Gets the total available length for the sequence.
         /// </summary>
-        internal readonly int Length;
+        public int Length { get; }
 #endif
 
         /// <summary>
@@ -52,6 +57,40 @@ public readonly ref struct RefEnumerable<T>
         /// <remarks>The distance refers to <typeparamref name="T"/> items, not byte offset.</remarks>
         internal readonly int Step;
 
+        /// <summary>
+        /// Gets the element at the specified zero-based index.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref T this[int index]
+        {
+            get
+            {
+                if ((uint)index >= (uint)Length)
+                {
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+                }
+
+                return ref DangerousGetReferenceAt(index);
+            }
+        }
+
+#if NETSTANDARD2_1_OR_GREATER
+        /// <summary>
+        /// Gets the element at the specified zero-based index.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref T this[Index index]
+        {
+            get => ref this[index.GetOffset(Length)];
+        }
+#endif
+
 #if SPAN_RUNTIME_SUPPORT
         /// <summary>
         /// Initializes a new instance of the <see cref="RefEnumerable{T}"/> struct.
@@ -66,6 +105,18 @@ internal RefEnumerable(ref T reference, int length, int step)
             Step = step;
         }
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RefEnumerable{T}"/> struct.
+        /// </summary>
+        /// <param name="span">The <see cref="Span{T}"/> instance pointing to the first item in the target memory area.</param>
+        /// <param name="step">The distance between items in the sequence to enumerate.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal RefEnumerable(Span<T> span, int step)
+        {
+            Span = span;
+            Step = step;
+        }
+
         /// <summary>
         /// Creates a new instance of the <see cref="RefEnumerable{T}"/> struct with the specified parameters.
         /// </summary>
@@ -109,16 +160,47 @@ internal RefEnumerable(object? instance, IntPtr offset, int length, int step)
         }
 #endif
 
+        /// <summary>
+        /// Returns a reference to the first element within the current instance, with no bounds check.
+        /// </summary>
+        /// <returns>A reference to the first element within the current instance.</returns>
+        internal ref T DangerousGetReference()
+        {
+#if SPAN_RUNTIME_SUPPORT
+            return ref MemoryMarshal.GetReference(this.Span);
+#else
+            return ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.Instance, this.Offset);
+#endif
+        }
+
+        /// <summary>
+        /// Returns a reference to a specified element within the current instance, with no bounds check.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        internal ref T DangerousGetReferenceAt(int index)
+        {
+#if SPAN_RUNTIME_SUPPORT
+            ref T r0 = ref MemoryMarshal.GetReference(this.Span);
+#else
+            ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.Instance, this.Offset);
+#endif
+            // Here we just offset by shifting down as if we were traversing a 2D array with a
+            // a single column, with the width of each row represented by the step, the height
+            // represented by the current position, and with only the first element of each row
+            // being inspected. We can perform all the indexing operations in this type as nint,
+            // as the maximum offset is guaranteed never to exceed the maximum value, since on
+            // 32 bit architectures it's not possible to allocate that much memory anyway.
+            nint offset = (nint)(uint)index * (nint)(uint)this.Step;
+            ref T ri = ref Unsafe.Add(ref r0, offset);
+            return ref ri;
+        }
+
         /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Enumerator GetEnumerator()
         {
-#if SPAN_RUNTIME_SUPPORT
-            return new Enumerator(this.Span, this.Step);
-#else
-            return new Enumerator(this.Instance, this.Offset, this.Length, this.Step);
-#endif
+            return new Enumerator(this);
         }
 
         /// <summary>
@@ -389,22 +471,10 @@ public T[] ToArray()
         /// </summary>
         public ref struct Enumerator
         {
-#if SPAN_RUNTIME_SUPPORT
-            /// <inheritdoc cref="RefEnumerable{T}.Span"/>
-            private readonly Span<T> span;
-#else
-            /// <inheritdoc cref="RefEnumerable{T}.Instance"/>
-            private readonly object? instance;
-
-            /// <inheritdoc cref="RefEnumerable{T}.Offset"/>
-            private readonly IntPtr offset;
-
-            /// <inheritdoc cref="RefEnumerable{T}.Length"/>
-            private readonly int length;
-#endif
-
-            /// <inheritdoc cref="RefEnumerable{T}.Step"/>
-            private readonly int step;
+            /// <summary>
+            /// The <see cref="RefEnumerable{T}"/> used by this enumerator.
+            /// </summary>
+            private readonly RefEnumerable<T> enumerable;
 
             /// <summary>
             /// The current position in the sequence.
@@ -419,10 +489,8 @@ public ref struct Enumerator
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(Span<T> span, int step)
+                : this(new RefEnumerable<T>(span, step))
             {
-                this.span = span;
-                this.step = step;
-                this.position = -1;
             }
 #else
             /// <summary>
@@ -434,23 +502,28 @@ internal Enumerator(Span<T> span, int step)
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(object? instance, IntPtr offset, int length, int step)
+                : this(new RefEnumerable<T>(instance, offset, length, step))
             {
-                this.instance = instance;
-                this.offset = offset;
-                this.length = length;
-                this.step = step;
-                this.position = -1;
             }
 #endif
 
+            /// <summary>
+            /// Initializes a new instance of the <see cref="Enumerator"/> struct.
+            /// </summary>
+            internal Enumerator(RefEnumerable<T> enumerable)
+            {
+                this.enumerable = enumerable;
+                this.position = -1;
+            }
+
             /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool MoveNext()
             {
 #if SPAN_RUNTIME_SUPPORT
-                return ++this.position < this.span.Length;
+                return ++this.position < this.enumerable.Span.Length;
 #else
-                return ++this.position < this.length;
+                return ++this.position < this.enumerable.Length;
 #endif
             }
 
@@ -458,25 +531,7 @@ public bool MoveNext()
             public readonly ref T Current
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get
-                {
-#if SPAN_RUNTIME_SUPPORT
-                    ref T r0 = ref this.span.DangerousGetReference();
-#else
-                    ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
-#endif
-
-                    // Here we just offset by shifting down as if we were traversing a 2D array with a
-                    // a single column, with the width of each row represented by the step, the height
-                    // represented by the current position, and with only the first element of each row
-                    // being inspected. We can perform all the indexing operations in this type as nint,
-                    // as the maximum offset is guaranteed never to exceed the maximum value, since on
-                    // 32 bit architectures it's not possible to allocate that much memory anyway.
-                    nint offset = (nint)(uint)this.position * (nint)(uint)this.step;
-                    ref T ri = ref Unsafe.Add(ref r0, offset);
-
-                    return ref ri;
-                }
+                get => ref this.enumerable.DangerousGetReferenceAt(this.position);
             }
         }
 

From 0152072564f88b1bdc96c127f8b88ce6a695a2b8 Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Thu, 27 May 2021 20:38:13 +1000
Subject: [PATCH 2/8] Add newline before comments in DangerousGetReferenceAt

---
 .../Enumerables/ReadOnlyRefEnumerable{T}.cs                      | 1 +
 .../Enumerables/RefEnumerable{T}.cs                              | 1 +
 2 files changed, 2 insertions(+)

diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
index 65be73fe452..831f95f7f1f 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
@@ -184,6 +184,7 @@ internal ref readonly T DangerousGetReferenceAt(int index)
 #else
             ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
 #endif
+
             // Here we just offset by shifting down as if we were traversing a 2D array with a
             // a single column, with the width of each row represented by the step, the height
             // represented by the current position, and with only the first element of each row
diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
index 6ce3e679a3f..70fe1521239 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
@@ -184,6 +184,7 @@ internal ref T DangerousGetReferenceAt(int index)
 #else
             ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.Instance, this.Offset);
 #endif
+
             // Here we just offset by shifting down as if we were traversing a 2D array with a
             // a single column, with the width of each row represented by the step, the height
             // represented by the current position, and with only the first element of each row

From 86625a097f6b9014225a3d681a4c1b219024c422 Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Fri, 28 May 2021 03:31:18 +1000
Subject: [PATCH 3/8] Rework public length and indexer properties for
 RefEnumerable<T>

---
 .../Enumerables/ReadOnlyRefEnumerable{T}.cs   | 169 ++++++++--------
 .../Enumerables/RefEnumerable{T}.cs           | 180 +++++++++---------
 2 files changed, 175 insertions(+), 174 deletions(-)

diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
index 831f95f7f1f..c251b0c1d57 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
@@ -29,11 +29,6 @@ public readonly ref struct ReadOnlyRefEnumerable<T>
         /// </summary>
         /// <remarks>The <see cref="ReadOnlySpan{T}.Length"/> field maps to the total available length.</remarks>
         private readonly ReadOnlySpan<T> span;
-
-        /// <summary>
-        /// Gets the total available length for the sequence.
-        /// </summary>
-        public int Length => span.Length;
 #else
         /// <summary>
         /// The target <see cref="object"/> instance, if present.
@@ -46,9 +41,9 @@ public readonly ref struct ReadOnlyRefEnumerable<T>
         private readonly IntPtr offset;
 
         /// <summary>
-        /// Gets the total available length for the sequence.
+        /// The total available length for the sequence.
         /// </summary>
-        public int Length { get; }
+        private readonly int length;
 #endif
 
         /// <summary>
@@ -57,40 +52,6 @@ public readonly ref struct ReadOnlyRefEnumerable<T>
         /// <remarks>The distance refers to <typeparamref name="T"/> items, not byte offset.</remarks>
         private readonly int step;
 
-        /// <summary>
-        /// Gets the element at the specified zero-based index.
-        /// </summary>
-        /// <returns>A reference to the element at the specified index.</returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when <paramref name="index"/> is invalid.
-        /// </exception>
-        public ref readonly T this[int index]
-        {
-            get
-            {
-                if ((uint)index >= (uint)Length)
-                {
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-                }
-
-                return ref DangerousGetReferenceAt(index);
-            }
-        }
-
-#if NETSTANDARD2_1_OR_GREATER
-        /// <summary>
-        /// Gets the element at the specified zero-based index.
-        /// </summary>
-        /// <returns>A reference to the element at the specified index.</returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when <paramref name="index"/> is invalid.
-        /// </exception>
-        public ref readonly T this[Index index]
-        {
-            get => ref this[index.GetOffset(Length)];
-        }
-#endif
-
 #if SPAN_RUNTIME_SUPPORT
         /// <summary>
         /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
@@ -155,53 +116,76 @@ internal ReadOnlyRefEnumerable(object? instance, IntPtr offset, int length, int
         {
             this.instance = instance;
             this.offset = offset;
-            Length = length;
+            this.length = length;
             this.step = step;
         }
 #endif
 
         /// <summary>
-        /// Returns a reference to the first element within the current instance, with no bounds check.
+        /// Gets the total available length for the sequence.
         /// </summary>
-        /// <returns>A reference to the first element within the current instance.</returns>
-        internal ref readonly T DangerousGetReference()
+        public int Length
         {
 #if SPAN_RUNTIME_SUPPORT
-            return ref MemoryMarshal.GetReference(this.span);
+            get => this.span.Length;
 #else
-            return ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
+            get => this.length;
 #endif
         }
 
         /// <summary>
-        /// Returns a reference to a specified element within the current instance, with no bounds check.
+        /// Gets the element at the specified zero-based index.
         /// </summary>
         /// <returns>A reference to the element at the specified index.</returns>
-        internal ref readonly T DangerousGetReferenceAt(int index)
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref readonly T this[int index]
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                if ((uint)index >= (uint)Length)
+                {
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+                }
+
 #if SPAN_RUNTIME_SUPPORT
-            ref T r0 = ref MemoryMarshal.GetReference(this.span);
+                ref T r0 = ref MemoryMarshal.GetReference(this.span);
 #else
-            ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
+                ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
 #endif
+                nint offset = (nint)(uint)index * (nint)(uint)this.step;
+                ref T ri = ref Unsafe.Add(ref r0, offset);
+                return ref ri;
+            }
+        }
 
-            // Here we just offset by shifting down as if we were traversing a 2D array with a
-            // a single column, with the width of each row represented by the step, the height
-            // represented by the current position, and with only the first element of each row
-            // being inspected. We can perform all the indexing operations in this type as nint,
-            // as the maximum offset is guaranteed never to exceed the maximum value, since on
-            // 32 bit architectures it's not possible to allocate that much memory anyway.
-            nint offset = (nint)(uint)index * (nint)(uint)this.step;
-            ref T ri = ref Unsafe.Add(ref r0, offset);
-            return ref ri;
+#if NETSTANDARD2_1_OR_GREATER
+        /// <summary>
+        /// Gets the element at the specified zero-based index.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref readonly T this[Index index]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => ref this[index.GetOffset(Length)];
         }
+#endif
 
         /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Enumerator GetEnumerator()
         {
-            return new Enumerator(this);
+#if SPAN_RUNTIME_SUPPORT
+            return new Enumerator(this.span, this.step);
+#else
+            return new Enumerator(this.instance, this.offset, this.length, this.step);
+#endif
         }
 
         /// <summary>
@@ -237,7 +221,7 @@ public void CopyTo(RefEnumerable<T> destination)
             ref T sourceRef = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
             ref T destinationRef = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(destination.Instance, destination.Offset);
             int
-                sourceLength = Length,
+                sourceLength = this.length,
                 destinationLength = destination.Length;
 #endif
 
@@ -262,7 +246,7 @@ public bool TryCopyTo(RefEnumerable<T> destination)
                 destinationLength = destination.Span.Length;
 #else
             int
-                sourceLength = Length,
+                sourceLength = this.length,
                 destinationLength = destination.Length;
 #endif
 
@@ -297,7 +281,7 @@ public void CopyTo(Span<T> destination)
             int length = this.span.Length;
 #else
             ref T sourceRef = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
-            int length = Length;
+            int length = this.length;
 #endif
             if ((uint)destination.Length < (uint)length)
             {
@@ -319,7 +303,7 @@ public bool TryCopyTo(Span<T> destination)
 #if SPAN_RUNTIME_SUPPORT
             int length = this.span.Length;
 #else
-            int length = Length;
+            int length = this.length;
 #endif
 
             if (destination.Length >= length)
@@ -339,7 +323,7 @@ public T[] ToArray()
 #if SPAN_RUNTIME_SUPPORT
             int length = this.span.Length;
 #else
-            int length = Length;
+            int length = this.length;
 #endif
 
             // Empty array if no data is mapped
@@ -374,10 +358,22 @@ public static implicit operator ReadOnlyRefEnumerable<T>(RefEnumerable<T> enumer
         /// </summary>
         public ref struct Enumerator
         {
-            /// <summary>
-            /// The <see cref="ReadOnlyRefEnumerable{T}"/> used by this enumerator.
-            /// </summary>
-            private readonly ReadOnlyRefEnumerable<T> enumerable;
+#if SPAN_RUNTIME_SUPPORT
+            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.span"/>
+            private readonly ReadOnlySpan<T> span;
+#else
+            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.instance"/>
+            private readonly object? instance;
+
+            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.offset"/>
+            private readonly IntPtr offset;
+
+            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.length"/>
+            private readonly int length;
+#endif
+
+            /// <inheritdoc cref="ReadOnlyRefEnumerable{T}.step"/>
+            private readonly int step;
 
             /// <summary>
             /// The current position in the sequence.
@@ -392,8 +388,10 @@ public ref struct Enumerator
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(ReadOnlySpan<T> span, int step)
-                : this(new ReadOnlyRefEnumerable<T>(span, step))
             {
+                this.span = span;
+                this.step = step;
+                this.position = -1;
             }
 #else
             /// <summary>
@@ -405,25 +403,23 @@ internal Enumerator(ReadOnlySpan<T> span, int step)
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(object? instance, IntPtr offset, int length, int step)
-                : this(new ReadOnlyRefEnumerable<T>(instance, offset, length, step))
             {
-            }
-#endif
-
-            internal Enumerator(ReadOnlyRefEnumerable<T> enumerable)
-            {
-                this.enumerable = enumerable;
+                this.instance = instance;
+                this.offset = offset;
+                this.length = length;
+                this.step = step;
                 this.position = -1;
             }
+#endif
 
             /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool MoveNext()
             {
 #if SPAN_RUNTIME_SUPPORT
-                return ++this.position < this.enumerable.span.Length;
+                return ++this.position < this.span.Length;
 #else
-                return ++this.position < this.enumerable.Length;
+                return ++this.position < this.length;
 #endif
             }
 
@@ -431,7 +427,18 @@ public bool MoveNext()
             public readonly ref readonly T Current
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => ref this.enumerable.DangerousGetReferenceAt(this.position);
+                get
+                {
+#if SPAN_RUNTIME_SUPPORT
+                    ref T r0 = ref this.span.DangerousGetReference();
+#else
+                    ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
+#endif
+                    nint offset = (nint)(uint)this.position * (nint)(uint)this.step;
+                    ref T ri = ref Unsafe.Add(ref r0, offset);
+
+                    return ref ri;
+                }
             }
         }
 
diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
index 70fe1521239..a65454938c9 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
@@ -29,11 +29,6 @@ public readonly ref struct RefEnumerable<T>
         /// </summary>
         /// <remarks>The <see cref="Span{T}.Length"/> field maps to the total available length.</remarks>
         internal readonly Span<T> Span;
-
-        /// <summary>
-        /// Gets the total available length for the sequence.
-        /// </summary>
-        public int Length => Span.Length;
 #else
         /// <summary>
         /// The target <see cref="object"/> instance, if present.
@@ -44,11 +39,6 @@ public readonly ref struct RefEnumerable<T>
         /// The initial offset within <see cref="Instance"/>.
         /// </summary>
         internal readonly IntPtr Offset;
-
-        /// <summary>
-        /// Gets the total available length for the sequence.
-        /// </summary>
-        public int Length { get; }
 #endif
 
         /// <summary>
@@ -57,40 +47,6 @@ public readonly ref struct RefEnumerable<T>
         /// <remarks>The distance refers to <typeparamref name="T"/> items, not byte offset.</remarks>
         internal readonly int Step;
 
-        /// <summary>
-        /// Gets the element at the specified zero-based index.
-        /// </summary>
-        /// <returns>A reference to the element at the specified index.</returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when <paramref name="index"/> is invalid.
-        /// </exception>
-        public ref T this[int index]
-        {
-            get
-            {
-                if ((uint)index >= (uint)Length)
-                {
-                    ThrowHelper.ThrowIndexOutOfRangeException();
-                }
-
-                return ref DangerousGetReferenceAt(index);
-            }
-        }
-
-#if NETSTANDARD2_1_OR_GREATER
-        /// <summary>
-        /// Gets the element at the specified zero-based index.
-        /// </summary>
-        /// <returns>A reference to the element at the specified index.</returns>
-        /// <exception cref="IndexOutOfRangeException">
-        /// Thrown when <paramref name="index"/> is invalid.
-        /// </exception>
-        public ref T this[Index index]
-        {
-            get => ref this[index.GetOffset(Length)];
-        }
-#endif
-
 #if SPAN_RUNTIME_SUPPORT
         /// <summary>
         /// Initializes a new instance of the <see cref="RefEnumerable{T}"/> struct.
@@ -105,18 +61,6 @@ internal RefEnumerable(ref T reference, int length, int step)
             Step = step;
         }
 
-        /// <summary>
-        /// Initializes a new instance of the <see cref="RefEnumerable{T}"/> struct.
-        /// </summary>
-        /// <param name="span">The <see cref="Span{T}"/> instance pointing to the first item in the target memory area.</param>
-        /// <param name="step">The distance between items in the sequence to enumerate.</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        internal RefEnumerable(Span<T> span, int step)
-        {
-            Span = span;
-            Step = step;
-        }
-
         /// <summary>
         /// Creates a new instance of the <see cref="RefEnumerable{T}"/> struct with the specified parameters.
         /// </summary>
@@ -161,47 +105,70 @@ internal RefEnumerable(object? instance, IntPtr offset, int length, int step)
 #endif
 
         /// <summary>
-        /// Returns a reference to the first element within the current instance, with no bounds check.
+        /// Gets the total available length for the sequence.
         /// </summary>
-        /// <returns>A reference to the first element within the current instance.</returns>
-        internal ref T DangerousGetReference()
+        public int Length
         {
 #if SPAN_RUNTIME_SUPPORT
-            return ref MemoryMarshal.GetReference(this.Span);
+            get => this.Span.Length;
 #else
-            return ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.Instance, this.Offset);
+            get;
 #endif
         }
 
         /// <summary>
-        /// Returns a reference to a specified element within the current instance, with no bounds check.
+        /// Gets the element at the specified zero-based index.
         /// </summary>
         /// <returns>A reference to the element at the specified index.</returns>
-        internal ref T DangerousGetReferenceAt(int index)
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref T this[int index]
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get
+            {
+                if ((uint)index >= (uint)Length)
+                {
+                    ThrowHelper.ThrowIndexOutOfRangeException();
+                }
+
 #if SPAN_RUNTIME_SUPPORT
-            ref T r0 = ref MemoryMarshal.GetReference(this.Span);
+                ref T r0 = ref MemoryMarshal.GetReference(this.Span);
 #else
-            ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.Instance, this.Offset);
+                ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.Instance, this.Offset);
 #endif
+                nint offset = (nint)(uint)index * (nint)(uint)this.Step;
+                ref T ri = ref Unsafe.Add(ref r0, offset);
+                return ref ri;
+            }
+        }
 
-            // Here we just offset by shifting down as if we were traversing a 2D array with a
-            // a single column, with the width of each row represented by the step, the height
-            // represented by the current position, and with only the first element of each row
-            // being inspected. We can perform all the indexing operations in this type as nint,
-            // as the maximum offset is guaranteed never to exceed the maximum value, since on
-            // 32 bit architectures it's not possible to allocate that much memory anyway.
-            nint offset = (nint)(uint)index * (nint)(uint)this.Step;
-            ref T ri = ref Unsafe.Add(ref r0, offset);
-            return ref ri;
+#if NETSTANDARD2_1_OR_GREATER
+        /// <summary>
+        /// Gets the element at the specified zero-based index.
+        /// </summary>
+        /// <returns>A reference to the element at the specified index.</returns>
+        /// <exception cref="IndexOutOfRangeException">
+        /// Thrown when <paramref name="index"/> is invalid.
+        /// </exception>
+        public ref T this[Index index]
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => ref this[index.GetOffset(Length)];
         }
+#endif
 
         /// <inheritdoc cref="System.Collections.IEnumerable.GetEnumerator"/>
         [Pure]
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Enumerator GetEnumerator()
         {
-            return new Enumerator(this);
+#if SPAN_RUNTIME_SUPPORT
+            return new Enumerator(this.Span, this.Step);
+#else
+            return new Enumerator(this.Instance, this.Offset, this.Length, this.Step);
+#endif
         }
 
         /// <summary>
@@ -472,10 +439,22 @@ public T[] ToArray()
         /// </summary>
         public ref struct Enumerator
         {
-            /// <summary>
-            /// The <see cref="RefEnumerable{T}"/> used by this enumerator.
-            /// </summary>
-            private readonly RefEnumerable<T> enumerable;
+#if SPAN_RUNTIME_SUPPORT
+            /// <inheritdoc cref="RefEnumerable{T}.Span"/>
+            private readonly Span<T> span;
+#else
+            /// <inheritdoc cref="RefEnumerable{T}.Instance"/>
+            private readonly object? instance;
+
+            /// <inheritdoc cref="RefEnumerable{T}.Offset"/>
+            private readonly IntPtr offset;
+
+            /// <inheritdoc cref="RefEnumerable{T}.Length"/>
+            private readonly int length;
+#endif
+
+            /// <inheritdoc cref="RefEnumerable{T}.Step"/>
+            private readonly int step;
 
             /// <summary>
             /// The current position in the sequence.
@@ -490,8 +469,10 @@ public ref struct Enumerator
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(Span<T> span, int step)
-                : this(new RefEnumerable<T>(span, step))
             {
+                this.span = span;
+                this.step = step;
+                this.position = -1;
             }
 #else
             /// <summary>
@@ -503,28 +484,23 @@ internal Enumerator(Span<T> span, int step)
             /// <param name="step">The distance between items in the sequence to enumerate.</param>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             internal Enumerator(object? instance, IntPtr offset, int length, int step)
-                : this(new RefEnumerable<T>(instance, offset, length, step))
-            {
-            }
-#endif
-
-            /// <summary>
-            /// Initializes a new instance of the <see cref="Enumerator"/> struct.
-            /// </summary>
-            internal Enumerator(RefEnumerable<T> enumerable)
             {
-                this.enumerable = enumerable;
+                this.instance = instance;
+                this.offset = offset;
+                this.length = length;
+                this.step = step;
                 this.position = -1;
             }
+#endif
 
             /// <inheritdoc cref="System.Collections.IEnumerator.MoveNext"/>
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
             public bool MoveNext()
             {
 #if SPAN_RUNTIME_SUPPORT
-                return ++this.position < this.enumerable.Span.Length;
+                return ++this.position < this.span.Length;
 #else
-                return ++this.position < this.enumerable.Length;
+                return ++this.position < this.length;
 #endif
             }
 
@@ -532,7 +508,25 @@ public bool MoveNext()
             public readonly ref T Current
             {
                 [MethodImpl(MethodImplOptions.AggressiveInlining)]
-                get => ref this.enumerable.DangerousGetReferenceAt(this.position);
+                get
+                {
+#if SPAN_RUNTIME_SUPPORT
+                    ref T r0 = ref this.span.DangerousGetReference();
+#else
+                    ref T r0 = ref RuntimeHelpers.GetObjectDataAtOffsetOrPointerReference<T>(this.instance, this.offset);
+#endif
+
+                    // Here we just offset by shifting down as if we were traversing a 2D array with a
+                    // a single column, with the width of each row represented by the step, the height
+                    // represented by the current position, and with only the first element of each row
+                    // being inspected. We can perform all the indexing operations in this type as nint,
+                    // as the maximum offset is guaranteed never to exceed the maximum value, since on
+                    // 32 bit architectures it's not possible to allocate that much memory anyway.
+                    nint offset = (nint)(uint)this.position * (nint)(uint)this.step;
+                    ref T ri = ref Unsafe.Add(ref r0, offset);
+
+                    return ref ri;
+                }
             }
         }
 

From dae4f84cd235910d0bd5211cacdbd9b49b8b1177 Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Fri, 28 May 2021 21:55:06 +1000
Subject: [PATCH 4/8] Add AggressiveInlining to Length property on
 RefEnumerable

---
 .../Enumerables/ReadOnlyRefEnumerable{T}.cs                    | 3 ++-
 .../Enumerables/RefEnumerable{T}.cs                            | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
index c251b0c1d57..ca82150a02f 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
@@ -10,7 +10,6 @@
 #endif
 using Microsoft.Toolkit.HighPerformance.Helpers.Internals;
 using Microsoft.Toolkit.HighPerformance.Memory.Internals;
-
 #if !SPAN_RUNTIME_SUPPORT
 using RuntimeHelpers = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
 #endif
@@ -126,6 +125,7 @@ internal ReadOnlyRefEnumerable(object? instance, IntPtr offset, int length, int
         /// </summary>
         public int Length
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #if SPAN_RUNTIME_SUPPORT
             get => this.span.Length;
 #else
@@ -157,6 +157,7 @@ public ref readonly T this[int index]
 #endif
                 nint offset = (nint)(uint)index * (nint)(uint)this.step;
                 ref T ri = ref Unsafe.Add(ref r0, offset);
+
                 return ref ri;
             }
         }
diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
index a65454938c9..7407781e2e5 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
@@ -10,7 +10,6 @@
 #endif
 using Microsoft.Toolkit.HighPerformance.Helpers.Internals;
 using Microsoft.Toolkit.HighPerformance.Memory.Internals;
-
 #if !SPAN_RUNTIME_SUPPORT
 using RuntimeHelpers = Microsoft.Toolkit.HighPerformance.Helpers.Internals.RuntimeHelpers;
 #endif
@@ -109,6 +108,7 @@ internal RefEnumerable(object? instance, IntPtr offset, int length, int step)
         /// </summary>
         public int Length
         {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
 #if SPAN_RUNTIME_SUPPORT
             get => this.Span.Length;
 #else
@@ -140,6 +140,7 @@ public ref T this[int index]
 #endif
                 nint offset = (nint)(uint)index * (nint)(uint)this.Step;
                 ref T ri = ref Unsafe.Add(ref r0, offset);
+
                 return ref ri;
             }
         }

From efd12430bf43436052bdbc11e5e34fe6a65e5499 Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Fri, 28 May 2021 21:55:39 +1000
Subject: [PATCH 5/8] Add tests for RefEnumerable indexers

---
 .../Test_ReadOnlyRefEnumerable{T}.cs          | 47 +++++++++++++++++++
 .../Enumerables/Test_RefEnumerable{T}.cs      | 47 +++++++++++++++++++
 2 files changed, 94 insertions(+)

diff --git a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
index d01dfb12239..bc8d50f57a8 100644
--- a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
+++ b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
@@ -47,6 +47,53 @@ public void Test_ReadOnlyRefEnumerable_DangerousCreate_BelowZero(int length, int
         {
             _ = ReadOnlyRefEnumerable<int>.DangerousCreate(in Unsafe.NullRef<int>(), length, step);
         }
+
+        [TestCategory("ReadOnlyRefEnumerable")]
+        [TestMethod]
+        [DataRow(1, 1, new[] { 1 })]
+        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
+        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
+        public void Test_ReadOnlyRefEnumerable_Indexer(int length, int step, int[] values)
+        {
+            Span<int> data = new[]
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16
+            };
+
+            ReadOnlyRefEnumerable<int> enumerable = ReadOnlyRefEnumerable<int>.DangerousCreate(in data[0], length, step);
+
+            for (int i = 0; i < enumerable.Length; i++)
+            {
+                Assert.AreEqual(enumerable[i], values[i]);
+            }
+        }
+
+#if NETCOREAPP3_1_OR_GREATER
+        [TestCategory("ReadOnlyRefEnumerable")]
+        [TestMethod]
+        [DataRow(1, 1, new[] { 1 })]
+        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
+        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
+        public void Test_ReadOnlyRefEnumerable_Index_Indexer(int length, int step, int[] values)
+        {
+            Span<int> data = new[]
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16
+            };
+
+            ReadOnlyRefEnumerable<int> enumerable = ReadOnlyRefEnumerable<int>.DangerousCreate(in data[0], length, step);
+
+            Assert.AreEqual(values[^1], enumerable[^1]);
+        }
+#endif
     }
 }
 
diff --git a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
index 0442be83ab3..8d46d7598f3 100644
--- a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
+++ b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
@@ -47,6 +47,53 @@ public void Test_RefEnumerable_DangerousCreate_BelowZero(int length, int step)
         {
             _ = RefEnumerable<int>.DangerousCreate(ref Unsafe.NullRef<int>(), length, step);
         }
+
+        [TestCategory("RefEnumerable")]
+        [TestMethod]
+        [DataRow(1, 1, new[] { 1 })]
+        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
+        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
+        public void Test_RefEnumerable_Indexer(int length, int step, int[] values)
+        {
+            Span<int> data = new[]
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16
+            };
+
+            RefEnumerable<int> enumerable = RefEnumerable<int>.DangerousCreate(ref data[0], length, step);
+
+            for (int i = 0; i < enumerable.Length; i++)
+            {
+                Assert.AreEqual(enumerable[i], values[i]);
+            }
+        }
+
+#if NETCOREAPP3_1_OR_GREATER
+        [TestCategory("RefEnumerable")]
+        [TestMethod]
+        [DataRow(1, 1, new[] { 1 })]
+        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
+        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
+        public void Test_RefEnumerable_Index_Indexer(int length, int step, int[] values)
+        {
+            Span<int> data = new[]
+            {
+                1, 2, 3, 4,
+                5, 6, 7, 8,
+                9, 10, 11, 12,
+                13, 14, 15, 16
+            };
+
+            RefEnumerable<int> enumerable = RefEnumerable<int>.DangerousCreate(ref data[0], length, step);
+
+            Assert.AreEqual(values[^1], enumerable[^1]);
+        }
+#endif
     }
 }
 

From e4810fb012a468269d862359fde7eea55025ea6c Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Sat, 29 May 2021 01:28:49 +1000
Subject: [PATCH 6/8] Add XML documentation for index parameter on
 RefEnumerable indexers

---
 .../Enumerables/ReadOnlyRefEnumerable{T}.cs                     | 2 ++
 .../Enumerables/RefEnumerable{T}.cs                             | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
index ca82150a02f..aa4507fafe8 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs
@@ -136,6 +136,7 @@ public int Length
         /// <summary>
         /// Gets the element at the specified zero-based index.
         /// </summary>
+        /// <param name="index">The zero-based index of the element.</param>
         /// <returns>A reference to the element at the specified index.</returns>
         /// <exception cref="IndexOutOfRangeException">
         /// Thrown when <paramref name="index"/> is invalid.
@@ -166,6 +167,7 @@ public ref readonly T this[int index]
         /// <summary>
         /// Gets the element at the specified zero-based index.
         /// </summary>
+        /// <param name="index">The zero-based index of the element.</param>
         /// <returns>A reference to the element at the specified index.</returns>
         /// <exception cref="IndexOutOfRangeException">
         /// Thrown when <paramref name="index"/> is invalid.
diff --git a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
index 7407781e2e5..535b742befa 100644
--- a/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
+++ b/Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs
@@ -119,6 +119,7 @@ public int Length
         /// <summary>
         /// Gets the element at the specified zero-based index.
         /// </summary>
+        /// <param name="index">The zero-based index of the element.</param>
         /// <returns>A reference to the element at the specified index.</returns>
         /// <exception cref="IndexOutOfRangeException">
         /// Thrown when <paramref name="index"/> is invalid.
@@ -149,6 +150,7 @@ public ref T this[int index]
         /// <summary>
         /// Gets the element at the specified zero-based index.
         /// </summary>
+        /// <param name="index">The zero-based index of the element.</param>
         /// <returns>A reference to the element at the specified index.</returns>
         /// <exception cref="IndexOutOfRangeException">
         /// Thrown when <paramref name="index"/> is invalid.

From 5a6bf626c093c52b23f90980f801eb610e9b545c Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Fri, 11 Jun 2021 20:20:16 +1000
Subject: [PATCH 7/8] Add RefEnumerable indexer exception tests

---
 .../Test_ReadOnlyRefEnumerable{T}.cs          | 55 ++++++++++++++-----
 .../Enumerables/Test_RefEnumerable{T}.cs      | 53 ++++++++++++++----
 2 files changed, 83 insertions(+), 25 deletions(-)

diff --git a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
index bc8d50f57a8..f5631f8e3d4 100644
--- a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
+++ b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_ReadOnlyRefEnumerable{T}.cs
@@ -50,11 +50,11 @@ public void Test_ReadOnlyRefEnumerable_DangerousCreate_BelowZero(int length, int
 
         [TestCategory("ReadOnlyRefEnumerable")]
         [TestMethod]
-        [DataRow(1, 1, new[] { 1 })]
-        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
-        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
-        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
-        public void Test_ReadOnlyRefEnumerable_Indexer(int length, int step, int[] values)
+        [DataRow(1, new[] { 1 })]
+        [DataRow(1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, new[] { 1, 5, 9, 13 })]
+        [DataRow(5, new[] { 1, 6, 11, 16 })]
+        public void Test_ReadOnlyRefEnumerable_Indexer(int step, int[] values)
         {
             Span<int> data = new[]
             {
@@ -64,7 +64,7 @@ public void Test_ReadOnlyRefEnumerable_Indexer(int length, int step, int[] value
                 13, 14, 15, 16
             };
 
-            ReadOnlyRefEnumerable<int> enumerable = ReadOnlyRefEnumerable<int>.DangerousCreate(in data[0], length, step);
+            ReadOnlyRefEnumerable<int> enumerable = ReadOnlyRefEnumerable<int>.DangerousCreate(in data[0], values.Length, step);
 
             for (int i = 0; i < enumerable.Length; i++)
             {
@@ -72,14 +72,27 @@ public void Test_ReadOnlyRefEnumerable_Indexer(int length, int step, int[] value
             }
         }
 
+        [TestCategory("ReadOnlyRefEnumerable")]
+        [TestMethod]
+        public void Test_ReadOnlyRefEnumerable_Indexer_ThrowsIndexOutOfRange()
+        {
+            int[] array = new[]
+            {
+                0, 0, 0, 0
+            };
+
+            Assert.ThrowsException<IndexOutOfRangeException>(() => ReadOnlyRefEnumerable<int>.DangerousCreate(in array[0], array.Length, 1)[-1]);
+            Assert.ThrowsException<IndexOutOfRangeException>(() => ReadOnlyRefEnumerable<int>.DangerousCreate(in array[0], array.Length, 1)[array.Length]);
+        }
+
 #if NETCOREAPP3_1_OR_GREATER
         [TestCategory("ReadOnlyRefEnumerable")]
         [TestMethod]
-        [DataRow(1, 1, new[] { 1 })]
-        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
-        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
-        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
-        public void Test_ReadOnlyRefEnumerable_Index_Indexer(int length, int step, int[] values)
+        [DataRow(1, new[] { 1 })]
+        [DataRow(1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, new[] { 1, 5, 9, 13 })]
+        [DataRow(5, new[] { 1, 6, 11, 16 })]
+        public void Test_ReadOnlyRefEnumerable_Index_Indexer(int step, int[] values)
         {
             Span<int> data = new[]
             {
@@ -89,9 +102,25 @@ public void Test_ReadOnlyRefEnumerable_Index_Indexer(int length, int step, int[]
                 13, 14, 15, 16
             };
 
-            ReadOnlyRefEnumerable<int> enumerable = ReadOnlyRefEnumerable<int>.DangerousCreate(in data[0], length, step);
+            ReadOnlyRefEnumerable<int> enumerable = ReadOnlyRefEnumerable<int>.DangerousCreate(in data[0], values.Length, step);
+
+            for (int i = 1; i <= enumerable.Length; i++)
+            {
+                Assert.AreEqual(values[^i], enumerable[^i]);
+            }
+        }
+
+        [TestCategory("ReadOnlyRefEnumerable")]
+        [TestMethod]
+        public void Test_ReadOnlyRefEnumerable_Index_Indexer_ThrowsIndexOutOfRange()
+        {
+            int[] array = new[]
+            {
+                0, 0, 0, 0
+            };
 
-            Assert.AreEqual(values[^1], enumerable[^1]);
+            Assert.ThrowsException<IndexOutOfRangeException>(() => ReadOnlyRefEnumerable<int>.DangerousCreate(in array[0], array.Length, 1)[new Index(array.Length)]);
+            Assert.ThrowsException<IndexOutOfRangeException>(() => ReadOnlyRefEnumerable<int>.DangerousCreate(in array[0], array.Length, 1)[^0]);
         }
 #endif
     }
diff --git a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
index 8d46d7598f3..a0c9a152c43 100644
--- a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
+++ b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
@@ -50,11 +50,11 @@ public void Test_RefEnumerable_DangerousCreate_BelowZero(int length, int step)
 
         [TestCategory("RefEnumerable")]
         [TestMethod]
-        [DataRow(1, 1, new[] { 1 })]
-        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
-        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
-        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
-        public void Test_RefEnumerable_Indexer(int length, int step, int[] values)
+        [DataRow(1, new[] { 1 })]
+        [DataRow(1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, new[] { 1, 5, 9, 13 })]
+        [DataRow(5, new[] { 1, 6, 11, 16 })]
+        public void Test_RefEnumerable_Indexer(int step, int[] values)
         {
             Span<int> data = new[]
             {
@@ -64,7 +64,7 @@ public void Test_RefEnumerable_Indexer(int length, int step, int[] values)
                 13, 14, 15, 16
             };
 
-            RefEnumerable<int> enumerable = RefEnumerable<int>.DangerousCreate(ref data[0], length, step);
+            RefEnumerable<int> enumerable = RefEnumerable<int>.DangerousCreate(ref data[0], values.Length, step);
 
             for (int i = 0; i < enumerable.Length; i++)
             {
@@ -72,13 +72,26 @@ public void Test_RefEnumerable_Indexer(int length, int step, int[] values)
             }
         }
 
+        [TestCategory("RefEnumerable")]
+        [TestMethod]
+        public void Test_RefEnumerable_Indexer_ThrowsIndexOutOfRange()
+        {
+            int[] array = new[]
+            {
+                0, 0, 0, 0
+            };
+
+            Assert.ThrowsException<IndexOutOfRangeException>(() => RefEnumerable<int>.DangerousCreate(ref array[0], array.Length, 1)[-1]);
+            Assert.ThrowsException<IndexOutOfRangeException>(() => RefEnumerable<int>.DangerousCreate(ref array[0], array.Length, 1)[array.Length]);
+        }
+
 #if NETCOREAPP3_1_OR_GREATER
         [TestCategory("RefEnumerable")]
         [TestMethod]
-        [DataRow(1, 1, new[] { 1 })]
-        [DataRow(4, 1, new[] { 1, 2, 3, 4 })]
-        [DataRow(4, 4, new[] { 1, 5, 9, 13 })]
-        [DataRow(4, 5, new[] { 1, 6, 11, 16 })]
+        [DataRow(1, new[] { 1 })]
+        [DataRow(1, new[] { 1, 2, 3, 4 })]
+        [DataRow(4, new[] { 1, 5, 9, 13 })]
+        [DataRow(5, new[] { 1, 6, 11, 16 })]
         public void Test_RefEnumerable_Index_Indexer(int length, int step, int[] values)
         {
             Span<int> data = new[]
@@ -89,9 +102,25 @@ public void Test_RefEnumerable_Index_Indexer(int length, int step, int[] values)
                 13, 14, 15, 16
             };
 
-            RefEnumerable<int> enumerable = RefEnumerable<int>.DangerousCreate(ref data[0], length, step);
+            RefEnumerable<int> enumerable = RefEnumerable<int>.DangerousCreate(ref data[0], values.Length, step);
+
+            for (int i = 1; i <= enumerable.Length; i++)
+            {
+                Assert.AreEqual(values[^i], enumerable[^i]);
+            }
+        }
+
+        [TestCategory("RefEnumerable")]
+        [TestMethod]
+        public void Test_RefEnumerable_Index_Indexer_ThrowsIndexOutOfRange()
+        {
+            int[] array = new[]
+            {
+                0, 0, 0, 0
+            };
 
-            Assert.AreEqual(values[^1], enumerable[^1]);
+            Assert.ThrowsException<IndexOutOfRangeException>(() => RefEnumerable<int>.DangerousCreate(ref array[0], array.Length, 1)[new Index(array.Length)]);
+            Assert.ThrowsException<IndexOutOfRangeException>(() => RefEnumerable<int>.DangerousCreate(ref array[0], array.Length, 1)[^0]);
         }
 #endif
     }

From 16b372fd975c80743bf7a6e117ec9f6d8f36e5f4 Mon Sep 17 00:00:00 2001
From: DaZombieKiller <bennyboy.private@hotmail.com.au>
Date: Fri, 11 Jun 2021 20:25:55 +1000
Subject: [PATCH 8/8] Remove missed length parameter on RefEnumerable test

---
 .../Enumerables/Test_RefEnumerable{T}.cs                        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
index a0c9a152c43..d60e4fe2c48 100644
--- a/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
+++ b/UnitTests/UnitTests.HighPerformance.Shared/Enumerables/Test_RefEnumerable{T}.cs
@@ -92,7 +92,7 @@ public void Test_RefEnumerable_Indexer_ThrowsIndexOutOfRange()
         [DataRow(1, new[] { 1, 2, 3, 4 })]
         [DataRow(4, new[] { 1, 5, 9, 13 })]
         [DataRow(5, new[] { 1, 6, 11, 16 })]
-        public void Test_RefEnumerable_Index_Indexer(int length, int step, int[] values)
+        public void Test_RefEnumerable_Index_Indexer(int step, int[] values)
         {
             Span<int> data = new[]
             {