Added special method to access the internal array of a list.

Author: JunaMeinhold

Hexa.NET.Utilities/Collections/ArrayAccessor.cs

@@ -0,0 +1,45 @@
+namespace Hexa.NET.Utilities.Collections
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Reflection;
+    using System.Reflection.Emit;
+
+    /// <summary>
+    /// Provides a hacky way to access the local array of a <see cref="List{T}"/>.
+    /// </summary>
+
+    internal static class ArrayAccessor<T>
+    {
+        /// <summary>
+        /// Gets a delegate that can be used to retrieve the local array of a <see cref="List{T}"/>.
+        /// </summary>
+        public static Func<List<T>, T[]> Getter;
+
+#nullable disable
+
+        static ArrayAccessor()
+        {
+            // Create a DynamicMethod to access the internal array field.
+#pragma warning disable IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            // suppressing warning because this code is always available in runtime
+            var dm = new DynamicMethod("get", MethodAttributes.Static | MethodAttributes.Public, CallingConventions.Standard, typeof(T[]), [typeof(List<T>)], typeof(ArrayAccessor<T>), true);
+#pragma warning restore IL3050 // Calling members annotated with 'RequiresDynamicCodeAttribute' may break functionality when AOT compiling.
+            var il = dm.GetILGenerator();
+
+            // Load List<T> argument onto the evaluation stack.
+            il.Emit(OpCodes.Ldarg_0);
+
+            // Load the internal array field from the List<T> instance.
+            il.Emit(OpCodes.Ldfld, typeof(List<T>).GetField("_items", BindingFlags.NonPublic | BindingFlags.Instance));
+
+            // Return the internal array field.
+            il.Emit(OpCodes.Ret);
+
+            // Create a delegate from the DynamicMethod to get the internal array.
+            Getter = (Func<List<T>, T[]>)dm.CreateDelegate(typeof(Func<List<T>, T[]>));
+        }
+
+#nullable restore
+    }
+}

Hexa.NET.Utilities/Collections/ListExtensions.cs

@@ -0,0 +1,37 @@
+namespace Hexa.NET.Utilities.Collections
+{
+    using System.Collections.Generic;
+    using System.Runtime.CompilerServices;
+
+    /// <summary>
+    /// Provides extension methods for <see cref="List{T}"/> and accessing the internal array.
+    /// </summary>
+    public static class ListExtensions
+    {
+        /// <summary>
+        /// Allows to access the internal array of a <see cref="List{T}"/>.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the list.</typeparam>
+        /// <param name="list">The list for which to access the internal array.</param>
+        /// <returns>The internal array of the list.</returns>
+        public static T[] GetInternalArray<T>(this List<T> list)
+        {
+            return ArrayAccessor<T>.Getter(list);
+        }
+
+        /// <summary>
+        /// Mutates the item at the specified index in the list using the provided function.
+        /// </summary>
+        /// <typeparam name="T">The type of elements in the list.</typeparam>
+        /// <param name="list">The list to mutate.</param>
+        /// <param name="index">The index of the item to mutate.</param>
+        /// <param name="func">The function to apply to the item at the specified index.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void MutateItem<T>(this IList<T> list, int index, Func<T, T> func)
+        {
+            var item = list[index];
+            item = func(item);
+            list[index] = item;
+        }
+    }
+}