Add reset behavior

Author: linkdotnet

LinkDotNet.Blog.Infrastructure/Persistence/CachedRepository.cs

@@ -1,16 +1,21 @@
 using System;
 using System.Linq.Expressions;
+using System.Threading;
 using System.Threading.Tasks;
 using LinkDotNet.Blog.Domain;
 using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Primitives;
 using X.PagedList;
 
 namespace LinkDotNet.Blog.Infrastructure.Persistence
 {
     public class CachedRepository<T> : IRepository<T>
         where T : Entity
     {
+        private static CancellationTokenSource resetToken = new();
+
         private readonly IRepository<T> repository;
+
         private readonly IMemoryCache memoryCache;
 
         public CachedRepository(IRepository<T> repository, IMemoryCache memoryCache)
@@ -19,12 +24,18 @@ public CachedRepository(IRepository<T> repository, IMemoryCache memoryCache)
             this.memoryCache = memoryCache;
         }
 
+        private static MemoryCacheEntryOptions Options => new()
+        {
+            ExpirationTokens = { new CancellationChangeToken(resetToken.Token) },
+            AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(7),
+        };
+
         public async Task<T> GetByIdAsync(string id)
         {
             if (!memoryCache.TryGetValue(id, out T value))
             {
                 value = await repository.GetByIdAsync(id);
-                memoryCache.Set(id, value);
+                memoryCache.Set(id, value, Options);
             }
 
             return value;
@@ -40,24 +51,34 @@ public async Task<IPagedList<T>> GetAllAsync(
             var key = $"{filter?.Body}-{orderBy?.Body}-{descending}-{page}-{pageSize}";
             return await memoryCache.GetOrCreate(key, async e =>
             {
-                e.SetOptions(new MemoryCacheEntryOptions
-                {
-                    AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(1),
-                });
+                e.SetOptions(Options);
                 return await repository.GetAllAsync(filter, orderBy, descending, page, pageSize);
             });
         }
 
         public async Task StoreAsync(T entity)
         {
-            memoryCache.Set(entity.Id, entity, TimeSpan.FromHours(1));
+            ResetCache();
+            memoryCache.Set(entity.Id, entity, Options);
             await repository.StoreAsync(entity);
         }
 
         public async Task DeleteAsync(string id)
         {
+            ResetCache();
             memoryCache.Remove(id);
             await repository.DeleteAsync(id);
         }
+
+        private static void ResetCache()
+        {
+            if (resetToken is { IsCancellationRequested: false, Token: { CanBeCanceled: true } })
+            {
+                resetToken.Cancel();
+                resetToken.Dispose();
+            }
+
+            resetToken = new CancellationTokenSource();
+        }
     }
 }

LinkDotNet.Blog.UnitTests/Infrastructure/Persistence/CachedRepositoryTests.cs

@@ -121,6 +121,25 @@ public async Task ShouldDelete()
             repositoryMock.Verify(r => r.DeleteAsync("id"), Times.Once);
         }
 
+        [Fact]
+        public async Task ShouldGetFreshDataAfterDelete()
+        {
+            SetupRepository();
+            await sut.GetAllAsync();
+            await sut.DeleteAsync("some_id");
+
+            await sut.GetAllAsync();
+
+            repositoryMock.Verify(
+                r => r.GetAllAsync(
+                It.IsAny<Expression<Func<BlogPost,bool>>>(),
+                It.IsAny<Expression<Func<BlogPost,object>>>(),
+                It.IsAny<bool>(),
+                It.IsAny<int>(),
+                It.IsAny<int>()),
+                Times.Exactly(2));
+        }
+
         private void SetupRepository()
         {
             var blogPost = new BlogPostBuilder().Build();

LinkDotNet.Blog.Web/RegistrationExtensions/StorageProviderExtensions.cs

@@ -30,6 +30,7 @@ public static void AddStorageProvider(this IServiceCollection services, IConfigu
             }
 
             services.AddScoped<IRepository<BlogPost>, Repository<BlogPost>>();
+            services.AddMemoryCache();
             services.Decorate(typeof(IRepository<>), typeof(CachedRepository<>));
         }
     }