feat(46): implements caching with Redis and in-memory cache by adding cache manager

src/Api/Microservice.csproj

@@ -24,6 +24,8 @@
 
   <ItemGroup>
 
+    <PackageReference Include="Microsoft.Extensions.Caching.StackExchangeRedis" Version="9.0.5" />
+
     <ProjectReference Include="../Domain/Domain.csproj" />
 
     <ProjectReference Include="../Infra/Infra.csproj" />

src/Api/Program.cs

@@ -6,6 +6,7 @@
 using Asp.Versioning.Builder;
 using Domain.Interfaces;
 using Domain.Services;
+using Infra.Cache;
 using Infra.Data;
 using Infra.Repositories;
 using Microsoft.EntityFrameworkCore;
@@ -49,6 +50,15 @@
 
 builder.Host.UseSerilog();
 
+builder.Services.AddMemoryCache();
+builder.Services.AddStackExchangeRedisCache(opts =>
+{
+    opts.Configuration = builder.Configuration.GetConnectionString("Redis");
+    opts.InstanceName = "SolutionTemplate:";
+});
+builder.Services.Configure<CacheManagerOptions>(builder.Configuration.GetSection("CacheOptions"));
+builder.Services.AddSingleton<ICacheManager, CacheManager>();
+
 var app = builder.Build();
 
 app.UseHttpMetrics();

src/Api/appsettings.Development.json

@@ -9,6 +9,12 @@
   },
   "UseJsonFormat": false,
   "ConnectionStrings": {
-    "PgpoolDb": ""
+    "PgpoolDb": "",
+    "Redis": ""
+  },
+  "CacheOptions": {
+    "UseDistributedCache": false,
+    "MemoryCacheDuration": "00:02:00",
+    "DistributedCacheDuration": "00:10:00"
   }
 }

src/Domain/Interfaces/ICacheManager.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace Domain.Interfaces
+{
+    public interface ICacheManager
+    {
+        Task<T?> GetAsync<T>(string key);
+        Task SetAsync<T>(string key, T value);
+        Task RemoveAsync(string key);
+    }
+}

src/Domain/Services/SampleService.cs

@@ -13,15 +13,26 @@ public class SampleService : ISampleService
     private readonly IRepository<SampleEntity> _repository;
     private readonly IMapper _mapper;
 
+    private readonly ICacheManager _cacheManager;
+
     public SampleService(IRepository<SampleEntity> repository,
-    IMapper mapper)
+    IMapper mapper,
+    ICacheManager cacheManager)
     {
         _repository = repository;
         _mapper = mapper;
+        _cacheManager = cacheManager;
     }
 
     public async Task<GetSampleResponseModel> GetSampleAsync(Guid id, CancellationToken cancellationToken = default)
     {
+        var cachedSample = await _cacheManager.GetAsync<SampleEntity>($"Sample_{id}");
+
+        if (cachedSample is not null)
+        {
+            return _mapper.Map<GetSampleResponseModel>(cachedSample);
+        }
+
         var entity = await _repository.GetByIdAsync(id, cancellationToken) ?? throw new DomainException($"Sample with ID {id} not found.");
 
         return _mapper.Map<GetSampleResponseModel>(entity);
@@ -66,15 +77,24 @@ public async Task<CreateSampleResponseModel> CreateSampleAsync(CreateSampleReque
     {
         var entity = _mapper.Map<SampleEntity>(request);
         var createdEntity = await _repository.AddAsync(entity, cancellationToken);
+
         await _repository.SaveChangesAsync(cancellationToken);
+
+        await _cacheManager.SetAsync($"Sample_{createdEntity.Id}", createdEntity);
+
         return _mapper.Map<CreateSampleResponseModel>(createdEntity);
     }
 
     public async Task<UpdateSampleResponseModel> UpdateSampleAsync(UpdateSampleRequestModel request, CancellationToken cancellationToken = default)
     {
         var entity = _mapper.Map<SampleEntity>(request);
+
         var updatedEntity = _repository.Update(entity);
+
         await _repository.SaveChangesAsync(cancellationToken);
+
+        await _cacheManager.SetAsync($"Sample_{updatedEntity.Id}", updatedEntity);
+
         return _mapper.Map<UpdateSampleResponseModel>(updatedEntity);
     }
 
@@ -84,6 +104,11 @@ public async Task<bool> DeleteSampleAsync(Guid id, CancellationToken cancellatio
         if (entity == null) return false;
 
         _repository.Remove(entity);
-        return true && await _repository.SaveChangesAsync(cancellationToken) > 0;
+
+        var result = await _repository.SaveChangesAsync(cancellationToken);
+
+        await _cacheManager.RemoveAsync($"Sample_{id}");
+
+        return result > 0;
     }
 }

src/Infra/Cache/CacheManager.cs

@@ -0,0 +1,84 @@
+using System.Text.Json;
+using Domain.Interfaces;
+using Microsoft.Extensions.Caching.Distributed;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Options;
+
+namespace Infra.Cache;
+
+public class CacheManagerOptions
+{
+    public bool UseDistributedCache { get; set; } = true;
+    public TimeSpan MemoryCacheDuration { get; set; } = TimeSpan.FromMinutes(2);
+    public TimeSpan DistributedCacheDuration { get; set; } = TimeSpan.FromMinutes(10);
+    public JsonSerializerOptions? JsonOptions { get; set; } 
+}
+
+public class CacheManager: ICacheManager
+{
+    private readonly IMemoryCache _memoryCache;
+    private readonly IDistributedCache _distributedCache;
+    private readonly CacheManagerOptions _options;
+
+    public CacheManager(
+        IMemoryCache memoryCache,
+        IDistributedCache distributedCache,
+        IOptions<CacheManagerOptions> options)
+    {
+        _memoryCache = memoryCache;
+        _distributedCache = distributedCache;
+        _options = options.Value;
+    }
+
+    public async Task<T?> GetAsync<T>(string key)
+    {
+        if (_memoryCache.TryGetValue(key, out T? value))
+            return value;
+
+        if(!_options.UseDistributedCache)
+            return default;
+
+        var serialized = await _distributedCache.GetStringAsync(key);
+        if (serialized is not null)
+        {
+            value = JsonSerializer.Deserialize<T>(serialized, _options.JsonOptions)!;
+            _memoryCache.Set(key, value, _options.MemoryCacheDuration);
+            return value;
+        }
+
+        return default;
+    }
+
+    public async Task RemoveAsync(string key)
+    {
+        _memoryCache.Remove(key);
+
+        if (_options.UseDistributedCache)
+            await _distributedCache.RemoveAsync(key);
+    }
+
+    public async Task SetAsync<T>(string key, T value)
+    {
+        this.SetMemory(key, value);
+
+        if (_options.UseDistributedCache)
+            await this.SetDistributedAsync(key, value);
+    }
+
+    private void SetMemory<T>(string key, T value, TimeSpan? duration = null)
+    {
+        _memoryCache.Set(key, value, duration ?? _options.MemoryCacheDuration);
+    }
+
+    private Task SetDistributedAsync<T>(string key, T value, TimeSpan? duration = null)
+    {
+        var serialized = JsonSerializer.Serialize(value, _options.JsonOptions);
+        return _distributedCache.SetStringAsync(
+            key,
+            serialized,
+            new DistributedCacheEntryOptions
+            {
+                AbsoluteExpirationRelativeToNow = duration ?? _options.DistributedCacheDuration
+            });
+    }
+}