Added separate pool

Author: usercode

src/AsyncKeyLock/AsyncKeyLock.csproj

@@ -7,7 +7,7 @@
     <Authors>usercode</Authors>
     <Version>1.0.0</Version>
     <PackageProjectUrl>https://github.com/usercode/AsyncKeyLock</PackageProjectUrl>
-    <Description>Async Key-based Reader Writer Lock</Description>
+    <Description>Async Key-based Reader Writer Lock with Cancellation Support</Description>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <PackageIcon>logo.png</PackageIcon>
     <PackageLicenseExpression>MIT</PackageLicenseExpression>

src/AsyncKeyLock/AsyncLock.cs

@@ -119,13 +119,13 @@ public Task<AsyncLockReleaser> WriterLockAsync(CancellationToken cancellation =
         }
     }
 
-    internal void Release(AsyncLockType type, bool sendReleasedEvent = true)
+    internal void Release(AsyncLockReleaser releaser, bool sendReleasedEvent = true)
     {
         lock (_syncObj)
         {
             try
             {
-                if (type == AsyncLockType.Write)
+                if (releaser.Type == AsyncLockType.Write)
                 {
                     WriterRelease();
                 }

src/AsyncKeyLock/AsyncLockReleaser.cs

@@ -9,28 +9,29 @@ namespace AsyncKeyLock;
 /// </summary>
 public sealed class AsyncLockReleaser : IDisposable
 {
-    private readonly AsyncLock _asyncLock;
-    private readonly AsyncLockType _type;
-    private readonly bool _lockAcquiredImmediately;
+    private bool _disposed;
 
-    internal AsyncLockReleaser(AsyncLock asyncLock, AsyncLockType type, bool lockAcquiredImmediately)
-    {
-        _asyncLock = asyncLock;
-        _type = type;
-        _lockAcquiredImmediately = lockAcquiredImmediately;
-    }
+    /// <summary>
+    /// AsyncLock
+    /// </summary>
+    private AsyncLock AsyncLock { get; }
 
     /// <summary>
     /// Type
     /// </summary>
-    public AsyncLockType Type => _type;
+    public AsyncLockType Type { get; }
 
     /// <summary>
     /// IsAcquiredImmediately
     /// </summary>
-    public bool IsAcquiredImmediately => _lockAcquiredImmediately;
+    public bool IsAcquiredImmediately { get; }
 
-    private bool _disposed;
+    internal AsyncLockReleaser(AsyncLock asyncLock, AsyncLockType type, bool lockAcquiredImmediately)
+    {
+        AsyncLock = asyncLock;
+        Type = type;
+        IsAcquiredImmediately = lockAcquiredImmediately;
+    }
 
     public void Dispose()
     {
@@ -39,7 +40,7 @@ public void Dispose()
             return;
         }
 
-        _asyncLock.Release(_type);
+        AsyncLock.Release(this);
 
         _disposed = true;
 

src/AsyncKeyLock/AsyncLock~.cs

@@ -12,12 +12,11 @@ public sealed class AsyncLock<TKey>
 {
     public AsyncLock(int maxPoolSize = 64)
     {
-        MaxPoolSize = maxPoolSize;
+        _pool = new Pool<AsyncLock>(maxPoolSize);
     }
 
     private readonly IDictionary<TKey, AsyncLock> _locks = new Dictionary<TKey, AsyncLock>();
-    private readonly IList<AsyncLock> _pool = new List<AsyncLock>();
-    private readonly int MaxPoolSize;
+    private readonly Pool<AsyncLock> _pool;
 
     /// <summary>
     /// GetAsyncLock
@@ -28,34 +27,25 @@ private AsyncLock GetAsyncLock(TKey key)
     {
         if (_locks.TryGetValue(key, out AsyncLock? asyncLock) == false)
         {
-            //is idle AsyncLock available
-            if (_pool.Count > 0)
-            {
-                int lastPos = _pool.Count - 1;
-
-                asyncLock = _pool[lastPos];
-
-                _pool.RemoveAt(lastPos);
-            }
-            else
-            {
-                //create new AsyncLock
-                asyncLock = new AsyncLock(_locks);
-                asyncLock.Released += x =>
+            //create new AsyncLock
+            _pool.GetOrCreate(out asyncLock,
+                () =>
                 {
-                    //is AsyncLock idle
-                    if (x.State == AsyncLockState.Idle)
+                    AsyncLock a = new AsyncLock(_locks);
+                    a.Released += x =>
                     {
-                        _locks.Remove(key);
-
-                        //add idle AsynLock to pool
-                        if (_pool.Count < MaxPoolSize)
+                        //is AsyncLock idle
+                        if (x.State == AsyncLockState.Idle)
                         {
+                            _locks.Remove(key);
+
+                            //add idle AsynLock to pool
                             _pool.Add(x);
                         }
-                    }
-                };
-            }
+                    };
+
+                    return a;
+                });
 
             _locks.Add(key, asyncLock);
         }

src/AsyncKeyLock/Pool.cs

@@ -0,0 +1,47 @@
+namespace AsyncKeyLock;
+
+/// <summary>
+/// Pool
+/// </summary>
+internal sealed class Pool<T>
+{
+    private readonly IList<T> _pool = new List<T>();
+    private readonly int MaxPoolSize;
+
+    public Pool(int maxPoolSize = 64)
+    {
+        MaxPoolSize = maxPoolSize;
+    }
+
+    public bool Add(T obj)
+    {
+        if (_pool.Count < MaxPoolSize)
+        {
+            _pool.Add(obj);
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public bool GetOrCreate(out T result, Func<T> factory)
+    {
+        if (_pool.Count > 0)
+        {
+            int lastPos = _pool.Count - 1;
+
+            result = _pool[lastPos];
+
+            _pool.RemoveAt(lastPos);
+
+            return true;
+        }
+        else
+        {
+            result = factory();
+
+            return false;
+        }
+    }
+}