Add support for Clearing the Lazy Static In-memory Cache. Updated version to release to Nuget. Updated Readme release notes.

Author: cajuncoding

LazyCacheHelpers.Tests/StaticInMemoryCacheTests.cs

@@ -1,13 +1,8 @@
 using LazyCacheHelpers;
 using System;
-using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
-using System.Runtime.Caching;
-using System.Threading;
 using System.Threading.Tasks;
-using System.Xml;
 using Attr = System.ComponentModel;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
@@ -123,6 +118,46 @@ public async Task TestCacheLoadingAndHitsAsync()
             Assert.AreEqual("C-3PO", cachedEnumDescriptions[StarWarsEnum.C3PO].FirstOrDefault());
         }
 
+        [TestMethod]
+        public async Task TestClearingStaticInMemoryCacheSyncAndAsync()
+        {
+            var enumCache = new LazyStaticInMemoryCache<Type, ILookup<Enum, string>>();
+            int runCount = 0;
+
+            var loadCacheAsync = new Func<Task>(async () =>
+            {
+                //#1 Load Async Cache item
+                var asyncCachedEnumDescriptions = await enumCache.GetOrAddAsync(typeof(StarWarsEnum), (t) =>
+                {
+                    runCount++;
+                    var enumDescriptionLookup = GetEnumDescriptionsLookup<StarWarsEnum>();
+                    //Simulate Async operation by returning the results as a Task!
+                    return Task.FromResult(enumDescriptionLookup);
+                });
+
+                //#2 Load Sync Cache item
+                var syncCachedEnumDescriptions = enumCache.GetOrAdd(typeof(StarWarsEnum), (t) =>
+                {
+                    runCount++;
+                    return GetEnumDescriptionsLookup<StarWarsEnum>();
+                });
+            });
+
+            //New Cache shoudl always have Zero entries...
+            Assert.AreEqual(0, enumCache.GetCacheCount());
+
+            await loadCacheAsync.Invoke();
+
+            Assert.AreEqual(runCount, enumCache.GetCacheCount());
+            Assert.AreEqual(runCount, enumCache.ClearCache());
+            Assert.AreEqual(0, enumCache.GetCacheCount());
+            runCount = 0;
+
+            //Test Reloading after being cleared with the Exact Same Data, Keys, etc.
+            await loadCacheAsync.Invoke();
+            Assert.AreEqual(runCount, enumCache.GetCacheCount());
+        }
+
         [TestMethod]
         public async Task TestCacheExceptionsAsync()
         {

LazyCacheHelpers/LazyCacheHelpers.csproj

@@ -11,9 +11,10 @@
     <RepositoryUrl>https://github.com/cajuncoding/LazyCacheHelpers</RepositoryUrl>
     <PackageTags>cache caching memory memorycache in-memory lazy loading load self populate populating abstraction abstract thread threadsafe thread-safe safe performance optimization optimize server utilization</PackageTags>
     <PackageReleaseNotes>
-        - Add support for Clearing the Cache and for getting the Cache Count; implemented for DefaultLazyCache as well as the Static In-memory caches.
+		- Add support for Clearing the Lazy Static In-memory Cache (wrapper for Lazy caching pattern for sync or async results based on the underlying ConcurrentDictionary&lt;Lazy&lt;T&gt;&gt;).
 
 		Prior Release Notes:
+		- Add support for Clearing the Cache and for getting the Cache Count; implemented for DefaultLazyCache as well as the Static In-memory caches.
 		- Restored LazyCacheConfig class capabilities for reading values dynamically from Configuration.
 		- Added support for Bootstrapping a Configuration Reader Func (Delegate) so that all reading of config values from the keys is completely dynamic now.
 		- Added new LazyStaticInMemoryCache&lt;&gt; class to make it significantly easier to implement in-memory caching of data that rarely or never changes with the lazy loading, blocking cache, pattern; great for minimizing the runtime impact of expensive Reflection or I/O Async logic for data that rarely or never changes.
@@ -22,7 +23,7 @@
 		- Now fully supported as a .Net Standard 2.0 library (sans Configuration reader helpers) whereby you can specify the timespan directly for Cache Policy initialization.
 		- Initial nuget release for .Net Framework.
 	</PackageReleaseNotes>
-    <Version>1.1.0</Version>
+    <Version>1.2.0</Version>
   </PropertyGroup>
 
   <ItemGroup>

LazyCacheHelpers/LazyStaticInMemoryCache.cs

@@ -17,6 +17,7 @@ public class LazyStaticInMemoryCache<TKey, TValue>
     {
         protected readonly ConcurrentDictionary<TKey, Lazy<TValue>> _lazySyncCache = new ConcurrentDictionary<TKey, Lazy<TValue>>();
         protected readonly ConcurrentDictionary<TKey, Lazy<Task<TValue>>> _lazyAsyncCache = new ConcurrentDictionary<TKey, Lazy<Task<TValue>>>();
+        protected readonly object _padLock = new object();
 
         /// Initialize a new Synchronous value factory for lazy loading a value from an expensive Async process, and execute the value factory at most one time (ever, across any/all threads).
         /// This provides a robust blocking cache mechanism backed by the Lazy<> class for high performance lazy loading of data that rarely ever changes.
@@ -112,5 +113,26 @@ public virtual bool TryRemoveAsyncValue(TKey key)
             return _lazyAsyncCache.TryRemove(key, out _);
         }
 
+        public virtual int GetCacheCount()
+        {
+            return _lazyAsyncCache.Count + _lazySyncCache.Count;
+        }
+
+        public virtual int ClearCache()
+        {
+            int clearCount = 0;
+            if (GetCacheCount() > 0)
+                lock (_padLock)
+                    if (GetCacheCount() > 0)
+                    {
+                        clearCount += _lazyAsyncCache.Count;
+                        _lazyAsyncCache.Clear();
+
+                        clearCount += _lazySyncCache.Count;
+                        _lazySyncCache.Clear();
+                    }
+
+            return clearCount;
+        }
     }
 }

README.md

@@ -56,6 +56,13 @@ LazyCacheConfig.BootstrapConfigValueReader(configKeyName => {
 OR use the ConfigurationManager Bootstrap helper above if you use AppSettings; it'll wire up a default reader for you (see below)!
 
 ## Release Notes:
+### v1.2
+- Add support for Clearing the Lazy Static In-memory Cache
+  - *The wrapper for Lazy caching pattern for sync or async results based on the underlying ConcurrentDictionary<Lazy<T>>).*
+
+### v1.1
+ - Add support for Clearing the Cache and for getting the Cache Count; implemented for DefaultLazyCache as well as the Static In-memory caches.
+
 ### v1.0.4
 - Restored LazyCacheConfig class capabilities for reading values dynamically from Configuration.
 - Added support for Bootstrapping a Configuration Reader Func (Delegate) so that all reading of config values from the keys is completely dynamic now.