Create ICacheDependency interface and implement it in memory cache and mark kernel cache as TODO items

1. Create ICacheDependency interface
2. Implement it in memory cache
3. Mark kernel cache as TODO items. We will reimplement in next verion
which can behavior base on netfx version

Author: lanlanlee2008

src/OutputCacheModuleAsync/DependencyCacheEntry.cs

@@ -5,14 +5,6 @@
     sealed class DependencyCacheEntry {
         public string RawResponseKey;
         public string KernelCacheUrl;
-        public string Name;
-    }
-
-    sealed class DependencyCacheEntryWrapper {
-        public DependencyCacheEntry DependencyCacheEntry;
-        public CacheDependency Dependencies;
-        public TimeSpan DependencyCacheTimeSpan;
-        public CacheItemPriority CacheItemPriority;
-        public CacheItemRemovedCallback DependencyRemovedCallback;
+        public string ProviderName;
     }
 }

src/OutputCacheModuleAsync/ICacheDependencyHandler.cs

@@ -0,0 +1,27 @@
+namespace Microsoft.AspNet.OutputCache {
+    using System.Runtime.Caching;
+    using System.Threading.Tasks;
+
+    /// <summary>
+    /// This interface is for the async outputCache providers to implement if they want to support Cache Dependencies 
+    /// </summary>
+    public interface ICacheDependencyHandler {
+        /// <summary>
+        /// Async Add method that takes cacheItemPolicy as parameter
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="entry"></param>
+        /// <param name="cacheItemPolicy"></param>
+        /// <returns></returns>
+        Task<object> AddAsync(string key, object entry, CacheItemPolicy cacheItemPolicy);
+
+        /// <summary>
+        /// Async Set method that takes cacheItemPolicy as parameter
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="entry"></param>
+        /// <param name="cacheItemPolicy"></param>
+        /// <returns></returns>
+        Task SetAsync(string key, object entry, CacheItemPolicy cacheItemPolicy);
+    }
+}

src/OutputCacheModuleAsync/InMemoryOutputCacheProvider.cs

@@ -4,24 +4,34 @@
     using System.Threading.Tasks;
     using System.Web.Caching;
 
-    class InMemoryOutputCacheProvider : OutputCacheProviderAsync {
-        private readonly MemoryCache _cache = new MemoryCache("Microsoft.AspNet.OutputCache Default In - Memory Provider");
+    class InMemoryOutputCacheProvider : OutputCacheProviderAsync, ICacheDependencyHandler {
+        private readonly static MemoryCache _cache = new MemoryCache("InMemoryOutputCacheProvider");
 
-        public override Task<object> GetAsync(string key) {
-            return Task.FromResult(Get(key)); 
+        public override Task<object> AddAsync(string key, object entry, DateTime utcExpiry) {
+            DateTimeOffset expiration = (utcExpiry == Cache.NoAbsoluteExpiration) ? ObjectCache.InfiniteAbsoluteExpiration : utcExpiry;
+            return Task.FromResult(_cache.AddOrGetExisting(key, entry, expiration));
         }
 
-        public override Task<object> AddAsync(string key, object entry, DateTime utcExpiry) {
-            return Task.FromResult(Add(key,entry,utcExpiry));
+        Task<object> ICacheDependencyHandler.AddAsync(string key, object entry, CacheItemPolicy cacheItemPolicy) {
+            return Task.FromResult(_cache.AddOrGetExisting(key, entry, cacheItemPolicy));
+        }
+
+        Task ICacheDependencyHandler.SetAsync(string key, object entry, CacheItemPolicy cacheItemPolicy) {
+            _cache.Set(key, entry, cacheItemPolicy);
+            return Task.CompletedTask;
+        }
+
+        public override Task<object> GetAsync(string key) {
+            return Task.FromResult(_cache.Get(key));
         }
 
         public override Task SetAsync(string key, object entry, DateTime utcExpiry) {
-            Set(key, entry, utcExpiry);
+            _cache.Set(key, entry, expiration);
             return Task.CompletedTask;
         }
 
-        public override Task RemoveAsync(string key) { 
-            Remove(key);
+        public override Task RemoveAsync(string key) {
+            _cache.Remove(key);
             return Task.CompletedTask;
         }
 

src/OutputCacheModuleAsync/Microsoft.AspNet.OutputCache.OutputCacheModuleAsync.csproj

@@ -55,6 +55,7 @@
     <Compile Include="HttpMethods.cs" />
     <Compile Include="CacheDirectives.cs" />
     <Compile Include="HttpHeaders.cs" />
+    <Compile Include="ICacheDependencyHandler.cs" />
     <Compile Include="InMemoryOutputCacheProvider.cs" />
     <Compile Include="DependencyCacheEntry.cs" />
     <Compile Include="CachedRawResponse.cs" />
@@ -64,6 +65,7 @@
     <Compile Include="OutputCacheHelper.cs" />
     <Compile Include="OutputCacheModuleAsync.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RemovedCallback.cs" />
     <Compile Include="Resource\SR.Designer.cs">
       <AutoGen>True</AutoGen>
       <DesignTime>True</DesignTime>

src/OutputCacheModuleAsync/OutputCacheModuleAsync.cs

@@ -94,11 +94,7 @@ private async Task OnEnterAsync(object source, EventArgs eventArgs) {
             }
             helper.UpdateCachedResponse(settings, cachedRawResponse.RawResponse);
 
-            //Re-insert entry in kernel cache if necessary
-            string originalCacheUrl = cachedRawResponse.KernelCacheUrl;
-            if (originalCacheUrl != null) {
-                OutputCacheUtility.SetupKernelCaching(originalCacheUrl, app.Context.Response);
-            }
+            //TODO Re-insert entry in kernel cache if necessary
 
             //Complete request
             app.CompleteRequest();

src/OutputCacheModuleAsync/RemovedCallback.cs

@@ -0,0 +1,39 @@
+namespace Microsoft.AspNet.OutputCache {
+    using System.Runtime.Caching;
+    using System.Web.Caching;
+
+    /// <summary>
+    /// This class convert System.Web.Caching.CacheItemRemovedCallback into format of System.Runtime.Caching.CacheEntryRemovedCallback
+    /// </summary>
+    sealed class RemovedCallback {
+        CacheItemRemovedCallback _callback;
+
+        public RemovedCallback(CacheItemRemovedCallback callback) {
+            _callback = callback;
+        }
+
+        public void CacheEntryRemovedCallback(CacheEntryRemovedArguments arguments) {
+            string key = arguments.CacheItem.Key;
+            object value = arguments.CacheItem.Value;
+            CacheItemRemovedReason reason;
+            switch (arguments.RemovedReason) {
+                case CacheEntryRemovedReason.Removed:
+                    reason = CacheItemRemovedReason.Removed;
+                    break;
+                case CacheEntryRemovedReason.Expired:
+                    reason = CacheItemRemovedReason.Expired;
+                    break;
+                case CacheEntryRemovedReason.Evicted:
+                    reason = CacheItemRemovedReason.Underused;
+                    break;
+                case CacheEntryRemovedReason.ChangeMonitorChanged:
+                    reason = CacheItemRemovedReason.DependencyChanged;
+                    break;
+                default:
+                    reason = CacheItemRemovedReason.Removed;
+                    break;
+            }
+            _callback(key, value, reason);
+        }
+    }
+}

test/CustomOutputCacheProvider/Microsoft.AspNet.OutputCache.CustomOutputCacheProvider.csproj

@@ -39,6 +39,7 @@
     <Reference Include="System" />
     <Reference Include="System.Configuration" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Runtime.Caching" />
     <Reference Include="System.Web" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />