diff --git a/src/CacheTower.Extensions.Redis/RedisLockExtension.cs b/src/CacheTower.Extensions.Redis/RedisLockExtension.cs
index 27ca21d..9f49455 100644
--- 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
index 7c9d87b..6412ae7 100644
--- 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
index 7473dd7..c5e9664 100644
--- 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,7 +92,7 @@ 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,
@@ -100,7 +100,7 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)
 				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
index 7fb03e5..f093631 100644
--- 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
index 62a68e0..495ca26 100644
--- 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,7 +184,7 @@ 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)
 			{
@@ -192,7 +192,7 @@ private async ValueTask InternalSetAsync<T>(string cacheKey, CacheEntry<T> cache
 			}
 		}
 
-		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,7 +377,7 @@ 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);
@@ -385,7 +385,7 @@ private async ValueTask BackPopulateCacheAsync<T>(int fromIndexExclusive, string
 			}
 
 			//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
index 3ccfd45..25bbc7c 100644
--- 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
index fdc5cdb..f975e86 100644
--- a/src/CacheTower/Extensions/AutoCleanupExtension.cs
+++ b/src/CacheTower/Extensions/AutoCleanupExtension.cs
@@ -57,9 +57,9 @@ private async Task BackgroundCleanup(ICacheStack cacheStack)
 				var cancellationToken = TokenSource.Token;
 				while (!cancellationToken.IsCancellationRequested)
 				{
-					await Task.Delay(Frequency, cancellationToken);
+					await Task.Delay(Frequency, cancellationToken).ConfigureAwait(false);
 					cancellationToken.ThrowIfCancellationRequested();
-					await cacheStack.CleanupAsync();
+					await cacheStack.CleanupAsync().ConfigureAwait(false);
 				}
 			}
 			catch (OperationCanceledException) { }
@@ -75,7 +75,7 @@ public async ValueTask DisposeAsync()
 
 			if (BackgroundTask is not null && !BackgroundTask.IsFaulted)
 			{
-				await BackgroundTask;
+				await BackgroundTask.ConfigureAwait(false);
 			}
 		}
 	}
diff --git a/src/CacheTower/Extensions/ExtensionContainer.cs b/src/CacheTower/Extensions/ExtensionContainer.cs
index af2bbf1..82661fa 100644
--- a/src/CacheTower/Extensions/ExtensionContainer.cs
+++ b/src/CacheTower/Extensions/ExtensionContainer.cs
@@ -73,7 +73,7 @@ public async ValueTask OnCacheUpdateAsync(string cacheKey, DateTime expiry, Cach
 			{
 				foreach (var extension in CacheChangeExtensions)
 				{
-					await extension.OnCacheUpdateAsync(cacheKey, expiry, cacheUpdateType);
+					await extension.OnCacheUpdateAsync(cacheKey, expiry, cacheUpdateType).ConfigureAwait(false);
 				}
 			}
 		}
@@ -85,7 +85,7 @@ public async ValueTask OnCacheEvictionAsync(string cacheKey)
 			{
 				foreach (var extension in CacheChangeExtensions)
 				{
-					await extension.OnCacheEvictionAsync(cacheKey);
+					await extension.OnCacheEvictionAsync(cacheKey).ConfigureAwait(false);
 				}
 			}
 		}
@@ -97,7 +97,7 @@ public async ValueTask OnCacheFlushAsync()
 			{
 				foreach (var extension in CacheChangeExtensions)
 				{
-					await extension.OnCacheFlushAsync();
+					await extension.OnCacheFlushAsync().ConfigureAwait(false);
 				}
 			}
 		}
@@ -117,7 +117,7 @@ public async ValueTask DisposeAsync()
 				}
 				else if (extension is IAsyncDisposable asyncDisposable)
 				{
-					await asyncDisposable.DisposeAsync();
+					await asyncDisposable.DisposeAsync().ConfigureAwait(false);
 				}
 			}
 
diff --git a/src/CacheTower/Providers/FileSystem/FileCacheLayer.cs b/src/CacheTower/Providers/FileSystem/FileCacheLayer.cs
index f98ae9a..2053779 100644
--- a/src/CacheTower/Providers/FileSystem/FileCacheLayer.cs
+++ b/src/CacheTower/Providers/FileSystem/FileCacheLayer.cs
@@ -50,8 +50,8 @@ private async Task BackgroundManifestSaving()
 				var cancellationToken = ManifestSavingCancellationTokenSource.Token;
 				while (!cancellationToken.IsCancellationRequested)
 				{
-					await Task.Delay(Options.ManifestSaveInterval, cancellationToken);
-					await SaveManifestAsync();
+					await Task.Delay(Options.ManifestSaveInterval, cancellationToken).ConfigureAwait(false);
+					await SaveManifestAsync().ConfigureAwait(false);
 				}
 			}
 			catch (OperationCanceledException) { }
@@ -61,7 +61,7 @@ private async Task BackgroundManifestSaving()
 		{
 			using var stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 1024);
 			using var memStream = new MemoryStream((int)stream.Length);
-			await stream.CopyToAsync(memStream);
+			await stream.CopyToAsync(memStream).ConfigureAwait(false);
 			memStream.Seek(0, SeekOrigin.Begin);
 			return Options.Serializer.Deserialize<T>(memStream);
 		}
@@ -72,7 +72,7 @@ private async Task SerializeFileAsync<T>(string path, T value)
 			using var memStream = new MemoryStream();
 			Options.Serializer.Serialize(memStream, value);
 			memStream.Seek(0, SeekOrigin.Begin);
-			await memStream.CopyToAsync(stream);
+			await memStream.CopyToAsync(stream).ConfigureAwait(false);
 		}
 
 		private async Task TryLoadManifestAsync()
@@ -80,7 +80,7 @@ private async Task TryLoadManifestAsync()
 			//Avoid unnecessary lock contention way after manifest is loaded by checking before lock
 			if (CacheManifest is null)
 			{
-				await ManifestLock.WaitAsync();
+				await ManifestLock.WaitAsync().ConfigureAwait(false);
 				try
 				{
 					//Check that once we have lock (due to a race condition on the outer check) that we still need to load the manifest
@@ -88,7 +88,7 @@ private async Task TryLoadManifestAsync()
 					{
 						if (File.Exists(ManifestPath))
 						{
-							CacheManifest = await DeserializeFileAsync<ConcurrentDictionary<string?, ManifestEntry>>(ManifestPath);
+							CacheManifest = await DeserializeFileAsync<ConcurrentDictionary<string?, ManifestEntry>>(ManifestPath).ConfigureAwait(false);
 							CacheManifest ??= new();
 						}
 						else
@@ -99,7 +99,7 @@ private async Task TryLoadManifestAsync()
 							}
 
 							CacheManifest = new();
-							await SerializeFileAsync(ManifestPath, CacheManifest);
+							await SerializeFileAsync(ManifestPath, CacheManifest).ConfigureAwait(false);
 						}
 					}
 				}
@@ -116,7 +116,7 @@ private async Task TryLoadManifestAsync()
 		/// <returns></returns>
 		public async Task SaveManifestAsync()
 		{
-			await ManifestLock.WaitAsync();
+			await ManifestLock.WaitAsync().ConfigureAwait(false);
 			try
 			{
 				if (!Directory.Exists(Options.DirectoryPath))
@@ -124,7 +124,7 @@ public async Task SaveManifestAsync()
 					Directory.CreateDirectory(Options.DirectoryPath);
 				}
 
-				await SerializeFileAsync(ManifestPath, CacheManifest);
+				await SerializeFileAsync(ManifestPath, CacheManifest).ConfigureAwait(false);
 			}
 			finally
 			{
@@ -135,7 +135,7 @@ public async Task SaveManifestAsync()
 		/// <inheritdoc/>
 		public async ValueTask CleanupAsync()
 		{
-			await TryLoadManifestAsync();
+			await TryLoadManifestAsync().ConfigureAwait(false);
 
 			var currentTime = DateTimeProvider.Now;
 			foreach (var cachePair in CacheManifest!)
@@ -161,7 +161,7 @@ public async ValueTask CleanupAsync()
 		/// <inheritdoc/>
 		public async ValueTask EvictAsync(string cacheKey)
 		{
-			await TryLoadManifestAsync();
+			await TryLoadManifestAsync().ConfigureAwait(false);
 
 			if (CacheManifest!.TryRemove(cacheKey, out var manifestEntry))
 			{
@@ -182,7 +182,7 @@ public async ValueTask EvictAsync(string cacheKey)
 		/// <inheritdoc/>
 		public async ValueTask FlushAsync()
 		{
-			await TryLoadManifestAsync();
+			await TryLoadManifestAsync().ConfigureAwait(false);
 
 			foreach (var manifestEntry in CacheManifest!.Values)
 			{
@@ -201,13 +201,13 @@ public async ValueTask FlushAsync()
 
 			CacheManifest.Clear();
 
-			await SaveManifestAsync();
+			await SaveManifestAsync().ConfigureAwait(false);
 		}
 
 		/// <inheritdoc/>
 		public async ValueTask<CacheEntry<T>?> GetAsync<T>(string cacheKey)
 		{
-			await TryLoadManifestAsync();
+			await TryLoadManifestAsync().ConfigureAwait(false);
 
 			if (CacheManifest!.TryGetValue(cacheKey, out var manifestEntry))
 			{
@@ -220,7 +220,7 @@ public async ValueTask FlushAsync()
 						var path = Path.Combine(Options.DirectoryPath, manifestEntry.FileName);
 						if (File.Exists(path))
 						{
-							var value = await DeserializeFileAsync<T>(path);
+							var value = await DeserializeFileAsync<T>(path).ConfigureAwait(false);
 							return new CacheEntry<T>(value, manifestEntry.Expiry);
 
 						}
@@ -247,7 +247,7 @@ public async ValueTask<bool> IsAvailableAsync(string cacheKey)
 			{
 				try
 				{
-					await TryLoadManifestAsync();
+					await TryLoadManifestAsync().ConfigureAwait(false);
 					IsManifestAvailable = true;
 				}
 				catch
@@ -262,7 +262,7 @@ public async ValueTask<bool> IsAvailableAsync(string cacheKey)
 		/// <inheritdoc/>
 		public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)
 		{
-			await TryLoadManifestAsync();
+			await TryLoadManifestAsync().ConfigureAwait(false);
 
 			//Update the manifest entry with the new expiry
 			if (CacheManifest!.TryGetValue(cacheKey, out var manifestEntry))
@@ -286,7 +286,7 @@ public async ValueTask SetAsync<T>(string cacheKey, CacheEntry<T> cacheEntry)
 			using (await lockObj.WriterLockAsync())
 			{
 				var path = Path.Combine(Options.DirectoryPath, manifestEntry.FileName);
-				await SerializeFileAsync(path, cacheEntry.Value);
+				await SerializeFileAsync(path, cacheEntry.Value).ConfigureAwait(false);
 			}
 		}
 
@@ -304,9 +304,9 @@ public async ValueTask DisposeAsync()
 			ManifestSavingCancellationTokenSource.Cancel();
 			if (!BackgroundManifestSavingTask.IsFaulted)
 			{
-				await BackgroundManifestSavingTask;
+				await BackgroundManifestSavingTask.ConfigureAwait(false);
 			}
-			await SaveManifestAsync();
+			await SaveManifestAsync().ConfigureAwait(false);
 
 			ManifestLock.Dispose();