format

Author: LoneWandererProductions

ExtendedSystemObjects/ImmutableLookupMapUnmanaged.cs

@@ -125,6 +125,7 @@ public ImmutableLookupMapUnmanaged(IDictionary<TKey, TValue> data)
         public void Dispose()
         {
             if (_disposed) return;
+
             _entries.Dispose();
             _disposed = true;
         }

ExtendedSystemObjects/UnmanagedIntArray.cs

@@ -16,6 +16,7 @@
 using System.Runtime.CompilerServices;
 using ExtendedSystemObjects.Helper;
 using ExtendedSystemObjects.Interfaces;
+// ReSharper disable MemberCanBePrivate.Global
 
 namespace ExtendedSystemObjects
 {
@@ -360,8 +361,9 @@ public void RemoveMultiple(ReadOnlySpan<int> indices)
         }
 
         /// <summary>
-        ///     Returns a Span over the used portion of the array.
+        /// Returns a Span over the used portion of the array.
         /// </summary>
+        /// <returns>Dta as span.</returns>
         public Span<int> AsSpan()
         {
             EnsureNotDisposed();

ExtendedSystemObjects/UnmanagedMap.cs

@@ -166,6 +166,7 @@ private List<TValue> GetValuesSnapshot()
         public void Dispose()
         {
             if (_disposed) return;
+
             Free();
             GC.SuppressFinalize(this);
             _disposed = true;

MemoryManager.Core/MemoryManagerConfig.cs

@@ -58,12 +58,12 @@ public MemoryManagerConfig(int slowLaneSize)
         /// <summary>
         /// Gets the free-list block search strategy used by the FastLane when running the FreeList strategy wrapper.
         /// </summary>
-        public AllocationStrategy FastLaneFreeListStrategy { get; init; } = AllocationStrategy.FirstFit;
+        public AllocationStrategy FastLaneFreeListStrategy { get; private init; } = AllocationStrategy.FirstFit;
 
         /// <summary>
         /// Gets the free-list block search strategy used by the SlowLane to manage gap allocations.
         /// </summary>
-        public AllocationStrategy SlowLaneFreeListStrategy { get; init; } = AllocationStrategy.BestFit;
+        public AllocationStrategy SlowLaneFreeListStrategy { get; private init; } = AllocationStrategy.BestFit;
 
         /// <summary>
         /// Gets the fast lane strategy.
@@ -203,13 +203,13 @@ public MemoryManagerConfig(int slowLaneSize)
         /// Fraction of the SlowLane capacity dedicated to the BlobManager for small, unpredictable data.
         /// Example: 0.20 reserves 20% of the SlowLane for tiny blobs.
         /// </summary>
-        public double SlowLaneBlobCapacityFraction { get; init; } = 0.20;
+        public double SlowLaneBlobCapacityFraction { get; private init; } = 0.20;
 
         /// <summary>
         /// Allocations in the SlowLane smaller than or equal to this size (in bytes)
         /// will be routed to the BlobManager instead of the main BlockManager.
         /// </summary>
-        public int SlowLaneBlobThreshold { get; init; } = 256;
+        public int SlowLaneBlobThreshold { get; private init; } = 256;
 
         /// <summary>
         ///      Estimates the total reserved unmanaged memory (in bytes) this configuration will request,
@@ -338,7 +338,8 @@ public static MemoryManagerConfig CreateForFrameScratch(int totalBudget = 8 * 10
                 Threshold = totalBudget, // Guarantees ALL allocations up to the full budget hit FastLane!
                 FastLaneStrategy = AllocatorStrategy.LinearBump, // Pure O(1) bump speed
                 MaxFastLaneAgeFrames = 1, // Single-frame turnover
-                EnableAutoCompaction = false, // Disabled: O(1) bump reset on Free handles cleanup, avoiding mid-frame stalls
+                EnableAutoCompaction =
+                    false, // Disabled: O(1) bump reset on Free handles cleanup, avoiding mid-frame stalls
                 FastLaneUsageThreshold = 0.99,
                 SlowLaneUsageThreshold = 0.99
             };

MemoryManager.Lanes/LinearLane.cs

@@ -125,6 +125,7 @@ public unsafe LinearLane(int size, SlowLane slowLane, int maxEntries = 1024)
         public unsafe void Dispose()
         {
             if (_disposed) return;
+
             _disposed = true;
 
             // 1. Free main native buffer and reset pointer

MemoryManager.Lanes/SlabLane.cs

@@ -142,6 +142,7 @@ public bool CanAllocate(int size)
         {
             var binIndex = FindBinIndex(size);
             if (binIndex == -1) return false;
+
             return _bins[binIndex].FreeCount > 0;
         }
 
@@ -335,6 +336,7 @@ public int EstimateFragmentation()
             }
 
             if (totalPhysicalActiveBytes == 0) return 0;
+
             return (int)((double)(totalPhysicalActiveBytes - totalUserRequestedBytes) / totalPhysicalActiveBytes * 100);
         }
 
@@ -368,6 +370,7 @@ public int GetAllocationSize(MemoryHandle handle) =>
         public IEnumerable<MemoryHandle> GetHandles()
         {
             if (_entries == null) yield break;
+
             foreach (var id in _handleIndex.Keys)
             {
                 if (_handleIndex.TryGetValue(id, out var index))

MemoryManager.Tests/ArenaBufferTests.cs

@@ -11,24 +11,39 @@
 
 namespace MemoryManager.Tests
 {
+    /// <summary>
+    /// Simple Arena tests.
+    /// </summary>
     [TestClass]
     public sealed class ArenaBufferTests
     {
-        private MemoryArena _arena;
-
+        /// <summary>
+        /// The arena
+        /// </summary>
+        private MemoryArena? _arena;
+
+        /// <summary>
+        /// Setups this instance.
+        /// </summary>
         [TestInitialize]
         public void Setup()
         {
             var config = MemoryManagerConfig.CreateForGameLoop(4 * 1024 * 1024);
             _arena = new MemoryArena(config);
         }
 
+        /// <summary>
+        /// Cleanups this instance.
+        /// </summary>
         [TestCleanup]
         public void Cleanup()
         {
             _arena?.Dispose();
         }
 
+        /// <summary>
+        /// Arenas the buffer add and read validates data integrity.
+        /// </summary>
         [TestMethod]
         public void ArenaBuffer_AddAndRead_ValidatesDataIntegrity()
         {
@@ -48,6 +63,9 @@ public void ArenaBuffer_AddAndRead_ValidatesDataIntegrity()
             }
         }
 
+        /// <summary>
+        /// Arenas the buffer exceed capacity throws invalid operation exception.
+        /// </summary>
         [TestMethod]
         public void ArenaBuffer_ExceedCapacity_ThrowsInvalidOperationException()
         {
@@ -60,6 +78,9 @@ public void ArenaBuffer_ExceedCapacity_ThrowsInvalidOperationException()
             Assert.ThrowsException<InvalidOperationException>(() => buffer.Add(4));
         }
 
+        /// <summary>
+        /// Arenas the buffer clear resets count without reallocating.
+        /// </summary>
         [TestMethod]
         public void ArenaBuffer_Clear_ResetsCountWithoutReallocating()
         {
@@ -78,6 +99,9 @@ public void ArenaBuffer_Clear_ResetsCountWithoutReallocating()
             Assert.AreEqual(300, buffer[0]);
         }
 
+        /// <summary>
+        /// Arenas the buffer index out of bounds throws index out of range exception.
+        /// </summary>
         [TestMethod]
         public void ArenaBuffer_IndexOutOfBounds_ThrowsIndexOutOfRangeException()
         {

MemoryManager.Tests/ArenaStackTests.cs

@@ -14,7 +14,7 @@ namespace MemoryManager.Tests
     [TestClass]
     public sealed class ArenaQueueTests
     {
-        private MemoryArena _arena;
+        private MemoryArena? _arena;
 
         [TestInitialize]
         public void Setup()

MemoryManager.Tests/FrameScratchTests.cs

@@ -65,7 +65,8 @@ public void FrameScratch_NoSpillHint_SucceedsSeamlessly()
             using var arena = new MemoryArena(config);
 
             // Rent with explicit NoSpill hint
-            using var rent = new ArenaRent<int>(arena, 1024, hints: AllocationHints.FrameCritical | AllocationHints.NoSpill);
+            using var rent = new ArenaRent<int>(arena, 1024,
+                hints: AllocationHints.FrameCritical | AllocationHints.NoSpill);
             rent[0] = 123;
 
             Assert.AreEqual(123, rent[0]);

MemoryManager.Tests/LinearLaneBugRegressionTests.cs

@@ -72,11 +72,9 @@ public void MemoryArena_GameLoopPreset_PreventsBumpExhaustionViaArenaRent()
             // Should complete cleanly without spilling to SlowLane or throwing OutOfMemoryException
             for (var i = 0; i < totalIterations; i++)
             {
-                using (var rent = new ArenaRent<int>(arena, rentElementCount))
-                {
-                    rent[0] = i;
-                    rent[rentElementCount - 1] = i * 2;
-                } // Dispose returns EntryCount to 0, triggering the bump offset reset
+                using var rent = new ArenaRent<int>(arena, rentElementCount);
+                rent[0] = i;
+                rent[rentElementCount - 1] = i * 2;
             }
 
             // Assert FastLane is back to zero active entries and ready for new frames