Support removing cache keys by pattern (#401)

* Support removing cache keys by pattern

* Fix redis port

* Handle removing cache by pattern in OnMessage

Author: xsoheilalizadeh

src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.Async.cs

@@ -299,6 +299,33 @@ public override async Task BaseRemoveByPrefixAsync(string prefix, CancellationTo
             await Task.WhenAll(tasks);
         }
 
+        /// <summary>
+        /// Removes the by pattern async.
+        /// </summary>
+        /// <returns>The by pattern async.</returns>
+        /// <param name="pattern">Pattern.</param>
+        /// <param name="cancellationToken">CancellationToken</param>
+        public override async Task BaseRemoveByPatternAsync(string pattern, CancellationToken cancellationToken = default)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(pattern, nameof(pattern));
+            
+            pattern = this.HandleKeyPattern(pattern);
+
+            if (_options.EnableLogging)
+                _logger?.LogInformation($"RemoveByPatternAsync : pattern = {pattern}");
+            
+            var redisKeys = this.SearchRedisKeys(pattern);
+
+            var tasks = new List<Task<long>>();
+
+            foreach (var item in redisKeys)
+            {
+                tasks.Add(_cache.DelAsync(item));
+            }
+
+            await Task.WhenAll(tasks);
+        }
+
         /// <summary>
         /// Sets all async.
         /// </summary>

src/EasyCaching.CSRedis/DefaultCSRedisCachingProvider.cs

@@ -275,6 +275,22 @@ private string HandlePrefix(string prefix)
 
             return prefix;
         }
+        
+        /// <summary>
+        /// Handles the pattern of CacheKey.
+        /// </summary>
+        /// <param name="pattern">Pattern of CacheKey.</param>
+        private string HandleKeyPattern(string pattern)
+        {
+            // Forbid
+            if (pattern.Equals("*"))
+                throw new ArgumentException("the pattern should not equal to *");
+
+            if (!string.IsNullOrWhiteSpace(_cache.Nodes?.Values?.FirstOrDefault()?.Prefix))
+                pattern = _cache.Nodes?.Values?.FirstOrDefault()?.Prefix + pattern;
+
+            return pattern;
+        }
 
         /// <summary>
         /// Searchs the redis keys.
@@ -401,6 +417,27 @@ public override void BaseRemoveByPrefix(string prefix)
             }
         }
 
+        /// <summary>
+        /// Remove cached value by pattern
+        /// </summary>
+        /// <param name="pattern">The pattern of cache key</param>
+        public override void BaseRemoveByPattern(string pattern)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(pattern, nameof(pattern));
+
+            pattern = this.HandleKeyPattern(pattern);
+
+            if (_options.EnableLogging)
+                _logger?.LogInformation($"RemoveByPattern : pattern = {pattern}");
+
+            var redisKeys = this.SearchRedisKeys(pattern);
+
+            foreach (var item in redisKeys)
+            {
+                _cache.Del(item);
+            }
+        }
+
         /// <summary>
         /// Set the specified cacheKey, cacheValue and expiration.
         /// </summary>

src/EasyCaching.Core/Bus/EasyCachingMessage.cs

@@ -25,5 +25,11 @@ public class EasyCachingMessage
         /// </summary>
         /// <value><c>true</c> if is prefix; otherwise, <c>false</c>.</value>
         public bool IsPrefix { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether this <see cref="T:EasyCaching.Core.Bus.EasyCachingMessage"/> is pattern.
+        /// </summary>
+        /// <value><c>true</c> if is pattern; otherwise, <c>false</c>.</value>
+        public bool IsPattern { get; set; }
     }
 }

src/EasyCaching.Core/EasyCachingAbstractProvider.cs

@@ -5,20 +5,20 @@ namespace EasyCaching.Core
     using System;
     using System.Collections.Generic;
     using System.Diagnostics;
-    using System.Linq;
-    using System.Threading;
-    using System.Threading.Tasks;
-    using EasyCaching.Core.Configurations;
+    using System.Linq;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using EasyCaching.Core.Configurations;
     using EasyCaching.Core.Diagnostics;
 
     public abstract class EasyCachingAbstractProvider : IEasyCachingProvider
     {
         protected static readonly DiagnosticListener s_diagnosticListener =
-                    new DiagnosticListener(EasyCachingDiagnosticListenerExtensions.DiagnosticListenerName);
-
-        private readonly IDistributedLockFactory _lockFactory;
-        private readonly BaseProviderOptions _options;
-
+                    new DiagnosticListener(EasyCachingDiagnosticListenerExtensions.DiagnosticListenerName);
+
+        private readonly IDistributedLockFactory _lockFactory;
+        private readonly BaseProviderOptions _options;
+
         protected string ProviderName { get; set; }
         protected bool IsDistributedProvider { get; set; }
         protected int ProviderMaxRdSecond { get; set; }
@@ -36,13 +36,13 @@ public abstract class EasyCachingAbstractProvider : IEasyCachingProvider
 
         protected EasyCachingAbstractProvider() { }
 
-        protected EasyCachingAbstractProvider(IDistributedLockFactory lockFactory, BaseProviderOptions options)
-        {
-            _lockFactory = lockFactory;
-            _options = options;
-        }
-
-        public abstract object BaseGetDatabse();
+        protected EasyCachingAbstractProvider(IDistributedLockFactory lockFactory, BaseProviderOptions options)
+        {
+            _lockFactory = lockFactory;
+            _options = options;
+        }
+
+        public abstract object BaseGetDatabse();
         public abstract bool BaseExists(string cacheKey);
         public abstract Task<bool> BaseExistsAsync(string cacheKey, CancellationToken cancellationToken = default);
         public abstract void BaseFlush();
@@ -64,6 +64,8 @@ protected EasyCachingAbstractProvider(IDistributedLockFactory lockFactory, BaseP
         public abstract Task BaseRemoveAsync(string cacheKey, CancellationToken cancellationToken = default);
         public abstract void BaseRemoveByPrefix(string prefix);
         public abstract Task BaseRemoveByPrefixAsync(string prefix, CancellationToken cancellationToken = default);
+        public abstract void BaseRemoveByPattern(string pattern);
+        public abstract Task BaseRemoveByPatternAsync(string pattern, 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, CancellationToken cancellationToken = default);
@@ -185,30 +187,30 @@ public CacheValue<T> Get<T>(string cacheKey, Func<T> dataRetriever, TimeSpan exp
             var operationId = s_diagnosticListener.WriteGetCacheBefore(new BeforeGetRequestEventData(CachingProviderType.ToString(), Name, nameof(Get), new[] { cacheKey }, expiration));
             Exception e = null;
             try
-            {
+            {
                 if (_lockFactory == null) return BaseGet<T>(cacheKey, dataRetriever, expiration);
 
                 var value = BaseGet<T>(cacheKey);
-                if (value.HasValue) return value;
-
-                using (var @lock = _lockFactory.CreateLock(Name, $"{cacheKey}_Lock"))
-                {
+                if (value.HasValue) return value;
+
+                using (var @lock = _lockFactory.CreateLock(Name, $"{cacheKey}_Lock"))
+                {
                     if (!@lock.Lock(_options.SleepMs)) throw new TimeoutException();
 
                     value = BaseGet<T>(cacheKey);
-                    if (value.HasValue) return value;
-
-                    var item = dataRetriever();
-                    if (item != null || _options.CacheNulls)
-                    {
-                        BaseSet(cacheKey, item, expiration);
-
-                        return new CacheValue<T>(item, true);
-                    }
-                    else
-                    {
-                        return CacheValue<T>.NoValue;
-                    }
+                    if (value.HasValue) return value;
+
+                    var item = dataRetriever();
+                    if (item != null || _options.CacheNulls)
+                    {
+                        BaseSet(cacheKey, item, expiration);
+
+                        return new CacheValue<T>(item, true);
+                    }
+                    else
+                    {
+                        return CacheValue<T>.NoValue;
+                    }
                 }
             }
             catch (Exception ex)
@@ -316,36 +318,36 @@ public async Task<CacheValue<T>> GetAsync<T>(string cacheKey, Func<Task<T>> data
                 if (_lockFactory == null) return await BaseGetAsync<T>(cacheKey, dataRetriever, expiration, cancellationToken);
 
                 var value = await BaseGetAsync<T>(cacheKey);
-                if (value.HasValue) return value;
-
-                var @lock = _lockFactory.CreateLock(Name, $"{cacheKey}_Lock");
-                try
-                {
+                if (value.HasValue) return value;
+
+                var @lock = _lockFactory.CreateLock(Name, $"{cacheKey}_Lock");
+                try
+                {
                     if (!await @lock.LockAsync(_options.SleepMs)) throw new TimeoutException();
 
                     value = await BaseGetAsync<T>(cacheKey, cancellationToken);
-                    if (value.HasValue) return value;
-
-                    var task = dataRetriever();
-                    if (!task.IsCompleted &&
-                        await Task.WhenAny(task, Task.Delay(_options.LockMs)) != task)
-                        throw new TimeoutException();
-
-                    var item = await task;
-                    if (item != null || _options.CacheNulls)
-                    {
-                        await BaseSetAsync(cacheKey, item, expiration, cancellationToken);
-
-                        return new CacheValue<T>(item, true);
-                    }
-                    else
-                    {
-                        return CacheValue<T>.NoValue;
-                    }
-                }
-                finally
-                {
-                    await @lock.DisposeAsync();
+                    if (value.HasValue) return value;
+
+                    var task = dataRetriever();
+                    if (!task.IsCompleted &&
+                        await Task.WhenAny(task, Task.Delay(_options.LockMs)) != task)
+                        throw new TimeoutException();
+
+                    var item = await task;
+                    if (item != null || _options.CacheNulls)
+                    {
+                        await BaseSetAsync(cacheKey, item, expiration, cancellationToken);
+
+                        return new CacheValue<T>(item, true);
+                    }
+                    else
+                    {
+                        return CacheValue<T>.NoValue;
+                    }
+                }
+                finally
+                {
+                    await @lock.DisposeAsync();
                 }
             }
             catch (Exception ex)
@@ -473,8 +475,8 @@ public async Task<IDictionary<string, CacheValue<T>>> GetByPrefixAsync<T>(string
         public int GetCount(string prefix = "")
         {
             return BaseGetCount(prefix);
-        }
-
+        }
+
         public async Task<int> GetCountAsync(string prefix = "", CancellationToken cancellationToken = default)
         {
             return await BaseGetCountAsync(prefix, cancellationToken);
@@ -636,6 +638,62 @@ public async Task RemoveByPrefixAsync(string prefix, CancellationToken cancellat
             }
         }
 
+        public void RemoveByPattern(string pattern)
+        {
+            var operationId = s_diagnosticListener.WriteRemoveCacheBefore(
+                new BeforeRemoveRequestEventData(CachingProviderType.ToString(), Name, nameof(RemoveByPattern),
+                    new[] { pattern }));
+            Exception e = null;
+            try
+            {
+                BaseRemoveByPattern(pattern);
+            }
+            catch (Exception ex)
+            {
+                e = ex;
+                throw;
+            }
+            finally
+            {
+                if (e != null)
+                {
+                    s_diagnosticListener.WriteRemoveCacheError(operationId, e);
+                }
+                else
+                {
+                    s_diagnosticListener.WriteRemoveCacheAfter(operationId);
+                }
+            }
+        }
+
+        public async Task RemoveByPatternAsync(string pattern, CancellationToken cancellationToken = default)
+        {
+            var operationId = s_diagnosticListener.WriteRemoveCacheBefore(
+                new BeforeRemoveRequestEventData(CachingProviderType.ToString(), Name, nameof(RemoveByPatternAsync),
+                    new[] { pattern }));
+            Exception e = null;
+            try
+            {
+                await BaseRemoveByPatternAsync(pattern, cancellationToken);
+            }
+            catch (Exception ex)
+            {
+                e = ex;
+                throw;
+            }
+            finally
+            {
+                if (e != null)
+                {
+                    s_diagnosticListener.WriteRemoveCacheError(operationId, e);
+                }
+                else
+                {
+                    s_diagnosticListener.WriteRemoveCacheAfter(operationId);
+                }
+            }
+        }
+
         public void Set<T>(string cacheKey, T cacheValue, TimeSpan expiration)
         {
             var operationId = s_diagnosticListener.WriteSetCacheBefore(new BeforeSetRequestEventData(CachingProviderType.ToString(), Name, nameof(Set), new Dictionary<string, object> { { cacheKey, cacheValue } }, expiration));
@@ -804,7 +862,37 @@ public async Task<TimeSpan> GetExpirationAsync(string cacheKey, CancellationToke
 
         public ProviderInfo GetProviderInfo()
         {
-            return BaseGetProviderInfo();
+            return BaseGetProviderInfo();
+        }
+
+        protected SearchKeyPattern ProcessSearchKeyPattern(string pattern)
+        {
+            var postfix = pattern.StartsWith("*");
+            var prefix = pattern.EndsWith("*");
+
+            var contains = postfix && prefix;
+
+            if (contains)
+            {
+                return SearchKeyPattern.Contains;
+            }
+
+            if (postfix)
+            {
+                return SearchKeyPattern.Postfix;
+            }
+
+            if (prefix)
+            {
+                return SearchKeyPattern.Prefix;
+            }
+
+            return SearchKeyPattern.Exact;
         }
+
+        protected string HandleSearchKeyPattern(string pattern)
+        {
+            return pattern.Replace("*", string.Empty);
+        } 
     }
 }