Added a RemoveAll function to clear the entire cache

LazyCache.AspNetCore/LazyCacheServiceCollectionExtensions.cs

@@ -3,6 +3,7 @@
 using LazyCache.Providers;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Options;
 
 // ReSharper disable once CheckNamespace - MS guidelines say put DI registration in this NS
 namespace Microsoft.Extensions.DependencyInjection
@@ -15,8 +16,8 @@ public static IServiceCollection AddLazyCache(this IServiceCollection services)
             if (services == null) throw new ArgumentNullException(nameof(services));
 
             services.AddOptions();
-            services.TryAdd(ServiceDescriptor.Singleton<IMemoryCache, MemoryCache>());
-            services.TryAdd(ServiceDescriptor.Singleton<ICacheProvider, MemoryCacheProvider>());
+            services.TryAdd(ServiceDescriptor.Singleton<ICacheProvider, MemoryCacheProvider>(serviceProvider => 
+                new MemoryCacheProvider(() => new MemoryCache(new MemoryCacheOptions()))));
 
             services.TryAdd(ServiceDescriptor.Singleton<IAppCache, CachingService>());
 
@@ -30,8 +31,8 @@ public static IServiceCollection AddLazyCache(this IServiceCollection services,
             if (implementationFactory == null) throw new ArgumentNullException(nameof(implementationFactory));
 
             services.AddOptions();
-            services.TryAdd(ServiceDescriptor.Singleton<IMemoryCache, MemoryCache>());
-            services.TryAdd(ServiceDescriptor.Singleton<ICacheProvider, MemoryCacheProvider>());
+            services.TryAdd(ServiceDescriptor.Singleton<ICacheProvider, MemoryCacheProvider>(serviceProvider =>
+                new MemoryCacheProvider(() => new MemoryCache(new MemoryCacheOptions()))));
 
             services.TryAdd(ServiceDescriptor.Singleton<IAppCache>(implementationFactory));
 

LazyCache.Ninject/LazyCacheModule.cs

@@ -2,6 +2,7 @@
 using LazyCache.Providers;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Options;
+using Ninject;
 using Ninject.Modules;
 
 namespace LazyCache
@@ -23,8 +24,8 @@ public LazyCacheModule(Func<IAppCache> implementationFactory)
         public override void Load()
         {
             Bind<IOptions<MemoryCacheOptions>>().ToConstant(Options.Create(new MemoryCacheOptions()));
-            Bind<IMemoryCache>().To<MemoryCache>().InSingletonScope();
-            Bind<ICacheProvider>().To<MemoryCacheProvider>().InSingletonScope();
+            Bind<ICacheProvider>().To<MemoryCacheProvider>().InSingletonScope()
+                .WithConstructorArgument<Func<IMemoryCache>>(context => () => new MemoryCache(context.Kernel.Get<IOptions<MemoryCacheOptions>>()));
 
             if (implementationFactory == null)
                 Bind<IAppCache>().To<CachingService>().InSingletonScope();

LazyCache.UnitTests/CachingServiceMemoryCacheProviderTests.cs

@@ -21,7 +21,7 @@ public void BeforeEachTest()
 
         private static CachingService BuildCache()
         {
-            return new CachingService(new MemoryCacheProvider(new MemoryCache(new MemoryCacheOptions())));
+            return new CachingService(new MemoryCacheProvider(() => new MemoryCache(new MemoryCacheOptions())));
         }
 
         private IAppCache sut;
@@ -755,5 +755,18 @@ public void RemovedItemCannotBeRetrievedFromCache()
             sut.Remove(TestKey);
             Assert.Null(sut.Get<object>(TestKey));
         }
+
+        [Test]
+        public void NoItemsCanBeRetrievedFromCacheAfterRemoveAll()
+        {
+            var testKey2 = "TestKey2";
+            sut.Add(TestKey, new object());
+            sut.Add(testKey2, new object());
+            Assert.NotNull(sut.Get<object>(TestKey));
+            Assert.NotNull(sut.Get<object>(testKey2));
+            sut.RemoveAll();
+            Assert.Null(sut.Get<object>(TestKey));
+            Assert.Null(sut.Get<object>(testKey2));
+        }
     }
 }

LazyCache/CachingService.cs

@@ -36,7 +36,7 @@ public CachingService(ICacheProvider cache) : this(() => cache)
 
         public static Lazy<ICacheProvider> DefaultCacheProvider { get; set; }
             = new Lazy<ICacheProvider>(() => 
-                new MemoryCacheProvider(
+                new MemoryCacheProvider(() =>
                     new MemoryCache(
                         new MemoryCacheOptions())
                 ));
@@ -122,6 +122,11 @@ public virtual void Remove(string key)
             CacheProvider.Remove(key);
         }
 
+        public virtual void RemoveAll()
+        {
+            CacheProvider.RemoveAll();
+        }
+
         public virtual ICacheProvider CacheProvider => cacheProvider.Value;
 
         public virtual async Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory)

LazyCache/IAppCache.cs

@@ -24,5 +24,7 @@ public interface IAppCache
         Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory);
 
         void Remove(string key);
+
+        void RemoveAll();
     }
 }

LazyCache/ICacheProvider.cs

@@ -10,6 +10,7 @@ public interface ICacheProvider : IDisposable
         object Get(string key);
         object GetOrCreate<T>(string key, Func<ICacheEntry, T> func);
         void Remove(string key);
+        void RemoveAll();
         Task<T> GetOrCreateAsync<T>(string key, Func<ICacheEntry, Task<T>> func);
     }
 }

LazyCache/Mocks/MockCacheProvider.cs

@@ -24,6 +24,10 @@ public void Remove(string key)
         {
         }
 
+        public void RemoveAll()
+        {
+        }
+
         public Task<T> GetOrCreateAsync<T>(string key, Func<ICacheEntry, Task<T>> func)
         {
             return func(null);

LazyCache/Mocks/MockCachingService.cs

@@ -27,6 +27,10 @@ public void Remove(string key)
         {
         }
 
+        public void RemoveAll()
+        {
+        }
+
         public Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory)
         {
             return addItemFactory(new MockCacheEntry(key));

LazyCache/Providers/MemoryCacheProvider.cs

@@ -6,11 +6,13 @@ namespace LazyCache.Providers
 {
     public class MemoryCacheProvider : ICacheProvider
     {
-        internal readonly IMemoryCache cache;
+        internal readonly Func<IMemoryCache> cacheFactory;
+        internal IMemoryCache cache;
 
-        public MemoryCacheProvider(IMemoryCache cache)
+        public MemoryCacheProvider(Func<IMemoryCache> cacheFactory)
         {
-            this.cache = cache;
+            this.cacheFactory = cacheFactory;
+            cache = cacheFactory();
         }
 
         public void Set(string key, object item, MemoryCacheEntryOptions policy)
@@ -33,6 +35,12 @@ public void Remove(string key)
             cache.Remove(key);
         }
 
+        public void RemoveAll()
+        {
+            var oldCache = System.Threading.Interlocked.Exchange(ref cache, cacheFactory());
+            oldCache?.Dispose();
+        }
+
         public Task<T> GetOrCreateAsync<T>(string key, Func<ICacheEntry, Task<T>> factory)
         {
             return cache.GetOrCreateAsync(key, factory);