Added a RemoveAll function to clear the entire cache

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,11 @@ public void Remove(string key)
             cache.Remove(key);
         }
 
+        public void RemoveAll()
+        {
+            cache = cacheFactory();
+        }
+
         public Task<T> GetOrCreateAsync<T>(string key, Func<ICacheEntry, Task<T>> factory)
         {
             return cache.GetOrCreateAsync(key, factory);