public static ICacheProvider GetCacheProvider() { var provider = CacheConfig.Create() .BuildCacheProviderWithTraceLogging(); return(provider); }
public void ShouldLogInfoMessages() { var provider = CacheConfig.Create() .UseMemoryCache() .BuildCacheProvider(new TestLogger()); provider.Add("test1", DateTime.Now.AddMinutes(1), "data"); Assert.IsTrue(TestLogger.InfoCount > 1, "Expected some informational messages to be logged but they were not"); }
public static ICache BuildTestCache() { if (_cache != null) { return(_cache); } _cache = CacheConfig.Create() .BuildCacheProviderWithTraceLogging() .InnerCache; return(_cache); }
public void ShouldLogInfoAndErrorMEssages() { try { var provider = CacheConfig.Create() .UseMemcachedCache() .UsingDistributedServerNode("1.2.3.4", 1) .BuildCacheProvider(new TestLogger()); provider.Add("test1", DateTime.Now.AddMinutes(1), "data"); } catch { } Assert.IsTrue(TestLogger.InfoCount > 1, "Expected some informational messages to be logged but they were not"); Assert.IsTrue(TestLogger.ErrorCount > 1, "Expected some error messages to be logged but they were not"); }
public CacheProvider(ICache cache, ILogging logger, CacheConfig config, ICacheDependencyManager cacheDependencyManager, ICacheFeatureSupport featureSupport) { _cache = cache; _logger = logger; _featureSupport = featureSupport; _config = config ?? CacheConfig.Create(); _cacheDependencyManager = cacheDependencyManager; if (_config.IsCacheDependencyManagementEnabled && _cacheDependencyManager != null) { _logger.WriteInfoMessage(string.Format("CacheKey dependency management enabled, using {0}.", _cacheDependencyManager.Name)); } else { _cacheDependencyManager = null; // Dependency Management is disabled _logger.WriteInfoMessage("CacheKey dependency management not enabled."); } }
public static bool ExampleAddUsingAsyncCalls() { ConsoleHelper.WriteHeadingSeparator("Simple Cache examples using Async calls"); var cacheProvider = CacheConfig.Create().BuildCacheProvider(new InMemoryLogger()); cacheProvider.ClearAll(); const string cacheData = "AsyncData"; const string cacheKey = "async-key"; Console.WriteLine("Call GetAsync with long running task to populate cache"); var expensiveData = cacheProvider.GetAsync <string>(cacheKey, DateTime.Now.AddDays(1), () => { return(System.Threading.Tasks.Task.Run(() => { ConsoleHelper.Wait(2); // simulate some long running operation return cacheData; })); }); Console.WriteLine("...Doing some small work and then checking if item is in cache yet (which it should not be)"); // Do some work ConsoleHelper.Wait(1); var doesCacheItemExistInCacheYet = (cacheProvider.InnerCache.Get <string>(cacheKey) != null); if (doesCacheItemExistInCacheYet == true) { ConsoleHelper.WriteErrMsgToConsole("Cache item was already in cache when it was not expected to be in there yet via the async method"); return(false); } Console.WriteLine("...Doing a little more work which should take longer than the async task that places data in cache so we expect it to exist in cache."); ConsoleHelper.Wait(1.1); var doesCacheItemExistInCacheNow = (cacheProvider.InnerCache.Get <string>(cacheKey) != null); if (doesCacheItemExistInCacheNow == false) { ConsoleHelper.WriteErrMsgToConsole("Cache item was NOT in cache when it was expected to be in there via the async method"); return(false); } Console.WriteLine(">> Item was placed in cache via async method as expected\n\n"); return(true); }
public static bool ExampleAddAndClearWithDependencies() { ConsoleHelper.WriteHeadingSeparator("Simple Cache Dependency examples"); // Use cache from config file. var cacheProvider = CacheConfig.Create() .BuildCacheProvider(new InMemoryLogger()); cacheProvider.ClearAll(); const string masterDataKey = "MasterData"; Console.WriteLine("1. Adding the main data to cache which acts as the trigger for the other added items"); var masterData = cacheProvider.Get <string>(masterDataKey, DateTime.Now.AddDays(1), () => "Master Data Item"); Console.WriteLine("\n2. Attempting to get some related Data from cache provider which will\nimplicitly add it to the cache and related it to the 'MasterItem'\nadded previously."); var bitOfRelatedData1 = cacheProvider.Get <string>("Bit1", DateTime.Now.AddDays(1), () => "Some Bit Of Data1", masterDataKey); var bitOfRelatedData2 = cacheProvider.Get <string>("Bit2", DateTime.Now.AddDays(1), () => "Some Bit Of Data2", masterDataKey); Console.WriteLine("\n3. Make sure everything is in the cache as expected."); var bit1Ok = cacheProvider.InnerCache.Get <string>("Bit1") != null; var bit2Ok = cacheProvider.InnerCache.Get <string>("Bit2") != null; var masterDataOk = cacheProvider.InnerCache.Get <string>(masterDataKey) != null; Console.WriteLine("Bit1 is in the cache?:{0}", bit1Ok); Console.WriteLine("Bit2 is in the cache?:{0}", bit2Ok); Console.WriteLine("MasterData item is in the cache?:{0}", masterDataOk); if (!bit1Ok || !bit2Ok || !masterDataOk) { ConsoleHelper.WriteErrMsgToConsole("Items were not present in cache."); return(false); } Console.WriteLine("\n5. Now clearing the master data item which should also clear the related items"); cacheProvider.InvalidateCacheItem(masterDataKey); ConsoleHelper.Wait(2); Console.WriteLine("\n6. Make sure everything is NOT in the cache as expected."); var bit1Value = cacheProvider.InnerCache.Get <string>("Bit1"); var bit2Value = cacheProvider.InnerCache.Get <string>("Bit2"); bit1Ok = bit1Value == null; bit2Ok = bit2Value == null; var masterDataValue = cacheProvider.InnerCache.Get <string>(masterDataKey); masterDataOk = masterDataValue == null; Console.WriteLine("Bit1 is NOT in the cache?:{0}", bit1Ok); Console.WriteLine("Bit2 is NOT in the cache?:{0}", bit2Ok); Console.WriteLine("MasterData item is NOT in the cache?:{0}", masterDataOk); if (!bit1Ok || !bit2Ok || !masterDataOk) { ConsoleHelper.WriteErrMsgToConsole("Items were present in cache when they should have been removed."); return(false); } Console.WriteLine("All dependencies worked as expected."); cacheProvider.ClearAll(); return(true); }
public static bool ExampleAddAndRetrieveFromCache() { int _accessCounter = 0; bool _allTestsPassed = true; ConsoleHelper.WriteHeadingSeparator("Simple Add and Retrieve Examples"); var cacheProvider = CacheConfig .Create() .BuildCacheProvider(new InMemoryLogger()); // Use the settings from config // Can do via dependency helper too //var cacheProvider = AppServices.Cache; // First try and get some data. It wont be in the cache, so the anonymous function is executed, // the item is automatically added to the cache and returned. Console.WriteLine("#1: Getting Some Data."); var data1 = cacheProvider.Get <SomeData>("cache-key", DateTime.Now.AddSeconds(5), () => { // This is the anonymous function which gets called if the data is not in the cache. // This method is executed and whatever is returned, is added to the cache with the // passed in expiry time. _accessCounter++; Console.WriteLine("... => Adding data to the cache... 1st call"); var someData = new SomeData() { SomeText = "cache example1", SomeNumber = 1 }; return(someData); }); Console.WriteLine("... => SomeData values: SomeText=[{0}], SomeNumber={1}\n", data1.SomeText, data1.SomeNumber); if (_accessCounter != 1) { ConsoleHelper.WriteErrMsgToConsole("Cache not added to, test result failed!"); } // Now try and get some data using the same cache-key and before the cached data expiry time elapses. // The data will be located in the cache and returned, and the anonymous function is NOT executed. Console.WriteLine("#2: Getting Some More Data which should now be cached."); var data2 = cacheProvider.Get <SomeData>("cache-key", DateTime.Now.AddSeconds(3), () => { // This is the anonymous function which gets called if the data is not in the cache. // This method is executed and whatever is returned, is added to the cache with the // passed in expiry time. _accessCounter++; Console.WriteLine("... => Adding data to the cache...2nd call- should not be displayed!"); var someData = new SomeData() { SomeText = "cache example2", SomeNumber = 2 }; return(someData); }); Console.WriteLine("... => SomeData values: SomeText=[{0}], SomeNumber={1}\n", data2.SomeText, data2.SomeNumber); if (_accessCounter == 2) { ConsoleHelper.WriteErrMsgToConsole("Data item not found in cachewhen it should have been found in cache, test result failed!"); } // Here we wait a period of time so that the cached data expiry time has passed and the data is // removed from the cache. We make the same call to retrieve the data using the same cache key, the data // is not found in the cache, so once again the anonymous function is executed, whatever is returned is // added to the cache, and then returned to the caller. ConsoleHelper.Wait(5); Console.WriteLine("#3: Getting Some More Data which should not be cached."); var data3 = cacheProvider.Get <SomeData>("cache-key", DateTime.Now.AddSeconds(5), () => { // This is the anonymous function which gets called if the data is not in the cache. // This method is executed and whatever is returned, is added to the cache with the // passed in expiry time. _accessCounter++; Console.WriteLine("... => Adding data to the cache...3rd call"); var someData = new SomeData() { SomeText = "cache example3", SomeNumber = 3 }; return(someData); }); Console.WriteLine("... => SomeData values: SomeText=[{0}], SomeNumber={1}\n", data3.SomeText, data3.SomeNumber); if (_accessCounter != 2) { ConsoleHelper.WriteErrMsgToConsole("Cache not added to, test result failed!"); } Func <SomeData> getCacheData = new Func <SomeData>(() => { // This is the anonymous function which gets called if the data is not in the cache. // This method is executed and whatever is returned, is added to the cache with the // passed in expiry time. _accessCounter++; Console.WriteLine("... => Adding data to the cache...4th call, with generated cache key - should only see this msg twice, NOT 3 times"); var someData = new SomeData() { SomeText = "cache example4 - generated cache key", SomeNumber = 4 }; return(someData); }); // Here we use the really simple API call to get an item from the cache without a cache key specified. // The cache key is generated from the function we pass in as the delegate used to retrieve the data Console.WriteLine("#4: Getting Some Data which should NOT BE cached."); var data4 = cacheProvider.Get <SomeData>(DateTime.Now.AddSeconds(3), getCacheData); if (_accessCounter != 3) { ConsoleHelper.WriteErrMsgToConsole("Cache not added to, test result failed!"); _allTestsPassed = false; } Console.WriteLine("#5: Getting Some More Data which should BE cached."); var data5 = cacheProvider.Get <SomeData>(DateTime.Now.AddSeconds(2), getCacheData); if (_accessCounter != 3) { ConsoleHelper.WriteErrMsgToConsole("Data item not found in cache when it should have been found in cache, test result failed!"); _allTestsPassed = false; } ConsoleHelper.Wait(3); Console.WriteLine("#6: Getting Some More Data which should NOT be cached."); var data6 = cacheProvider.Get <SomeData>(DateTime.Now.AddSeconds(2), getCacheData); if (_accessCounter != 4) { ConsoleHelper.WriteErrMsgToConsole("Cache not added to, test result failed!"); _allTestsPassed = false; } return(_allTestsPassed); }
public static ICacheDependencyManager GetDependencyManager() { var config = CacheConfig.Create(); return(new GenericDependencyManager(config.BuildCacheProviderWithTraceLogging().InnerCache, new Core.Diagnostics.Logger(config))); }