🚧 SQLite and Redis Caching provider impl RemoveByPrefix method.

dotnetcore · Jan 31, 2018 · 1969ba1 · 1969ba1
1 parent dc1c53d
commit 1969ba1
Show file tree

Hide file tree

Showing 10 changed files with 195 additions and 11 deletions.
diff --git a/sample/EasyCaching.Demo.HybridCache/Controllers/ValuesController.cs b/sample/EasyCaching.Demo.HybridCache/Controllers/ValuesController.cs
@@ -1,10 +1,10 @@
 namespace EasyCaching.Demo.HybridCache.Controllers
-{
-    using EasyCaching.HybridCache;
+{    
+    using EasyCaching.Core;
     using Microsoft.AspNetCore.Mvc;
-    using System;
-    using System.Threading.Tasks;
-    
+    using System;
+    using System.Threading.Tasks;
+
     [Route("api/[controller]")]
     public class ValuesController : Controller
     {

diff --git a/src/EasyCaching.Core/IEasyCachingProvider.cs b/src/EasyCaching.Core/IEasyCachingProvider.cs
@@ -114,5 +114,17 @@ public interface IEasyCachingProvider
         /// <param name="expiration">Expiration.</param>
         /// <typeparam name="T">The 1st type parameter.</typeparam>
         Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expiration) where T : class;
+
+        /// <summary>
+        /// Removes cached item by cachekey's prefix.
+        /// </summary>
+        /// <param name="prefix">Prefix of CacheKey.</param>
+        void RemoveByPrefix(string prefix);
+
+        /// <summary>
+        /// Removes cached item by cachekey's prefix async.
+        /// </summary>
+        /// <param name="prefix">Prefix of CacheKey.</param>
+        Task RemoveByPrefixAsync(string prefix);
     }
 }
diff --git a/src/EasyCaching.Core/IHybridCachingProvider.cs b/src/EasyCaching.Core/IHybridCachingProvider.cs
@@ -0,0 +1,7 @@
+namespace EasyCaching.Core
+{
+    /// <summary>
+    /// Hybrid caching provider.
+    /// </summary>
+    public interface IHybridCachingProvider : IEasyCachingProvider { }
+}
diff --git a/src/EasyCaching.HybridCache/HybridCacheServiceCollectionExtensions.cs b/src/EasyCaching.HybridCache/HybridCacheServiceCollectionExtensions.cs
@@ -1,5 +1,6 @@
 namespace EasyCaching.HybridCache
 {
+    using EasyCaching.Core;
     using EasyCaching.Core.Internal;
     using Microsoft.Extensions.DependencyInjection;
     using Microsoft.Extensions.DependencyInjection.Extensions;

diff --git a/src/EasyCaching.HybridCache/HybridCachingProvider.cs b/src/EasyCaching.HybridCache/HybridCachingProvider.cs
@@ -5,11 +5,6 @@
     using System;
     using System.Threading.Tasks;
 
-    /// <summary>
-    /// Hybrid caching provider.
-    /// </summary>
-    public interface IHybridCachingProvider : IEasyCachingProvider{}
-
     /// <summary>
     /// Hybrid caching provider.
     /// </summary>
@@ -331,5 +326,15 @@ public async Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expira
             await this.RemoveAsync(cacheKey);
             await this.SetAsync(cacheKey, cacheValue, expiration);
         }
+
+        public void RemoveByPrefix(string prefix)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task RemoveByPrefixAsync(string prefix)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/src/EasyCaching.InMemory/InMemoryCachingProvider.cs b/src/EasyCaching.InMemory/InMemoryCachingProvider.cs
@@ -247,5 +247,15 @@ public async Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expira
             await this.RemoveAsync(cacheKey);
             await this.SetAsync(cacheKey, cacheValue, expiration);
         }
+
+        public void RemoveByPrefix(string prefix)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task RemoveByPrefixAsync(string prefix)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.cs b/src/EasyCaching.Memcached/DefaultMemcachedCachingProvider.cs
@@ -251,5 +251,15 @@ public async Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expira
             await this.RemoveAsync(cacheKey);
             await this.SetAsync(cacheKey, cacheValue, expiration);
         }
+
+        public void RemoveByPrefix(string prefix)
+        {
+            throw new NotImplementedException();
+        }
+
+        public Task RemoveByPrefixAsync(string prefix)
+        {
+            throw new NotImplementedException();
+        }
     }
 }
diff --git a/src/EasyCaching.Redis/DefaultRedisCachingProvider.cs b/src/EasyCaching.Redis/DefaultRedisCachingProvider.cs
@@ -4,6 +4,8 @@
     using EasyCaching.Core.Internal;
     using StackExchange.Redis;
     using System;
+    using System.Collections.Generic;
+    using System.Linq;
     using System.Threading.Tasks;
 
     /// <summary>
@@ -16,6 +18,11 @@ public class DefaultRedisCachingProvider : IEasyCachingProvider
         /// </summary>
         private readonly IDatabase _cache;
 
+        /// <summary>
+        /// The servers.
+        /// </summary>
+        private readonly IEnumerable<IServer> _servers;
+
         /// <summary>
         /// The db provider.
         /// </summary>
@@ -28,7 +35,7 @@ public class DefaultRedisCachingProvider : IEasyCachingProvider
 
         /// <summary>
         /// <see cref="T:EasyCaching.Redis.DefaultRedisCachingProvider"/> 
-        /// is not distributed cache.
+        /// is distributed cache.
         /// </summary>
         public bool IsDistributedCache => false;
 
@@ -47,6 +54,7 @@ public DefaultRedisCachingProvider(
             _dbProvider = dbProvider;
             _serializer = serializer;
             _cache = _dbProvider.GetDatabase();
+            _servers = _dbProvider.GetServerList();
         }
 
         /// <summary>
@@ -279,5 +287,109 @@ public async Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expira
             await this.RemoveAsync(cacheKey);
             await this.SetAsync(cacheKey, cacheValue, expiration);
         }
+
+        /// <summary>
+        /// Removes cached item by cachekey's prefix.
+        /// </summary>
+        /// <param name="prefix">Prefix of CacheKey.</param>
+        public void RemoveByPrefix(string prefix)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
+
+            this.HandlePrefix(prefix);
+
+            foreach (var server in _servers)
+            {
+                this.HandleKeyDelWithTran(server, prefix);
+            }
+        }
+
+        /// <summary>
+        /// Removes cached item by cachekey's prefix async.
+        /// </summary>
+        /// <param name="prefix">Prefix of CacheKey.</param>
+        public async Task RemoveByPrefixAsync(string prefix)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
+
+            this.HandlePrefix(prefix);
+
+            foreach (var server in _servers)
+            {
+                await this.HandleKeyDelWithTranAsync(server, prefix);
+            }
+        }
+
+        /// <summary>
+        /// Delete keys of Redis using transaction.
+        /// </summary>
+        /// <param name="server">Server.</param>
+        /// <param name="prefix">Prefix.</param>
+        private void HandleKeyDelWithTran(IServer server, string prefix)
+        {
+            int count = 1;
+            do
+            {
+                var keys = server.Keys(pattern: prefix, pageSize: 100);
+                count = keys.Count();
+                if (count > 0)
+                {
+                    var tran = _cache.CreateTransaction();
+
+                    tran.KeyDeleteAsync(keys.ToArray());
+
+                    tran.Execute(CommandFlags.FireAndForget);
+                }
+            }
+            while (count <= 0);
+        }
+
+        /// <summary>
+        /// Delete keys of Redis using transaction async.
+        /// </summary>
+        /// <returns>The key del with tran async.</returns>
+        /// <param name="server">Server.</param>
+        /// <param name="prefix">Prefix.</param>
+        private async Task HandleKeyDelWithTranAsync(IServer server, string prefix)
+        {
+            int count = 1;
+            do
+            {
+                var keys = server.Keys(pattern: prefix, pageSize: 100);
+                count = keys.Count();
+                if (count > 0)
+                {
+                    var tran = _cache.CreateTransaction();
+
+                    await tran.KeyDeleteAsync(keys.ToArray());
+
+                    await tran.ExecuteAsync(CommandFlags.FireAndForget);
+                }
+            }
+            while (count <= 0);
+        }
+
+        /// <summary>
+        /// Handles the prefix of CacheKey.
+        /// </summary>
+        /// <param name="prefix">Prefix of CacheKey.</param>
+        /// <exception cref="ArgumentException">
+        private void HandlePrefix(string prefix)
+        {
+            // Forbid
+            if (prefix.Equals("*"))
+            {                
+                throw new ArgumentException("the prefix should not to *");
+            }
+
+            // Don't start with *
+            prefix = new System.Text.RegularExpressions.Regex("^\\*+").Replace(prefix, "");
+
+            // End with *
+            if (!prefix.EndsWith("*", StringComparison.OrdinalIgnoreCase))
+            {
+                prefix = string.Concat(prefix, "*");
+            }
+        }
     }
 }
diff --git a/src/EasyCaching.SQLite/ConstSQL.cs b/src/EasyCaching.SQLite/ConstSQL.cs
@@ -31,6 +31,11 @@ FROM [easycaching]
         /// </summary>
         public const string REMOVESQL = @"DELETE FROM [easycaching] WHERE [cachekey] = @cachekey ";
 
+        /// <summary>
+        /// The removebyprefixsql.
+        /// </summary>
+        public const string REMOVEBYPREFIXSQL = @"DELETE FROM [easycaching] WHERE [cachekey] like @cachekey ";
+
         /// <summary>
         /// The existssql.
         /// </summary>

diff --git a/src/EasyCaching.SQLite/SQLiteCachingProvider.cs b/src/EasyCaching.SQLite/SQLiteCachingProvider.cs
@@ -302,5 +302,27 @@ public async Task RefreshAsync<T>(string cacheKey, T cacheValue, TimeSpan expira
             await this.RemoveAsync(cacheKey);
             await this.SetAsync(cacheKey, cacheValue, expiration);
         }
+
+        /// <summary>
+        /// Removes cached item by cachekey's prefix.
+        /// </summary>
+        /// <param name="prefix">Prefix of CacheKey.</param>
+        public void RemoveByPrefix(string prefix)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
+
+            _cache.Execute(ConstSQL.REMOVEBYPREFIXSQL, new { cachekey = string.Concat(prefix, "%") });
+        }
+
+        /// <summary>
+        /// Removes cached item by cachekey's prefix async.
+        /// </summary>
+        /// <param name="prefix">Prefix of CacheKey.</param>
+        public async Task RemoveByPrefixAsync(string prefix)
+        {
+            ArgumentCheck.NotNullOrWhiteSpace(prefix, nameof(prefix));
+
+            await _cache.ExecuteAsync(ConstSQL.REMOVEBYPREFIXSQL, new { cachekey = string.Concat(prefix ,"%")  });
+        }
     }
 }