improve unmanaged array

Author: LoneWandererProductions

ExtendedSystemObjects/ImmutableLookupMap.cs

@@ -121,7 +121,7 @@ IEnumerator IEnumerable.GetEnumerator()
         ///     Retrieves the value associated with the specified key.
         /// </summary>
         /// <param name="key">The key.</param>
-        /// <returns></returns>
+        /// <returns>Requested Value from Key</returns>
         /// <exception cref="KeyNotFoundException">The key {key} was not found in the lookup map.</exception>
         public TValue Get(TKey key)
         {

ExtendedSystemObjects/IntArray.cs

@@ -326,6 +326,7 @@ public void EnsureCapacity(int minCapacity)
             }
 
             var newCapacity = Capacity == 0 ? 4 : Capacity;
+
             while (newCapacity < minCapacity)
             {
                 newCapacity *= 2;

ExtendedSystemObjects/UnmanagedArray.cs

@@ -33,9 +33,12 @@ public sealed unsafe class UnmanagedArray<T> : IUnmanagedArray<T>, IEnumerable<T
         private IntPtr _buffer;
 
         /// <summary>
-        ///     The capacity
+        /// The capacity of the current Array.
         /// </summary>
-        private int _capacity;
+        /// <value>
+        /// The capacity.
+        /// </value>
+        public int Capacity { get; private set; }
 
         /// <summary>
         ///     The disposed
@@ -53,7 +56,7 @@ public sealed unsafe class UnmanagedArray<T> : IUnmanagedArray<T>, IEnumerable<T
         /// <param name="size">The size.</param>
         public UnmanagedArray(int size)
         {
-            _capacity = size;
+            Capacity = size;
             Length = size;
             _buffer = Marshal.AllocHGlobal(size * sizeof(T));
             _ptr = (T*)_buffer;
@@ -123,7 +126,7 @@ public void RemoveAt(int index)
                 Buffer.MemoryCopy(
                     _ptr + index + 1,
                     _ptr + index,
-                    (_capacity - index - 1) * sizeof(T),
+                    (Capacity - index - 1) * sizeof(T),
                     elementsToShift * sizeof(T));
             }
 
@@ -162,15 +165,32 @@ IEnumerator IEnumerable.GetEnumerator()
         /// <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;
-            _capacity = newSize;
+            if (newSize < 0)
+                throw new ArgumentOutOfRangeException(nameof(newSize));
+
+            if (newSize == Capacity)
+                return;
+
+            var newBuffer = Marshal.ReAllocHGlobal(_buffer, (IntPtr)(newSize * sizeof(T)));
+            var newPtr = (T*)newBuffer;
+
+            if (newSize > Capacity)
+            {
+                var newRegion = new Span<T>(newPtr + Capacity, newSize - Capacity);
+                newRegion.Clear();
+            }
+
+            _buffer = newBuffer;
+            _ptr = newPtr;
+            Capacity = newSize;
+
             if (Length > newSize)
             {
                 Length = newSize;
             }
         }
 
+
         /// <inheritdoc />
         /// <summary>
         ///     Clears the array by setting all elements to zero.
@@ -228,7 +248,7 @@ public void InsertAt(int index, T value, int count = 1)
                 Buffer.MemoryCopy(
                     _ptr + index,
                     _ptr + index + count,
-                    (_capacity - index - count) * sizeof(T),
+                    (Capacity - index - count) * sizeof(T),
                     elementsToShift * sizeof(T));
             }
 
@@ -247,12 +267,12 @@ public void InsertAt(int index, T value, int count = 1)
         /// <param name="minCapacity">The minimum capacity.</param>
         public void EnsureCapacity(int minCapacity)
         {
-            if (minCapacity <= _capacity)
+            if (minCapacity <= Capacity)
             {
                 return;
             }
 
-            var newCapacity = _capacity == 0 ? 4 : _capacity;
+            var newCapacity = Capacity == 0 ? 4 : Capacity;
             while (newCapacity < minCapacity)
             {
                 newCapacity *= 2;
@@ -299,7 +319,7 @@ private void Dispose(bool disposing)
                 _buffer = IntPtr.Zero;
                 _ptr = null;
                 Length = 0;
-                _capacity = 0;
+                Capacity = 0;
             }
 
             _disposed = true;