/// <summary>
        /// BBernard
        /// Add or update the cache with the specified cache key and item that will be Lazy Initialized from Lambda function/logic.
        /// This method ensures that the item is initialized with full thread safety and that only one thread ever executes the work
        /// to initialize the item to be cached -- significantly improving server utilization and performance.
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="key"></param>
        /// <param name="fnValueFactory"></param>
        /// <param name="cacheItemPolicy"></param>
        /// <returns></returns>
        public static TValue GetOrAddFromCache <TKey, TValue>(TKey key, Func <TValue> fnValueFactory, CacheItemPolicy cacheItemPolicy)
            where TValue : class
        {
            TValue result = LazyCachePolicy.IsPolicyEnabled(cacheItemPolicy)
                                ? (TValue)_lazyCache.GetOrAddFromCache(key, fnValueFactory, cacheItemPolicy)
                                : fnValueFactory();

            return(result);
        }
        /// <summary>
        /// BBernard
        /// Add or update the cache with the specified cache key and item that will be Lazy Initialized Asynchronously from Lambda function/logic.
        /// This method ensures that the item is initialized with full thread safety and that only one thread ever executes the work
        /// to initialize the item to be cached -- significantly improving server utilization and performance.
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <typeparam name="TValue"></typeparam>
        /// <param name="key"></param>
        /// <param name="fnAsyncValueFactory"></param>
        /// <param name="cacheItemPolicy"></param>
        /// <returns></returns>
        public static async Task <TValue> GetOrAddFromCacheAsync <TKey, TValue>(TKey key, Func <Task <TValue> > fnAsyncValueFactory, CacheItemPolicy cacheItemPolicy)
            where TValue : class
        {
            //Because the underlying cache is set up to store any object and the async coercion isn't as easy as the synchronous,
            //  we must wrap the original generics typed async factory into a new Func<> that matches the required type.
            var wrappedFnValueFactory = new Func <Task <object> >(async() => await fnAsyncValueFactory());

            TValue result = LazyCachePolicy.IsPolicyEnabled(cacheItemPolicy)
                                ? (TValue)await _lazyCache.GetOrAddFromCacheAsync(key, wrappedFnValueFactory, cacheItemPolicy)
                                : await fnAsyncValueFactory();

            return(result);
        }