fix: remove MaxCount from async lock config

CacheManager.Redis/CacheSource/RedisCacheSource.cs

@@ -87,7 +87,7 @@
 		var server = connectionMultiplexer.GetServer(_config.ConnectionString);
 		var pattern = $"{_keyPrefix}*";
 
-		await foreach (var key in server.KeysAsync(pattern: pattern))
+		await foreach (var key in server.KeysAsync(pattern: pattern).ConfigureAwait(false))
 		{
 			_ = await _redisCache.KeyDeleteAsync(key).ConfigureAwait(false);
 		}
@@ -118,7 +118,7 @@
 	/// Dispose
 	/// </summary>
 	/// <returns></returns>
 	public async ValueTask DisposeAsync() => await StopAsync().ConfigureAwait(false);
 
 	/// <summary>
 	/// Priority, Lowest priority - checked last

CacheManager/CacheManager.csproj

@@ -18,9 +18,9 @@
 		<RepositoryType>public</RepositoryType>
 		<PackageTags>CacheManager</PackageTags>
 		<PackageReleaseNotes>CacheManager</PackageReleaseNotes>
-		<AssemblyVersion>2.1.0</AssemblyVersion>
-		<FileVersion>2.1.0</FileVersion>
-		<Version>2.1.0</Version>
+		<AssemblyVersion>2.1.1</AssemblyVersion>
+		<FileVersion>2.1.1</FileVersion>
+		<Version>2.1.1</Version>
 		<SignAssembly>true</SignAssembly>
 		<AssemblyOriginatorKeyFile>MHKarami97.snk</AssemblyOriginatorKeyFile>
 		<PublicSign>true</PublicSign>

CacheManager/CacheSource/ICacheSourceBase.cs

@@ -11,7 +11,7 @@ public interface ICacheSourceBase : IAsyncDisposable
 	/// Stop cache source
 	/// </summary>
 	/// <returns></returns>
-	Task StopAsync();
+	public Task StopAsync();
 
 	/// <summary>
 	/// Priority, Lowest priority - checked last
@@ -20,6 +20,7 @@ public interface ICacheSourceBase : IAsyncDisposable
 	/// The value of <see cref="Priority"/> should be between 1 and 100.
 	/// </remarks>
 	[Range(1, 100)]
+	public
 #if NET8_0_OR_GREATER
 	int Priority { get; init; }
 #else

CacheManager/CacheSource/ICacheSourceWithGet.cs

@@ -10,5 +10,5 @@ public interface ICacheSourceWithGet : ICacheSourceBase
 	/// </summary>
 	/// <param name="key">Key</param>
 	/// <returns>Result</returns>
-	Task<T?> GetAsync<T>(string key);
+	public Task<T?> GetAsync<T>(string key);
 }

CacheManager/CacheSource/ICacheSourceWithGetWithClear.cs

@@ -9,10 +9,10 @@ public interface ICacheSourceWithGetWithClear : ICacheSourceWithGet
 	/// Clear from cache with key
 	/// </summary>
 	/// <param name="key"></param>
-	Task ClearAsync(string key);
+	public Task ClearAsync(string key);
 
 	/// <summary>
 	/// Clear all from cache
 	/// </summary>
-	Task ClearAllAsync();
+	public Task ClearAllAsync();
 }

CacheManager/CacheSource/ICacheSourceWithGetWithSet.cs

@@ -10,5 +10,5 @@ public interface ICacheSourceWithGetWithSet : ICacheSourceWithGet
 	/// </summary>
 	/// <param name="key">Key</param>
 	/// <param name="data">Data to cache</param>
-	Task SetAsync<T>(string key, T data);
+	public Task SetAsync<T>(string key, T data);
 }

CacheManager/Config/LockConfig.cs

@@ -5,15 +5,6 @@
 /// </summary>
 public class LockConfig
 {
-	/// <summary>
-	/// The maximum number of requests for the semaphore that can be granted concurrently. Defaults to 1.
-	/// </summary>
-#if NET8_0_OR_GREATER
-	public int MaxCount { get; init; } = 1;
-#else
-	public int MaxCount { get; set; } = 1;
-#endif
-
 	/// <summary>
 	/// The size of the pool to use in order for generated objects to be reused. This is NOT a concurrency limit,
 	/// but if the pool is empty then a new object will be created rather than waiting for an object to return to

CacheManager/EasyCacheManager.cs

@@ -49,7 +49,7 @@
 
 		if (duplicatePriorities.Count != 0)
 		{
 			throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.Duplicate_priority, string.Join(", ", duplicatePriorities)), nameof(cacheSources));
 		}
 
 		_cacheSources = baseCacheSources.OrderBy(x => x.Priority);
@@ -58,7 +58,9 @@
 
 		_asyncLock = new AsyncKeyedLocker<string>(new AsyncKeyedLockOptions
 		{
-			PoolSize = Environment.ProcessorCount * lockConfig.PoolSize, PoolInitialFill = lockConfig.PoolInitialFill, MaxCount = lockConfig.MaxCount
+			PoolSize = Environment.ProcessorCount * lockConfig.PoolSize,
+			PoolInitialFill = lockConfig.PoolInitialFill,
+			MaxCount = 1
 		});
 
 		_ongoingOperations = new ConcurrentDictionary<string, Task>();

CacheManager/IEasyCacheManager.cs

@@ -10,30 +10,30 @@ public interface IEasyCacheManager : IAsyncDisposable
 	/// </summary>
 	/// <param name="key">Key</param>
 	/// <returns>cached item</returns>
-	Task<T?> GetAsync<T>(string key);
+	public Task<T?> GetAsync<T>(string key);
 
 	/// <summary>
 	/// Manual set value to cache
 	/// </summary>
 	/// <param name="key">Key</param>
 	/// <param name="value">Value</param>
 	/// <returns>cached item</returns>
-	Task SetAsync<T>(string key, T value);
+	public Task SetAsync<T>(string key, T value);
 
 	/// <summary>
 	/// Clear cached item by key
 	/// </summary>
 	/// <param name="key">Key</param>
-	Task ClearCacheAsync(string key);
+	public Task ClearCacheAsync(string key);
 
 	/// <summary>
 	/// Clear cached item from all
 	/// </summary>
-	Task ClearAllCacheAsync();
+	public Task ClearAllCacheAsync();
 
 	/// <summary>
 	/// Stop all cache sources
 	/// </summary>
 	/// <returns></returns>
-	Task StopAsync();
+	public Task StopAsync();
 }

CacheManagerClear/ICachePublisher.cs

@@ -11,17 +11,17 @@ public interface ICachePublisher : IAsyncDisposable
 	/// <param name="key">key</param>
 	/// <param name="cancellationToken">CancellationToken</param>
 	/// <returns></returns>
-	Task PublishClearCacheAsync(string key, CancellationToken? cancellationToken);
+	public Task PublishClearCacheAsync(string key, CancellationToken? cancellationToken);
 
 	/// <summary>
 	/// Publish clear all cached event
 	/// </summary>
 	/// <returns></returns>
-	Task PublishClearAllCacheAsync(CancellationToken? cancellationToken);
+	public Task PublishClearAllCacheAsync(CancellationToken? cancellationToken);
 
 	/// <summary>
 	/// Stops the Kafka subscription process
 	/// </summary>
 	/// <returns></returns>
-	Task StopAsync();
+	public Task StopAsync();
 }

CacheManagerClear/ICacheSubscriber.cs

@@ -8,11 +8,11 @@ public interface ICacheSubscriber : IAsyncDisposable
 	/// <summary>
 	/// Subscriber for cache clear event
 	/// </summary>
-	Task SubscribeAsync(CancellationToken cancellationToken);
+	public Task SubscribeAsync(CancellationToken cancellationToken);
 
 	/// <summary>
 	/// Stops the subscription process
 	/// </summary>
 	/// <returns></returns>
-	Task StopAsync();
+	public Task StopAsync();
 }

CacheManagerUnitTest/EasyCacheManagerTests.cs

@@ -11,7 +11,7 @@ public class EasyCacheManagerTests : IAsyncLifetime
 
 	public Task InitializeAsync()
 	{
-		_lockConfig = new LockConfig { PoolSize = 1, PoolInitialFill = 1, MaxCount = 1, TimeOut = TimeSpan.FromSeconds(5) };
+		_lockConfig = new LockConfig { PoolSize = 1, PoolInitialFill = 1, TimeOut = TimeSpan.FromSeconds(5) };
 
 		return Task.CompletedTask;
 	}