Enhance caching and argument validation

This commit significantly improves the `DistributedCachingServices` class by introducing robust argument validation using the `ArgumentValidator` library and expanding caching capabilities to support both memory and Redis-based strategies. Key changes include the addition of `Microsoft.Extensions.Caching.Memory` and `Microsoft.Extensions.Caching.StackExchangeRedis` packages for enhanced caching flexibility, namespace and dependency adjustments to accommodate new features, and method enhancements for better nullability handling and argument validation. Notably, a new `GetAllKeys` method has been added to fetch all cache keys, with specific implementations for Redis and in-memory caching. Project file updates reflect the addition of necessary package references.

Author: chintans

Promact.Caching/Promact.Caching/DistributedCachingServices.cs

@@ -1,5 +1,10 @@
-using Microsoft.Extensions.Caching.Distributed;
+using ArgumentValidator;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Caching.StackExchangeRedis;
 using Promact.Core.Caching;
+using StackExchange.Redis;
+using System.Reflection;
 using System.Text.Json;
 
 namespace Promact.Caching
@@ -9,27 +14,66 @@ public class DistributedCachingServices : ICachingService
         private readonly IDistributedCache _distributedCache;
         public DistributedCachingServices(IDistributedCache distributedCache)
         {
-            _distributedCache = distributedCache;            
+            _distributedCache = distributedCache;
         }
-        public T? Get<T>(string key)
+        public T Get<T>(string key)
         {
             if (key == null) throw new ArgumentNullException(nameof(key));
             var data = _distributedCache.GetString(key);
-            return data == null ? default : JsonSerializer.Deserialize<T>(data);
+#pragma warning disable CS8603 // Possible null reference return.
+            return string.IsNullOrEmpty(data) ? default(T) : JsonSerializer.Deserialize<T>(data);
+#pragma warning restore CS8603 // Possible null reference return.
         }
 
         public void Remove(string key)
         {
             if (key == null) throw new ArgumentNullException(nameof(key));
-            _distributedCache.Remove(key);            
+            _distributedCache.Remove(key);
         }
 
         public void Set<T>(string key, T value)
         {
-            if(key == null) throw new ArgumentNullException(nameof(key));
-            if(value == null) throw new ArgumentNullException(nameof(value));
+            Throw.IfNull(key, nameof(key));
+            Throw.IfNull(value, nameof(value));
             var data = JsonSerializer.Serialize(value);
             _distributedCache.SetString(key, data);
         }
+
+#pragma warning disable CS8602 // Dereference of a possibly null reference.
+#pragma warning disable CS8600 // Converting null literal or possible null value to non-nullable type.
+#pragma warning disable CS8604 // Possible null reference argument.
+        public HashSet<string> GetAllKeys()
+        {
+            //Check if the Caching provider is Redis then cast it to RedisCache and get the keys
+            if (_distributedCache is RedisCache)
+            {
+                var redisCache = _distributedCache as RedisCache;
+
+                IDatabase db = redisCache.GetType().GetField("_cache", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(redisCache) as IDatabase;
+                var keysResult = ((RedisValue[])db.Execute("KEYS", "*"));
+                return new HashSet<string>(keysResult.Select(k => k.ToString()));
+
+            }
+            //Check if the Caching provider is InMemory then cast it and return all the keys
+            else if (_distributedCache is MemoryDistributedCache)
+            {
+                var memoryCache = _distributedCache as MemoryDistributedCache;
+                var cache = memoryCache.GetType().GetField("_memCache", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(memoryCache) as MemoryCache;
+                dynamic _coherentState = cache.GetType().GetField("_coherentState", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(cache);
+                var keys = new HashSet<string>();
+                foreach (KeyValuePair<object, dynamic> pairs in _coherentState._entries)
+                {
+                    keys.Add(Convert.ToString(pairs.Key));
+                }           
+                return keys;
+            }
+            else
+            {
+                throw new NotSupportedException("This method is not supported for the current caching provider");
+            }
+        }
+#pragma warning restore CS8600 // Converting null literal or possible null value to non-nullable type.
+#pragma warning restore CS8602 // Dereference of a possibly null reference.
+#pragma warning restore CS8604 // Possible null reference argument.
     }
-}
+}

Promact.Caching/Promact.Caching/Promact.Caching.csproj

@@ -7,7 +7,10 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Argument.Validator" Version="2.0.0" />
     <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="8.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="8.0.6" />
     <PackageReference Include="Promact.Core" Version="1.0.0.2" />
     <PackageReference Include="System.IO.Hashing" Version="8.0.0" />
     <PackageReference Include="xxHash.Core" Version="2.0.1" />