WIP: Implemented caching strategies. Not yet tested.

RCommon-Team · Sep 6, 2024 · 58f6326 · 58f6326
1 parent 54f4e70
commit 58f6326
Show file tree

Hide file tree

Showing 28 changed files with 528 additions and 420 deletions.
diff --git a/Examples/Caching/Examples.Caching.MemoryCaching/Program.cs b/Examples/Caching/Examples.Caching.MemoryCaching/Program.cs
@@ -24,13 +24,13 @@
                     // Configure RCommon
                     services.AddRCommon()
                         .WithJsonSerialization<JsonNetBuilder>() // Distributed memory caching requires serialization
-                        .WithMemoryCaching<MemoryCachingBuilder>(cache =>
+                        .WithMemoryCaching<InMemoryCachingBuilder>(cache =>
                         {
                             cache.Configure(x =>
                             {
                                 x.ExpirationScanFrequency = TimeSpan.FromMinutes(1);
-                            })
-                            .CacheDynamicallyCompiledExpressions();
+                            });
+                            cache.CacheDynamicallyCompiledExpressions();
                         })
                         .WithDistributedCaching<DistributedMemoryCacheBuilder>(cache =>
                         {

diff --git a/Src/RCommon.ApplicationServices/Commands/CommandBus.cs b/Src/RCommon.ApplicationServices/Commands/CommandBus.cs
@@ -28,14 +28,13 @@
 using System.Security.Principal;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
-using RCommon.ApplicationServices.Caching;
 using RCommon.ApplicationServices.Commands;
 using RCommon.ApplicationServices.ExecutionResults;
 using RCommon.ApplicationServices.Validation;
+using RCommon.Caching;
 using RCommon.Reflection;
 
 namespace RCommon.ApplicationServices.Commands
@@ -44,19 +43,19 @@ public class CommandBus : ICommandBus
     {
         private readonly ILogger<CommandBus> _logger;
         private readonly IServiceProvider _serviceProvider;
-        private readonly IMemoryCache _memoryCache;
         private readonly IValidationService _validationService;
         private readonly IOptions<CqrsValidationOptions> _validationOptions;
+        private readonly ICacheService _cacheService;
         private readonly CachingOptions _cachingOptions;
 
-        public CommandBus(ILogger<CommandBus> logger, IServiceProvider serviceProvider, IMemoryCache memoryCache, IValidationService validationService, 
-            IOptions<CqrsValidationOptions> validationOptions, IOptions<CachingOptions> cachingOptions)
+        public CommandBus(ILogger<CommandBus> logger, IServiceProvider serviceProvider, IValidationService validationService, 
+            IOptions<CqrsValidationOptions> validationOptions, IOptions<CachingOptions> cachingOptions, ICommonFactory<ExpressionCachingStrategy, ICacheService> cacheFactory)
         {
             _logger = logger;
             _serviceProvider = serviceProvider;
-            _memoryCache = memoryCache;
             _validationService = validationService;
             _validationOptions = validationOptions;
+            _cacheService = cacheFactory.Create(ExpressionCachingStrategy.Default);
             _cachingOptions = cachingOptions.Value;
         }
 
@@ -135,16 +134,7 @@ private CommandExecutionDetails GetCommandExecutionDetails(Type commandType)
         {
             if (_cachingOptions.CachingEnabled && _cachingOptions.CacheDynamicallyCompiledExpressions)
             {
-                var memoryCache = this._serviceProvider.GetService<IMemoryCache>();
-                Guard.IsNotNull(memoryCache, nameof(memoryCache));
-
-                return memoryCache.GetOrCreate(
-                    CacheKey.With(GetType(), commandType.GetCacheKey()),
-                    e =>
-                    {
-                        e.AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1);
-                        return this.BuildCommandDetails(commandType);
-                    });
+                return _cacheService.GetOrCreate(CacheKey.With(GetType(), commandType.GetCacheKey()), this.BuildCommandDetails(commandType));
             }
             return this.BuildCommandDetails(commandType);
         }

diff --git a/Src/RCommon.ApplicationServices/CqrsBuilder.cs b/Src/RCommon.ApplicationServices/CqrsBuilder.cs
@@ -1,5 +1,4 @@
-using Microsoft.Extensions.Caching.Memory;
-using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
 using RCommon.ApplicationServices.Commands;
 using RCommon.ApplicationServices.Queries;
 using RCommon.EventHandling;

diff --git a/Src/RCommon.ApplicationServices/Queries/QueryBus.cs b/Src/RCommon.ApplicationServices/Queries/QueryBus.cs
@@ -26,12 +26,11 @@
 using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
-using RCommon.ApplicationServices.Caching;
 using RCommon.ApplicationServices.Validation;
+using RCommon.Caching;
 using RCommon.Reflection;
 
 namespace RCommon.ApplicationServices.Queries
@@ -49,15 +48,17 @@ private class HandlerFuncMapping
         private readonly IValidationService _validationService;
         private readonly IOptions<CqrsValidationOptions> _validationOptions;
         private readonly CachingOptions _cachingOptions;
+        private readonly ICacheService _cacheService;
 
         public QueryBus(ILogger<QueryBus> logger, IServiceProvider serviceProvider, IValidationService validationService,
-            IOptions<CqrsValidationOptions> validationOptions, IOptions<CachingOptions> cachingOptions)
+            IOptions<CqrsValidationOptions> validationOptions, IOptions<CachingOptions> cachingOptions, ICommonFactory<ExpressionCachingStrategy, ICacheService> cacheFactory)
         {
             _logger = logger;
             _serviceProvider = serviceProvider;
             _validationService = validationService;
             _validationOptions = validationOptions;
             _cachingOptions = cachingOptions.Value;
+            _cacheService = cacheFactory.Create(ExpressionCachingStrategy.Default);
         }
 
         public async Task<TResult> DispatchQueryAsync<TResult>(IQuery<TResult> query, CancellationToken cancellationToken = default)
@@ -90,16 +91,8 @@ private HandlerFuncMapping GetHandlerFuncMapping(Type queryType)
         {
             if (_cachingOptions.CachingEnabled && _cachingOptions.CacheDynamicallyCompiledExpressions)
             {
-                var memoryCache = this._serviceProvider.GetService<IMemoryCache>();
-                Guard.IsNotNull(memoryCache, nameof(memoryCache));
-
-                return memoryCache.GetOrCreate(
-                    CacheKey.With(GetType(), queryType.GetCacheKey()),
-                    e =>
-                    {
-                        e.AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1);
-                        return this.BuildHandlerFuncMapping(queryType);
-                    });
+                return _cacheService.GetOrCreate(CacheKey.With(GetType(), queryType.GetCacheKey()), 
+                    this.BuildHandlerFuncMapping(queryType));
             }
             return this.BuildHandlerFuncMapping(queryType);
 

diff --git a/Src/RCommon.ApplicationServices/RCommon.ApplicationServices.csproj b/Src/RCommon.ApplicationServices/RCommon.ApplicationServices.csproj
@@ -4,10 +4,6 @@
     <TargetFrameworks>net6.0;net8.0;</TargetFrameworks>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\RCommon.Caching\RCommon.Caching.csproj" />
     <ProjectReference Include="..\RCommon.Core\RCommon.Core.csproj" />
@@ -20,5 +16,8 @@
 	<ItemGroup Condition=" '$(TargetFramework)' == 'net8.0' ">
 		<PackageReference Include="Microsoft.Extensions.Options" Version="8.0.2" />
 	</ItemGroup>
+	<ItemGroup>
+	  <Folder Include="Caching\" />
+	</ItemGroup>
 
 </Project>
diff --git a/...n.ApplicationServices/Caching/CacheKey.cs → Src/RCommon.Caching/CacheKey.cs b/...n.ApplicationServices/Caching/CacheKey.cs → Src/RCommon.Caching/CacheKey.cs
@@ -22,16 +22,21 @@
 // CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 using System;
-using Newtonsoft.Json;
-using RCommon.Entities.ValueObjects;
 
-namespace RCommon.ApplicationServices.Caching
+namespace RCommon.Caching
 {
-    [JsonConverter(typeof(SingleValueObjectConverter))]
-    public class CacheKey : SingleValueObject<string>
+    public class CacheKey
     {
         public const int MaxLength = 256;
 
+        public CacheKey(string value)
+        {
+            if (string.IsNullOrEmpty(value))
+                throw new ArgumentNullException(nameof(value));
+            if (value.Length > MaxLength)
+                throw new ArgumentOutOfRangeException(nameof(value), value, $"Cache keys can maximum be '{MaxLength}' in length");
+        }
+
         public static CacheKey With(params string[] keys)
         {
             return new CacheKey(string.Join("-", keys));
@@ -41,13 +46,5 @@ public static CacheKey With(Type ownerType, params string[] keys)
         {
             return With($"{ownerType.GetCacheKey()}:{string.Join("-", keys)}");
         }
-
-        public CacheKey(string value) : base(value)
-        {
-            if (string.IsNullOrEmpty(value))
-                throw new ArgumentNullException(nameof(value));
-            if (value.Length > MaxLength)
-                throw new ArgumentOutOfRangeException(nameof(value), value, $"Cache keys can maximum be '{MaxLength}' in length");
-        }
     }
 }
diff --git a/Src/RCommon.Caching/CachingBuilderExtensions.cs b/Src/RCommon.Caching/CachingBuilderExtensions.cs
@@ -1,4 +1,5 @@
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using RCommon.Json;
 using System;
 using System.Collections.Generic;

diff --git a/Src/RCommon.Caching/ExpressionCachingStrategy.cs b/Src/RCommon.Caching/ExpressionCachingStrategy.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RCommon.Caching
+{
+    public enum ExpressionCachingStrategy
+    {
+        Default
+    }
+}
diff --git a/Src/RCommon.Caching/ICacheService.cs b/Src/RCommon.Caching/ICacheService.cs
@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RCommon.Caching
+{
+    public interface ICacheService
+    {
+        TData GetOrCreate<TData>(object key, TData data);
+        Task<TData> GetOrCreateAsync<TData>(object key, TData data);
+    }
+}
diff --git a/Src/RCommon.Core/CommonFactory.cs b/Src/RCommon.Core/CommonFactory.cs
@@ -6,21 +6,21 @@
 
 namespace RCommon
 {
-    public class CommonFactory<T> : ICommonFactory<T>
+    public class CommonFactory<TResult> : ICommonFactory<TResult>
     {
-        private readonly Func<T> _initFunc;
+        private readonly Func<TResult> _initFunc;
 
-        public CommonFactory(Func<T> initFunc)
+        public CommonFactory(Func<TResult> initFunc)
         {
             _initFunc = initFunc;
         }
 
-        public T Create()
+        public TResult Create()
         {
             return _initFunc();
         }
 
-        public T Create(Action<T> customize)
+        public TResult Create(Action<TResult> customize)
         {
             var concreteObject = _initFunc();
             customize(concreteObject);

diff --git a/Src/RCommon.Entities/ValueObjects/ISingleValueObject.cs b/Src/RCommon.Entities/ValueObjects/ISingleValueObject.cs
diff --git a/Src/RCommon.Entities/ValueObjects/SingleValueObject.cs b/Src/RCommon.Entities/ValueObjects/SingleValueObject.cs