Expose public indexer and length properties on RefEnumerable<T> and ReadOnlyRefEnumerable<T>

Author: DaZombieKiller

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,42 +404,33 @@ 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
             }
 
             /// <inheritdoc cref="System.Collections.Generic.IEnumerator{T}.Current"/>
             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);
             }
         }