Improve my unmanagedIntList

Author: LoneWandererProductions

CommonLibraryGuiTests/Image/example Polaris.png

@@ -164,10 +164,16 @@ public void RemoveAt(int index, int count = 1)
             }
 #endif
 
-            if (index + count < Length)
+            int moveCount = Length - (index + count);
+            if (moveCount > 0)
             {
-                // Shift elements left by 'count' to fill the gap
-                UnmanagedMemoryHelper.ShiftLeft(_ptr, index, count, Length);
+                // Source: Elements after the deleted range
+                ReadOnlySpan<int> source = new ReadOnlySpan<int>(_ptr + index + count, moveCount);
+                // Destination: The start of the deleted range
+                Span<int> destination = new Span<int>(_ptr + index, moveCount);
+
+                // This is a high-speed memmove equivalent
+                source.CopyTo(destination);
             }
 
             Length -= count;
@@ -237,10 +243,14 @@ public bool Remove(int value)
         /// <returns>A new <see cref="UnmanagedIntList" /> instance with the same values.</returns>
         public UnmanagedIntList Clone()
         {
+            // Create the new list with enough capacity
             var clone = new UnmanagedIntList(Length);
-            for (var i = 0; i < Length; i++)
+
+            if (Length > 0)
             {
-                clone._ptr[i] = _ptr[i];
+                // Source: Our current valid data (via the fixed AsSpan)
+                // Destination: A new span wrapping the clone's raw pointer
+                AsSpan().CopyTo(new Span<int>(clone._ptr, Length));
             }
 
             clone.Length = Length;
@@ -348,33 +358,38 @@ public void InsertAt(int index, int value, int count = 1)
                 throw new ArgumentOutOfRangeException(nameof(index));
             }
 #endif
-            if (count <= 0)
-            {
-                return;
-            }
+            if (count <= 0) return;
 
             EnsureCapacity(Length + count);
 
-            // Shift elements to the right
-            UnmanagedMemoryHelper.ShiftRight(_ptr, index, count, Length, Capacity);
-
-            // Fill with value
-            for (var i = 0; i < count; i++)
+            int moveCount = Length - index;
+            if (moveCount > 0)
             {
-                _ptr[index + i] = value;
+                // Source: Elements from index to the end
+                ReadOnlySpan<int> source = new ReadOnlySpan<int>(_ptr + index, moveCount);
+                // Destination: The new position after the gap
+                Span<int> destination = new Span<int>(_ptr + index + count, moveCount);
+
+                source.CopyTo(destination);
             }
 
+            // High-performance fill
+            new Span<int>(_ptr + index, count).Fill(value);
+
             Length += count;
         }
 
         /// <summary>
-        ///     Returns a span over the valid elements of the list.
-        ///     Allows fast, safe access to the underlying data.
+        ///      Returns a span over the valid elements of the list.
+        ///      Allows fast, safe access to the underlying data.
         /// </summary>
-        /// <returns>A <see cref="Span{Int32}" /> representing the list's contents.</returns>
+        /// <returns>A <see cref="Span{Int32}" /> representing the list's valid contents.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Span<int> AsSpan()
         {
-            return new Span<int>(_ptr, Capacity);
+            // Fix: Use 'Length' instead of 'Capacity' 
+            // to prevent access to uninitialized memory.
+            return new Span<int>(_ptr, Length);
         }
 
         /// <summary>
@@ -384,12 +399,12 @@ public Span<int> AsSpan()
         public UnmanagedIntList Sorted()
         {
             var copy = new UnmanagedIntList(Length);
-            for (var i = 0; i < Length; i++)
+            if (Length > 0)
             {
-                copy.Add(_ptr[i]);
+                AsSpan().CopyTo(new Span<int>(copy._ptr, Length));
+                copy.Length = Length; // Set length before sorting so AsSpan() works
+                copy.Sort();
             }
-
-            copy.Sort(); // Uses internal AsSpan().Sort()
             return copy;
         }