From 0edac98f5fd84da03e057e168eacb090fe9c96f5 Mon Sep 17 00:00:00 2001
From: st0o0 <jan.schloots@bluewin.ch>
Date: Tue, 2 Aug 2022 08:17:25 +0200
Subject: [PATCH 1/5] init CancellationToken implementation

---
 .../DefaultCSRedisCachingProvider.Async.cs    |  54 +++++----
 .../EasyCachingAbstractProvider.cs            |  95 ++++++++--------
 src/EasyCaching.Core/IEasyCachingProvider.cs  |  16 ++-
 .../IEasyCachingProviderBase.cs               |  31 +++--
 .../DefaultDiskCachingProvider.Async.cs       |  71 ++++++------
 .../HybridCachingProvider.cs                  |  95 +++++++++-------
 .../DefaultInMemoryCachingProvider.Async.cs   |  67 ++++++-----
 .../DefaultLiteDBCachingProvider.Async.cs     |  74 +++++++-----
 .../DefaultSQLiteCachingProvider.Async.cs     | 107 +++++++++++-------
 9 files changed, 355 insertions(+), 255 deletions(-)

diff --git a/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs b/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs
index e85c3831..501d0778 100644
--- a/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs
+++ b/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs
@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
     using global::CSRedis;
@@ -14,32 +15,35 @@ public partial class DefaultCSRedisCachingProvider : EasyCachingAbstractProvider
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task<bool> BaseExistsAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
             return await _cache.ExistsAsync(cacheKey);
         }
-      
+
         /// <summary>
         /// Flushs the async.
         /// </summary>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns>The async.</returns>
-        public override async Task BaseFlushAsync()
+        public override async Task BaseFlushAsync(CancellationToken cancellationToken = default)
         {
             if (_options.EnableLogging)
                 _logger?.LogInformation("Redis -- FlushAsync");
 
             await _cache.NodesServerManager.FlushDbAsync();
         }
-     
+
         /// <summary>
         /// Gets all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -67,8 +71,9 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
@@ -120,7 +125,8 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="type">Object Type.</param>
-        public override async Task<object> BaseGetAsync(string cacheKey, Type type)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -151,8 +157,9 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -183,7 +190,8 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
         /// </summary>
         /// <returns>The count.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override Task<int> BaseGetCountAsync(string prefix = "")
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             if (string.IsNullOrWhiteSpace(prefix))
             {
@@ -207,8 +215,9 @@ public override Task<int> BaseGetCountAsync(string prefix = "")
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
@@ -229,13 +238,14 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAs
 
             return result;
         }
-    
+
         /// <summary>
         /// Removes all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -254,19 +264,21 @@ public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task BaseRemoveAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
             await _cache.DelAsync(cacheKey);
-        }     
+        }
 
         /// <summary>
         /// Removes the by prefix async.
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override async Task BaseRemoveByPrefixAsync(string prefix)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
@@ -293,8 +305,9 @@ public override async Task BaseRemoveByPrefixAsync(string prefix)
         /// <returns>The all async.</returns>
         /// <param name="value">Value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration)
+        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             //whether to use pipe based on redis mode 
             var tasks = new List<Task<bool>>();
@@ -320,8 +333,9 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> value, Time
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -349,8 +363,9 @@ await _cache.SetAsync(
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -374,8 +389,9 @@ public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValu
         /// Get the expiration of cache key async
         /// </summary>
         /// <param name="cacheKey">cache key</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns>expiration</returns>
-        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
diff --git a/src/EasyCaching.Core/EasyCachingAbstractProvider.cs b/src/EasyCaching.Core/EasyCachingAbstractProvider.cs
index 8dac2e5a..6f06028d 100644
--- a/src/EasyCaching.Core/EasyCachingAbstractProvider.cs
+++ b/src/EasyCaching.Core/EasyCachingAbstractProvider.cs
@@ -6,6 +6,7 @@ namespace EasyCaching.Core
     using System.Collections.Generic;
     using System.Diagnostics;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core.Configurations;
     using EasyCaching.Core.Diagnostics;
@@ -43,35 +44,35 @@ protected EasyCachingAbstractProvider(IDistributedLockFactory lockFactory, BaseP
 
         public abstract object BaseGetDatabse();
         public abstract bool BaseExists(string cacheKey);
-        public abstract Task<bool> BaseExistsAsync(string cacheKey);
+        public abstract Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default);
         public abstract void BaseFlush();
-        public abstract Task BaseFlushAsync();
+        public abstract Task BaseFlushAsync(CancellationToken cancellationToken = default);
         public abstract CacheValue<T> BaseGet<T>(string cacheKey, Func<T> dataRetriever, TimeSpan expiration);
         public abstract CacheValue<T> BaseGet<T>(string cacheKey);
         public abstract IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<string> cacheKeys);
-        public abstract Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys);
-        public abstract Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration);
-        public abstract Task<object> BaseGetAsync(string cacheKey, Type type);
-        public abstract Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey);
+        public abstract Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default);
+        public abstract Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default);
+        public abstract Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default);
+        public abstract Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default);
         public abstract IDictionary<string, CacheValue<T>> BaseGetByPrefix<T>(string prefix);
-        public abstract Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix);
+        public abstract Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default);
         public abstract int BaseGetCount(string prefix = "");
-        public abstract Task<int> BaseGetCountAsync(string prefix = "");
+        public abstract Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default);
         public abstract void BaseRemove(string cacheKey);
         public abstract void BaseRemoveAll(IEnumerable<string> cacheKeys);
-        public abstract Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys);
-        public abstract Task BaseRemoveAsync(string cacheKey);
+        public abstract Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellation = default);
+        public abstract Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default);
         public abstract void BaseRemoveByPrefix(string prefix);
-        public abstract Task BaseRemoveByPrefixAsync(string prefix);
+        public abstract Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default);
         public abstract void BaseSet<T>(string cacheKey, T cacheValue, TimeSpan expiration);
         public abstract void BaseSetAll<T>(IDictionary<string, T> values, TimeSpan expiration);
-        public abstract Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration);
-        public abstract Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration);
+        public abstract Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default);
+        public abstract Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default);
         public abstract bool BaseTrySet<T>(string cacheKey, T cacheValue, TimeSpan expiration);
-        public abstract Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration);
+        public abstract Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default);
 
         public abstract TimeSpan BaseGetExpiration(string cacheKey);
-        public abstract Task<TimeSpan> BaseGetExpirationAsync(string cacheKey);
+        public abstract Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default);
         public abstract ProviderInfo BaseGetProviderInfo();
 
         public bool Exists(string cacheKey)
@@ -100,13 +101,13 @@ public bool Exists(string cacheKey)
             }
         }
 
-        public async Task<bool> ExistsAsync(string cacheKey)
+        public async Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteExistsCacheBefore(new BeforeExistsRequestEventData(CachingProviderType.ToString(), Name, nameof(ExistsAsync), cacheKey));
             Exception e = null;
             try
             {
-                var flag = await BaseExistsAsync(cacheKey);
+                var flag = await BaseExistsAsync(cacheKey, cancellationToken);
                 return flag;
             }
             catch (Exception ex)
@@ -153,13 +154,13 @@ public void Flush()
             }
         }
 
-        public async Task FlushAsync()
+        public async Task FlushAsync(CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteFlushCacheBefore(new EventData(CachingProviderType.ToString(), Name, nameof(FlushAsync)));
             Exception e = null;
             try
             {
-                await BaseFlushAsync();
+                await BaseFlushAsync(cancellationToken);
             }
             catch (Exception ex)
             {
@@ -280,13 +281,13 @@ public IDictionary<string, CacheValue<T>> GetAll<T>(IEnumerable<string> cacheKey
             }
         }
 
-        public async Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public async Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAllAsync), cacheKeys.ToArray()));
             Exception e = null;
             try
             {
-                return await BaseGetAllAsync<T>(cacheKeys);
+                return await BaseGetAllAsync<T>(cacheKeys, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -306,13 +307,13 @@ public async Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable
             }
         }
 
-        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAsync), new[] { cacheKey }, expiration));
             Exception e = null;
             try
             {
-                if (_lockFactory == null) return await BaseGetAsync<T>(cacheKey, dataRetriever, expiration);
+                if (_lockFactory == null) return await BaseGetAsync<T>(cacheKey, dataRetriever, expiration, cancellationToken);
 
                 var value = await BaseGetAsync<T>(cacheKey);
                 if (value.HasValue) return value;
@@ -322,7 +323,7 @@ public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> data
                 {
                     if (!await @lock.LockAsync(_options.SleepMs)) throw new TimeoutException();
 
-                    value = await BaseGetAsync<T>(cacheKey);
+                    value = await BaseGetAsync<T>(cacheKey, cancellationToken);
                     if (value.HasValue) return value;
 
                     var task = dataRetriever();
@@ -333,7 +334,7 @@ await Task.WhenAny(task, Task.Delay(_options.LockMs)) != task)
                     var item = await task;
                     if (item != null || _options.CacheNulls)
                     {
-                        await BaseSetAsync(cacheKey, item, expiration);
+                        await BaseSetAsync(cacheKey, item, expiration, cancellationToken);
 
                         return new CacheValue<T>(item, true);
                     }
@@ -365,13 +366,13 @@ await Task.WhenAny(task, Task.Delay(_options.LockMs)) != task)
             }
         }
 
-        public async Task<object> GetAsync(string cacheKey, Type type)
+        public async Task<object> GetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, "GetAsync_Type", new[] { cacheKey }));
             Exception e = null;
             try
             {
-                return await BaseGetAsync(cacheKey, type);
+                return await BaseGetAsync(cacheKey, type, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -391,13 +392,13 @@ public async Task<object> GetAsync(string cacheKey, Type type)
             }
         }
 
-        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey)
+        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAsync), new[] { cacheKey }));
             Exception e = null;
             try
             {
-                return await BaseGetAsync<T>(cacheKey);
+                return await BaseGetAsync<T>(cacheKey, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -443,13 +444,13 @@ public IDictionary<string, CacheValue<T>> GetByPrefix<T>(string prefix)
             }
         }
 
-        public async Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix)
+        public async Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetByPrefixAsync), new[] { prefix }));
             Exception e = null;
             try
             {
-                return await BaseGetByPrefixAsync<T>(prefix);
+                return await BaseGetByPrefixAsync<T>(prefix, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -474,9 +475,9 @@ public int GetCount(string prefix = "")
             return BaseGetCount(prefix);
         }
 
-        public async Task<int> GetCountAsync(string prefix = "")
+        public async Task<int> GetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
-            return await BaseGetCountAsync(prefix);
+            return await BaseGetCountAsync(prefix, cancellationToken);
         }
 
         public void Remove(string cacheKey)
@@ -531,13 +532,13 @@ public void RemoveAll(IEnumerable<string> cacheKeys)
             }
         }
 
-        public async Task RemoveAllAsync(IEnumerable<string> cacheKeys)
+        public async Task RemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteRemoveCacheBefore(new BeforeRemoveRequestEventData(CachingProviderType.ToString(), Name, nameof(RemoveAllAsync), cacheKeys.ToArray()));
             Exception e = null;
             try
             {
-                await BaseRemoveAllAsync(cacheKeys);
+                await BaseRemoveAllAsync(cacheKeys, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -557,13 +558,13 @@ public async Task RemoveAllAsync(IEnumerable<string> cacheKeys)
             }
         }
 
-        public async Task RemoveAsync(string cacheKey)
+        public async Task RemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteRemoveCacheBefore(new BeforeRemoveRequestEventData(CachingProviderType.ToString(), Name, nameof(RemoveAsync), new[] { cacheKey }));
             Exception e = null;
             try
             {
-                await BaseRemoveAsync(cacheKey);
+                await BaseRemoveAsync(cacheKey, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -609,13 +610,13 @@ public void RemoveByPrefix(string prefix)
             }
         }
 
-        public async Task RemoveByPrefixAsync(string prefix)
+        public async Task RemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteRemoveCacheBefore(new BeforeRemoveRequestEventData(CachingProviderType.ToString(), Name, nameof(RemoveByPrefixAsync), new[] { prefix }));
             Exception e = null;
             try
             {
-                await BaseRemoveByPrefixAsync(prefix);
+                await BaseRemoveByPrefixAsync(prefix, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -687,13 +688,13 @@ public void SetAll<T>(IDictionary<string, T> value, TimeSpan expiration)
             }
         }
 
-        public async Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration)
+        public async Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteSetCacheBefore(new BeforeSetRequestEventData(CachingProviderType.ToString(), Name, nameof(SetAllAsync), value.ToDictionary(k => k.Key, v => (object)v.Value), expiration));
             Exception e = null;
             try
             {
-                await BaseSetAllAsync(value, expiration);
+                await BaseSetAllAsync(value, expiration, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -713,13 +714,13 @@ public async Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expirati
             }
         }
 
-        public async Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public async Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteSetCacheBefore(new BeforeSetRequestEventData(CachingProviderType.ToString(), Name, nameof(SetAsync), new Dictionary<string, object> { { cacheKey, cacheValue } }, expiration));
             Exception e = null;
             try
             {
-                await BaseSetAsync(cacheKey, cacheValue, expiration);
+                await BaseSetAsync(cacheKey, cacheValue, expiration, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -765,13 +766,13 @@ public bool TrySet<T>(string cacheKey, T cacheValue, TimeSpan expiration)
             }
         }
 
-        public async Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public async Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             var operationId = s_diagnosticListener.WriteSetCacheBefore(new BeforeSetRequestEventData(CachingProviderType.ToString(), Name, nameof(TrySetAsync), new Dictionary<string, object> { { cacheKey, cacheValue } }, expiration));
             Exception e = null;
             try
             {
-                return await BaseTrySetAsync(cacheKey, cacheValue, expiration);
+                return await BaseTrySetAsync(cacheKey, cacheValue, expiration, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -796,9 +797,9 @@ public TimeSpan GetExpiration(string cacheKey)
             return BaseGetExpiration(cacheKey);
         }
 
-        public async Task<TimeSpan> GetExpirationAsync(string cacheKey)
+        public async Task<TimeSpan> GetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
-            return await BaseGetExpirationAsync(cacheKey);
+            return await BaseGetExpirationAsync(cacheKey, cancellationToken);
         }
 
         public ProviderInfo GetProviderInfo()
diff --git a/src/EasyCaching.Core/IEasyCachingProvider.cs b/src/EasyCaching.Core/IEasyCachingProvider.cs
index 0aca8d21..4606904b 100644
--- a/src/EasyCaching.Core/IEasyCachingProvider.cs
+++ b/src/EasyCaching.Core/IEasyCachingProvider.cs
@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
 
     /// <summary>
@@ -34,8 +35,9 @@ public interface IEasyCachingProvider : IEasyCachingProviderBase
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys);
+        Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Gets the by prefix.
@@ -50,8 +52,9 @@ public interface IEasyCachingProvider : IEasyCachingProviderBase
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix);
+        Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Gets the count.
@@ -65,7 +68,8 @@ public interface IEasyCachingProvider : IEasyCachingProviderBase
         /// </summary>
         /// <returns>The count.</returns>
         /// <param name="prefix">Prefix.</param>
-        Task<int> GetCountAsync(string prefix = "");
+        /// <param name="cancellationToken">CancellationToken</param>
+        Task<int> GetCountAsync(string prefix = "", CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Flush All Cached Item.
@@ -76,7 +80,8 @@ public interface IEasyCachingProvider : IEasyCachingProviderBase
         /// Flush All Cached Item async.
         /// </summary>
         /// <returns>The async.</returns>
-        Task FlushAsync();
+        /// <param name="cancellationToken">CancellationToken</param>
+        Task FlushAsync(CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Gets the max rd second.
@@ -107,8 +112,9 @@ public interface IEasyCachingProvider : IEasyCachingProviderBase
         /// Gets the exporation of specify cachekey async.
         /// </summary>
         /// <param name="cacheKey"></param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns></returns>
-        Task<TimeSpan> GetExpirationAsync(string cacheKey);
+        Task<TimeSpan> GetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Gets the information of provider.
diff --git a/src/EasyCaching.Core/IEasyCachingProviderBase.cs b/src/EasyCaching.Core/IEasyCachingProviderBase.cs
index a7fce998..9b232e18 100644
--- a/src/EasyCaching.Core/IEasyCachingProviderBase.cs
+++ b/src/EasyCaching.Core/IEasyCachingProviderBase.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace EasyCaching.Core
@@ -28,8 +29,9 @@ public interface IEasyCachingProviderBase
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken"></param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration);
+        Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Get the specified cacheKey.
@@ -44,8 +46,9 @@ public interface IEasyCachingProviderBase
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken"></param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        Task<CacheValue<T>> GetAsync<T>(string cacheKey);
+        Task<CacheValue<T>> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Remove the specified cacheKey.
@@ -58,14 +61,16 @@ public interface IEasyCachingProviderBase
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        Task RemoveAsync(string cacheKey);
+        /// <param name="cancellationToken"></param>
+        Task RemoveAsync(string cacheKey, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Exists the specified cacheKey async.
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        Task<bool> ExistsAsync(string cacheKey);
+        /// <param name="cancellationToken"></param>
+        Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Exists the specified cacheKey.
@@ -91,8 +96,9 @@ public interface IEasyCachingProviderBase
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken"></param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration);
+        Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Sets all.
@@ -108,8 +114,9 @@ public interface IEasyCachingProviderBase
         /// <returns>The all async.</returns>
         /// <param name="value">Value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken"></param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration);
+        Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Removes all.
@@ -122,7 +129,8 @@ public interface IEasyCachingProviderBase
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        Task RemoveAllAsync(IEnumerable<string> cacheKeys);
+        /// <param name="cancellationToken"></param>
+        Task RemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Get the specified cacheKey, dataRetriever and expiration.
@@ -141,8 +149,9 @@ public interface IEasyCachingProviderBase
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken"></param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration);
+        Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Removes cached item by cachekey's prefix.
@@ -154,7 +163,8 @@ public interface IEasyCachingProviderBase
         /// Removes cached item by cachekey's prefix async.
         /// </summary>
         /// <param name="prefix">Prefix of CacheKey.</param>
-        Task RemoveByPrefixAsync(string prefix);
+        /// <param name="cancellationToken"></param>
+        Task RemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default);
 
         /// <summary>
         /// Gets the specified cacheKey async.
@@ -162,6 +172,7 @@ public interface IEasyCachingProviderBase
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="type">Object Type.</param>
-        Task<object> GetAsync(string cacheKey, Type type);
+        /// <param name="cancellationToken"></param>
+        Task<object> GetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default);
     }
 }
\ No newline at end of file
diff --git a/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs b/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs
index b96ace0b..4e74545e 100644
--- a/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs
+++ b/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs
@@ -4,6 +4,7 @@
     using System.Collections.Generic;
     using System.IO;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
     using MessagePack;
@@ -12,7 +13,7 @@
 
     public partial class DefaultDiskCachingProvider : EasyCachingAbstractProvider
     {   
-        public override async Task<bool> BaseExistsAsync(string cacheKey)
+        public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -20,12 +21,12 @@ public override async Task<bool> BaseExistsAsync(string cacheKey)
 
             if (!File.Exists(path)) return false;
 
-            var val = await GetDiskCacheValueAsync(path);
+            var val = await GetDiskCacheValueAsync(path, cancellationToken);
 
             return val.Expiration > DateTimeOffset.UtcNow;
         }
 
-        public override Task BaseFlushAsync()
+        public override Task BaseFlushAsync(CancellationToken cancellationToken = default)
         {
             if (_options.EnableLogging)
                 _logger?.LogInformation("FlushAsync");
@@ -41,7 +42,7 @@ public override Task BaseFlushAsync()
             return Task.CompletedTask;
         }            
 
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -60,11 +61,11 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
                 }
                 else
                 {
-                    var cached = await GetDiskCacheValueAsync(path);
+                    var cached = await GetDiskCacheValueAsync(path, cancellationToken);
 
                     if (cached.Expiration > DateTimeOffset.UtcNow)
                     {
-                        var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance));
+                        var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance), cancellationToken);
 
                         if (!dict.ContainsKey(item))
                         {
@@ -84,7 +85,7 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
             return dict;
         }
 
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
@@ -99,13 +100,13 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
                  MessagePack.MessagePackSerializationException : Failed to deserialize EasyCaching.Disk.DiskCacheValue value.
                     ---- System.IO.EndOfStreamException : Attempted to read past the end of the stream.
                  */
-                var cached = await GetDiskCacheValueAsync(path);
+                var cached = await GetDiskCacheValueAsync(path, cancellationToken);
                 //var cached = GetDiskCacheValueAsync(path).ConfigureAwait(false).GetAwaiter().GetResult();
                 //var cached = GetDiskCacheValue(path);
 
                 if (cached.Expiration > DateTimeOffset.UtcNow)
                 {
-                    var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance));
+                    var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance), cancellationToken);
 
                     if (_options.EnableLogging)
                         _logger?.LogInformation($"Cache Hit : cachekey = {cacheKey}");
@@ -125,14 +126,14 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
             if (!_cacheKeysMap.TryAdd($"{cacheKey}_Lock", "1"))
             {
                 System.Threading.Thread.Sleep(_options.SleepMs);
-                return await GetAsync(cacheKey, dataRetriever, expiration);
+                return await GetAsync(cacheKey, dataRetriever, expiration, cancellationToken);
             }
 
             var res = await dataRetriever();
 
             if (res != null || _options.CacheNulls)
             {
-                await SetAsync(cacheKey, res, expiration);
+                await SetAsync(cacheKey, res, expiration, cancellationToken);
                 //remove mutex key
                 _cacheKeysMap.TryRemove($"{cacheKey}_Lock", out _);
                 return new CacheValue<T>(res, true);
@@ -145,7 +146,7 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
             }
         }
 
-        public override Task<int> BaseGetCountAsync(string prefix = "")
+        public override Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             if (string.IsNullOrWhiteSpace(prefix))
             {
@@ -157,7 +158,7 @@ public override Task<int> BaseGetCountAsync(string prefix = "")
             }
         }
 
-        public override async Task<object> BaseGetAsync(string cacheKey, Type type)
+        public override async Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -173,7 +174,7 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
                 return null;
             }
 
-            var cached = await GetDiskCacheValueAsync(path);
+            var cached = await GetDiskCacheValueAsync(path, cancellationToken);
 
             if (cached.Expiration > DateTimeOffset.UtcNow)
             {
@@ -182,7 +183,7 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
 
                 CacheStats.OnHit();
 
-                var t = MessagePackSerializer.Deserialize(type, cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance));
+                var t = MessagePackSerializer.Deserialize(type, cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance), cancellationToken);
                 return t;
             }
             else
@@ -196,7 +197,7 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
             }
         }
 
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -212,7 +213,7 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
                 return CacheValue<T>.NoValue;
             }
 
-            var cached = await GetDiskCacheValueAsync(path);
+            var cached = await GetDiskCacheValueAsync(path, cancellationToken);
 
             if (cached.Expiration > DateTimeOffset.UtcNow)
             {
@@ -221,7 +222,7 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
 
                 CacheStats.OnHit();
 
-                var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance));
+                var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance), cancellationToken);
                 return new CacheValue<T>(t, true);
             }
             else
@@ -235,7 +236,7 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
             }
         }
             
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
@@ -258,11 +259,11 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAs
                 }
                 else
                 {
-                    var cached = await GetDiskCacheValueAsync(path);
+                    var cached = await GetDiskCacheValueAsync(path, cancellationToken);
 
                     if (cached.Expiration > DateTimeOffset.UtcNow)
                     {
-                        var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance));
+                        var t = MessagePackSerializer.Deserialize<T>(cached.Value, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance), cancellationToken);
 
                         if (!dict.ContainsKey(item))
                         {
@@ -282,7 +283,7 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAs
             return dict;
         }
              
-        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -293,12 +294,12 @@ public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
                 return TimeSpan.Zero;
             }
 
-            var cached = await GetDiskCacheValueAsync(path);
+            var cached = await GetDiskCacheValueAsync(path, cancellationToken);
 
             return cached.Expiration.Subtract(DateTimeOffset.UtcNow);
         }             
               
-        public override Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        public override Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -323,7 +324,7 @@ public override Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
             return Task.CompletedTask;
         }
 
-        public override Task BaseRemoveAsync(string cacheKey)
+        public override Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -343,7 +344,7 @@ public override Task BaseRemoveAsync(string cacheKey)
             return Task.CompletedTask;
         }
 
-        public override Task BaseRemoveByPrefixAsync(string prefix)
+        public override Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
@@ -362,7 +363,7 @@ public override Task BaseRemoveByPrefixAsync(string prefix)
             return Task.CompletedTask;
         }
           
-        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration)
+        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
             ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
@@ -377,7 +378,7 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
 
                     using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
                     {
-                        await stream.WriteAsync(bytes, 0, bytes.Length);
+                        await stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken);
                     }
 
                     AppendKey(item.Key, fileName);
@@ -389,7 +390,7 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
             }
         }
 
-        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -401,14 +402,14 @@ public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSp
 
             using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
             {
-                await stream.WriteAsync(bytes, 0, bytes.Length);
+                await stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken);
                 //return true;
             }
 
             AppendKey(cacheKey, fileName);
         }
 
-        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -418,7 +419,7 @@ public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValu
 
             if (File.Exists(path))
             {
-                var cached = await GetDiskCacheValueAsync(path);
+                var cached = await GetDiskCacheValueAsync(path, cancellationToken);
 
                 if (cached.Expiration.Subtract(DateTimeOffset.UtcNow) > TimeSpan.Zero)
                 {
@@ -430,17 +431,17 @@ public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValu
 
             using (FileStream stream = new FileStream(path, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None))
             {
-                await stream.WriteAsync(bytes, 0, bytes.Length);
+                await stream.WriteAsync(bytes, 0, bytes.Length, cancellationToken);
                 AppendKey(cacheKey, fileName);
                 return true;
             }
         }
                
-        private async Task<DiskCacheValue> GetDiskCacheValueAsync(string path)
+        private async Task<DiskCacheValue> GetDiskCacheValueAsync(string path, CancellationToken cancellationToken = default)
         {
             using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
             {
-                var cached = await MessagePackSerializer.DeserializeAsync<DiskCacheValue>(stream, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance));
+                var cached = await MessagePackSerializer.DeserializeAsync<DiskCacheValue>(stream, MessagePackSerializerOptions.Standard.WithResolver(ContractlessStandardResolver.Instance), cancellationToken);
 
                 return cached;
             }
diff --git a/src/EasyCaching.HybridCache/HybridCachingProvider.cs b/src/EasyCaching.HybridCache/HybridCachingProvider.cs
index 44721990..55a41839 100644
--- a/src/EasyCaching.HybridCache/HybridCachingProvider.cs
+++ b/src/EasyCaching.HybridCache/HybridCachingProvider.cs
@@ -2,7 +2,8 @@
 {
     using System;
     using System.Collections.Generic;
-    using System.Linq;
+    using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
     using EasyCaching.Core.Bus;
@@ -177,7 +178,8 @@ public bool Exists(string cacheKey)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public async Task<bool> ExistsAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public async Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -203,6 +205,7 @@ public async Task<bool> ExistsAsync(string cacheKey)
         /// </summary>
         /// <returns>The get.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
         public CacheValue<T> Get<T>(string cacheKey)
         {
@@ -246,12 +249,13 @@ public CacheValue<T> Get<T>(string cacheKey)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey)
+        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            var cacheValue = await _localCache.GetAsync<T>(cacheKey);
+            var cacheValue = await _localCache.GetAsync<T>(cacheKey, cancellationToken);
 
             if (cacheValue.HasValue)
             {
@@ -262,7 +266,7 @@ public async Task<CacheValue<T>> GetAsync<T>(string cacheKey)
 
             try
             {
-                cacheValue = await _distributedCache.GetAsync<T>(cacheKey);
+                cacheValue = await _distributedCache.GetAsync<T>(cacheKey, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -271,9 +275,9 @@ public async Task<CacheValue<T>> GetAsync<T>(string cacheKey)
 
             if (cacheValue.HasValue)
             {
-                TimeSpan ts = await GetExpirationAsync(cacheKey);
+                TimeSpan ts = await GetExpirationAsync(cacheKey, cancellationToken);
 
-                await _localCache.SetAsync(cacheKey, cacheValue.Value, ts);
+                await _localCache.SetAsync(cacheKey, cacheValue.Value, ts, cancellationToken);
 
                 return cacheValue;
             }
@@ -312,24 +316,25 @@ public void Remove(string cacheKey)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public async Task RemoveAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public async Task RemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
             try
             {
                 // distributed cache at first
-                await _distributedCache.RemoveAsync(cacheKey);
+                await _distributedCache.RemoveAsync(cacheKey, cancellationToken);
             }
             catch (Exception ex)
             {
                 LogMessage($"remove cache key [{cacheKey}] error", ex);
             }
 
-            await _localCache.RemoveAsync(cacheKey);
+            await _localCache.RemoveAsync(cacheKey, cancellationToken);
 
             // send message to bus 
-            await _busAsyncWrap.ExecuteAsync(async () => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { cacheKey } }));
+            await _busAsyncWrap.ExecuteAsync(async (ct) => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { cacheKey } }, ct), cancellationToken);
         }
 
         /// <summary>
@@ -365,16 +370,17 @@ public void Set<T>(string cacheKey, T cacheValue, TimeSpan expiration)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public async Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public async Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            await _localCache.SetAsync(cacheKey, cacheValue, expiration);
+            await _localCache.SetAsync(cacheKey, cacheValue, expiration, cancellationToken);
 
             try
             {
-                await _distributedCache.SetAsync(cacheKey, cacheValue, expiration);
+                await _distributedCache.SetAsync(cacheKey, cacheValue, expiration, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -382,7 +388,7 @@ public async Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration
             }
 
             // When create/update cache, send message to bus so that other clients can remove it.
-            await _busAsyncWrap.ExecuteAsync(async () => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { cacheKey } }));
+            await _busAsyncWrap.ExecuteAsync(async (ct) => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { cacheKey } }, ct), cancellationToken);
         }
 
         /// <summary>
@@ -439,8 +445,9 @@ public bool TrySet<T>(string cacheKey, T cacheValue, TimeSpan expiration)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public async Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public async Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -449,7 +456,7 @@ public async Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan e
 
             try
             {
-                flag = await _distributedCache.TrySetAsync(cacheKey, cacheValue, expiration);
+                flag = await _distributedCache.TrySetAsync(cacheKey, cacheValue, expiration, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -461,19 +468,19 @@ public async Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan e
             {
                 // When we TrySet succeed in distributed cache, we should Set this cache to local cache.
                 // It's mainly to prevent the cache value was changed
-                await _localCache.SetAsync(cacheKey, cacheValue, expiration);
+                await _localCache.SetAsync(cacheKey, cacheValue, expiration, cancellationToken);
             }
 
             // distributed cache occur error, have a try with local cache
             if (distributedError)
             {
-                flag = await _localCache.TrySetAsync(cacheKey, cacheValue, expiration);
+                flag = await _localCache.TrySetAsync(cacheKey, cacheValue, expiration, cancellationToken);
             }
 
             if (flag)
             {
                 // Here should send message to bus due to cache was set successfully.
-                await _busAsyncWrap.ExecuteAsync(async () => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { cacheKey } }));
+                await _busAsyncWrap.ExecuteAsync(async (ct) => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { cacheKey } }, ct), cancellationToken);
             }
 
             return flag;
@@ -508,14 +515,15 @@ public void SetAll<T>(IDictionary<string, T> value, TimeSpan expiration)
         /// <returns>The all async.</returns>
         /// <param name="value">Value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public async Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration)
+        public async Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
-            await _localCache.SetAllAsync(value, expiration);
+            await _localCache.SetAllAsync(value, expiration, cancellationToken);
 
             try
             {
-                await _distributedCache.SetAllAsync(value, expiration);
+                await _distributedCache.SetAllAsync(value, expiration, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -523,7 +531,7 @@ public async Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expirati
             }
 
             // send message to bus 
-            await _busAsyncWrap.ExecuteAsync(async () => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = value.Keys.ToArray(), IsPrefix = false }));
+            await _busAsyncWrap.ExecuteAsync(async (ct) => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = value.Keys.ToArray(), IsPrefix = false }, ct), cancellationToken);
         }
 
         /// <summary>
@@ -554,23 +562,24 @@ public void RemoveAll(IEnumerable<string> cacheKeys)
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        public async Task RemoveAllAsync(IEnumerable<string> cacheKeys)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public async Task RemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
             try
             {
-                await _distributedCache.RemoveAllAsync(cacheKeys);
+                await _distributedCache.RemoveAllAsync(cacheKeys, cancellationToken);
             }
             catch (Exception ex)
             {
                 LogMessage($"remove all async from distributed provider error [{string.Join(",", cacheKeys)}]", ex);
             }
 
-            await _localCache.RemoveAllAsync(cacheKeys);
+            await _localCache.RemoveAllAsync(cacheKeys, cancellationToken);
 
             // send message to bus in order to notify other clients.
-            await _busAsyncWrap.ExecuteAsync(async () => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = cacheKeys.ToArray() }));
+            await _busAsyncWrap.ExecuteAsync(async (ct) => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = cacheKeys.ToArray() }, ct), cancellationToken);
         }
 
         /// <summary>
@@ -621,13 +630,14 @@ public CacheValue<T> Get<T>(string cacheKey, Func<T> dataRetriever, TimeSpan exp
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
 
-            var result = await _localCache.GetAsync<T>(cacheKey);
+            var result = await _localCache.GetAsync<T>(cacheKey, cancellationToken);
 
             if (result.HasValue)
             {
@@ -636,7 +646,7 @@ public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> data
 
             try
             {
-                result = await _distributedCache.GetAsync<T>(cacheKey, dataRetriever, expiration);
+                result = await _distributedCache.GetAsync<T>(cacheKey, dataRetriever, expiration, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -645,7 +655,7 @@ public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> data
 
             if (result.HasValue)
             {
-                TimeSpan ts = await GetExpirationAsync(cacheKey);
+                TimeSpan ts = await GetExpirationAsync(cacheKey, cancellationToken);
 
                 _localCache.Set(cacheKey, result.Value, ts);
 
@@ -683,13 +693,14 @@ public void RemoveByPrefix(string prefix)
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
-        public async Task RemoveByPrefixAsync(string prefix)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public async Task RemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
             try
             {
-                await _distributedCache.RemoveByPrefixAsync(prefix);
+                await _distributedCache.RemoveByPrefixAsync(prefix, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -699,7 +710,7 @@ public async Task RemoveByPrefixAsync(string prefix)
             await _localCache.RemoveByPrefixAsync(prefix);
 
             // send message to bus in order to notify other clients.
-            await _busAsyncWrap.ExecuteAsync(async () => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { prefix }, IsPrefix = true }));
+            await _busAsyncWrap.ExecuteAsync(async (ct) => await _bus.PublishAsync(_options.TopicName, new EasyCachingMessage { Id = _cacheId, CacheKeys = new string[] { prefix }, IsPrefix = true }, ct), cancellationToken);
         }
 
         /// <summary>
@@ -722,13 +733,13 @@ private void LogMessage(string message, Exception ex = null)
             }
         }
 
-        private async Task<TimeSpan> GetExpirationAsync(string cacheKey)
+        private async Task<TimeSpan> GetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             TimeSpan ts = TimeSpan.Zero;
 
             try
             {
-                ts = await _distributedCache.GetExpirationAsync(cacheKey);
+                ts = await _distributedCache.GetExpirationAsync(cacheKey, cancellationToken);
             }
             catch
             {
@@ -764,11 +775,11 @@ private TimeSpan GetExpiration(string cacheKey)
             return ts;
         }
 
-        public async Task<object> GetAsync(string cacheKey, Type type)
+        public async Task<object> GetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            var cacheValue = await _localCache.GetAsync(cacheKey, type);
+            var cacheValue = await _localCache.GetAsync(cacheKey, type, cancellationToken);
 
             if (cacheValue != null)
             {
@@ -779,7 +790,7 @@ public async Task<object> GetAsync(string cacheKey, Type type)
 
             try
             {
-                cacheValue = await _distributedCache.GetAsync(cacheKey, type);
+                cacheValue = await _distributedCache.GetAsync(cacheKey, type, cancellationToken);
             }
             catch (Exception ex)
             {
@@ -788,9 +799,9 @@ public async Task<object> GetAsync(string cacheKey, Type type)
 
             if (cacheValue != null)
             {
-                TimeSpan ts = await GetExpirationAsync(cacheKey);
+                TimeSpan ts = await GetExpirationAsync(cacheKey, cancellationToken);
               
-                await _localCache.SetAsync(cacheKey, cacheValue, ts);
+                await _localCache.SetAsync(cacheKey, cacheValue, ts, cancellationToken);
 
                 return cacheValue;
             }
diff --git a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs
index 2ad61691..cfa87be8 100644
--- a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs
+++ b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs
@@ -2,6 +2,7 @@
 {
     using System;
     using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
     using Microsoft.Extensions.Logging;
@@ -18,9 +19,9 @@ public partial class DefaultInMemoryCachingProvider : EasyCachingAbstractProvide
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever,
-            TimeSpan expiration)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
@@ -44,7 +45,7 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
             if (!_cache.Add($"{cacheKey}_Lock", 1, TimeSpan.FromMilliseconds(_options.LockMs)))
             {
                 //wait for some ms
-                await Task.Delay(_options.SleepMs);
+                await Task.Delay(_options.SleepMs, cancellationToken);
                 return await GetAsync(cacheKey, dataRetriever, expiration);
             }
 
@@ -80,8 +81,9 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -112,7 +114,8 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
         /// </summary>
         /// <returns>The count.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override Task<int> BaseGetCountAsync(string prefix = "")
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             return Task.FromResult(_cache.GetCount(prefix));
         }
@@ -123,7 +126,8 @@ public override Task<int> BaseGetCountAsync(string prefix = "")
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="type">Object Type.</param>
-        public override async Task<object> BaseGetAsync(string cacheKey, Type type)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -154,12 +158,13 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task BaseRemoveAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            await Task.Run(() => { _cache.Remove(cacheKey); });
-        }      
+            await Task.Run(() => { _cache.Remove(cacheKey); }, cancellationToken);
+        }
 
         /// <summary>
         /// Sets the specified cacheKey, cacheValue and expiration async.
@@ -168,8 +173,9 @@ public override async Task BaseRemoveAsync(string cacheKey)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -186,7 +192,7 @@ await Task.Run(() =>
                 //var valExpiration = expiration.Seconds <= 1 ? expiration : TimeSpan.FromSeconds(expiration.Seconds / 2);
                 //var val = new CacheValue<T>(cacheValue, true, valExpiration);
                 _cache.Set(cacheKey, cacheValue, expiration);
-            });
+            }, cancellationToken);
         }
 
         /// <summary>
@@ -194,41 +200,44 @@ await Task.Run(() =>
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task<bool> BaseExistsAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
             return await Task.FromResult(_cache.Exists(cacheKey));
-        }              
+        }
 
         /// <summary>
         /// Removes cached item by cachekey's prefix async.
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override async Task BaseRemoveByPrefixAsync(string prefix)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
-            var count = await Task.Run(() => _cache.RemoveByPrefix(prefix));
+            var count = await Task.Run(() => _cache.RemoveByPrefix(prefix), cancellationToken);
 
             if (_options.EnableLogging)
                 _logger?.LogInformation($"RemoveByPrefixAsync : prefix = {prefix} , count = {count}");
         }
-      
+
         /// <summary>
         /// Sets all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="values">Values.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration)
+        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
             ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
 
-            await Task.Run(() => _cache.SetAll(values, expiration));
+            await Task.Run(() => _cache.SetAll(values, expiration), cancellationToken);
         }
 
         /// <summary>
@@ -236,8 +245,9 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -246,14 +256,15 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
 
             return await Task.FromResult(_cache.GetAll<T>(cacheKeys));
         }
-      
+
         /// <summary>
         /// Gets the by prefix async.
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
             var map = new Dictionary<string, CacheValue<T>>();
@@ -269,21 +280,23 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAs
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
             if (_options.EnableLogging)
                 _logger?.LogInformation($"RemoveAllAsync : cacheKeys = {string.Join(",", cacheKeys)}");
 
-            await Task.Run(() => _cache.RemoveAll(cacheKeys));
+            await Task.Run(() => _cache.RemoveAll(cacheKeys), cancellationToken);
         }
 
         /// <summary>
         /// Flush All Cached Item async.
         /// </summary>
         /// <returns>The async.</returns>
-        public override async Task BaseFlushAsync()
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseFlushAsync(CancellationToken cancellationToken = default)
         {
             if (_options.EnableLogging)
                 _logger?.LogInformation("FlushAsync");
@@ -299,8 +312,9 @@ public override async Task BaseFlushAsync()
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -314,8 +328,9 @@ public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, Tim
         /// Get the expiration of cache key
         /// </summary>
         /// <param name="cacheKey">cache key</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns>expiration</returns>
-        public override Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
diff --git a/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs b/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs
index a14a0997..9e866ce6 100644
--- a/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs
+++ b/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs
@@ -4,6 +4,7 @@
     using Microsoft.Extensions.Logging;
     using System;
     using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
 
     /// <summary>
@@ -16,11 +17,12 @@ public partial class DefaultLiteDBCachingProvider : EasyCachingAbstractProvider
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task<bool> BaseExistsAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            return await Task.Run(() => BaseExists(cacheKey));
+            return await Task.Run(() => BaseExists(cacheKey), cancellationToken);
         }
 
         /// <summary>
@@ -30,8 +32,9 @@ public override async Task<bool> BaseExistsAsync(string cacheKey)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
@@ -41,7 +44,7 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
                                 {
                                     return dataRetriever.Invoke().GetAwaiter().GetResult();
                                 }, expiration);
-                        });
+                        }, cancellationToken);
         }
 
         /// <summary>
@@ -49,11 +52,12 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
-            return await Task.Run(() => BaseGet<T>(cacheKey));
+            return await Task.Run(() => BaseGet<T>(cacheKey), cancellationToken);
         }
 
         /// <summary>
@@ -61,9 +65,10 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
         /// </summary>
         /// <returns>The count.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override async Task<int> BaseGetCountAsync(string prefix = "")
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
-            return await Task.Run(() => BaseGetCount(prefix));
+            return await Task.Run(() => BaseGetCount(prefix), cancellationToken);
         }
 
         /// <summary>
@@ -72,10 +77,11 @@ public override async Task<int> BaseGetCountAsync(string prefix = "")
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="type">Object Type.</param>
-        public override async Task<object> BaseGetAsync(string cacheKey, Type type)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
-            return await Task.Run(() => System.Convert.ChangeType(BaseGet<object>(cacheKey).Value, type));
+            return await Task.Run(() => System.Convert.ChangeType(BaseGet<object>(cacheKey).Value, type), cancellationToken);
         }
 
         /// <summary>
@@ -83,11 +89,12 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task BaseRemoveAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            await Task.Run(() => BaseRemove(cacheKey));
+            await Task.Run(() => BaseRemove(cacheKey), cancellationToken);
         }
 
         /// <summary>
@@ -97,27 +104,29 @@ public override async Task BaseRemoveAsync(string cacheKey)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
-            await Task.Run(() => BaseSet<T>(cacheKey, cacheValue, expiration));
+            await Task.Run(() => BaseSet<T>(cacheKey, cacheValue, expiration), cancellationToken);
         }
 
         /// <summary>
         /// Removes cached item by cachekey's prefix async.
         /// </summary>
         /// <param name="prefix">Prefix of CacheKey.</param>
-        public override async Task BaseRemoveByPrefixAsync(string prefix)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
             if (_options.EnableLogging)
                 _logger?.LogInformation($"RemoveByPrefixAsync : prefix = {prefix}");
 
-            await Task.Run(() => BaseRemoveByPrefix(prefix));
+            await Task.Run(() => BaseRemoveByPrefix(prefix), cancellationToken);
         }
 
         /// <summary>
@@ -126,10 +135,11 @@ public override async Task BaseRemoveByPrefixAsync(string prefix)
         /// <returns>The all async.</returns>
         /// <param name="values">Values.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration)
+        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
-            await Task.Run(() => BaseSetAll(values, expiration));
+            await Task.Run(() => BaseSetAll(values, expiration), cancellationToken);
         }
 
         /// <summary>
@@ -137,11 +147,12 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
-            return await Task.Run(() => BaseGetAll<T>(cacheKeys));
+            return await Task.Run(() => BaseGetAll<T>(cacheKeys), cancellationToken);
         }
 
         /// <summary>
@@ -149,12 +160,13 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
-            return await Task.Run(() => BaseGetByPrefix<T>(prefix));
+            return await Task.Run(() => BaseGetByPrefix<T>(prefix), cancellationToken);
         }
 
         /// <summary>
@@ -162,17 +174,19 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAs
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
-            await Task.Run(() => BaseRemoveAll(cacheKeys));
+            await Task.Run(() => BaseRemoveAll(cacheKeys), cancellationToken);
         }
 
         /// <summary>
         /// Flush All Cached Item async.
         /// </summary>
         /// <returns>The async.</returns>
-        public override async Task BaseFlushAsync() => await Task.Run(BaseFlush);
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseFlushAsync(CancellationToken cancellationToken = default) => await Task.Run(BaseFlush, cancellationToken);
 
         /// <summary>
         /// Tries the set async.
@@ -181,24 +195,26 @@ public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
-            return await Task.Run(() => BaseTrySet(cacheKey, cacheValue, expiration));
+            return await Task.Run(() => BaseTrySet(cacheKey, cacheValue, expiration), cancellationToken);
         }
 
         /// <summary>
         /// Get the expiration of cache key async
         /// </summary>
         /// <param name="cacheKey">cache key</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns>expiration</returns>
-        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
-            return await Task.Run(() => BaseGetExpiration(cacheKey));
+            return await Task.Run(() => BaseGetExpiration(cacheKey), cancellationToken);
         }
     }
 }
\ No newline at end of file
diff --git a/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs b/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs
index 71cced65..6354aa87 100644
--- a/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs
+++ b/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs
@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using Dapper;
     using EasyCaching.Core;
@@ -18,15 +19,16 @@ public partial class DefaultSQLiteCachingProvider : EasyCachingAbstractProvider
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task<bool> BaseExistsAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            var dbResult = await _cache.ExecuteScalarAsync<int>(ConstSQL.EXISTSSQL, new
+            var dbResult = await _cache.ExecuteScalarAsync<int>(new CommandDefinition(ConstSQL.EXISTSSQL, new
             {
                 cachekey = cacheKey,
                 name = _name
-            });
+            }, cancellationToken: cancellationToken));
 
             return dbResult == 1;
         }
@@ -38,17 +40,18 @@ public override async Task<bool> BaseExistsAsync(string cacheKey)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
 
-            var list = await _cache.QueryAsync<string>(ConstSQL.GETSQL, new
+            var list = await _cache.QueryAsync<string>(new CommandDefinition(ConstSQL.GETSQL, new
             {
                 cachekey = cacheKey,
                 name = _name
-            });
+            }, cancellationToken: cancellationToken));
 
             var dbResult = list.FirstOrDefault();
 
@@ -85,16 +88,17 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            var list = await _cache.QueryAsync<string>(ConstSQL.GETSQL, new
+            var list = await _cache.QueryAsync<string>(new CommandDefinition(ConstSQL.GETSQL, new
             {
                 cachekey = cacheKey,
                 name = _name
-            });
+            }, cancellationToken: cancellationToken));
 
             var dbResult = list.FirstOrDefault();
 
@@ -123,15 +127,17 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
         /// </summary>
         /// <returns>The count.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override async Task<int> BaseGetCountAsync(string prefix = "")
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             if (string.IsNullOrWhiteSpace(prefix))
             {
-                return await _cache.ExecuteScalarAsync<int>(ConstSQL.COUNTALLSQL, new { name = _name });
+                
+                return await _cache.ExecuteScalarAsync<int>(new CommandDefinition(ConstSQL.COUNTALLSQL, new { name = _name }, cancellationToken: cancellationToken));
             }
             else
             {
-                return await _cache.ExecuteScalarAsync<int>(ConstSQL.COUNTPREFIXSQL, new { cachekey = string.Concat(prefix, "%"), name = _name });
+                return await _cache.ExecuteScalarAsync<int>(new CommandDefinition(ConstSQL.COUNTPREFIXSQL, new { cachekey = string.Concat(prefix, "%"), name = _name }, cancellationToken: cancellationToken));
             }
         }
 
@@ -141,15 +147,18 @@ public override async Task<int> BaseGetCountAsync(string prefix = "")
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="type">Object Type.</param>
-        public override async Task<object> BaseGetAsync(string cacheKey, Type type)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            var list = await _cache.QueryAsync<string>(ConstSQL.GETSQL, new
+            
+
+            var list = await _cache.QueryAsync<string>(new CommandDefinition(ConstSQL.GETSQL, new
             {
                 cachekey = cacheKey,
                 name = _name
-            });
+            }, cancellationToken: cancellationToken));
 
             var dbResult = list.FirstOrDefault();
 
@@ -178,11 +187,12 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task BaseRemoveAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            await _cache.ExecuteAsync(ConstSQL.REMOVESQL, new { cachekey = cacheKey, name = _name });
+            await _cache.ExecuteAsync(new CommandDefinition(ConstSQL.REMOVESQL, new { cachekey = cacheKey, name = _name }, cancellationToken: cancellationToken));
         }
 
         /// <summary>
@@ -192,8 +202,9 @@ public override async Task BaseRemoveAsync(string cacheKey)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -205,37 +216,43 @@ public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSp
                 expiration.Add(new TimeSpan(0, 0, addSec));
             }
 
-            await _cache.ExecuteAsync(ConstSQL.SETSQL, new
+            await _cache.ExecuteAsync(new CommandDefinition(ConstSQL.SETSQL, new
             {
                 cachekey = cacheKey,
                 name = _name,
                 cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(cacheValue),
                 expiration = expiration.Ticks / 10000000
-            });
-        }            
-  
+            }, cancellationToken: cancellationToken));
+        }
+
         /// <summary>
         /// Removes cached item by cachekey's prefix async.
         /// </summary>
         /// <param name="prefix">Prefix of CacheKey.</param>
-        public override async Task BaseRemoveByPrefixAsync(string prefix)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
             if (_options.EnableLogging)
                 _logger?.LogInformation($"RemoveByPrefixAsync : prefix = {prefix}");
 
-            await _cache.ExecuteAsync(ConstSQL.REMOVEBYPREFIXSQL, new { cachekey = string.Concat(prefix, "%"), name = _name });
+            await _cache.ExecuteAsync(new CommandDefinition(ConstSQL.REMOVEBYPREFIXSQL, new
+            {
+                cachekey = string.Concat(prefix, "%"),
+                name = _name
+            }, cancellationToken: cancellationToken));
         }
-  
+
         /// <summary>
         /// Sets all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="values">Values.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration)
+        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
             ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
@@ -257,22 +274,23 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
 
             tran.Commit();
         }
-   
+
         /// <summary>
         /// Gets all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
-            var list = (await _cache.QueryAsync(ConstSQL.GETALLSQL, new
+            var list = (await _cache.QueryAsync(new CommandDefinition(ConstSQL.GETALLSQL, new
             {
                 cachekey = cacheKeys.ToArray(),
                 name = _name
-            })).ToList();
+            }, cancellationToken: cancellationToken))).ToList();
 
             return GetDict<T>(list);
         }
@@ -282,26 +300,28 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
-            var list = (await _cache.QueryAsync(ConstSQL.GETBYPREFIXSQL, new
+            var list = (await _cache.QueryAsync(new CommandDefinition(ConstSQL.GETBYPREFIXSQL, new
             {
                 cachekey = string.Concat(prefix, "%"),
                 name = _name
-            })).ToList();
+            }, cancellationToken: cancellationToken))).ToList();
 
             return GetDict<T>(list);
         }
-  
+
         /// <summary>
         /// Removes all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -318,8 +338,9 @@ public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
         /// <summary>
         /// Flush All Cached Item async.
         /// </summary>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns>The async.</returns>
-        public override async Task BaseFlushAsync() => await _cache.ExecuteAsync(ConstSQL.FLUSHSQL, new { name = _name });
+        public override async Task BaseFlushAsync(CancellationToken cancellationToken = default) => await _cache.ExecuteAsync(new CommandDefinition(ConstSQL.FLUSHSQL, new { name = _name }, cancellationToken: cancellationToken));
 
         /// <summary>
         /// Tries the set async.
@@ -328,8 +349,9 @@ public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -341,13 +363,13 @@ public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValu
                 expiration.Add(new TimeSpan(0, 0, addSec));
             }
 
-            var rows = await _cache.ExecuteAsync(ConstSQL.TRYSETSQL, new
+            var rows = await _cache.ExecuteAsync(new CommandDefinition(ConstSQL.TRYSETSQL, new
             {
                 cachekey = cacheKey,
                 name = _name,
                 cachevalue = Newtonsoft.Json.JsonConvert.SerializeObject(cacheValue),
                 expiration = expiration.Ticks / 10000000
-            });
+            }, cancellationToken: cancellationToken));
 
             return rows > 0;
         }
@@ -356,16 +378,17 @@ public override async Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValu
         /// Get the expiration of cache key async
         /// </summary>
         /// <param name="cacheKey">cache key</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns>expiration</returns>
-        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
-            var time = await _cache.ExecuteScalarAsync<long>(ConstSQL.GETEXPIRATIONSQL, new
+            var time = await _cache.ExecuteScalarAsync<long>(new CommandDefinition(ConstSQL.GETEXPIRATIONSQL, new
             {
                 cachekey = cacheKey,
                 name = _name
-            });
+            }, cancellationToken: cancellationToken));
 
             if (time <= 0) return TimeSpan.Zero;
             else return TimeSpan.FromSeconds(time);

From bd164b7cf62c228c164610c210ab87af3fe066d3 Mon Sep 17 00:00:00 2001
From: st0o0 <jan.schloots@bluewin.ch>
Date: Tue, 2 Aug 2022 11:22:20 +0200
Subject: [PATCH 2/5] finished CancellationToken implementation

---
 .../DefaultMemcachedCachingProvider.Async.cs  | 69 +++++++++++--------
 .../DefaultRedisCachingProvider.Async.cs      | 51 +++++++++-----
 2 files changed, 75 insertions(+), 45 deletions(-)

diff --git a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs
index 600ace27..5ab09d71 100644
--- a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs
+++ b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs
@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
     using Microsoft.Extensions.Logging;
@@ -11,7 +12,7 @@
     /// Default memcached caching provider.
     /// </summary>
     public partial class DefaultMemcachedCachingProvider : EasyCachingAbstractProvider
-    {       
+    {
         /// <summary>
         /// Gets the specified cacheKey, dataRetriever and expiration async.
         /// </summary>
@@ -19,13 +20,14 @@ public partial class DefaultMemcachedCachingProvider : EasyCachingAbstractProvid
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
 
-            var result = await BaseGetAsync<T>(cacheKey);
+            var result = await BaseGetAsync<T>(cacheKey, cancellationToken);
 
             if (result.HasValue)
             {
@@ -38,13 +40,13 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
             if (!flag)
             {
                 await Task.Delay(_options.SleepMs);
-                return await GetAsync(cacheKey, dataRetriever, expiration);
+                return await GetAsync(cacheKey, dataRetriever, expiration, cancellationToken);
             }
 
             var item = await dataRetriever();
             if (item != null || _options.CacheNulls)
             {
-                await this.SetAsync(cacheKey, item, expiration);
+                await this.SetAsync(cacheKey, item, expiration, cancellationToken);
                 await _memcachedClient.RemoveAsync(this.HandleCacheKey($"{cacheKey}_Lock"));
                 return new CacheValue<T>(item, true);
             }
@@ -54,14 +56,15 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
                 return CacheValue<T>.NoValue;
             }
         }
-      
+
         /// <summary>
         /// Gets the specified cacheKey async.
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -88,7 +91,8 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
         /// </summary>
         /// <returns>The count.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override Task<int> BaseGetCountAsync(string prefix = "")
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             if (string.IsNullOrWhiteSpace(prefix))
             {
@@ -107,7 +111,8 @@ public override Task<int> BaseGetCountAsync(string prefix = "")
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="type">Object Type.</param>
-        public override async Task<object> BaseGetAsync(string cacheKey, Type type)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -129,7 +134,8 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task BaseRemoveAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -144,8 +150,9 @@ public override async Task BaseRemoveAsync(string cacheKey)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -169,13 +176,14 @@ await _memcachedClient.StoreAsync(
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task<bool> BaseExistsAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
             return await Task.FromResult(_memcachedClient.TryGet(this.HandleCacheKey(cacheKey), out object obj));
         }
-                 
+
         /// <summary>
         /// Removes cached item by cachekey's prefix async.
         /// </summary>
@@ -185,8 +193,9 @@ public override async Task<bool> BaseExistsAsync(string cacheKey)
         /// and confirm that you use the namespacing when you set and get the cache.
         /// </remarks>
         /// <param name="prefix">Prefix of CacheKey.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns></returns>
-        public override async Task BaseRemoveByPrefixAsync(string prefix)
+        public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
@@ -215,8 +224,9 @@ await _memcachedClient.StoreAsync(
         /// <returns>The all async.</returns>
         /// <param name="values">Values.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration)
+        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
             ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
@@ -224,18 +234,19 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
             var tasks = new List<Task>();
             foreach (var item in values)
             {
-                tasks.Add(SetAsync(item.Key, item.Value, expiration));
+                tasks.Add(SetAsync(item.Key, item.Value, expiration, cancellationToken));
             }
             await Task.WhenAll(tasks);
         }
-  
+
         /// <summary>
         /// Gets all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -246,30 +257,32 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
                     pair => pair.Key,
                     pair => ConvertFromStoredValue<T>(pair.Value));
         }
-      
+
         /// <summary>
         /// Gets the by prefix async.
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException();
         }
-      
+
         /// <summary>
         /// Removes all async.
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
             var tasks = new List<Task>();
             foreach (var item in cacheKeys.Distinct())
-                tasks.Add(RemoveAsync(item));
+                tasks.Add(RemoveAsync(item, cancellationToken));
 
             await Task.WhenAll(tasks);
         }
@@ -278,14 +291,15 @@ public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
         /// Flush All Cached Item async.
         /// </summary>
         /// <returns>The async.</returns>
-        public override async Task BaseFlushAsync()
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseFlushAsync(CancellationToken cancellationToken = default)
         {
             if (_options.EnableLogging)
                 _logger?.LogInformation("Memcached -- FlushAsync");
 
             await _memcachedClient.FlushAllAsync();
         }
-     
+
         /// <summary>
         /// Tries the set async.
         /// </summary>
@@ -293,8 +307,9 @@ public override async Task BaseFlushAsync()
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -313,7 +328,7 @@ public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, Tim
                 expiration);
         }
 
-        public override Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException();
         }
diff --git a/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs b/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs
index 89a7d137..3fffbfdb 100644
--- a/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs
+++ b/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs
@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
     using Microsoft.Extensions.Logging;
@@ -19,7 +20,8 @@ public partial class DefaultRedisCachingProvider : EasyCachingAbstractProvider
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="type">Object Type.</param>
-        public override async Task<object> BaseGetAsync(string cacheKey, Type type)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -52,8 +54,9 @@ public override async Task<object> BaseGetAsync(string cacheKey, Type type)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="dataRetriever">Data retriever.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
@@ -79,8 +82,8 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
 
             if (!flag)
             {
-                await Task.Delay(_options.SleepMs);
-                return await GetAsync(cacheKey, dataRetriever, expiration);
+                await Task.Delay(_options.SleepMs, cancellationToken);
+                return await GetAsync(cacheKey, dataRetriever, expiration, cancellationToken);
             }
 
             var item = await dataRetriever();
@@ -105,8 +108,9 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -137,7 +141,8 @@ public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
         /// </summary>
         /// <returns>The count.</returns>
         /// <param name="prefix">Prefix.</param>
-        public override Task<int> BaseGetCountAsync(string prefix = "")
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             if (string.IsNullOrWhiteSpace(prefix))
             {
@@ -157,7 +162,8 @@ public override Task<int> BaseGetCountAsync(string prefix = "")
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task BaseRemoveAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -171,8 +177,9 @@ public override async Task BaseRemoveAsync(string cacheKey)
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override async Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -195,7 +202,8 @@ await _cache.StringSetAsync(
         /// </summary>
         /// <returns>The async.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        public override async Task<bool> BaseExistsAsync(string cacheKey)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 
@@ -206,7 +214,8 @@ public override async Task<bool> BaseExistsAsync(string cacheKey)
         /// Removes cached item by cachekey's prefix async.
         /// </summary>
         /// <param name="prefix">Prefix of CacheKey.</param>
-        public override async Task BaseRemoveByPrefixAsync(string prefix)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
@@ -226,8 +235,9 @@ public override async Task BaseRemoveByPrefixAsync(string prefix)
         /// <returns>The all async.</returns>
         /// <param name="values">Values.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration)
+        public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNegativeOrZero(expiration, nameof(expiration));
             ArgumentCheck.NotNullAndCountGTZero(values, nameof(values));
@@ -235,7 +245,7 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
             var tasks = new List<Task>();
 
             foreach (var item in values)
-                tasks.Add(SetAsync(item.Key, item.Value, expiration));
+                tasks.Add(SetAsync(item.Key, item.Value, expiration, cancellationToken));
 
             await Task.WhenAll(tasks);
         }
@@ -245,8 +255,9 @@ public override async Task BaseSetAllAsync<T>(IDictionary<string, T> values, Tim
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -271,8 +282,9 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
         /// </summary>
         /// <returns>The by prefix async.</returns>
         /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
 
@@ -300,7 +312,8 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAs
         /// </summary>
         /// <returns>The all async.</returns>
         /// <param name="cacheKeys">Cache keys.</param>
-        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
 
@@ -313,7 +326,7 @@ public override async Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
         /// Flush All Cached Item async.
         /// </summary>
         /// <returns>The async.</returns>
-        public override async Task BaseFlushAsync()
+        public override async Task BaseFlushAsync(CancellationToken cancellationToken = default)
         {
             if (_options.EnableLogging)
                 _logger?.LogInformation("Redis -- FlushAsync");
@@ -335,8 +348,9 @@ public override async Task BaseFlushAsync()
         /// <param name="cacheKey">Cache key.</param>
         /// <param name="cacheValue">Cache value.</param>
         /// <param name="expiration">Expiration.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
-        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
             ArgumentCheck.NotNull(cacheValue, nameof(cacheValue), _options.CacheNulls);
@@ -360,8 +374,9 @@ public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, Tim
         /// Get the expiration of cache key
         /// </summary>
         /// <param name="cacheKey">cache key</param>
+        /// <param name="cancellationToken">CancellationToken</param>
         /// <returns>expiration</returns>
-        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override async Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
 

From 1b5304d646f49ed6500fe4d725bbe2ebb89c7d88 Mon Sep 17 00:00:00 2001
From: st0o0 <jan.schloots@bluewin.ch>
Date: Tue, 2 Aug 2022 18:52:56 +0200
Subject: [PATCH 3/5] bugfixes Unittest

---
 .../Diagnostics/MyCachingProvider.cs          | 33 ++++++++---------
 .../EasyCachingAbstractProviderTest.cs        |  3 +-
 .../Fake/FakeDistributedCachingProvider.cs    | 35 ++++++++++---------
 .../Fake/FakeLocalCachingProvider.cs          | 35 ++++++++++---------
 4 files changed, 55 insertions(+), 51 deletions(-)

diff --git a/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs b/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs
index 59c3165d..698d10f7 100644
--- a/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs
+++ b/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs
@@ -2,7 +2,8 @@
 {
     using EasyCaching.Core;
     using System;
-    using System.Collections.Generic;
+    using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
 
     public class MyCachingProvider : EasyCachingAbstractProvider
@@ -21,7 +22,7 @@ public override bool BaseExists(string cacheKey)
             return true;
         }
 
-        public override Task<bool> BaseExistsAsync(string cacheKey)
+        public override Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(false);
         }
@@ -31,7 +32,7 @@ public override void BaseFlush()
 
         }
 
-        public override Task BaseFlushAsync()
+        public override Task BaseFlushAsync(CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -51,22 +52,22 @@ public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<str
             return null;
         }
 
-        public override Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public override Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             return null;
         }
 
-        public override Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(CacheValue<T>.NoValue);
         }
 
-        public override Task<object> BaseGetAsync(string cacheKey, Type type)
+        public override Task<object> BaseGetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             return Task.FromResult<object>(null);
         }
 
-        public override Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey)
+        public override Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(CacheValue<T>.NoValue);
         }
@@ -76,7 +77,7 @@ public override IDictionary<string, CacheValue<T>> BaseGetByPrefix<T>(string pre
             return null;
         }
 
-        public override Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix)
+        public override Task<IDictionary<string, CacheValue<T>>> BaseGetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             return Task.FromResult<IDictionary<string, CacheValue<T>>>(null);
         }
@@ -86,7 +87,7 @@ public override int BaseGetCount(string prefix = "")
             return 1;
         }
 
-        public override Task<int> BaseGetCountAsync(string prefix = "")
+        public override Task<int> BaseGetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             return Task.FromResult(1);
         }
@@ -96,7 +97,7 @@ public override TimeSpan BaseGetExpiration(string cacheKey)
             return TimeSpan.FromSeconds(1);
         }
 
-        public override Task<TimeSpan> BaseGetExpirationAsync(string cacheKey)
+        public override Task<TimeSpan> BaseGetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(TimeSpan.FromSeconds(1));
         }
@@ -116,12 +117,12 @@ public override void BaseRemoveAll(IEnumerable<string> cacheKeys)
 
         }
 
-        public override Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys)
+        public override Task BaseRemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
 
-        public override Task BaseRemoveAsync(string cacheKey)
+        public override Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -131,7 +132,7 @@ public override void BaseRemoveByPrefix(string prefix)
 
         }
 
-        public override Task BaseRemoveByPrefixAsync(string prefix)
+        public override Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -146,12 +147,12 @@ public override void BaseSetAll<T>(IDictionary<string, T> values, TimeSpan expir
 
         }
 
-        public override Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration)
+        public override Task BaseSetAllAsync<T>(IDictionary<string, T> values, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
 
-        public override Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override Task BaseSetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -161,7 +162,7 @@ public override bool BaseTrySet<T>(string cacheKey, T cacheValue, TimeSpan expir
             return false;
         }
 
-        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public override Task<bool> BaseTrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(false);
         }
diff --git a/test/EasyCaching.UnitTests/DistributedLock/EasyCachingAbstractProviderTest.cs b/test/EasyCaching.UnitTests/DistributedLock/EasyCachingAbstractProviderTest.cs
index 158a5e5a..1ae207db 100644
--- a/test/EasyCaching.UnitTests/DistributedLock/EasyCachingAbstractProviderTest.cs
+++ b/test/EasyCaching.UnitTests/DistributedLock/EasyCachingAbstractProviderTest.cs
@@ -5,6 +5,7 @@
 using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using Xunit;
 
@@ -55,7 +56,7 @@ public override CacheValue<T> BaseGet<T>(string cacheKey, Func<T> dataRetriever,
             throw new InvalidOperationException();
         }
 
-        public override Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public override Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             throw new InvalidOperationException();
         }
diff --git a/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs
index a5927505..8d350618 100644
--- a/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs
+++ b/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs
@@ -1,7 +1,8 @@
 namespace EasyCaching.UnitTests
 {
     using System;
-    using System.Collections.Generic;
+    using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
 
@@ -28,7 +29,7 @@ public virtual bool Exists(string cacheKey)
             return true;
         }
 
-        public virtual Task<bool> ExistsAsync(string cacheKey)
+        public virtual Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(true);
         }
@@ -38,7 +39,7 @@ public virtual void Flush()
 
         }
 
-        public virtual Task FlushAsync()
+        public virtual Task FlushAsync(CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -58,23 +59,23 @@ public virtual IDictionary<string, CacheValue<T>> GetAll<T>(IEnumerable<string>
             return new Dictionary<string, CacheValue<T>>();
         }
 
-        public virtual Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public virtual Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             IDictionary<string, CacheValue<T>> dict = new Dictionary<string, CacheValue<T>>();
             return Task.FromResult(dict);
         }
 
-        public virtual Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public virtual Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new CacheValue<T>(default(T), true));
         }
 
-        public virtual Task<object> GetAsync(string cacheKey, Type type)
+        public virtual Task<object> GetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             return Task.FromResult<object>(null);
         }
 
-        public virtual Task<CacheValue<T>> GetAsync<T>(string cacheKey)
+        public virtual Task<CacheValue<T>> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new CacheValue<T>(default(T), true));
         }
@@ -84,7 +85,7 @@ public virtual IDictionary<string, CacheValue<T>> GetByPrefix<T>(string prefix)
             return new Dictionary<string, CacheValue<T>>();
         }
 
-        public virtual Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix)
+        public virtual Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             IDictionary<string, CacheValue<T>> dict = new Dictionary<string, CacheValue<T>>();
             return Task.FromResult(dict);
@@ -95,7 +96,7 @@ public virtual int GetCount(string prefix = "")
             return 1;
         }
 
-        public Task<int> GetCountAsync(string prefix = "")
+        public Task<int> GetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             return Task.FromResult(1);
         }
@@ -105,7 +106,7 @@ public virtual TimeSpan GetExpiration(string cacheKey)
             return TimeSpan.FromSeconds(1);
         }
 
-        public virtual Task<TimeSpan> GetExpirationAsync(string cacheKey)
+        public virtual Task<TimeSpan> GetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(TimeSpan.FromSeconds(1));
         }
@@ -120,7 +121,7 @@ public virtual void Refresh<T>(string cacheKey, T cacheValue, TimeSpan expiratio
 
         }
 
-        public virtual Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public virtual Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -135,12 +136,12 @@ public virtual void RemoveAll(IEnumerable<string> cacheKeys)
 
         }
 
-        public virtual Task RemoveAllAsync(IEnumerable<string> cacheKeys)
+        public virtual Task RemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
 
-        public virtual Task RemoveAsync(string cacheKey)
+        public virtual Task RemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -150,7 +151,7 @@ public virtual void RemoveByPrefix(string prefix)
 
         }
 
-        public virtual Task RemoveByPrefixAsync(string prefix)
+        public virtual Task RemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -165,12 +166,12 @@ public virtual void SetAll<T>(IDictionary<string, T> value, TimeSpan expiration)
 
         }
 
-        public virtual Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration)
+        public virtual Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
 
-        public virtual Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public virtual Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -180,7 +181,7 @@ public virtual bool TrySet<T>(string cacheKey, T cacheValue, TimeSpan expiration
             return true;
         }
 
-        public virtual Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public virtual Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(true);
         }
diff --git a/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs
index f1fa863a..a2bead29 100644
--- a/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs
+++ b/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs
@@ -1,7 +1,8 @@
 namespace EasyCaching.UnitTests
 {
     using System;
-    using System.Collections.Generic;
+    using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
     using EasyCaching.Core;
 
@@ -28,7 +29,7 @@ public bool Exists(string cacheKey)
             return true;
         }
 
-        public Task<bool> ExistsAsync(string cacheKey)
+        public Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(true);
         }
@@ -38,7 +39,7 @@ public void Flush()
 
         }
 
-        public Task FlushAsync()
+        public Task FlushAsync(CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -58,23 +59,23 @@ public IDictionary<string, CacheValue<T>> GetAll<T>(IEnumerable<string> cacheKey
             return new Dictionary<string, CacheValue<T>>();
         }
 
-        public Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys)
+        public Task<IDictionary<string, CacheValue<T>>> GetAllAsync<T>(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             IDictionary<string, CacheValue<T>> dict = new Dictionary<string, CacheValue<T>>();
             return Task.FromResult(dict);
         }
 
-        public Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration)
+        public Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new CacheValue<T>(default(T), true));
         }
 
-        public Task<object> GetAsync(string cacheKey, Type type)
+        public Task<object> GetAsync(string cacheKey, Type type, CancellationToken cancellationToken = default)
         {
             return Task.FromResult<object>(null);
         }
 
-        public Task<CacheValue<T>> GetAsync<T>(string cacheKey)
+        public Task<CacheValue<T>> GetAsync<T>(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(new CacheValue<T>(default(T), true));
         }
@@ -84,7 +85,7 @@ public IDictionary<string, CacheValue<T>> GetByPrefix<T>(string prefix)
             return new Dictionary<string, CacheValue<T>>();
         }
 
-        public Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix)
+        public Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string prefix, CancellationToken cancellationToken = default)
         {
             IDictionary<string, CacheValue<T>> dict = new Dictionary<string, CacheValue<T>>();
             return Task.FromResult(dict);
@@ -95,7 +96,7 @@ public int GetCount(string prefix = "")
             return 1;
         }
 
-        public Task<int> GetCountAsync(string prefix = "")
+        public Task<int> GetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             return Task.FromResult(1);
         }
@@ -105,7 +106,7 @@ public TimeSpan GetExpiration(string cacheKey)
             return TimeSpan.FromSeconds(1);
         }
 
-        public Task<TimeSpan> GetExpirationAsync(string cacheKey)
+        public Task<TimeSpan> GetExpirationAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(TimeSpan.FromSeconds(1));
         }
@@ -120,7 +121,7 @@ public void Refresh<T>(string cacheKey, T cacheValue, TimeSpan expiration)
 
         }
 
-        public Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -135,12 +136,12 @@ public void RemoveAll(IEnumerable<string> cacheKeys)
 
         }
 
-        public Task RemoveAllAsync(IEnumerable<string> cacheKeys)
+        public Task RemoveAllAsync(IEnumerable<string> cacheKeys, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
 
-        public Task RemoveAsync(string cacheKey)
+        public Task RemoveAsync(string cacheKey, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -150,7 +151,7 @@ public void RemoveByPrefix(string prefix)
 
         }
 
-        public Task RemoveByPrefixAsync(string prefix)
+        public Task RemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -165,12 +166,12 @@ public void SetAll<T>(IDictionary<string, T> value, TimeSpan expiration)
 
         }
 
-        public Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration)
+        public Task SetAllAsync<T>(IDictionary<string, T> value, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
 
-        public Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public Task SetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.CompletedTask;
         }
@@ -180,7 +181,7 @@ public bool TrySet<T>(string cacheKey, T cacheValue, TimeSpan expiration)
             return true;
         }
 
-        public Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration)
+        public Task<bool> TrySetAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             return Task.FromResult(true);
         }

From 04d2bed08f9d70c606585b7172805c7fc3240ead Mon Sep 17 00:00:00 2001
From: st0o0 <jan.schloots@bluewin.ch>
Date: Tue, 2 Aug 2022 18:59:02 +0200
Subject: [PATCH 4/5] HybridCachingTest needed a default CancellationToken

---
 test/EasyCaching.UnitTests/CachingTests/HybridCachingTest.cs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/EasyCaching.UnitTests/CachingTests/HybridCachingTest.cs b/test/EasyCaching.UnitTests/CachingTests/HybridCachingTest.cs
index 1cb389ff..b4170b95 100644
--- a/test/EasyCaching.UnitTests/CachingTests/HybridCachingTest.cs
+++ b/test/EasyCaching.UnitTests/CachingTests/HybridCachingTest.cs
@@ -185,7 +185,7 @@ public void Distributed_Remove_Throw_Exception_Should_Not_Break()
         [Fact]
         public async Task Distributed_Remove_Async_Throw_Exception_Should_Not_Break()
         {
-            A.CallTo(() => fakeDisProvider.RemoveAsync("fake-remove-key")).ThrowsAsync(new Exception());
+            A.CallTo(() => fakeDisProvider.RemoveAsync("fake-remove-key", default)).ThrowsAsync(new Exception());
 
             await fakeHybrid.RemoveAsync("fake-remove-key");
 
@@ -210,7 +210,7 @@ public void Distributed_Set_Throw_Exception_Should_Not_Break()
         [Fact]
         public async Task Distributed_Set_Async_Throw_Exception_Should_Not_Break()
         {
-            A.CallTo(() => fakeDisProvider.SetAsync(A<string>.Ignored, A<string>.Ignored, A<TimeSpan>.Ignored)).ThrowsAsync(new Exception());
+            A.CallTo(() => fakeDisProvider.SetAsync(A<string>.Ignored, A<string>.Ignored, A<TimeSpan>.Ignored, default)).ThrowsAsync(new Exception());
 
             var key = $"d-set-{Guid.NewGuid().ToString()}";
 

From df12b51d484fbd9bd19305ef71070a2a4e7b4d5e Mon Sep 17 00:00:00 2001
From: st0o0 <jan.schloots@bluewin.ch>
Date: Wed, 3 Aug 2022 16:08:29 +0200
Subject: [PATCH 5/5] XML Comment removed

---
 src/EasyCaching.HybridCache/HybridCachingProvider.cs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/EasyCaching.HybridCache/HybridCachingProvider.cs b/src/EasyCaching.HybridCache/HybridCachingProvider.cs
index 55a41839..92f7ab79 100644
--- a/src/EasyCaching.HybridCache/HybridCachingProvider.cs
+++ b/src/EasyCaching.HybridCache/HybridCachingProvider.cs
@@ -188,7 +188,7 @@ public async Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellat
             // Circuit Breaker may be more better
             try
             {
-                flag = await _distributedCache.ExistsAsync(cacheKey);
+                flag = await _distributedCache.ExistsAsync(cacheKey, cancellationToken);
                 return flag;
             }
             catch (Exception ex)
@@ -196,7 +196,7 @@ public async Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellat
                 LogMessage($"Check cache key [{cacheKey}] exists error", ex);
             }
 
-            flag = await _localCache.ExistsAsync(cacheKey);
+            flag = await _localCache.ExistsAsync(cacheKey, cancellationToken);
             return flag;
         }
 
@@ -205,7 +205,6 @@ public async Task<bool> ExistsAsync(string cacheKey, CancellationToken cancellat
         /// </summary>
         /// <returns>The get.</returns>
         /// <param name="cacheKey">Cache key.</param>
-        /// <param name="cancellationToken">CancellationToken</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
         public CacheValue<T> Get<T>(string cacheKey)
         {