5.0.2-rc

MarkCiliaVincenti · Nov 26, 2022 · ccd55b8 · ccd55b8
1 parent cf067fb
commit ccd55b8
Show file tree

Hide file tree

Showing 6 changed files with 36 additions and 39 deletions.
diff --git a/AsyncKeyedLock/AsyncKeyedLock.csproj b/AsyncKeyedLock/AsyncKeyedLock.csproj
@@ -7,16 +7,16 @@
 		<RepositoryUrl>https://github.com/MarkCiliaVincenti/AsyncKeyedLock.git</RepositoryUrl>
 		<PackageProjectUrl>https://github.com/MarkCiliaVincenti/AsyncKeyedLock</PackageProjectUrl>
 		<PackageLicenseFile>LICENSE</PackageLicenseFile>
-		<Version>5.0.1</Version>
+		<Version>5.0.2-rc</Version>
 		<PackageIcon>logo.png</PackageIcon>
 		<PackageReleaseNotes>Performance improvements and allowing for object pooling.</PackageReleaseNotes>
 		<Description>An asynchronous .NET Standard 2.0 library that allows you to lock based on a key (keyed semaphores), limiting concurrent threads sharing the same key to a specified number.</Description>
 		<Copyright>© 2022 Mark Cilia Vincenti</Copyright>
 		<PackageTags>async,lock,key,semaphore,dictionary,pooling,duplicate</PackageTags>
 		<RepositoryType>git</RepositoryType>
 		<GeneratePackageOnBuild>false</GeneratePackageOnBuild>
-		<AssemblyVersion>5.0.1.0</AssemblyVersion>
-		<FileVersion>5.0.1.0</FileVersion>
+		<AssemblyVersion>5.0.1.9</AssemblyVersion>
+		<FileVersion>5.0.1.9</FileVersion>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
 		<IsPackable>true</IsPackable>
 		<IsTrimmable>true</IsTrimmable>

diff --git a/AsyncKeyedLock/AsyncKeyedLockOptions.cs b/AsyncKeyedLock/AsyncKeyedLockOptions.cs
@@ -1,13 +1,9 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace AsyncKeyedLock
+namespace AsyncKeyedLock
 {
     /// <summary>
     /// Options for the <see cref="AsyncKeyedLocker"/> constructors
     /// </summary>
-    public class AsyncKeyedLockOptions
+    public sealed class AsyncKeyedLockOptions
     {
         /// <summary>
         /// The maximum number of requests for the semaphore that can be granted concurrently. Defaults to 1.
@@ -30,4 +26,4 @@ public AsyncKeyedLockOptions(int maxCount = 1, int poolSize = 0)
             PoolSize = poolSize;
         }
     }
-}
+}
diff --git a/AsyncKeyedLock/AsyncKeyedLockPool.cs b/AsyncKeyedLock/AsyncKeyedLockPool.cs
@@ -1,11 +1,9 @@
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Text;
 
 namespace AsyncKeyedLock
 {
-    internal class AsyncKeyedLockPool<TKey>
+    internal sealed class AsyncKeyedLockPool<TKey>
     {
         private readonly BlockingCollection<AsyncKeyedLockReleaser<TKey>> _objects;
         private readonly Func<TKey, AsyncKeyedLockReleaser<TKey>> _objectGenerator;
@@ -35,4 +33,4 @@ public void PutObject(AsyncKeyedLockReleaser<TKey> item)
             _objects.TryAdd(item);
         }
     }
-}
+}
diff --git a/AsyncKeyedLock/AsyncKeyedLockReleaser.cs b/AsyncKeyedLock/AsyncKeyedLockReleaser.cs
@@ -6,7 +6,7 @@ namespace AsyncKeyedLock
     /// <summary>
     /// Represents an <see cref="IDisposable"/> for AsyncKeyedLock.
     /// </summary>
-    public class AsyncKeyedLockReleaser<TKey> : IDisposable
+    public sealed class AsyncKeyedLockReleaser<TKey> : IDisposable
     {
         private TKey _key;
 

diff --git a/AsyncKeyedLock/AsyncKeyedLocker.cs b/AsyncKeyedLock/AsyncKeyedLocker.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;

diff --git a/AsyncKeyedLock/AsyncKeyedLockerDictionary.cs b/AsyncKeyedLock/AsyncKeyedLockerDictionary.cs
@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Concurrent;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Threading;
 
@@ -67,45 +66,47 @@ public AsyncKeyedLockerDictionary(AsyncKeyedLockOptions options, int concurrency
             }
         }
 
-        private AsyncKeyedLockReleaser<TKey> GetReleaser(TKey key)
+        public AsyncKeyedLockReleaser<TKey> GetOrAdd(TKey key)
         {
-            if (_poolingEnabled)
+            if (TryGetValue(key, out var referenceCounter) && referenceCounter.TryIncrement())
             {
-                return _pool.GetObject(key);
+                return referenceCounter;
             }
-            return new AsyncKeyedLockReleaser<TKey>(key, new SemaphoreSlim(MaxCount), this);
-        }
 
-        private void AddToPool(AsyncKeyedLockReleaser<TKey> item)
-        {
             if (_poolingEnabled)
             {
-                _pool.PutObject((AsyncKeyedLockReleaser<TKey>)item);
-            }
-        }
+                var toAddReferenceCounter = _pool.GetObject(key);
+                if (TryAdd(key, toAddReferenceCounter))
+                {
+                    return toAddReferenceCounter;
+                }
 
-        public AsyncKeyedLockReleaser<TKey> GetOrAdd(TKey key)
-        {
-            if (TryGetValue(key, out var referenceCounter) && referenceCounter.TryIncrement())
-            {
+                while (!(TryGetValue(key, out referenceCounter) && referenceCounter.TryIncrement()))
+                {
+                    if (TryAdd(key, toAddReferenceCounter))
+                    {
+                        return toAddReferenceCounter;
+                    }
+                }
+
+                _pool.PutObject(toAddReferenceCounter);
                 return referenceCounter;
             }
 
-            var toAddReferenceCounter = GetReleaser(key);
-            if (TryAdd(key, toAddReferenceCounter))
+            var toAddReferenceCounterNoPooling = new AsyncKeyedLockReleaser<TKey>(key, new SemaphoreSlim(MaxCount), this);
+            if (TryAdd(key, toAddReferenceCounterNoPooling))
             {
-                return toAddReferenceCounter;
+                return toAddReferenceCounterNoPooling;
             }
 
             while (!(TryGetValue(key, out referenceCounter) && referenceCounter.TryIncrement()))
             {
-                if (TryAdd(key, toAddReferenceCounter))
+                if (TryAdd(key, toAddReferenceCounterNoPooling))
                 {
-                    return toAddReferenceCounter;
+                    return toAddReferenceCounterNoPooling;
                 }
             }
 
-            AddToPool(toAddReferenceCounter);
             return referenceCounter;
         }
 
@@ -117,7 +118,10 @@ public void Release(AsyncKeyedLockReleaser<TKey> referenceCounter)
             {
                 TryRemove(referenceCounter.Key, out _);
                 Monitor.Exit(referenceCounter);
-                AddToPool(referenceCounter);
+                if (_poolingEnabled)
+                {
+                    _pool.PutObject(referenceCounter);
+                }
                 referenceCounter.SemaphoreSlim.Release();
                 return;
             }