Optimize ToList method for .NET 9

Author: rameel

Ramstack.Structures.Tests/Collections/ReadOnlyArrayTests.cs

@@ -583,6 +583,19 @@ public void Operator_Conversions(string? value)
         }
     }
 
+    [TestCase(0)]
+    [TestCase(1)]
+    [TestCase(9)]
+    public void Linq_ToList(int count)
+    {
+        var array = CreateArray(count).ToReadOnlyArray();
+        var list = array.ToList();
+
+        Assert.That(list.Count, Is.EqualTo(count));
+        Assert.That(list.Capacity, Is.EqualTo(count));
+        Assert.That(list, Is.EqualTo(array));
+    }
+
     private static int[] CreateArray(int length) =>
         Enumerable.Range(0, length).ToArray();
 }

Ramstack.Structures/Collections/ArrayViewExtensions.cs

@@ -148,7 +148,7 @@ public static ArrayView<T> AsView<T>(this List<T>? list)
     {
         if (list is not null)
         {
-            var array = ListAccessor<T>.GetBuffer(list);
+            var array = ListAccessor<T>.GetArray(list);
             var count = Math.Min(list.Count, array.Length);
 
             return new ArrayView<T>(array, 0, count);
@@ -157,26 +157,5 @@ public static ArrayView<T> AsView<T>(this List<T>? list)
         return ArrayView<T>.Empty;
     }
 
-    #region Inner type: ListAccessor<T>
-
-    /// <summary>
-    /// Provides low-level access to the internal array buffer of a <see cref="List{T}"/>.
-    /// </summary>
-    /// <typeparam name="T">The type of the elements in the list.</typeparam>
-    private static class ListAccessor<T>
-    {
-        /// <summary>
-        /// Retrieves a reference to the internal array buffer of the specified <see cref="List{T}"/>.
-        /// </summary>
-        /// <param name="list">The list whose internal buffer is to be accessed.</param>
-        /// <returns>
-        /// A reference to the internal array used by the list.
-        /// </returns>
-        [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_items")]
-        public static extern ref T[] GetBuffer(List<T> list);
-    }
-
-    #endregion
-
     #endif
 }

Ramstack.Structures/Collections/ReadOnlyArrayExtensions.Linq.cs

@@ -392,15 +392,22 @@ public static T[] ToArray<T>(this ReadOnlyArray<T> source)
     /// <inheritdoc cref="Enumerable.ToList{TSource}"/>
     public static List<T> ToList<T>(this ReadOnlyArray<T> source)
     {
-        #if NET8_0_OR_GREATER
+        #if NET9_0_OR_GREATER
+        var list = new List<T>();
+
+        ListAccessor<T>.GetArray(list) = source.ToArray();
+        ListAccessor<T>.GetCount(list) = source.Length;
+
+        return list;
+        #elif NET8_0_OR_GREATER
         var list = new List<T>(source.Length);
 
         System.Runtime.InteropServices.CollectionsMarshal.SetCount(list, source.Length);
-        source.CopyTo(System.Runtime.InteropServices.CollectionsMarshal.AsSpan(list));
+        source.TryCopyTo(System.Runtime.InteropServices.CollectionsMarshal.AsSpan(list));
 
         return list;
         #else
-        return source.Inner!.ToList();
+        return [..source.Inner!];
         #endif
     }
 

Ramstack.Structures/Internal/ListAccessor.cs

@@ -0,0 +1,33 @@
+namespace Ramstack.Internal;
+
+#if NET9_0_OR_GREATER
+
+/// <summary>
+/// Provides low-level access to the internal array buffer of a <see cref="List{T}"/>.
+/// </summary>
+/// <typeparam name="T">The type of the elements in the list.</typeparam>
+internal static class ListAccessor<T>
+{
+    /// <summary>
+    /// Returns a reference to the internal array buffer of the specified <see cref="List{T}"/>.
+    /// </summary>
+    /// <param name="list">The list whose internal buffer is to be accessed.</param>
+    /// <returns>
+    /// A reference to the internal array used by the list.
+    /// </returns>
+    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_items")]
+    public static extern ref T[] GetArray(List<T> list);
+
+    /// <summary>
+    /// Returns a reference to the internal "_size" field of the specified <see cref="List{T}"/>
+    /// representing the number of elements in the list.
+    /// </summary>
+    /// <param name="list">The list whose internal "_size" field is to be accessed.</param>
+    /// <returns>
+    /// A reference to the internal "_size" field representing the number of elements in the list.
+    /// </returns>
+    [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_size")]
+    public static extern ref int GetCount(List<T> list);
+}
+
+#endif