Add .ConfigureAwait(false) to awaited calls (#290)

wazzamatazz · web-flow · commit 87de1695dc9b · 2024-08-01T00:19:50.000+09:30
diff --git a/src/CacheTower.Extensions.Redis/RedisLockExtension.cs b/src/CacheTower.Extensions.Redis/RedisLockExtension.cs
@@ -70,8 +70,8 @@ public void Register(ICacheStack cacheStack)
 	private async ValueTask ReleaseLockAsync(string cacheKey)
 	{
 		var lockKey = string.Format(Options.KeyFormat, cacheKey);
-		await Subscriber.PublishAsync(GetRedisChannel(), cacheKey, CommandFlags.FireAndForget);
-		await Database.KeyDeleteAsync(lockKey, CommandFlags.FireAndForget);
+		await Subscriber.PublishAsync(GetRedisChannel(), cacheKey, CommandFlags.FireAndForget).ConfigureAwait(false);
+		await Database.KeyDeleteAsync(lockKey, CommandFlags.FireAndForget).ConfigureAwait(false);
 		UnlockWaitingTasks(cacheKey);
 	}
 
@@ -86,7 +86,7 @@ private async ValueTask SpinWaitAsync(TaskCompletionSource<bool> taskCompletionS
 			var lockExists = await Database.KeyExistsAsync(lockKey).ConfigureAwait(false);
 			if (lockExists)
 			{
-				await Task.Delay(Options.LockCheckStrategy.SpinTime);
+				await Task.Delay(Options.LockCheckStrategy.SpinTime).ConfigureAwait(false);
 				continue;
 			}
 
@@ -107,7 +107,7 @@ private async ValueTask DelayWaitAsync(TaskCompletionSource<bool> taskCompletion
 	public async ValueTask<DistributedLock> AwaitAccessAsync(string cacheKey)
 	{
 		var lockKey = string.Format(Options.KeyFormat, cacheKey);
-		var hasLock = await Database.StringSetAsync(lockKey, RedisValue.EmptyString, expiry: Options.LockTimeout, when: When.NotExists);
+		var hasLock = await Database.StringSetAsync(lockKey, RedisValue.EmptyString, expiry: Options.LockTimeout, when: When.NotExists).ConfigureAwait(false);
 		
 		if (hasLock)
 		{
@@ -132,13 +132,13 @@ public async ValueTask<DistributedLock> AwaitAccessAsync(string cacheKey)
 			});
 
 			//Last minute check to confirm whether waiting is required (in case the notification is missed)
-			if (!await Database.KeyExistsAsync(lockKey))
+			if (!await Database.KeyExistsAsync(lockKey).ConfigureAwait(false))
 			{
 				UnlockWaitingTasks(cacheKey);
 				return DistributedLock.Unlocked(cacheKey);
 			}
 
-			await completionSource.Task;
+			await completionSource.Task.ConfigureAwait(false);
 			return DistributedLock.Unlocked(cacheKey);
 		}
 	}
diff --git a/src/CacheTower.Extensions.Redis/RedisRemoteEvictionExtension.cs b/src/CacheTower.Extensions.Redis/RedisRemoteEvictionExtension.cs
@@ -72,7 +72,7 @@ private async ValueTask FlagEvictionAsync(string cacheKey)
 				FlaggedEvictions.Add(cacheKey);
 			}
 
-			await Subscriber.PublishAsync(EvictionChannel, cacheKey, CommandFlags.FireAndForget);
+			await Subscriber.PublishAsync(EvictionChannel, cacheKey, CommandFlags.FireAndForget).ConfigureAwait(false);
 		}
 
 		/// <remarks>
@@ -86,7 +86,7 @@ public async ValueTask OnCacheFlushAsync()
 				HasFlushTriggered = true;
 			}
 
-			await Subscriber.PublishAsync(FlushChannel, RedisValue.EmptyString, CommandFlags.FireAndForget);
+			await Subscriber.PublishAsync(FlushChannel, RedisValue.EmptyString, CommandFlags.FireAndForget).ConfigureAwait(false);
 		}
 
 		/// <inheritdoc/>
@@ -122,7 +122,7 @@ public void Register(ICacheStack cacheStack)
 							var cacheLayer = cacheLayers[i];
 							if (cacheLayer is ILocalCacheLayer)
 							{
-								await cacheLayer.EvictAsync(cacheKey);
+								await cacheLayer.EvictAsync(cacheKey).ConfigureAwait(false);
 							}
 						}
 					}
@@ -146,7 +146,7 @@ public void Register(ICacheStack cacheStack)
 							var cacheLayer = cacheLayers[i];
 							if (cacheLayer is ILocalCacheLayer)
 							{
-								await cacheLayer.FlushAsync();
+								await cacheLayer.FlushAsync().ConfigureAwait(false);
 							}
 						}
 					}
diff --git a/src/CacheTower.Providers.Database.MongoDB/MongoDbCacheLayer.cs b/src/CacheTower.Providers.Database.MongoDB/MongoDbCacheLayer.cs
@@ -46,34 +46,34 @@ private async ValueTask TryConfigureIndexes()
 			if (!HasSetIndexes)
 			{
 				HasSetIndexes = true;
-				await EntityIndexWriter.ApplyIndexingAsync<DbCachedEntry>(Connection);
+				await EntityIndexWriter.ApplyIndexingAsync<DbCachedEntry>(Connection).ConfigureAwait(false);
 			}
 		}
 
 		/// <inheritdoc/>
 		public async ValueTask CleanupAsync()
 		{
-			await TryConfigureIndexes();
-			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new CleanupCommand() }, default);
+			await TryConfigureIndexes().ConfigureAwait(false);
+			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new CleanupCommand() }, default).ConfigureAwait(false);
 		}
 
 		/// <inheritdoc/>
 		public async ValueTask EvictAsync(string cacheKey)
 		{
-			await TryConfigureIndexes();
-			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new EvictCommand(cacheKey) }, default);
+			await TryConfigureIndexes().ConfigureAwait(false);
+			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new EvictCommand(cacheKey) }, default).ConfigureAwait(false);
 		}
 
 		/// <inheritdoc/>
 		public async ValueTask FlushAsync()
 		{
-			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new FlushCommand() }, default);
+			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new FlushCommand() }, default).ConfigureAwait(false);
 		}
 
 		/// <inheritdoc/>
 		public async ValueTask<CacheEntry<T>?> GetAsync<T>(string cacheKey)
 		{
-			await TryConfigureIndexes();
+			await TryConfigureIndexes().ConfigureAwait(false);
 
 			var provider = new MongoFrameworkQueryProvider<DbCachedEntry>(Connection);
 			var queryable = new MongoFrameworkQueryable<DbCachedEntry>(provider);
@@ -92,15 +92,15 @@ public async ValueTask FlushAsync()
 		/// <inheritdoc/>
 		public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)
 		{
-			await TryConfigureIndexes();
+			await TryConfigureIndexes().ConfigureAwait(false);
 			var command = new SetCommand(new DbCachedEntry
 			{
 				CacheKey = cacheKey,
 				Expiry = cacheEntry.Expiry,
 				Value = cacheEntry.Value!
 			});
 
-			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { command }, default);
+			await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { command }, default).ConfigureAwait(false);
 		}
 
 		/// <inheritdoc/>
@@ -110,7 +110,7 @@ public async ValueTask<bool> IsAvailableAsync(string cacheKey)
 			{
 				try
 				{
-					await TryConfigureIndexes();
+					await TryConfigureIndexes().ConfigureAwait(false);
 					IsDatabaseAvailable = true;
 				}
 				catch
diff --git a/src/CacheTower.Providers.Redis/RedisCacheLayer.cs b/src/CacheTower.Providers.Redis/RedisCacheLayer.cs
@@ -52,7 +52,7 @@ public ValueTask CleanupAsync()
 		/// <inheritdoc/>
 		public async ValueTask EvictAsync(string cacheKey)
 		{
-			await Database.KeyDeleteAsync(cacheKey);
+			await Database.KeyDeleteAsync(cacheKey).ConfigureAwait(false);
 		}
 
 		/// <inheritdoc/>
@@ -65,14 +65,14 @@ public async ValueTask FlushAsync()
 			var redisEndpoints = Connection.GetEndPoints();
 			foreach (var endpoint in redisEndpoints)
 			{
-				await Connection.GetServer(endpoint).FlushDatabaseAsync(Options.DatabaseIndex);
+				await Connection.GetServer(endpoint).FlushDatabaseAsync(Options.DatabaseIndex).ConfigureAwait(false);
 			}
 		}
 
 		/// <inheritdoc/>
 		public async ValueTask<CacheEntry<T>?> GetAsync<T>(string cacheKey)
 		{
-			var redisValue = await Database.StringGetAsync(cacheKey);
+			var redisValue = await Database.StringGetAsync(cacheKey).ConfigureAwait(false);
 			if (redisValue != RedisValue.Null)
 			{
 				using var stream = new MemoryStream(redisValue);
@@ -101,7 +101,7 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)
 			Options.Serializer.Serialize(stream, cacheEntry);
 			stream.Seek(0, SeekOrigin.Begin);
 			var redisValue = RedisValue.CreateFrom(stream);
-			await Database.StringSetAsync(cacheKey, redisValue, expiryOffset);
+			await Database.StringSetAsync(cacheKey, redisValue, expiryOffset).ConfigureAwait(false);
 		}
 	}
 }
diff --git a/src/CacheTower/CacheStack.cs b/src/CacheTower/CacheStack.cs
@@ -106,10 +106,10 @@ public async ValueTask FlushAsync()
 		for (int i = 0, l = CacheLayers.Length; i < l; i++)
 		{
 			var layer = CacheLayers[i];
-			await layer.FlushAsync();
+			await layer.FlushAsync().ConfigureAwait(false);
 		}
 
-		await Extensions.OnCacheFlushAsync();
+		await Extensions.OnCacheFlushAsync().ConfigureAwait(false);
 	}
 
 	/// <inheritdoc/>
@@ -120,7 +120,7 @@ public async ValueTask CleanupAsync()
 		for (int i = 0, l = CacheLayers.Length; i < l; i++)
 		{
 			var layer = CacheLayers[i];
-			await layer.CleanupAsync();
+			await layer.CleanupAsync().ConfigureAwait(false);
 		}
 	}
 
@@ -137,10 +137,10 @@ public async ValueTask EvictAsync(string cacheKey)
 		for (int i = 0, l = CacheLayers.Length; i < l; i++)
 		{
 			var layer = CacheLayers[i];
-			await layer.EvictAsync(cacheKey);
+			await layer.EvictAsync(cacheKey).ConfigureAwait(false);
 		}
 
-		await Extensions.OnCacheEvictionAsync(cacheKey);
+		await Extensions.OnCacheEvictionAsync(cacheKey).ConfigureAwait(false);
 	}
 
 	/// <inheritdoc/>
@@ -154,7 +154,7 @@ public async ValueTask<CacheEntry<T>> SetAsync<T>(string cacheKey, T value, Time
 		}
 
 		var cacheEntry = new CacheEntry<T>(value, timeToLive);
-		await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry);
+		await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry).ConfigureAwait(false);
 		return cacheEntry;
 	}
 
@@ -173,7 +173,7 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)
 			throw new ArgumentNullException(nameof(cacheEntry));
 		}
 
-		await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry);
+		await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry).ConfigureAwait(false);
 	}
 
 	private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry, CacheUpdateType cacheUpdateType)
@@ -184,15 +184,15 @@ private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cache
 
 			try
 			{
-				await layer.SetAsync(cacheKey, cacheEntry);
+				await layer.SetAsync(cacheKey, cacheEntry).ConfigureAwait(false);
 			}
 			catch (CacheSerializationException ex)
 			{
 				Logger.LogWarning(ex, "Unable to set CacheKey={CacheKey} on CacheLayer={CacheLayer} due to an exception. This will result in cache misses on this layer.", cacheKey, layer.GetType());
 			}
 		}
 
-		await Extensions.OnCacheUpdateAsync(cacheKey, cacheEntry.Expiry, cacheUpdateType);
+		await Extensions.OnCacheUpdateAsync(cacheKey, cacheEntry.Expiry, cacheUpdateType).ConfigureAwait(false);
 	}
 
 	/// <inheritdoc/>
@@ -208,11 +208,11 @@ private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cache
 		for (var layerIndex = 0; layerIndex < CacheLayers.Length; layerIndex++)
 		{
 			var layer = CacheLayers[layerIndex];
-			if (await layer.IsAvailableAsync(cacheKey))
+			if (await layer.IsAvailableAsync(cacheKey).ConfigureAwait(false))
 			{
 				try
 				{
-					var cacheEntry = await layer.GetAsync<T>(cacheKey);
+					var cacheEntry = await layer.GetAsync<T>(cacheKey).ConfigureAwait(false);
 					if (cacheEntry != default)
 					{
 						return cacheEntry;
@@ -234,11 +234,11 @@ private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cache
 		for (var layerIndex = 0; layerIndex < CacheLayers.Length; layerIndex++)
 		{
 			var layer = CacheLayers[layerIndex];
-			if (await layer.IsAvailableAsync(cacheKey))
+			if (await layer.IsAvailableAsync(cacheKey).ConfigureAwait(false))
 			{
 				try
 				{
-					var cacheEntry = await layer.GetAsync<T>(cacheKey);
+					var cacheEntry = await layer.GetAsync<T>(cacheKey).ConfigureAwait(false);
 					if (cacheEntry != default)
 					{
 						return (layerIndex, cacheEntry);
@@ -270,7 +270,7 @@ public async ValueTask<T> GetOrSetAsync<T>(string cacheKey, Func<T, Task<T>> val
 		}
 
 		var currentTime = DateTimeProvider.Now;
-		var cacheEntryPoint = await GetWithLayerIndexAsync<T>(cacheKey);
+		var cacheEntryPoint = await GetWithLayerIndexAsync<T>(cacheKey).ConfigureAwait(false);
 		var cacheEntryStatus = CacheEntryStatus.Stale;
 		if (cacheEntryPoint != default)
 		{
@@ -302,7 +302,7 @@ public async ValueTask<T> GetOrSetAsync<T>(string cacheKey, Func<T, Task<T>> val
 			cacheEntryStatus = CacheEntryStatus.Miss;
 		}
 
-		return (await RefreshValueAsync(cacheKey, valueFactory, settings, cacheEntryStatus))!.Value!;
+		return (await RefreshValueAsync(cacheKey, valueFactory, settings, cacheEntryStatus).ConfigureAwait(false))!.Value!;
 	}
 
 	private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string cacheKey, CacheEntry<T> cacheEntry)
@@ -314,9 +314,9 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string
 				for (; --fromIndexExclusive >= 0;)
 				{
 					var previousLayer = CacheLayers[fromIndexExclusive];
-					if (await previousLayer.IsAvailableAsync(cacheKey))
+					if (await previousLayer.IsAvailableAsync(cacheKey).ConfigureAwait(false))
 					{
-						await previousLayer.SetAsync(cacheKey, cacheEntry);
+						await previousLayer.SetAsync(cacheKey, cacheEntry).ConfigureAwait(false);
 					}
 				}
 			}
@@ -333,7 +333,7 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string
 		{
 			try
 			{
-				var previousEntry = await GetAsync<T>(cacheKey);
+				var previousEntry = await GetAsync<T>(cacheKey).ConfigureAwait(false);
 				if (previousEntry != default && entryStatus == CacheEntryStatus.Miss && previousEntry.Expiry >= DateTimeProvider.Now)
 				{
 					//The Cache Stack will always return an unexpired value if one exists.
@@ -344,26 +344,26 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string
 					return previousEntry;
 				}
 
-				await using var distributedLock = await Extensions.AwaitAccessAsync(cacheKey);
+				await using var distributedLock = await Extensions.AwaitAccessAsync(cacheKey).ConfigureAwait(false);
 
 				CacheEntry<T>? cacheEntry;
 				if (distributedLock.IsLockOwner)
 				{
 					var oldValue = previousEntry != default ? previousEntry.Value : default;
-					var refreshedValue = await asyncValueFactory(oldValue!);
+					var refreshedValue = await asyncValueFactory(oldValue!).ConfigureAwait(false);
 					cacheEntry = new CacheEntry<T>(refreshedValue, settings.TimeToLive);
 					var cacheUpdateType = entryStatus switch
 					{
 						CacheEntryStatus.Miss => CacheUpdateType.AddEntry,
 						_ => CacheUpdateType.AddOrUpdateEntry
 					};
-					await InternalSetAsync(cacheKey, cacheEntry, cacheUpdateType);
+					await InternalSetAsync(cacheKey, cacheEntry, cacheUpdateType).ConfigureAwait(false);
 
 					KeyLock.ReleaseLock(cacheKey, cacheEntry);
 				}
 				else
 				{
-					cacheEntry = await GetAsync<T>(cacheKey);
+					cacheEntry = await GetAsync<T>(cacheKey).ConfigureAwait(false);
 				}
 
 				return cacheEntry;
@@ -377,15 +377,15 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string
 		else if (entryStatus != CacheEntryStatus.Stale)
 		{
 			//Last minute check to confirm whether waiting is required
-			var currentEntry = await GetAsync<T>(cacheKey);
+			var currentEntry = await GetAsync<T>(cacheKey).ConfigureAwait(false);
 			if (currentEntry != null && currentEntry.GetStaleDate(settings) > DateTimeProvider.Now)
 			{
 				KeyLock.ReleaseLock(cacheKey, currentEntry);
 				return currentEntry;
 			}
 
 			//Lock until we are notified to be unlocked
-			return await KeyLock.WaitAsync(cacheKey) as CacheEntry<T>;
+			return await KeyLock.WaitAsync(cacheKey).ConfigureAwait(false) as CacheEntry<T>;
 		}
 
 		return default;
@@ -410,11 +410,11 @@ public async ValueTask DisposeAsync()
 			}
 			else if (layer is IAsyncDisposable asyncDisposableLayer)
 			{
-				await asyncDisposableLayer.DisposeAsync();
+				await asyncDisposableLayer.DisposeAsync().ConfigureAwait(false);
 			}
 		}
 
-		await Extensions.DisposeAsync();
+		await Extensions.DisposeAsync().ConfigureAwait(false);
 
 		Disposed = true;
 	}
diff --git a/src/CacheTower/CacheStack{TContext}.cs b/src/CacheTower/CacheStack{TContext}.cs
@@ -57,7 +57,7 @@ public async ValueTask<T> GetOrSetAsync<T>(string cacheKey, Func<T, TContext, Ta
 		{
 			using var scope = CacheContextActivator.BeginScope();
 			var context = (TContext)scope.Resolve(typeof(TContext));
-			return await getter(old, context);
-		}, settings);
+			return await getter(old, context).ConfigureAwait(false);
+		}, settings).ConfigureAwait(false);
 	}
 }
diff --git a/src/CacheTower/Extensions/AutoCleanupExtension.cs b/src/CacheTower/Extensions/AutoCleanupExtension.cs
diff --git a/src/CacheTower/Extensions/ExtensionContainer.cs b/src/CacheTower/Extensions/ExtensionContainer.cs
diff --git a/src/CacheTower/Providers/FileSystem/FileCacheLayer.cs b/src/CacheTower/Providers/FileSystem/FileCacheLayer.cs

Original file line number	Diff line number	Diff line change
`@@ -70,8 +70,8 @@ public void Register(ICacheStack cacheStack)`
`70`	`70`	`private async ValueTask ReleaseLockAsync(string cacheKey)`
`71`	`71`	`{`
`72`	`72`	`var lockKey = string.Format(Options.KeyFormat, cacheKey);`
`73`		`- await Subscriber.PublishAsync(GetRedisChannel(), cacheKey, CommandFlags.FireAndForget);`
`74`		`- await Database.KeyDeleteAsync(lockKey, CommandFlags.FireAndForget);`
	`73`	`+ await Subscriber.PublishAsync(GetRedisChannel(), cacheKey, CommandFlags.FireAndForget).ConfigureAwait(false);`
	`74`	`+ await Database.KeyDeleteAsync(lockKey, CommandFlags.FireAndForget).ConfigureAwait(false);`
`75`	`75`	`UnlockWaitingTasks(cacheKey);`
`76`	`76`	`}`
`77`	`77`
`@@ -86,7 +86,7 @@ private async ValueTask SpinWaitAsync(TaskCompletionSource<bool> taskCompletionS`
`86`	`86`	`var lockExists = await Database.KeyExistsAsync(lockKey).ConfigureAwait(false);`
`87`	`87`	`if (lockExists)`
`88`	`88`	`{`
`89`		`- await Task.Delay(Options.LockCheckStrategy.SpinTime);`
	`89`	`+ await Task.Delay(Options.LockCheckStrategy.SpinTime).ConfigureAwait(false);`
`90`	`90`	`continue;`
`91`	`91`	`}`
`92`	`92`
`@@ -107,7 +107,7 @@ private async ValueTask DelayWaitAsync(TaskCompletionSource<bool> taskCompletion`
`107`	`107`	`public async ValueTask<DistributedLock> AwaitAccessAsync(string cacheKey)`
`108`	`108`	`{`
`109`	`109`	`var lockKey = string.Format(Options.KeyFormat, cacheKey);`
`110`		`- var hasLock = await Database.StringSetAsync(lockKey, RedisValue.EmptyString, expiry: Options.LockTimeout, when: When.NotExists);`
	`110`	`+ var hasLock = await Database.StringSetAsync(lockKey, RedisValue.EmptyString, expiry: Options.LockTimeout, when: When.NotExists).ConfigureAwait(false);`
`111`	`111`
`112`	`112`	`if (hasLock)`
`113`	`113`	`{`
`@@ -132,13 +132,13 @@ public async ValueTask<DistributedLock> AwaitAccessAsync(string cacheKey)`
`132`	`132`	`});`
`133`	`133`
`134`	`134`	`//Last minute check to confirm whether waiting is required (in case the notification is missed)`
`135`		`- if (!await Database.KeyExistsAsync(lockKey))`
	`135`	`+ if (!await Database.KeyExistsAsync(lockKey).ConfigureAwait(false))`
`136`	`136`	`{`
`137`	`137`	`UnlockWaitingTasks(cacheKey);`
`138`	`138`	`return DistributedLock.Unlocked(cacheKey);`
`139`	`139`	`}`
`140`	`140`
`141`		`- await completionSource.Task;`
	`141`	`+ await completionSource.Task.ConfigureAwait(false);`
`142`	`142`	`return DistributedLock.Unlocked(cacheKey);`
`143`	`143`	`}`
`144`	`144`	`}`
Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,7 @@ private async ValueTask FlagEvictionAsync(string cacheKey)`
`72`	`72`	`FlaggedEvictions.Add(cacheKey);`
`73`	`73`	`}`
`74`	`74`
`75`		`- await Subscriber.PublishAsync(EvictionChannel, cacheKey, CommandFlags.FireAndForget);`
	`75`	`+ await Subscriber.PublishAsync(EvictionChannel, cacheKey, CommandFlags.FireAndForget).ConfigureAwait(false);`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`/// <remarks>`
`@@ -86,7 +86,7 @@ public async ValueTask OnCacheFlushAsync()`
`86`	`86`	`HasFlushTriggered = true;`
`87`	`87`	`}`
`88`	`88`
`89`		`- await Subscriber.PublishAsync(FlushChannel, RedisValue.EmptyString, CommandFlags.FireAndForget);`
	`89`	`+ await Subscriber.PublishAsync(FlushChannel, RedisValue.EmptyString, CommandFlags.FireAndForget).ConfigureAwait(false);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`/// <inheritdoc/>`
`@@ -122,7 +122,7 @@ public void Register(ICacheStack cacheStack)`
`122`	`122`	`var cacheLayer = cacheLayers[i];`
`123`	`123`	`if (cacheLayer is ILocalCacheLayer)`
`124`	`124`	`{`
`125`		`- await cacheLayer.EvictAsync(cacheKey);`
	`125`	`+ await cacheLayer.EvictAsync(cacheKey).ConfigureAwait(false);`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`	`}`
`@@ -146,7 +146,7 @@ public void Register(ICacheStack cacheStack)`
`146`	`146`	`var cacheLayer = cacheLayers[i];`
`147`	`147`	`if (cacheLayer is ILocalCacheLayer)`
`148`	`148`	`{`
`149`		`- await cacheLayer.FlushAsync();`
	`149`	`+ await cacheLayer.FlushAsync().ConfigureAwait(false);`
`150`	`150`	`}`
`151`	`151`	`}`
`152`	`152`	`}`
Original file line number	Diff line number	Diff line change
`@@ -46,34 +46,34 @@ private async ValueTask TryConfigureIndexes()`
`46`	`46`	`if (!HasSetIndexes)`
`47`	`47`	`{`
`48`	`48`	`HasSetIndexes = true;`
`49`		`- await EntityIndexWriter.ApplyIndexingAsync<DbCachedEntry>(Connection);`
	`49`	`+ await EntityIndexWriter.ApplyIndexingAsync<DbCachedEntry>(Connection).ConfigureAwait(false);`
`50`	`50`	`}`
`51`	`51`	`}`
`52`	`52`
`53`	`53`	`/// <inheritdoc/>`
`54`	`54`	`public async ValueTask CleanupAsync()`
`55`	`55`	`{`
`56`		`- await TryConfigureIndexes();`
`57`		`- await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new CleanupCommand() }, default);`
	`56`	`+ await TryConfigureIndexes().ConfigureAwait(false);`
	`57`	`+ await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new CleanupCommand() }, default).ConfigureAwait(false);`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`/// <inheritdoc/>`
`61`	`61`	`public async ValueTask EvictAsync(string cacheKey)`
`62`	`62`	`{`
`63`		`- await TryConfigureIndexes();`
`64`		`- await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new EvictCommand(cacheKey) }, default);`
	`63`	`+ await TryConfigureIndexes().ConfigureAwait(false);`
	`64`	`+ await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new EvictCommand(cacheKey) }, default).ConfigureAwait(false);`
`65`	`65`	`}`
`66`	`66`
`67`	`67`	`/// <inheritdoc/>`
`68`	`68`	`public async ValueTask FlushAsync()`
`69`	`69`	`{`
`70`		`- await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new FlushCommand() }, default);`
	`70`	`+ await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { new FlushCommand() }, default).ConfigureAwait(false);`
`71`	`71`	`}`
`72`	`72`
`73`	`73`	`/// <inheritdoc/>`
`74`	`74`	`public async ValueTask<CacheEntry<T>?> GetAsync<T>(string cacheKey)`
`75`	`75`	`{`
`76`		`- await TryConfigureIndexes();`
	`76`	`+ await TryConfigureIndexes().ConfigureAwait(false);`
`77`	`77`
`78`	`78`	`var provider = new MongoFrameworkQueryProvider<DbCachedEntry>(Connection);`
`79`	`79`	`var queryable = new MongoFrameworkQueryable<DbCachedEntry>(provider);`
`@@ -92,15 +92,15 @@ public async ValueTask FlushAsync()`
`92`	`92`	`/// <inheritdoc/>`
`93`	`93`	`public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)`
`94`	`94`	`{`
`95`		`- await TryConfigureIndexes();`
	`95`	`+ await TryConfigureIndexes().ConfigureAwait(false);`
`96`	`96`	`var command = new SetCommand(new DbCachedEntry`
`97`	`97`	`{`
`98`	`98`	`CacheKey = cacheKey,`
`99`	`99`	`Expiry = cacheEntry.Expiry,`
`100`	`100`	`Value = cacheEntry.Value!`
`101`	`101`	`});`
`102`	`102`
`103`		`- await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { command }, default);`
	`103`	`+ await EntityCommandWriter.WriteAsync<DbCachedEntry>(Connection, new[] { command }, default).ConfigureAwait(false);`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`/// <inheritdoc/>`
`@@ -110,7 +110,7 @@ public async ValueTask<bool> IsAvailableAsync(string cacheKey)`
`110`	`110`	`{`
`111`	`111`	`try`
`112`	`112`	`{`
`113`		`- await TryConfigureIndexes();`
	`113`	`+ await TryConfigureIndexes().ConfigureAwait(false);`
`114`	`114`	`IsDatabaseAvailable = true;`
`115`	`115`	`}`
`116`	`116`	`catch`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ public ValueTask CleanupAsync()`
`52`	`52`	`/// <inheritdoc/>`
`53`	`53`	`public async ValueTask EvictAsync(string cacheKey)`
`54`	`54`	`{`
`55`		`- await Database.KeyDeleteAsync(cacheKey);`
	`55`	`+ await Database.KeyDeleteAsync(cacheKey).ConfigureAwait(false);`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`/// <inheritdoc/>`
`@@ -65,14 +65,14 @@ public async ValueTask FlushAsync()`
`65`	`65`	`var redisEndpoints = Connection.GetEndPoints();`
`66`	`66`	`foreach (var endpoint in redisEndpoints)`
`67`	`67`	`{`
`68`		`- await Connection.GetServer(endpoint).FlushDatabaseAsync(Options.DatabaseIndex);`
	`68`	`+ await Connection.GetServer(endpoint).FlushDatabaseAsync(Options.DatabaseIndex).ConfigureAwait(false);`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`/// <inheritdoc/>`
`73`	`73`	`public async ValueTask<CacheEntry<T>?> GetAsync<T>(string cacheKey)`
`74`	`74`	`{`
`75`		`- var redisValue = await Database.StringGetAsync(cacheKey);`
	`75`	`+ var redisValue = await Database.StringGetAsync(cacheKey).ConfigureAwait(false);`
`76`	`76`	`if (redisValue != RedisValue.Null)`
`77`	`77`	`{`
`78`	`78`	`using var stream = new MemoryStream(redisValue);`
`@@ -101,7 +101,7 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)`
`101`	`101`	`Options.Serializer.Serialize(stream, cacheEntry);`
`102`	`102`	`stream.Seek(0, SeekOrigin.Begin);`
`103`	`103`	`var redisValue = RedisValue.CreateFrom(stream);`
`104`		`- await Database.StringSetAsync(cacheKey, redisValue, expiryOffset);`
	`104`	`+ await Database.StringSetAsync(cacheKey, redisValue, expiryOffset).ConfigureAwait(false);`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`	`}`
Original file line number	Diff line number	Diff line change
`@@ -106,10 +106,10 @@ public async ValueTask FlushAsync()`
`106`	`106`	`for (int i = 0, l = CacheLayers.Length; i < l; i++)`
`107`	`107`	`{`
`108`	`108`	`var layer = CacheLayers[i];`
`109`		`- await layer.FlushAsync();`
	`109`	`+ await layer.FlushAsync().ConfigureAwait(false);`
`110`	`110`	`}`
`111`	`111`
`112`		`- await Extensions.OnCacheFlushAsync();`
	`112`	`+ await Extensions.OnCacheFlushAsync().ConfigureAwait(false);`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`/// <inheritdoc/>`
`@@ -120,7 +120,7 @@ public async ValueTask CleanupAsync()`
`120`	`120`	`for (int i = 0, l = CacheLayers.Length; i < l; i++)`
`121`	`121`	`{`
`122`	`122`	`var layer = CacheLayers[i];`
`123`		`- await layer.CleanupAsync();`
	`123`	`+ await layer.CleanupAsync().ConfigureAwait(false);`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`@@ -137,10 +137,10 @@ public async ValueTask EvictAsync(string cacheKey)`
`137`	`137`	`for (int i = 0, l = CacheLayers.Length; i < l; i++)`
`138`	`138`	`{`
`139`	`139`	`var layer = CacheLayers[i];`
`140`		`- await layer.EvictAsync(cacheKey);`
	`140`	`+ await layer.EvictAsync(cacheKey).ConfigureAwait(false);`
`141`	`141`	`}`
`142`	`142`
`143`		`- await Extensions.OnCacheEvictionAsync(cacheKey);`
	`143`	`+ await Extensions.OnCacheEvictionAsync(cacheKey).ConfigureAwait(false);`
`144`	`144`	`}`
`145`	`145`
`146`	`146`	`/// <inheritdoc/>`
`@@ -154,7 +154,7 @@ public async ValueTask<CacheEntry<T>> SetAsync<T>(string cacheKey, T value, Time`
`154`	`154`	`}`
`155`	`155`
`156`	`156`	`var cacheEntry = new CacheEntry<T>(value, timeToLive);`
`157`		`- await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry);`
	`157`	`+ await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry).ConfigureAwait(false);`
`158`	`158`	`return cacheEntry;`
`159`	`159`	`}`
`160`	`160`
`@@ -173,7 +173,7 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)`
`173`	`173`	`throw new ArgumentNullException(nameof(cacheEntry));`
`174`	`174`	`}`
`175`	`175`
`176`		`- await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry);`
	`176`	`+ await InternalSetAsync(cacheKey, cacheEntry, CacheUpdateType.AddOrUpdateEntry).ConfigureAwait(false);`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry, CacheUpdateType cacheUpdateType)`
`@@ -184,15 +184,15 @@ private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cache`
`184`	`184`
`185`	`185`	`try`
`186`	`186`	`{`
`187`		`- await layer.SetAsync(cacheKey, cacheEntry);`
	`187`	`+ await layer.SetAsync(cacheKey, cacheEntry).ConfigureAwait(false);`
`188`	`188`	`}`
`189`	`189`	`catch (CacheSerializationException ex)`
`190`	`190`	`{`
`191`	`191`	`Logger.LogWarning(ex, "Unable to set CacheKey={CacheKey} on CacheLayer={CacheLayer} due to an exception. This will result in cache misses on this layer.", cacheKey, layer.GetType());`
`192`	`192`	`}`
`193`	`193`	`}`
`194`	`194`
`195`		`- await Extensions.OnCacheUpdateAsync(cacheKey, cacheEntry.Expiry, cacheUpdateType);`
	`195`	`+ await Extensions.OnCacheUpdateAsync(cacheKey, cacheEntry.Expiry, cacheUpdateType).ConfigureAwait(false);`
`196`	`196`	`}`
`197`	`197`
`198`	`198`	`/// <inheritdoc/>`
`@@ -208,11 +208,11 @@ private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cache`
`208`	`208`	`for (var layerIndex = 0; layerIndex < CacheLayers.Length; layerIndex++)`
`209`	`209`	`{`
`210`	`210`	`var layer = CacheLayers[layerIndex];`
`211`		`- if (await layer.IsAvailableAsync(cacheKey))`
	`211`	`+ if (await layer.IsAvailableAsync(cacheKey).ConfigureAwait(false))`
`212`	`212`	`{`
`213`	`213`	`try`
`214`	`214`	`{`
`215`		`- var cacheEntry = await layer.GetAsync<T>(cacheKey);`
	`215`	`+ var cacheEntry = await layer.GetAsync<T>(cacheKey).ConfigureAwait(false);`
`216`	`216`	`if (cacheEntry != default)`
`217`	`217`	`{`
`218`	`218`	`return cacheEntry;`
`@@ -234,11 +234,11 @@ private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cache`
`234`	`234`	`for (var layerIndex = 0; layerIndex < CacheLayers.Length; layerIndex++)`
`235`	`235`	`{`
`236`	`236`	`var layer = CacheLayers[layerIndex];`
`237`		`- if (await layer.IsAvailableAsync(cacheKey))`
	`237`	`+ if (await layer.IsAvailableAsync(cacheKey).ConfigureAwait(false))`
`238`	`238`	`{`
`239`	`239`	`try`
`240`	`240`	`{`
`241`		`- var cacheEntry = await layer.GetAsync<T>(cacheKey);`
	`241`	`+ var cacheEntry = await layer.GetAsync<T>(cacheKey).ConfigureAwait(false);`
`242`	`242`	`if (cacheEntry != default)`
`243`	`243`	`{`
`244`	`244`	`return (layerIndex, cacheEntry);`
`@@ -270,7 +270,7 @@ public async ValueTask<T> GetOrSetAsync<T>(string cacheKey, Func<T, Task<T>> val`
`270`	`270`	`}`
`271`	`271`
`272`	`272`	`var currentTime = DateTimeProvider.Now;`
`273`		`- var cacheEntryPoint = await GetWithLayerIndexAsync<T>(cacheKey);`
	`273`	`+ var cacheEntryPoint = await GetWithLayerIndexAsync<T>(cacheKey).ConfigureAwait(false);`
`274`	`274`	`var cacheEntryStatus = CacheEntryStatus.Stale;`
`275`	`275`	`if (cacheEntryPoint != default)`
`276`	`276`	`{`
`@@ -302,7 +302,7 @@ public async ValueTask<T> GetOrSetAsync<T>(string cacheKey, Func<T, Task<T>> val`
`302`	`302`	`cacheEntryStatus = CacheEntryStatus.Miss;`
`303`	`303`	`}`
`304`	`304`
`305`		`- return (await RefreshValueAsync(cacheKey, valueFactory, settings, cacheEntryStatus))!.Value!;`
	`305`	`+ return (await RefreshValueAsync(cacheKey, valueFactory, settings, cacheEntryStatus).ConfigureAwait(false))!.Value!;`
`306`	`306`	`}`
`307`	`307`
`308`	`308`	`private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string cacheKey, CacheEntry<T> cacheEntry)`
`@@ -314,9 +314,9 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string`
`314`	`314`	`for (; --fromIndexExclusive >= 0;)`
`315`	`315`	`{`
`316`	`316`	`var previousLayer = CacheLayers[fromIndexExclusive];`
`317`		`- if (await previousLayer.IsAvailableAsync(cacheKey))`
	`317`	`+ if (await previousLayer.IsAvailableAsync(cacheKey).ConfigureAwait(false))`
`318`	`318`	`{`
`319`		`- await previousLayer.SetAsync(cacheKey, cacheEntry);`
	`319`	`+ await previousLayer.SetAsync(cacheKey, cacheEntry).ConfigureAwait(false);`
`320`	`320`	`}`
`321`	`321`	`}`
`322`	`322`	`}`
`@@ -333,7 +333,7 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string`
`333`	`333`	`{`
`334`	`334`	`try`
`335`	`335`	`{`
`336`		`- var previousEntry = await GetAsync<T>(cacheKey);`
	`336`	`+ var previousEntry = await GetAsync<T>(cacheKey).ConfigureAwait(false);`
`337`	`337`	`if (previousEntry != default && entryStatus == CacheEntryStatus.Miss && previousEntry.Expiry >= DateTimeProvider.Now)`
`338`	`338`	`{`
`339`	`339`	`//The Cache Stack will always return an unexpired value if one exists.`
`@@ -344,26 +344,26 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string`
`344`	`344`	`return previousEntry;`
`345`	`345`	`}`
`346`	`346`
`347`		`- await using var distributedLock = await Extensions.AwaitAccessAsync(cacheKey);`
	`347`	`+ await using var distributedLock = await Extensions.AwaitAccessAsync(cacheKey).ConfigureAwait(false);`
`348`	`348`
`349`	`349`	`CacheEntry<T>? cacheEntry;`
`350`	`350`	`if (distributedLock.IsLockOwner)`
`351`	`351`	`{`
`352`	`352`	`var oldValue = previousEntry != default ? previousEntry.Value : default;`
`353`		`- var refreshedValue = await asyncValueFactory(oldValue!);`
	`353`	`+ var refreshedValue = await asyncValueFactory(oldValue!).ConfigureAwait(false);`
`354`	`354`	`cacheEntry = new CacheEntry<T>(refreshedValue, settings.TimeToLive);`
`355`	`355`	`var cacheUpdateType = entryStatus switch`
`356`	`356`	`{`
`357`	`357`	`CacheEntryStatus.Miss => CacheUpdateType.AddEntry,`
`358`	`358`	`_ => CacheUpdateType.AddOrUpdateEntry`
`359`	`359`	`};`
`360`		`- await InternalSetAsync(cacheKey, cacheEntry, cacheUpdateType);`
	`360`	`+ await InternalSetAsync(cacheKey, cacheEntry, cacheUpdateType).ConfigureAwait(false);`
`361`	`361`
`362`	`362`	`KeyLock.ReleaseLock(cacheKey, cacheEntry);`
`363`	`363`	`}`
`364`	`364`	`else`
`365`	`365`	`{`
`366`		`- cacheEntry = await GetAsync<T>(cacheKey);`
	`366`	`+ cacheEntry = await GetAsync<T>(cacheKey).ConfigureAwait(false);`
`367`	`367`	`}`
`368`	`368`
`369`	`369`	`return cacheEntry;`
`@@ -377,15 +377,15 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string`
`377`	`377`	`else if (entryStatus != CacheEntryStatus.Stale)`
`378`	`378`	`{`
`379`	`379`	`//Last minute check to confirm whether waiting is required`
`380`		`- var currentEntry = await GetAsync<T>(cacheKey);`
	`380`	`+ var currentEntry = await GetAsync<T>(cacheKey).ConfigureAwait(false);`
`381`	`381`	`if (currentEntry != null && currentEntry.GetStaleDate(settings) > DateTimeProvider.Now)`
`382`	`382`	`{`
`383`	`383`	`KeyLock.ReleaseLock(cacheKey, currentEntry);`
`384`	`384`	`return currentEntry;`
`385`	`385`	`}`
`386`	`386`
`387`	`387`	`//Lock until we are notified to be unlocked`
`388`		`- return await KeyLock.WaitAsync(cacheKey) as CacheEntry<T>;`
	`388`	`+ return await KeyLock.WaitAsync(cacheKey).ConfigureAwait(false) as CacheEntry<T>;`
`389`	`389`	`}`
`390`	`390`
`391`	`391`	`return default;`
`@@ -410,11 +410,11 @@ public async ValueTask DisposeAsync()`
`410`	`410`	`}`
`411`	`411`	`else if (layer is IAsyncDisposable asyncDisposableLayer)`
`412`	`412`	`{`
`413`		`- await asyncDisposableLayer.DisposeAsync();`
	`413`	`+ await asyncDisposableLayer.DisposeAsync().ConfigureAwait(false);`
`414`	`414`	`}`
`415`	`415`	`}`
`416`	`416`
`417`		`- await Extensions.DisposeAsync();`
	`417`	`+ await Extensions.DisposeAsync().ConfigureAwait(false);`
`418`	`418`
`419`	`419`	`Disposed = true;`
`420`	`420`	`}`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ public async ValueTask<T> GetOrSetAsync<T>(string cacheKey, Func<T, TContext, Ta`
`57`	`57`	`{`
`58`	`58`	`using var scope = CacheContextActivator.BeginScope();`
`59`	`59`	`var context = (TContext)scope.Resolve(typeof(TContext));`
`60`		`- return await getter(old, context);`
`61`		`- }, settings);`
	`60`	`+ return await getter(old, context).ConfigureAwait(false);`
	`61`	`+ }, settings).ConfigureAwait(false);`
`62`	`62`	`}`
`63`	`63`	`}`