Merge pull request #1 from cajuncoding/feature/add_support_for_self_expiring_cache_results

Feature/add support for self expiring cache results

Author: cajuncoding

LazyCacheHelpers.Tests/AsyncTests.cs

@@ -44,6 +44,27 @@ public async Task TestCacheHitsAsync()
             Assert.AreSame(result1, result4);
         }
 
+        [TestMethod]
+        public async Task TestCacheHitsForSelfExpiringResultsAsync()
+        {
+            string key = $"CachedDataWithSameKey[{nameof(GetTestDataWithCachingForSelfExpiringResultsAsync)}]";
+
+            var result1 = await GetTestDataWithCachingForSelfExpiringResultsAsync(key);
+            var result2 = await GetTestDataWithCachingForSelfExpiringResultsAsync(key);
+            var result3 = await GetTestDataWithCachingForSelfExpiringResultsAsync(key);
+            var result4 = await GetTestDataWithCachingForSelfExpiringResultsAsync(key);
+
+            Assert.AreEqual(result1, result2);
+            Assert.AreSame(result1, result2);
+
+            Assert.AreEqual(result3, result4);
+            Assert.AreSame(result3, result4);
+
+            //Compare First and Last to ensure that ALL are the same!
+            Assert.AreEqual(result1, result4);
+            Assert.AreSame(result1, result4);
+        }
+
         [TestMethod]
         public async Task TestCacheMissesAsync()
         {
@@ -63,6 +84,24 @@ await GetTestDataWithCachingAsync($"{key}[{++c}]")
             Assert.AreEqual(results.Count, distinctCount);
         }
 
+        [TestMethod]
+        public async Task TestCacheMissesForSelfExpiringResultsAsync()
+        {
+            int c = 0;
+            string key = $"CachedDataWithDifferentKey[{nameof(TestCacheMissesAsync)}]";
+            var results = new List<string>()
+            {
+                await GetTestDataWithCachingForSelfExpiringResultsAsync($"{key}[{++c}]"),
+                await GetTestDataWithCachingForSelfExpiringResultsAsync($"{key}[{++c}]"),
+                await GetTestDataWithCachingForSelfExpiringResultsAsync($"{key}[{++c}]"),
+                await GetTestDataWithCachingForSelfExpiringResultsAsync($"{key}[{++c}]")
+            };
+
+            var distinctCount = results.Distinct().Count();
+
+            //Ensure that ALL Items are Distinctly Different!
+            Assert.AreEqual(results.Count, distinctCount);
+        }
 
         [TestMethod]
         public async Task TestCacheMissesBecauseOfDisabledPolicyAsync()
@@ -164,7 +203,53 @@ public async Task TestCacheThreadSafetyWithLazyInitializationAsync()
             //  meaning globalCount is only ever incremented 1 time!
             Assert.AreEqual(1, globalCount);
 
-            //Ensure ONLY ONE item was ever generated and ALL other's were identical from Cache!
+            //Ensure ONLY ONE item was ever generated and ALL others were identical from Cache!
+            Assert.AreEqual(1, distinctCount);
+
+            //Ensure that the Total time takes barely longer than one iteration of the Long Running Task!
+            Assert.IsTrue(timer.ElapsedMilliseconds < (LongRunningTaskMillis * 2));
+        }
+
+        [TestMethod]
+        public async Task TestCacheThreadSafetyForSelfExpiringResultsAsync()
+        {
+            string key = $"CachedDataWithSameKey[{nameof(TestCacheThreadSafetyForSelfExpiringResultsAsync)}]";
+            int secondsTTL = 300;
+            int threadCount = 1000;
+            var globalCount = 0;
+            var timer = Stopwatch.StartNew();
+
+            var tasks = new List<Task<string>>();
+            for (int x = 0; x < threadCount; x++)
+            {
+                //Simulated MANY threads running at the same time attempting to get the same data for the same Cache key!!!
+                tasks.Add(Task.Run(async () =>
+                {
+                    //THIS RUNS ON IT'S OWN THREAD, but the Lazy Cache initialization will ensure that the Value Factory Function
+                    //  is only executed by the FIRST thread, and all other threads will immediately benefit from the result!
+                    return await TestCacheFacade.GetCachedSelfExpiringDataAsync(new TestCacheParams(key), async () =>
+                    {
+                        //TEST that this Code ONLY ever runs ONE TIME by ONE THREAD via Lazy<> initialization!
+                        //  meaning globalCount is only ever incremented 1 time!
+                        Interlocked.Increment(ref globalCount);
+
+                        //TEST that the cached data is never re-generated so only ONE Value is ever created!
+                        var longTaskResult = await SomeLongRunningMethodAsync(DateTime.Now);
+                        return LazySelfExpiringCacheResult.From(longTaskResult, secondsTTL);
+                    });
+                }));
+            }
+
+            //Allow all threads to complete and get the results...
+            var results = await Task.WhenAll(tasks.ToArray());
+            var distinctCount = results.Distinct().Count();
+            timer.Stop();
+
+            //TEST that this Code ONLY ever runs ONE TIME by ONE THREAD via Lazy<> initialization!
+            //  meaning globalCount is only ever incremented 1 time!
+            Assert.AreEqual(1, globalCount);
+
+            //Ensure ONLY ONE item was ever generated and ALL others were identical from Cache!
             Assert.AreEqual(1, distinctCount);
 
             //Ensure that the Total time takes barely longer than one iteration of the Long Running Task!
@@ -183,6 +268,15 @@ public static async Task<string> GetTestDataWithCachingAsync(string key, CacheIt
             });
         }
 
+        public static async Task<string> GetTestDataWithCachingForSelfExpiringResultsAsync(string key, int secondsTTL = 5, bool isLongRunning = true)
+        {
+            return await TestCacheFacade.GetCachedSelfExpiringDataAsync(new TestCacheParams(key), async () =>
+            {
+                var cacheResult = await SomeLongRunningMethodAsync(DateTime.Now);
+                return LazySelfExpiringCacheResult.From(cacheResult, secondsTTL);
+            });
+        }
+
         public static async Task<string> GetTestDataWithCachingAndTTLAsync(string key, int secondsTTL)
         {
             return await TestCacheFacade.GetCachedDataAsync(

LazyCacheHelpers.Tests/LazyCacheHelpers.Tests.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFramework>net6</TargetFramework>
 
     <IsPackable>false</IsPackable>
   </PropertyGroup>
@@ -29,8 +29,8 @@
   </ItemGroup>
 
   <ItemGroup>
-    <None Update="testhost.x86.dll.config">
-      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    <None Update="testhost.dll.config">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
 

LazyCacheHelpers.Tests/SyncTests.cs

@@ -43,6 +43,27 @@ public void TestCacheHits()
             Assert.AreSame(result1, result4);
         }
 
+        [TestMethod]
+        public void TestCacheHitsForSelfExpiringResults()
+        {
+            string key = $"CachedDataWithSameKey[{nameof(TestCacheHitsForSelfExpiringResults)}]";
+
+            var result1 = GetTestDataWithCachingForSelfExpiringResults(key);
+            var result2 = GetTestDataWithCachingForSelfExpiringResults(key);
+            var result3 = GetTestDataWithCachingForSelfExpiringResults(key);
+            var result4 = GetTestDataWithCachingForSelfExpiringResults(key);
+
+            Assert.AreEqual(result1, result2);
+            Assert.AreSame(result1, result2);
+
+            Assert.AreEqual(result3, result4);
+            Assert.AreSame(result3, result4);
+
+            //Compare First and Last to ensure that ALL are the same!
+            Assert.AreEqual(result1, result4);
+            Assert.AreSame(result1, result4);
+        }
+
         [TestMethod]
         public void TestCacheMisses()
         {
@@ -62,6 +83,25 @@ public void TestCacheMisses()
             Assert.AreEqual(results.Count, distinctCount);
         }
 
+        [TestMethod]
+        public void TestCacheMissesForSelfExpiringResults()
+        {
+            int c = 0;
+            string key = $"CachedDataWithDifferentKey[{nameof(TestCacheMisses)}]";
+            var results = new List<string>()
+            {
+                GetTestDataWithCachingForSelfExpiringResults($"{key}[{++c}]"),
+                GetTestDataWithCachingForSelfExpiringResults($"{key}[{++c}]"),
+                GetTestDataWithCachingForSelfExpiringResults($"{key}[{++c}]"),
+                GetTestDataWithCachingForSelfExpiringResults($"{key}[{++c}]")
+            };
+
+            var distinctCount = results.Distinct().Count();
+
+            //Ensure that ALL Items are Distinctly Different!
+            Assert.AreEqual(results.Count, distinctCount);
+        }
+
         [TestMethod]
         public void TestCacheMissesBecauseOfDisabledPolicy()
         {
@@ -145,7 +185,6 @@ public void TestCacheRemoval()
             Assert.AreNotSame(result1, result3);
         }
 
-
         [TestMethod]
         public void TestCacheCountAndClearing()
         {   
@@ -243,7 +282,53 @@ public async Task TestCacheThreadSafetyWithLazyInitialization()
             //  meaning globalCount is only ever incremented 1 time!
             Assert.AreEqual(1, globalCount);
 
-            //Ensure ONLY ONE item was ever generated and ALL other's were identical from Cache!
+            //Ensure ONLY ONE item was ever generated and ALL others were identical from Cache!
+            Assert.AreEqual(1, distinctCount);
+
+            //Ensure that the Total time takes barely longer than one iteration of the Long Running Task!
+            Assert.IsTrue(timer.ElapsedMilliseconds < (LongRunningTaskMillis * 2));
+        }
+
+        [TestMethod]
+        public async Task TestCacheThreadSafetyForSelfExpiringCacheResults()
+        {
+            string key = $"CachedDataWithSameKey[{nameof(TestCacheThreadSafetyForSelfExpiringCacheResults)}]";
+            int secondsTTL = 300;
+            int threadCount = 1000;
+            var globalCount = 0;
+            var timer = Stopwatch.StartNew();
+
+            var tasks = new List<Task<string>>();
+            for (int x = 0; x < threadCount; x++)
+            {
+                //Simulated MANY threads running at the same time attempting to get the same data for the same Cache key!!!
+                tasks.Add(Task.Run(() =>
+                {
+                    //THIS RUNS ON IT'S OWN THREAD, but the Lazy Cache initialization will ensure that the Value Factory Function
+                    //  is only executed by the FIRST thread, and all other threads will immediately benefit from the result!
+                    return TestCacheFacade.GetCachedSelfExpiringData(new TestCacheParams(key), () =>
+                    {
+                        //TEST that this Code ONLY ever runs ONE TIME by ONE THREAD via Lazy<> initialization!
+                        //  meaning globalCount is only ever incremented 1 time!
+                        Interlocked.Increment(ref globalCount);
+
+                        //TEST that the cached data is never re-generated so only ONE Value is ever created!
+                        var longTaskResult = SomeLongRunningMethod(DateTime.Now);
+                        return LazySelfExpiringCacheResult.From(longTaskResult, secondsTTL);
+                    });
+                }));
+            }
+
+            //Allow all threads to complete and get the results...
+            var results = await Task.WhenAll(tasks.ToArray());
+            var distinctCount = results.Distinct().Count();
+            timer.Stop();
+
+            //TEST that this Code ONLY ever runs ONE TIME by ONE THREAD via Lazy<> initialization!
+            //  meaning globalCount is only ever incremented 1 time!
+            Assert.AreEqual(1, globalCount);
+
+            //Ensure ONLY ONE item was ever generated and ALL others were identical from Cache!
             Assert.AreEqual(1, distinctCount);
 
             //Ensure that the Total time takes barely longer than one iteration of the Long Running Task!
@@ -262,7 +347,16 @@ public static string GetTestDataWithCaching(string key, CacheItemPolicy override
             });
         }
 
-        public static string GetTestDataWithCachingAndTTL(string key, int secondsTTL)
+        public static string GetTestDataWithCachingForSelfExpiringResults(string key, int secondsTTL = 5, bool isLongRunning = true)
+        {
+            return TestCacheFacade.GetCachedSelfExpiringData(new TestCacheParams(key), () =>
+            {
+                var cacheResult = SomeLongRunningMethod(DateTime.Now, isLongRunning);
+                return LazySelfExpiringCacheResult.From(cacheResult, secondsTTL);
+            });
+        }
+
+        public static string GetTestDataWithCachingAndTTL(string key, int secondsTTL = 5)
         {
             return TestCacheFacade.GetCachedData(
                 new TestCacheParams(key, secondsTTL), 

LazyCacheHelpers.Tests/TestCacheFacade/TestCacheFacade.cs

@@ -21,6 +21,12 @@ public static string GetCachedData(ILazyCacheParams cacheParams, Func<string> fn
             return result;
         }
 
+        public static string GetCachedSelfExpiringData(ILazyCacheParams cacheParams, Func<ILazySelfExpiringCacheResult<string>> fnSelfExpiringValueFactory)
+        {
+            var result = DefaultLazyCache.GetOrAddFromCache(cacheParams, fnSelfExpiringValueFactory);
+            return result;
+        }
+
         public static async Task<string> GetCachedDataAsync(ILazyCacheParams cacheParams, Func<Task<string>> fnValueFactory)
         {
             var result = await DefaultLazyCache.GetOrAddFromCacheAsync<ILazyCacheKey, string>(
@@ -32,6 +38,12 @@ public static async Task<string> GetCachedDataAsync(ILazyCacheParams cacheParams
             return result;
         }
 
+        public static async Task<string> GetCachedSelfExpiringDataAsync(ILazyCacheParams cacheParams, Func<Task<ILazySelfExpiringCacheResult<string>>> fnSelfExpiringValueFactory)
+        {
+            var result = await DefaultLazyCache.GetOrAddFromCacheAsync(cacheParams, fnSelfExpiringValueFactory);
+            return result;
+        }
+
         public static void RemoveCachedData(ILazyCacheKey cacheKey)
         {
             DefaultLazyCache.RemoveFromCache(cacheKey);

…cheHelpers.Tests/testhost.x86.dll.config …zyCacheHelpers.Tests/testhost.dll.configLazyCacheHelpers.Tests/testhost.x86.dll.config renamed to LazyCacheHelpers.Tests/testhost.dll.config LazyCacheHelpers.Tests/testhost.x86.dll.config renamed to LazyCacheHelpers.Tests/testhost.dll.config

@@ -18,9 +18,10 @@ public class LazyCachePolicy
         /// Static Reference to a CacheItemPolicy that represents a completely Disabled cache with an AbsoluteExpiration of DateTimeOffset.MinValue (e.g. beginning-of-time).
         /// </summary>
         public static CacheItemPolicy DisabledCachingPolicy => new CacheItemPolicy() { AbsoluteExpiration = DateTimeOffset.MinValue };
+        public static CacheItemPolicy InfiniteCachingPolicy => new CacheItemPolicy() { AbsoluteExpiration = DateTimeOffset.MaxValue };
 
         /// <summary>
-        /// Helper method to abstract logic for determining if a CacheItemPolicy is disabled (e.g. AbsoluteExpiration of DateTimeOffset.MinValue).
+        /// Helper method to abstract logic for determining if a CacheItemPolicy is disabled or same as LazyCachePolicy.DisabledCachingPolicy (e.g. AbsoluteExpiration of DateTimeOffset.MinValue).
         /// </summary>
         /// <param name="policy"></param>
         /// <returns></returns>
@@ -66,7 +67,7 @@ public static CacheItemPolicy NewAbsoluteExpirationPolicy(TimeSpan cacheTimeSpan
         private static readonly ThreadLocal<Random> _threadLocalRandomGenerator = new ThreadLocal<Random>(() => new Random(Guid.NewGuid().GetHashCode()));
 
         /// <summary>
-        /// Provides logic to randomly distribute Cache TTL values within the specified threshhold to help ensure that
+        /// Provides logic to randomly distribute Cache TTL values within the specified threshold to help ensure that
         ///     cached values are not all exactly equal.  This is helpful to provide dynamic caching that is much less likely
         ///     to result in all elements being expired from cache at the exact same time, but balances this with the fact that
         ///     they should expire relatively close in time.  So the Threshold value should be small; e.g. with 30 seconds, or
@@ -84,7 +85,7 @@ public static TimeSpan RandomizeCacheTTLDistribution(TimeSpan timeSpanTTL, int m
             //BBernard
             //Salt the timespan with a small randomly generated offset value (e.g. spice it up a little with some salt)!
             //NOTE: We use a random number generator to help us salt our Cache intervals and better
-            //  stimilate offset caching of items.  This is a simplistic way to help level out the 
+            //  stimulate offset caching of items.  This is a simplistic way to help level out the 
             //  cache hit/miss distribution so that fewer requests take the same large hit to refresh
             //  when they expire by absolute time.
             //For Example: If in a high load environment multiple requests could all result in cache misses

LazyCacheHelpers/CacheHelpers/LazyCachePolicy.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Threading.Tasks;
+
+namespace LazyCacheHelpers
+{
+    /// <summary>
+    /// BBernard
+    /// Original Source (MIT License): https://github.com/cajuncoding/LazyCacheHelpers
+    /// 
+    /// Public Interface for the Lazy Cache Handler which adds support for the value factories to be self-managing/self-expiring
+    /// by returning both the result and the policy!  This is very useful in use cases such as loading Auth Tokens or other
+    /// data from external APIs whereby the API response determines how long the result is valid for, and therefore it does
+    /// not need to be refreshed/reloaded until that time has lapsed. So the logic can build a Cache Expiration policy based
+    /// on the information in the response and create a valid CachePolicy.
+    ///
+    /// NOTE: This is intended to be an extension of the base ILazyCacheHandler, but is separate now as a composable interface to
+    /// to mitigate potentially breaking existing custom implementations of the ILazyCacheHandler.
+    /// </summary>
+    /// <typeparam name="TValue"></typeparam>
+    public interface ILazyCacheHandlerSelfExpiring<TValue>
+    {
+        TValue GetOrAddFromCache<TKey>(TKey key, Func<ILazySelfExpiringCacheResult<TValue>> fnValueFactory);
+        Task<TValue> GetOrAddFromCacheAsync<TKey>(TKey key, Func<Task<ILazySelfExpiringCacheResult<TValue>>> fnAsyncValueFactory);
+    }
+}

LazyCacheHelpers/CacheInterfaces/ILazyCacheHandlerSelfExpiring.cs

@@ -0,0 +1,10 @@
+using System.Runtime.Caching;
+
+namespace LazyCacheHelpers
+{
+    public interface ILazySelfExpiringCacheResult<out TValue>
+    {
+        CacheItemPolicy CachePolicy { get; }
+        TValue CacheItem { get; }
+    }
+}