feat: move app cache overload methods out to extensions methods

alastairtree · alastairtree · commit b0b970ee855a · 2018-03-04T15:27:15.000Z
diff --git a/CacheDatabaseQueriesApiSample/Startup.cs b/CacheDatabaseQueriesApiSample/Startup.cs
@@ -1,5 +1,4 @@
-﻿using LazyCache;
-using Microsoft.AspNetCore.Builder;
+﻿using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
@@ -30,7 +29,6 @@ public void ConfigureServices(IServiceCollection services)
 
             // Register IAppCache as a singleton CachingService
             services.AddLazyCache();
-
         }
 
         // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
diff --git a/LazyCache.AspNetCore/LazyCacheServiceCollectionExtensions.cs b/LazyCache.AspNetCore/LazyCacheServiceCollectionExtensions.cs
@@ -23,7 +23,8 @@ public static IServiceCollection AddLazyCache(this IServiceCollection services)
             return services;
         }
 
-        public static IServiceCollection AddLazyCache(this IServiceCollection services, Func<IServiceProvider, CachingService> implmentationFactory)
+        public static IServiceCollection AddLazyCache(this IServiceCollection services,
+            Func<IServiceProvider, CachingService> implmentationFactory)
         {
             if (services == null) throw new ArgumentNullException(nameof(services));
             if (implmentationFactory == null) throw new ArgumentNullException(nameof(implmentationFactory));
@@ -37,4 +38,4 @@ public static IServiceCollection AddLazyCache(this IServiceCollection services,
             return services;
         }
     }
-}
+}
diff --git a/LazyCache.UnitTests/CachingServiceMemoryCacheProviderTests.cs b/LazyCache.UnitTests/CachingServiceMemoryCacheProviderTests.cs
@@ -24,7 +24,7 @@ private static CachingService BuildCache()
             return new CachingService(new MemoryCacheProvider());
         }
 
-        private CachingService sut;
+        private IAppCache sut;
 
         private readonly MemoryCacheEntryOptions oneHourNonRemoveableMemoryCacheEntryOptions =
             new MemoryCacheEntryOptions
@@ -175,6 +175,12 @@ public void AddWithSlidingThatExpiresReturnsNull()
             Assert.IsNull(sut.Get<string>(TestKey));
         }
 
+        [Test]
+        public void CacheProviderIsNotNull()
+        {
+            sut.CacheProvider.Should().NotBeNull();
+        }
+
         [Test]
         public void DefaultContructorThenGetOrAddFromSecondCachingServiceHasSharedUnderlyingCache()
         {
@@ -626,7 +632,11 @@ public void GetOrAddWithPolicyAndThenGetObjectReturnsCorrectType()
         [Test]
         public void GetOrAddWithPolicyAndThenGetValueObjectReturnsCorrectType()
         {
-            int Fetch() => 123;
+            int Fetch()
+            {
+                return 123;
+            }
+
             sut.GetOrAdd(TestKey, Fetch, oneHourNonRemoveableMemoryCacheEntryOptions);
             var actual = sut.Get<int>(TestKey);
             Assert.AreEqual(123, actual);
diff --git a/LazyCache/AppCacheExtenions.cs b/LazyCache/AppCacheExtenions.cs
@@ -0,0 +1,100 @@
+﻿using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace LazyCache
+{
+    public static class AppCacheExtenions
+    {
+        public static void Add<T>(this IAppCache cache, string key, T item)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            cache.Add(key, item, cache.DefaultCachePolicy.BuildOptions());
+        }
+
+        public static void Add<T>(this IAppCache cache, string key, T item, DateTimeOffset expires)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            cache.Add(key, item, new MemoryCacheEntryOptions {AbsoluteExpiration = expires});
+        }
+
+        public static void Add<T>(this IAppCache cache, string key, T item, TimeSpan slidingExpiration)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            cache.Add(key, item, new MemoryCacheEntryOptions {SlidingExpiration = slidingExpiration});
+        }
+
+        public static T GetOrAdd<T>(this IAppCache cache, string key, Func<T> addItemFactory)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            return cache.GetOrAdd(key, addItemFactory, cache.DefaultCachePolicy.BuildOptions());
+        }
+
+        public static T GetOrAdd<T>(this IAppCache cache, string key, Func<T> addItemFactory, DateTimeOffset expires)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            return cache.GetOrAdd(key, addItemFactory, new MemoryCacheEntryOptions {AbsoluteExpiration = expires});
+        }
+
+        public static T GetOrAdd<T>(this IAppCache cache, string key, Func<T> addItemFactory,
+            TimeSpan slidingExpiration)
+        {
+            return cache.GetOrAdd(key, addItemFactory,
+                new MemoryCacheEntryOptions {SlidingExpiration = slidingExpiration});
+        }
+
+        public static T GetOrAdd<T>(this IAppCache cache, string key, Func<T> addItemFactory,
+            MemoryCacheEntryOptions policy)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            return cache.GetOrAdd(key, entry =>
+            {
+                entry.SetOptions(policy);
+                return addItemFactory();
+            });
+        }
+
+        public static Task<T> GetOrAddAsync<T>(this IAppCache cache, string key, Func<Task<T>> addItemFactory)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            return cache.GetOrAddAsync(key, addItemFactory, cache.DefaultCachePolicy.BuildOptions());
+        }
+
+
+        public static Task<T> GetOrAddAsync<T>(this IAppCache cache, string key, Func<Task<T>> addItemFactory,
+            DateTimeOffset expires)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            return cache.GetOrAddAsync(key, addItemFactory, new MemoryCacheEntryOptions {AbsoluteExpiration = expires});
+        }
+
+        public static Task<T> GetOrAddAsync<T>(this IAppCache cache, string key, Func<Task<T>> addItemFactory,
+            TimeSpan slidingExpiration)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            return cache.GetOrAddAsync(key, addItemFactory,
+                new MemoryCacheEntryOptions {SlidingExpiration = slidingExpiration});
+        }
+
+        public static Task<T> GetOrAddAsync<T>(this IAppCache cache, string key, Func<Task<T>> addItemFactory,
+            MemoryCacheEntryOptions policy)
+        {
+            if (cache == null) throw new ArgumentNullException(nameof(cache));
+
+            return cache.GetOrAddAsync(key, entry =>
+            {
+                entry.SetOptions(policy);
+                return addItemFactory();
+            });
+        }
+    }
+}
diff --git a/LazyCache/CacheDefaults.cs b/LazyCache/CacheDefaults.cs
@@ -0,0 +1,18 @@
+﻿using System;
+using Microsoft.Extensions.Caching.Memory;
+
+namespace LazyCache
+{
+    public class CacheDefaults
+    {
+        public virtual int DefaultCacheDurationSeconds { get; set; } = 60 * 20;
+
+        internal MemoryCacheEntryOptions BuildOptions()
+        {
+            return new MemoryCacheEntryOptions
+            {
+                AbsoluteExpiration = DateTimeOffset.UtcNow.AddSeconds(DefaultCacheDurationSeconds)
+            };
+        }
+    }
+}
diff --git a/LazyCache/CacheItemPolicy.cs b/LazyCache/CacheItemPolicy.cs
@@ -6,7 +6,7 @@ namespace LazyCache
 {
     [Obsolete(
         "CacheItemPolicy was part of System.Runtime.Caching which is no longer used by LazyCache. " +
-        "This class is a fake used to maintain backward compatibility and will be removed in a later version."+
+        "This class is a fake used to maintain backward compatibility and will be removed in a later version." +
         "Change to MemoryCacheEntryOptions instead")]
     public class CacheItemPolicy : MemoryCacheEntryOptions
     {
diff --git a/LazyCache/CachingService.cs b/LazyCache/CachingService.cs
@@ -22,7 +22,6 @@ public CachingService(Lazy<ICacheProvider> cacheProvider)
             this.cacheProvider = cacheProvider ?? throw new ArgumentNullException(nameof(cacheProvider));
         }
 
-
         public CachingService(Func<ICacheProvider> cacheProviderFactory)
         {
             if (cacheProviderFactory == null) throw new ArgumentNullException(nameof(cacheProviderFactory));
@@ -37,38 +36,20 @@ public CachingService(ICacheProvider cache) : this(() => cache)
         public static Lazy<ICacheProvider> DefaultCacheProvider { get; set; }
             = new Lazy<ICacheProvider>(() => new MemoryCacheProvider());
 
-        /// <summary>
-        ///     Seconds to cache objects for by default
-        /// </summary>
-        public virtual int DefaultCacheDurationSeconds { get; set; } = 60 * 20;
-
         /// <summary>
         ///     Seconds to cache objects for by default
         /// </summary>
         [Obsolete("DefaultCacheDuration has been replaced with DefaultCacheDurationSeconds")]
-
         public virtual int DefaultCacheDuration
         {
-            get => DefaultCacheDurationSeconds;
-            set => DefaultCacheDurationSeconds = value;
-        }
-
-        private DateTimeOffset DefaultExpiryDateTime => DateTimeOffset.Now.AddSeconds(DefaultCacheDurationSeconds);
-
-        public virtual void Add<T>(string key, T item)
-        {
-            Add(key, item, DefaultExpiryDateTime);
-        }
-
-        public virtual void Add<T>(string key, T item, DateTimeOffset expires)
-        {
-            Add(key, item, new MemoryCacheEntryOptions {AbsoluteExpiration = expires});
+            get => DefaultCachePolicy.DefaultCacheDurationSeconds;
+            set => DefaultCachePolicy.DefaultCacheDurationSeconds = value;
         }
 
-        public virtual void Add<T>(string key, T item, TimeSpan slidingExpiration)
-        {
-            Add(key, item, new MemoryCacheEntryOptions {SlidingExpiration = slidingExpiration});
-        }
+        /// <summary>
+        ///     Policy defining how long items should be cached for unless specified
+        /// </summary>
+        public virtual CacheDefaults DefaultCachePolicy { get; set; } = new CacheDefaults();
 
         public virtual void Add<T>(string key, T item, MemoryCacheEntryOptions policy)
         {
@@ -97,30 +78,6 @@ public virtual Task<T> GetAsync<T>(string key)
             return UnwrapAsyncLazys<T>(item);
         }
 
-        public virtual T GetOrAdd<T>(string key, Func<T> addItemFactory)
-        {
-            return GetOrAdd(key, addItemFactory, DefaultExpiryDateTime);
-        }
-
-        public virtual T GetOrAdd<T>(string key, Func<T> addItemFactory, DateTimeOffset expires)
-        {
-            return GetOrAdd(key, addItemFactory, new MemoryCacheEntryOptions {AbsoluteExpiration = expires});
-        }
-
-        public virtual T GetOrAdd<T>(string key, Func<T> addItemFactory, TimeSpan slidingExpiration)
-        {
-            return GetOrAdd(key, addItemFactory, new MemoryCacheEntryOptions {SlidingExpiration = slidingExpiration});
-        }
-
-        public virtual T GetOrAdd<T>(string key, Func<T> addItemFactory, MemoryCacheEntryOptions policy)
-        {
-            return GetOrAdd(key, entry =>
-            {
-                entry.SetOptions(policy);
-                return addItemFactory();
-            });
-        }
-
         public virtual T GetOrAdd<T>(string key, Func<ICacheEntry, T> addItemFactory)
         {
             ValidateKey(key);
@@ -162,33 +119,6 @@ public virtual void Remove(string key)
 
         public virtual ICacheProvider CacheProvider => cacheProvider.Value;
 
-        public virtual Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory)
-        {
-            return GetOrAddAsync(key, addItemFactory, DefaultExpiryDateTime);
-        }
-
-        public virtual Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory, DateTimeOffset expires)
-        {
-            return GetOrAddAsync(key, addItemFactory, new MemoryCacheEntryOptions {AbsoluteExpiration = expires});
-        }
-
-        public virtual Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory,
-            TimeSpan slidingExpiration)
-        {
-            return GetOrAddAsync(key, addItemFactory,
-                new MemoryCacheEntryOptions {SlidingExpiration = slidingExpiration});
-        }
-
-        public virtual Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory,
-            MemoryCacheEntryOptions policy)
-        {
-            return GetOrAddAsync(key, entry =>
-            {
-                entry.SetOptions(policy);
-                return addItemFactory();
-            });
-        }
-
         public virtual async Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory)
         {
             ValidateKey(key);
diff --git a/LazyCache/IAppCache.cs b/LazyCache/IAppCache.cs
@@ -8,27 +8,21 @@ public interface IAppCache
     {
         ICacheProvider CacheProvider { get; }
 
-        void Add<T>(string key, T item);
-        void Add<T>(string key, T item, DateTimeOffset absoluteExpiration);
-        void Add<T>(string key, T item, TimeSpan slidingExpiration);
+        /// <summary>
+        ///     Define the number of seconds to cache objects for by default
+        /// </summary>
+        CacheDefaults DefaultCachePolicy { get; }
+
         void Add<T>(string key, T item, MemoryCacheEntryOptions policy);
 
         T Get<T>(string key);
 
-        T GetOrAdd<T>(string key, Func<T> addItemFactory);
-        T GetOrAdd<T>(string key, Func<T> addItemFactory, DateTimeOffset absoluteExpiration);
-        T GetOrAdd<T>(string key, Func<T> addItemFactory, TimeSpan slidingExpiration);
-        T GetOrAdd<T>(string key, Func<T> addItemFactory, MemoryCacheEntryOptions policy);
         T GetOrAdd<T>(string key, Func<ICacheEntry, T> addItemFactory);
 
-        void Remove(string key);
+        Task<T> GetAsync<T>(string key);
 
-        Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory);
-        Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory, MemoryCacheEntryOptions policy);
-        Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory, DateTimeOffset expires);
-        Task<T> GetOrAddAsync<T>(string key, Func<Task<T>> addItemFactory, TimeSpan slidingExpiration);
         Task<T> GetOrAddAsync<T>(string key, Func<ICacheEntry, Task<T>> addItemFactory);
 
-        Task<T> GetAsync<T>(string key);
+        void Remove(string key);
     }
 }
diff --git a/LazyCache/Mocks/MockCacheEntry.cs b/LazyCache/Mocks/MockCacheEntry.cs
@@ -0,0 +1,29 @@
+﻿using System;
+using System.Collections.Generic;
+using Microsoft.Extensions.Caching.Memory;
+using Microsoft.Extensions.Primitives;
+
+namespace LazyCache.Mocks
+{
+    public class MockCacheEntry : ICacheEntry
+    {
+        public MockCacheEntry(string key)
+        {
+            Key = key;
+        }
+
+        public void Dispose()
+        {
+        }
+
+        public object Key { get; }
+        public object Value { get; set; }
+        public DateTimeOffset? AbsoluteExpiration { get; set; }
+        public TimeSpan? AbsoluteExpirationRelativeToNow { get; set; }
+        public TimeSpan? SlidingExpiration { get; set; }
+        public IList<IChangeToken> ExpirationTokens { get; }
+        public IList<PostEvictionCallbackRegistration> PostEvictionCallbacks { get; }
+        public CacheItemPriority Priority { get; set; }
+        public long? Size { get; set; }
+    }
+}
diff --git a/LazyCache/Mocks/MockCacheProvider.cs b/LazyCache/Mocks/MockCacheProvider.cs
diff --git a/LazyCache/Mocks/MockCachingService.cs b/LazyCache/Mocks/MockCachingService.cs
diff --git a/ReleaseNotes.md b/ReleaseNotes.md

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,8 @@ public static IServiceCollection AddLazyCache(this IServiceCollection services)`
`23`	`23`	`return services;`
`24`	`24`	`}`
`25`	`25`
`26`		`- public static IServiceCollection AddLazyCache(this IServiceCollection services, Func<IServiceProvider, CachingService> implmentationFactory)`
	`26`	`+ public static IServiceCollection AddLazyCache(this IServiceCollection services,`
	`27`	`+ Func<IServiceProvider, CachingService> implmentationFactory)`
`27`	`28`	`{`
`28`	`29`	`if (services == null) throw new ArgumentNullException(nameof(services));`
`29`	`30`	`if (implmentationFactory == null) throw new ArgumentNullException(nameof(implmentationFactory));`
`@@ -37,4 +38,4 @@ public static IServiceCollection AddLazyCache(this IServiceCollection services,`
`37`	`38`	`return services;`
`38`	`39`	`}`
`39`	`40`	`}`
`40`		`-}`
	`41`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ namespace LazyCache`
`6`	`6`	`{`
`7`	`7`	`[Obsolete(`
`8`	`8`	`"CacheItemPolicy was part of System.Runtime.Caching which is no longer used by LazyCache. " +`
`9`		`- "This class is a fake used to maintain backward compatibility and will be removed in a later version."+`
	`9`	`+ "This class is a fake used to maintain backward compatibility and will be removed in a later version." +`
`10`	`10`	`"Change to MemoryCacheEntryOptions instead")]`
`11`	`11`	`public class CacheItemPolicy : MemoryCacheEntryOptions`
`12`	`12`	`{`