Add GetAllKeysByPrefix to InMemory and Redis (#422)

meysamhadeli · web-flow · commit 7b63e2687efe · 2022-11-30T10:35:19.000+08:00
* - add getall (inMemory - redis)
- add getall-keys (inMemory - resis)

* refactor get-all and get-all-keys with optional prefix

* add GetAllKeysByPrefix for InMemoryCache and Redis

* handle base KeyPrefix from config in result GetAllKeysByPrefix
diff --git a/sample/EasyCaching.Demo.ConsoleApp/Program.cs b/sample/EasyCaching.Demo.ConsoleApp/Program.cs
@@ -1,4 +1,6 @@
-﻿namespace EasyCaching.Demo.ConsoleApp
+﻿using System.Threading.Tasks;
+
+namespace EasyCaching.Demo.ConsoleApp
 {
     using EasyCaching.Core;
     using EasyCaching.SQLite;
@@ -16,13 +18,13 @@ static void Main(string[] args)
             {
                 option.UseInMemory("m1");
 
-                //option.UseRedis(config =>
-                //{
-                //    config.DBConfig = new Redis.RedisDBOptions { Configuration = "localhost" };
-                //    config.SerializerName = "json";
-                //}, "r1");
-
-
+                // option.UseRedis(config =>
+                // {
+                //     config.DBConfig = new Redis.RedisDBOptions { Configuration = "localhost" };
+                //     config.SerializerName = "json";
+                // }, "r1");
+                //
+                
                 option.UseSQLite(c =>
                 {
                     c.DBConfig = new SQLiteDBOptions
@@ -33,43 +35,51 @@ static void Main(string[] args)
                     };
                 }, "s1");
 
-                //option.WithJson(jsonSerializerSettingsConfigure: x =>
-                //{
-                //    x.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None;
-                //}, "json");
+                // option.WithJson(jsonSerializerSettingsConfigure: x =>
+                // {
+                //     x.TypeNameHandling = Newtonsoft.Json.TypeNameHandling.None;
+                // }, "json");
             });
 
             IServiceProvider serviceProvider = services.BuildServiceProvider();
             var factory = serviceProvider.GetService<IEasyCachingProviderFactory>();
-
-            //var redisCache = factory.GetCachingProvider("r1");
-
-            //redisCache.Set<Product>("rkey", new Product() { Name = "test" }, TimeSpan.FromSeconds(20));
-
-            //var redisVal = redisCache.Get<Product>("rkey");
-
-            //Console.WriteLine($"redis cache get value, {redisVal.HasValue} {redisVal.IsNull} {redisVal.Value} ");
-
-
+            
+            // var redisCache = factory.GetCachingProvider("r1");
+            //
+            // redisCache.Set<Product>("rkey", new Product() { Name = "test" }, TimeSpan.FromSeconds(20));
+            //
+            // var redisAllKey = redisCache.GetAllKeysByPrefix("rkey");
+            //
+            // var redisVal = redisCache.Get<Product>("rkey");
+            //
+            // Console.WriteLine($"redis cache get value, {redisVal.HasValue} {redisVal.IsNull} {redisVal.Value}");
+
+
+            
             var mCache = factory.GetCachingProvider("m1");
-
+            
             mCache.Set<Product>("mkey1", new Product() { Name = "test" }, TimeSpan.FromSeconds(20));
 
             var mVal1 = mCache.Get<Product>("mkey1");
 
-
             mCache.Set<string>("mkey", "mvalue", TimeSpan.FromSeconds(20));
-
+            
             var mVal = mCache.Get<string>("mkey");
-
+            
+            var mAllKey = mCache.GetAllKeysByPrefix("mk");
+            
             Console.WriteLine($"in-memory cache get value, {mVal.HasValue} {mVal.IsNull} {mVal.Value} ");
 
+            
             var sCache = factory.GetCachingProvider("s1");
 
+            
             sCache.Set<string>("skey", "svalue", TimeSpan.FromSeconds(20));
 
+            
             var sVal = sCache.Get<string>("skey");
 
+            
             Console.WriteLine($"sqlite cache get value, {sVal.HasValue} {sVal.IsNull} {sVal.Value} ");
 
             Console.ReadKey();
@@ -82,3 +92,4 @@ public class Product
         public string Name { get; set; }
     }
 }
+
diff --git a/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs b/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs
@@ -64,6 +64,11 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
             return result;
         }
 
+        public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException();
+        }
+
         /// <summary>
         /// Gets the async.
         /// </summary>
diff --git a/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.cs b/src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.cs
@@ -252,6 +252,11 @@ public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<str
             return result;
         }
 
+        public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)
+        {
+            throw new NotSupportedException();
+        }
+
         /// <summary>
         /// Handles the prefix of CacheKey.
         /// </summary>
diff --git a/src/EasyCaching.Core/EasyCachingAbstractProvider.cs b/src/EasyCaching.Core/EasyCachingAbstractProvider.cs
@@ -49,6 +49,8 @@ protected EasyCachingAbstractProvider(IDistributedLockFactory lockFactory, BaseP
         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 IEnumerable<string> BaseGetAllKeysByPrefix(string prefix);
+        public abstract Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default);
         public abstract IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<string> cacheKeys);
         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);
@@ -256,6 +258,58 @@ public CacheValue<T> Get<T>(string cacheKey)
                 }
             }
         }
+        
+        public IEnumerable<string> GetAllKeysByPrefix(string prefix)
+        {
+            var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAllKeysByPrefix), new[] { prefix }));
+            Exception e = null;
+            try
+            {
+                return BaseGetAllKeysByPrefix(prefix);
+            }
+            catch (Exception ex)
+            {
+                e = ex;
+                throw;
+            }
+            finally
+            {
+                if (e != null)
+                {
+                    s_diagnosticListener.WriteGetCacheError(operationId, e);
+                }
+                else
+                {
+                    s_diagnosticListener.WriteGetCacheAfter(operationId);
+                } 
+            }        
+        }
+        
+        public async Task<IEnumerable<string>> GetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
+        {
+            var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(GetAllKeysByPrefixAsync), new[] { prefix }));
+            Exception e = null;
+            try
+            {
+                return await BaseGetAllKeysByPrefixAsync(prefix);
+            }
+            catch (Exception ex)
+            {
+                e = ex;
+                throw;
+            }
+            finally
+            {
+                if (e != null)
+                {
+                    s_diagnosticListener.WriteGetCacheError(operationId, e);
+                }
+                else
+                {
+                    s_diagnosticListener.WriteGetCacheAfter(operationId);
+                }
+            }
+        }
 
         public IDictionary<string, CacheValue<T>> GetAll<T>(IEnumerable<string> cacheKeys)
         {
diff --git a/src/EasyCaching.Core/IEasyCachingProvider.cs b/src/EasyCaching.Core/IEasyCachingProvider.cs
@@ -21,8 +21,23 @@ public interface IEasyCachingProvider : IEasyCachingProviderBase
         /// </summary>
         /// <value><c>true</c> if is use lock; otherwise, <c>false</c>.</value>
         bool UseLock { get; }
+        
+        /// <summary>
+        /// Gets all keys by prefix.
+        /// </summary>
+        /// <param name="prefix">Prefix.</param>
+        /// <returns>The all keys by prefix.</returns>
+        IEnumerable<string> GetAllKeysByPrefix(string prefix);
+        
+        /// <summary>
+        /// Gets all keys by prefix async.
+        /// </summary>
+        /// <param name="prefix">Prefix.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
+        /// <returns>The all keys by prefix async.</returns>
+        Task<IEnumerable<string>> GetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default);
 
-       /// <summary>
+        /// <summary>
         /// Gets all.
         /// </summary>
         /// <returns>The all.</returns>
diff --git a/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs b/src/EasyCaching.Disk/DefaultDiskCachingProvider.Async.cs
@@ -85,6 +85,12 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
             return dict;
         }
 
+
+        public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException();
+        }
+
         public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)
         {
             ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));
diff --git a/src/EasyCaching.Disk/DefaultDiskCachingProvider.cs b/src/EasyCaching.Disk/DefaultDiskCachingProvider.cs
@@ -336,6 +336,11 @@ public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<str
             return dict;
         }
 
+        public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)
+        {
+            throw new NotSupportedException();
+        }
+
         public override IDictionary<string, CacheValue<T>> BaseGetByPrefix<T>(string prefix)
         {
             ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
diff --git a/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs b/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.Async.cs
@@ -29,6 +29,10 @@ public override async Task BaseFlushAsync(CancellationToken cancellationToken =
             }
         }  
 
+        public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException();
+        }
 
         public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys,
             CancellationToken cancellationToken = default)
diff --git a/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.cs b/src/EasyCaching.FasterKv/DefaultFasterKvCachingProvider.cs
@@ -161,6 +161,11 @@ public override CacheValue<T> BaseGet<T>(string cacheKey)
             using var session = GetSession();
             return BaseGetInternal<T>(cacheKey, session);
         }
+        
+        public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)
+        {
+            throw new NotSupportedException();
+        }
 
         public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<string> cacheKeys)
         {
diff --git a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.Async.cs
@@ -275,6 +275,21 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
 
             return await Task.FromResult(_cache.GetAll<T>(cacheKeys));
         }
+        
+
+        /// <summary>
+        /// Get all cacheKey by prefix async.
+        /// </summary>
+        /// <param name="prefix">Cache keys.</param>
+        /// <param name="cancellationToken">Cache keys.</param>
+        /// <returns>Get all cacheKey by prefix async.</returns>
+        public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
+        {
+            if (_options.EnableLogging)
+                _logger?.LogInformation("GetAllKeysAsync");
+
+            return Task.FromResult(_cache.GetAllKeys(prefix));
+        }
 
         /// <summary>
         /// Gets the by prefix async.
diff --git a/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.cs b/src/EasyCaching.InMemory/DefaultInMemoryCachingProvider.cs
@@ -307,6 +307,19 @@ public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<str
             return _cache.GetAll<T>(cacheKeys);
         }
 
+        /// <summary>
+        /// Get all cacheKey by prefix.
+        /// </summary>
+        /// <param name="prefix">Prefix.</param>
+        /// <returns>Get all cacheKey by prefix.</returns>
+        public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)
+        {
+            if (_options.EnableLogging)
+                _logger?.LogInformation("GetAllKeys");
+
+            return _cache.GetAllKeys(prefix);
+        }
+
         /// <summary>
         /// Gets the by prefix.
         /// </summary>
diff --git a/src/EasyCaching.InMemory/Internal/IInMemoryCaching.cs b/src/EasyCaching.InMemory/Internal/IInMemoryCaching.cs
@@ -19,6 +19,7 @@ public interface IInMemoryCaching
         bool Remove(string key);
         int RemoveByPrefix(string prefix);
         int RemoveByPattern(string searchKey, SearchKeyPattern searchPattern);
+        IEnumerable<string> GetAllKeys(string prefix);
         IDictionary<string, CacheValue<T>> GetAll<T>(IEnumerable<string> keys);
         int SetAll<T>(IDictionary<string, T> values, TimeSpan? expiresIn = null);
         bool Replace<T>(string key, T value, TimeSpan? expiresIn = null);
diff --git a/src/EasyCaching.InMemory/Internal/InMemoryCaching.cs b/src/EasyCaching.InMemory/Internal/InMemoryCaching.cs
@@ -280,6 +280,12 @@ public int RemoveByPattern(string searchKey, SearchKeyPattern searchPattern)
             return RemoveAll(keysToRemove);
         }
 
+        public IEnumerable<string> GetAllKeys(string prefix)
+        {
+            return _memory.Values.Where(x => x.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && x.ExpiresAt > SystemClock.UtcNow)
+                .Select(x=> x.Key).ToList();
+        }
+
         private static bool FilterByPattern(string key, string searchKey, SearchKeyPattern searchKeyPattern)
         {
             switch (searchKeyPattern)
@@ -306,6 +312,15 @@ public IDictionary<string, CacheValue<T>> GetAll<T>(IEnumerable<string> keys)
             return map;
         }
 
+        public IDictionary<string, CacheValue<T>> GetAll<T>(string prefix = "")
+        {
+            var values = string.IsNullOrEmpty(prefix) 
+                ? _memory.Values.Where(x => x.ExpiresAt > SystemClock.UtcNow) 
+                : _memory.Values.Where(x => x.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && x.ExpiresAt > SystemClock.UtcNow);
+            
+            return values.ToDictionary(k => k.Key, v => new CacheValue<T>(v.GetValue<T>(_options.EnableReadDeepClone), true));
+        }
+
         public int SetAll<T>(IDictionary<string, T> values, TimeSpan? expiresIn = null)
         {
             if (values == null || values.Count == 0) return 0;
diff --git a/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs b/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.Async.cs
@@ -169,6 +169,11 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
             ArgumentCheck.NotNullAndCountGTZero(cacheKeys, nameof(cacheKeys));
             return await Task.Run(() => BaseGetAll<T>(cacheKeys), cancellationToken);
         }
+        
+        public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException();
+        }
 
         /// <summary>
         /// Gets the by prefix async.
diff --git a/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.cs b/src/EasyCaching.LiteDB/DefaultLiteDBCachingProvider.cs
@@ -321,6 +321,11 @@ public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<str
             return GetDict<T>(list);
         }
 
+        public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)
+        {
+            throw new NotSupportedException();
+        }
+
         /// <summary>
         /// Gets the dict.
         /// </summary>
diff --git a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.Async.cs
@@ -262,6 +262,11 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T
                     pair => pair.Key,
                     pair => ConvertFromStoredValue<T>(pair.Value));
         }
+        
+        public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)
+        {
+            throw new NotSupportedException();
+        }
 
         /// <summary>
         /// Gets the by prefix async.
diff --git a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.cs b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.cs
@@ -336,6 +336,11 @@ public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<str
                     pair => ConvertFromStoredValue<T>(pair.Value));
         }
 
+        public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)
+        {
+            throw new NotSupportedException();
+        }
+
         /// <summary>
         /// Gets the by prefix.
         /// </summary>
diff --git a/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs b/src/EasyCaching.Redis/DefaultRedisCachingProvider.Async.cs
diff --git a/src/EasyCaching.Redis/DefaultRedisCachingProvider.cs b/src/EasyCaching.Redis/DefaultRedisCachingProvider.cs
diff --git a/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs b/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.Async.cs
diff --git a/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.cs b/src/EasyCaching.SQLite/DefaultSQLiteCachingProvider.cs
diff --git a/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs b/test/EasyCaching.UnitTests/Diagnostics/MyCachingProvider.cs
diff --git a/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeDistributedCachingProvider.cs
diff --git a/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs b/test/EasyCaching.UnitTests/Fake/FakeLocalCachingProvider.cs

Original file line number	Diff line number	Diff line change
`@@ -85,6 +85,12 @@ public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T`
`85`	`85`	`return dict;`
`86`	`86`	`}`
`87`	`87`
	`88`	`+`
	`89`	`+ public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)`
	`90`	`+ {`
	`91`	`+ throw new NotSupportedException();`
	`92`	`+ }`
	`93`	`+`
`88`	`94`	`public override async Task<CacheValue<T>> BaseGetAsync<T>(string cacheKey, Func<Task<T>> dataRetriever, TimeSpan expiration, CancellationToken cancellationToken = default)`
`89`	`95`	`{`
`90`	`96`	`ArgumentCheck.NotNullOrWhiteSpace(cacheKey, nameof(cacheKey));`
Original file line number	Diff line number	Diff line change
`@@ -336,6 +336,11 @@ public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<str`
`336`	`336`	`return dict;`
`337`	`337`	`}`
`338`	`338`
	`339`	`+ public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)`
	`340`	`+ {`
	`341`	`+ throw new NotSupportedException();`
	`342`	`+ }`
	`343`	`+`
`339`	`344`	`public override IDictionary<string, CacheValue<T>> BaseGetByPrefix<T>(string prefix)`
`340`	`345`	`{`
`341`	`346`	`ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));`
Original file line number	Diff line number	Diff line change
`@@ -29,6 +29,10 @@ public override async Task BaseFlushAsync(CancellationToken cancellationToken =`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
	`32`	`+ public override Task<IEnumerable<string>> BaseGetAllKeysByPrefixAsync(string prefix, CancellationToken cancellationToken = default)`
	`33`	`+ {`
	`34`	`+ throw new NotSupportedException();`
	`35`	`+ }`
`32`	`36`
`33`	`37`	`public override async Task<IDictionary<string, CacheValue<T>>> BaseGetAllAsync<T>(IEnumerable<string> cacheKeys,`
`34`	`38`	`CancellationToken cancellationToken = default)`
Original file line number	Diff line number	Diff line change
`@@ -161,6 +161,11 @@ public override CacheValue<T> BaseGet<T>(string cacheKey)`
`161`	`161`	`using var session = GetSession();`
`162`	`162`	`return BaseGetInternal<T>(cacheKey, session);`
`163`	`163`	`}`
	`164`	`+`
	`165`	`+ public override IEnumerable<string> BaseGetAllKeysByPrefix(string prefix)`
	`166`	`+ {`
	`167`	`+ throw new NotSupportedException();`
	`168`	`+ }`
`164`	`169`
`165`	`170`	`public override IDictionary<string, CacheValue<T>> BaseGetAll<T>(IEnumerable<string> cacheKeys)`
`166`	`171`	`{`