add some more stuff.

Author: LoneWandererProductions

CommonExtendedObjectsTests/IntArrayTests.cs

@@ -117,7 +117,7 @@ public void CompareIntArrayvsIntArrayDotNetPerformance()
             var customTime = stopwatch.ElapsedMilliseconds;
             intArray.Dispose();
 
-            Console.WriteLine($"IntArray (unmanaged) time: {customTime} ms");
+            Trace.WriteLine($"IntArray (unmanaged) time: {customTime} ms");
 
             // === Native int[] Test ===
             var nativeArray = new int[Size];
@@ -133,7 +133,7 @@ public void CompareIntArrayvsIntArrayDotNetPerformance()
             stopwatch.Stop();
             var nativeTime = stopwatch.ElapsedMilliseconds;
 
-            Console.WriteLine($"int[] (managed) time: {nativeTime} ms");
+            Trace.WriteLine($"int[] (managed) time: {nativeTime} ms");
 
             // === Sanity Check ===
             var expected = (long)(Size - 1) * Size / 2;
@@ -143,6 +143,52 @@ public void CompareIntArrayvsIntArrayDotNetPerformance()
             // Optional performance sanity check (loose threshold)
             Assert.IsTrue(customTime < 2000, $"IntArray took too long: {customTime}ms");
             Assert.IsTrue(nativeTime < 2000, $"int[] took too long: {nativeTime}ms");
+
+            // === UnmanagedArray<T> Test ===
+            var genericArray = new UnmanagedArray<int>(Size);
+            stopwatch.Restart();
+
+            for (int i = 0; i < Size; i++)
+                genericArray[i] = i;
+
+            long genericSum = 0;
+            for (int i = 0; i < Size; i++)
+                genericSum += genericArray[i];
+
+            stopwatch.Stop();
+            var genericTime = stopwatch.ElapsedMilliseconds;
+            genericArray.Dispose();
+
+            Trace.WriteLine($"UnmanagedArray<int> time: {genericTime} ms");
+            Assert.AreEqual(expected, genericSum, "UnmanagedArray sum mismatch");
+
+        }
+
+        /// <summary>
+        /// Indexings the should work for int array.
+        /// </summary>
+        [TestMethod]
+        public void IndexingShouldWorkForIntArray() => RunIndexingTest(new IntArray(5));
+
+        /// <summary>
+        /// Indexings the should work for unmanaged array.
+        /// </summary>
+        [TestMethod]
+        public void IndexingShouldWorkForUnmanagedArray() => RunIndexingTest(new UnmanagedArray<int>(5));
+
+        /// <summary>
+        /// Runs the indexing test.
+        /// </summary>
+        /// <param name="arr">The arr.</param>
+        private static void RunIndexingTest(IUnmanagedArray<int> arr)
+        {
+            for (int i = 0; i < arr.Length; i++)
+                arr[i] = i * 10;
+
+            for (int i = 0; i < arr.Length; i++)
+                Assert.AreEqual(i * 10, arr[i]);
+
+            arr.Dispose();
         }
     }
 }

ExtendedSystemObjects/IUnmanagedArray.cs

@@ -0,0 +1,26 @@
+/*
+ * COPYRIGHT:   See COPYING in the top level directory
+ * PROJECT:     ExtendedSystemObjects
+ * FILE:        ExtendedSystemObjects/IUnmanagedArray.cs
+ * PURPOSE:     An Abstraction for UnmanagedArray and IntArray to make both exchangeable.
+ * PROGRAMMER:  Peter Geinitz (Wayfarer)
+ */
+
+using System;
+
+namespace ExtendedSystemObjects
+{
+    /// <summary>
+    /// Interface to make unmanaged arrays interchangeable.
+    /// </summary>
+    /// <typeparam name="T">Generic Type</typeparam>
+    /// <seealso cref="System.IDisposable" />
+    public interface IUnmanagedArray<T> : IDisposable
+    {
+        int Length { get; }
+        T this[int index] { get; set; }
+        void Resize(int newSize);
+        void Clear();
+    }
+
+}

ExtendedSystemObjects/IntArray.cs

@@ -17,8 +17,9 @@ namespace ExtendedSystemObjects
     /// backed by unmanaged memory. Designed for performance-critical
     /// scenarios where garbage collection overhead must be avoided.
     /// </summary>
+    /// <seealso cref="ExtendedSystemObjects.IUnmanagedArray" />
     /// <seealso cref="System.IDisposable" />
-    public unsafe class IntArray : IDisposable
+    public unsafe class IntArray : IUnmanagedArray<int>, IDisposable
     {
         /// <summary>
         /// The buffer

ExtendedSystemObjects/UnmanagedArray.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Runtime.InteropServices;
+
+namespace ExtendedSystemObjects
+{
+    /// <summary>
+    /// Unsafe array
+    /// </summary>
+    /// <typeparam name="T">Generic Type, must be unmanaged</typeparam>
+    /// <seealso cref="System.IDisposable" />
+    public unsafe class UnmanagedArray<T> : IUnmanagedArray<T>, IDisposable where T : unmanaged
+    {
+        private IntPtr _buffer;
+        private T* _ptr;
+        private int _length;
+
+        public int Length => _length;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UnmanagedArray{T}"/> class.
+        /// </summary>
+        /// <param name="size">The size.</param>
+        public UnmanagedArray(int size)
+        {
+            _length = size;
+            _buffer = Marshal.AllocHGlobal(size * sizeof(T));
+            _ptr = (T*)_buffer;
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="T"/> at the specified index.
+        /// </summary>
+        /// <value>
+        /// The <see cref="T"/>.
+        /// </value>
+        /// <param name="index">The index.</param>
+        /// <returns>The value at the specified index.</returns>
+        /// <exception cref="System.IndexOutOfRangeException"></exception>
+        public T this[int index]
+        {
+            get
+            {
+#if DEBUG
+                if (index < 0 || index >= _length) throw new IndexOutOfRangeException();
+#endif
+                return _ptr[index];
+            }
+            set
+            {
+#if DEBUG
+                if (index < 0 || index >= _length) throw new IndexOutOfRangeException();
+#endif
+                _ptr[index] = value;
+            }
+        }
+
+
+        /// <summary>
+        /// Resizes the internal array to the specified new size.
+        /// Contents will be preserved up to the minimum of old and new size.
+        /// </summary>
+        /// <param name="newSize">The new size of the array.</param>
+        public void Resize(int newSize)
+        {
+            _buffer = Marshal.ReAllocHGlobal(_buffer, (IntPtr)(newSize * sizeof(T)));
+            _ptr = (T*)_buffer;
+            _length = newSize;
+        }
+
+        /// <summary>
+        /// Clears the array by setting all elements to zero.
+        /// </summary>
+        public void Clear()
+        {
+            // Use Span<T>.Clear for safety and type correctness
+            AsSpan().Clear();
+        }
+
+        public Span<T> AsSpan() => new Span<T>(_ptr, _length);
+
+        public void Dispose()
+        {
+            if (_buffer != IntPtr.Zero)
+            {
+                Marshal.FreeHGlobal(_buffer);
+                _buffer = IntPtr.Zero;
+                _ptr = null;
+                _length = 0;
+            }
+        }
+    }
+}