Added implicit ReadOnlyRefEnumerable operator

Author: Sergio0694

Microsoft.Toolkit.HighPerformance/Enumerables/ReadOnlyRefEnumerable{T}.cs

@@ -59,6 +59,20 @@ public ref struct ReadOnlyRefEnumerable<T>
         private int position;
 
 #if SPAN_RUNTIME_SUPPORT
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
+        /// </summary>
+        /// <param name="span">The <see cref="ReadOnlySpan{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>
+        /// <param name="position">The current position in the sequence.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private ReadOnlyRefEnumerable(ReadOnlySpan<T> span, int step, int position)
+        {
+            this.span = span;
+            this.step = step;
+            this.position = position;
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
         /// </summary>
@@ -73,6 +87,24 @@ internal ReadOnlyRefEnumerable(in T reference, int length, int step)
             this.position = -1;
         }
 #else
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
+        /// </summary>
+        /// <param name="instance">The target <see cref="object"/> instance.</param>
+        /// <param name="offset">The initial offset within <see paramref="instance"/>.</param>
+        /// <param name="length">The number of items in the sequence.</param>
+        /// <param name="step">The distance between items in the sequence to enumerate.</param>
+        /// <param name="position">The current position in the sequence.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private ReadOnlyRefEnumerable(object? instance, IntPtr offset, int length, int step, int position)
+        {
+            this.instance = instance;
+            this.offset = offset;
+            this.length = length;
+            this.step = step;
+            this.position = position;
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ReadOnlyRefEnumerable{T}"/> struct.
         /// </summary>
@@ -204,6 +236,20 @@ public readonly T[] ToArray()
             return array;
         }
 
+        /// <summary>
+        /// Implicitly converts a <see cref="RefEnumerable{T}"/> instance into a <see cref="ReadOnlyRefEnumerable{T}"/> one.
+        /// </summary>
+        /// <param name="enumerable">The input <see cref="RefEnumerable{T}"/> instance.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static implicit operator ReadOnlyRefEnumerable<T>(RefEnumerable<T> enumerable)
+        {
+#if SPAN_RUNTIME_SUPPORT
+            return new ReadOnlyRefEnumerable<T>(enumerable.Span, enumerable.Step, enumerable.Position);
+#else
+            return new ReadOnlyRefEnumerable<T>(enumerable.Instance, enumerable.Offset, enumerable.Length, enumerable.Position);
+#endif
+        }
+
         /// <summary>
         /// Throws an <see cref="ArgumentException"/> when the target span is too short.
         /// </summary>

Microsoft.Toolkit.HighPerformance/Enumerables/RefEnumerable{T}.cs

@@ -56,7 +56,7 @@ public ref struct RefEnumerable<T>
         /// <summary>
         /// The current position in the sequence.
         /// </summary>
-        private int position;
+        internal int Position;
 
 #if SPAN_RUNTIME_SUPPORT
         /// <summary>
@@ -71,7 +71,7 @@ internal RefEnumerable(ref T reference, int length, int step)
             Span = MemoryMarshal.CreateSpan(ref reference, length);
             Step = step;
 
-            this.position = -1;
+            this.Position = -1;
         }
 #else
         /// <summary>
@@ -89,7 +89,7 @@ internal RefEnumerable(object? instance, IntPtr offset, int length, int step)
             Length = length;
             Step = step;
 
-            this.position = -1;
+            this.Position = -1;
         }
 #endif
 
@@ -103,9 +103,9 @@ internal RefEnumerable(object? instance, IntPtr offset, int length, int step)
         public bool MoveNext()
         {
 #if SPAN_RUNTIME_SUPPORT
-            return ++this.position < this.Span.Length;
+            return ++this.Position < this.Span.Length;
 #else
-            return ++this.position < this.Length;
+            return ++this.Position < this.Length;
 #endif
         }
 
@@ -127,7 +127,7 @@ public readonly ref T Current
                 // 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;
+                nint offset = (nint)(uint)this.Position * (nint)(uint)this.Step;
                 ref T ri = ref Unsafe.Add(ref r0, offset);
 
                 return ref ri;