Add configurable options for ResponseCaching

Override RequestIsCacheable

Override ResponseIsCacheable

Append customized cache key

Author: JunTaoLuo

src/Microsoft.AspNetCore.ResponseCaching/IResponseCache.cs renamed to src/Microsoft.AspNetCore.ResponseCaching/Interfaces/IResponseCache.cs

@@ -0,0 +1,17 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.ResponseCaching
+{
+    public interface IResponseCachingCacheKeySuffixProvider
+    {
+        /// <summary>
+        /// Create a key segment that is appended to the default cache key.
+        /// </summary>
+        /// <param name="httpContext">The <see cref="HttpContext"/>.</param>
+        /// <returns>The key segment that will be appended to the default cache key.</returns>
+        string CreateCustomKeySuffix(HttpContext httpContext);
+    }
+}

src/Microsoft.AspNetCore.ResponseCaching/Interfaces/IResponseCachingCacheKeySuffixProvider.cs

@@ -0,0 +1,24 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.ResponseCaching
+{
+    public interface IResponseCachingCacheabilityValidator
+    {
+        /// <summary>
+        /// Override default behavior for determining cacheability of an HTTP request.
+        /// </summary>
+        /// <param name="httpContext">The <see cref="HttpContext"/>.</param>
+        /// <returns>The <see cref="OverrideResult"/>.</returns>
+        OverrideResult RequestIsCacheableOverride(HttpContext httpContext);
+
+        /// <summary>
+        /// Override default behavior for determining cacheability of an HTTP response.
+        /// </summary>
+        /// <param name="httpContext">The <see cref="HttpContext"/>.</param>
+        /// <returns>The <see cref="OverrideResult"/>.</returns>
+        OverrideResult ResponseIsCacheableOverride(HttpContext httpContext);
+    }
+}

src/Microsoft.AspNetCore.ResponseCaching/Interfaces/IResponseCachingCacheabilityValidator.cs

@@ -0,0 +1,12 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.ResponseCaching.Internal
+{
+    public class NoopCacheKeySuffixProvider : IResponseCachingCacheKeySuffixProvider
+    {
+        public string CreateCustomKeySuffix(HttpContext httpContext) => null;
+    }
+}

src/Microsoft.AspNetCore.ResponseCaching/Internal/NoopCacheKeySuffixProvider.cs

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Microsoft.AspNetCore.Http;
+
+namespace Microsoft.AspNetCore.ResponseCaching.Internal
+{
+    public class NoopCacheabilityValidator : IResponseCachingCacheabilityValidator
+    {
+        public OverrideResult RequestIsCacheableOverride(HttpContext httpContext) => OverrideResult.UseDefaultLogic;
+
+        public OverrideResult ResponseIsCacheableOverride(HttpContext httpContext) => OverrideResult.UseDefaultLogic;
+    }
+}

src/Microsoft.AspNetCore.ResponseCaching/Internal/NoopCacheabilityValidator.cs

@@ -0,0 +1,23 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+namespace Microsoft.AspNetCore.ResponseCaching
+{
+    public enum OverrideResult
+    {
+        /// <summary>
+        /// Use the default logic for determining cacheability.
+        /// </summary>
+        UseDefaultLogic,
+
+        /// <summary>
+        /// Ignore default logic and do not cache.
+        /// </summary>
+        DoNotCache,
+
+        /// <summary>
+        /// Ignore default logic and cache.
+        /// </summary>
+        Cache
+    }
+}

src/Microsoft.AspNetCore.ResponseCaching/OverrideResult.cs

@@ -28,31 +28,29 @@ public class ResponseCachingContext
         private CachedResponse _cachedResponse;
         private TimeSpan _cachedResponseValidFor;
         internal DateTimeOffset _responseTime;
-
-        public ResponseCachingContext(HttpContext httpContext, IResponseCache cache)
-            : this(httpContext, cache, new SystemClock())
+        
+        public ResponseCachingContext(
+            HttpContext httpContext,
+            IResponseCache cache,
+            IResponseCachingCacheabilityValidator cacheabilityValidator,
+            IResponseCachingCacheKeySuffixProvider cacheKeySuffixProvider)
+            : this(httpContext, cache, new SystemClock(), cacheabilityValidator, cacheKeySuffixProvider)
         {
         }
 
         // Internal for testing
-        internal ResponseCachingContext(HttpContext httpContext, IResponseCache cache, ISystemClock clock)
+        internal ResponseCachingContext(
+            HttpContext httpContext, 
+            IResponseCache cache,
+            ISystemClock clock,
+            IResponseCachingCacheabilityValidator cacheabilityValidator,
+            IResponseCachingCacheKeySuffixProvider cacheKeySuffixProvider)
         {
-            if (cache == null)
-            {
-                throw new ArgumentNullException(nameof(cache));
-            }
-            if (httpContext == null)
-            {
-                throw new ArgumentNullException(nameof(httpContext));
-            }
-            if (clock == null)
-            {
-                throw new ArgumentNullException(nameof(clock));
-            }
-
             HttpContext = httpContext;
             Cache = cache;
             Clock = clock;
+            CacheabilityValidator = cacheabilityValidator;
+            CacheKeySuffixProvider = cacheKeySuffixProvider;
         }
 
         internal bool CacheResponse
@@ -72,12 +70,16 @@ internal bool CacheResponse
 
         internal bool ResponseStarted { get; set; }
 
-        private ISystemClock Clock { get; }
-
         private HttpContext HttpContext { get; }
 
         private IResponseCache Cache { get; }
 
+        private ISystemClock Clock { get; }
+
+        private IResponseCachingCacheabilityValidator CacheabilityValidator { get; }
+
+        private IResponseCachingCacheKeySuffixProvider CacheKeySuffixProvider { get; }
+
         private Stream OriginalResponseStream { get; set; }
 
         private ResponseCacheStream ResponseCacheStream { get; set; }
@@ -145,46 +147,56 @@ internal string CreateCacheKey(CachedVaryBy varyBy)
             var builder = new StringBuilder()
                 .Append(request.Method.ToUpperInvariant())
                 .Append(";")
-                .Append(request.Path.Value.ToUpperInvariant())
-                .Append(CreateVaryByCacheKey(varyBy));
+                .Append(request.Path.Value.ToUpperInvariant());
 
-            return builder.ToString();
-        }
-
-        private string CreateVaryByCacheKey(CachedVaryBy varyBy)
-        {
-            // TODO: resolve key format and delimiters
-            if (varyBy == null || varyBy.Headers.Count == 0)
+            if (varyBy?.Headers.Count > 0)
             {
-                return string.Empty;
-            }
-
-            var builder = new StringBuilder(";");
+                // TODO: resolve key format and delimiters
+                foreach (var header in varyBy.Headers)
+                {
+                    // TODO: Normalization of order, case?
+                    var value = HttpContext.Request.Headers[header];
 
-            foreach (var header in varyBy.Headers)
-            {
-                // TODO: Normalization of order, case?
-                var value = HttpContext.Request.Headers[header].ToString();
+                    // TODO: How to handle null/empty string?
+                    if (StringValues.IsNullOrEmpty(value))
+                    {
+                        value = "null";
+                    }
 
-                // TODO: How to handle null/empty string?
-                if (string.IsNullOrEmpty(value))
-                {
-                    value = "null";
+                    builder.Append(";")
+                        .Append(header)
+                        .Append("=")
+                        .Append(value);
                 }
-
-                builder.Append(header)
-                    .Append("=")
-                    .Append(value)
-                    .Append(";");
             }
+            // TODO: Parse querystring params
 
-            // Parse querystring params
+            // Append custom cache key segment
+            var customKey = CacheKeySuffixProvider.CreateCustomKeySuffix(HttpContext);
+            if (!string.IsNullOrEmpty(customKey))
+            {
+                builder.Append(";")
+                    .Append(customKey);
+            }
 
             return builder.ToString();
         }
 
         internal bool RequestIsCacheable()
         {
+            // Use optional override if specified by user
+            switch(CacheabilityValidator.RequestIsCacheableOverride(HttpContext))
+            {
+                case OverrideResult.UseDefaultLogic:
+                    break;
+                case OverrideResult.DoNotCache:
+                    return false;
+                case OverrideResult.Cache:
+                    return true;
+                default:
+                    throw new NotSupportedException($"Unrecognized result from {nameof(CacheabilityValidator.RequestIsCacheableOverride)}.");
+            }
+
             // Verify the method
             // TODO: RFC lists POST as a cacheable method when explicit freshness information is provided, but this is not widely implemented. Will revisit.
             var request = HttpContext.Request;
@@ -236,6 +248,19 @@ internal bool RequestIsCacheable()
 
         internal bool ResponseIsCacheable()
         {
+            // Use optional override if specified by user
+            switch (CacheabilityValidator.ResponseIsCacheableOverride(HttpContext))
+            {
+                case OverrideResult.UseDefaultLogic:
+                    break;
+                case OverrideResult.DoNotCache:
+                    return false;
+                case OverrideResult.Cache:
+                    return true;
+                default:
+                    throw new NotSupportedException($"Unrecognized result from {nameof(CacheabilityValidator.ResponseIsCacheableOverride)}.");
+            }
+
             // Only cache pages explicitly marked with public
             // TODO: Consider caching responses that are not marked as public but otherwise cacheable?
             if (!ResponseCacheControl.Public)

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingContext.cs

@@ -1,14 +1,21 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using Microsoft.AspNetCore.ResponseCaching;
+using Microsoft.Extensions.Options;
 
 namespace Microsoft.AspNetCore.Builder
 {
     public static class ResponseCachingExtensions
     {
         public static IApplicationBuilder UseResponseCaching(this IApplicationBuilder app)
         {
+            if (app == null)
+            {
+                throw new ArgumentNullException(nameof(app));
+            }
+
             return app.UseMiddleware<ResponseCachingMiddleware>();
         }
     }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingExtensions.cs

@@ -4,11 +4,9 @@
 using System;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Http;
-using Microsoft.AspNetCore.Http.Features;
 
 namespace Microsoft.AspNetCore.ResponseCaching
 {
-    // http://tools.ietf.org/html/rfc7234
     public class ResponseCachingMiddleware
     {
         private static readonly Func<object, Task> OnStartingCallback = state =>
@@ -19,26 +17,45 @@ public class ResponseCachingMiddleware
 
         private readonly RequestDelegate _next;
         private readonly IResponseCache _cache;
+        IResponseCachingCacheabilityValidator _cacheabilityValidator;
+        IResponseCachingCacheKeySuffixProvider _cacheKeySuffixProvider;
 
-        public ResponseCachingMiddleware(RequestDelegate next, IResponseCache cache)
+        public ResponseCachingMiddleware(
+            RequestDelegate next, 
+            IResponseCache cache, 
+            IResponseCachingCacheabilityValidator cacheabilityValidator,
+            IResponseCachingCacheKeySuffixProvider cacheKeySuffixProvider)
         {
             if (cache == null)
             {
                 throw new ArgumentNullException(nameof(cache));
             }
-
             if (next == null)
             {
                 throw new ArgumentNullException(nameof(next));
             }
+            if (cacheabilityValidator == null)
+            {
+                throw new ArgumentNullException(nameof(cacheabilityValidator));
+            }
+            if (cacheKeySuffixProvider == null)
+            {
+                throw new ArgumentNullException(nameof(cacheKeySuffixProvider));
+            }
 
             _next = next;
             _cache = cache;
+            _cacheabilityValidator = cacheabilityValidator;
+            _cacheKeySuffixProvider = cacheKeySuffixProvider;
         }
 
         public async Task Invoke(HttpContext context)
         {
-            var cachingContext = new ResponseCachingContext(context, _cache);
+            var cachingContext = new ResponseCachingContext(
+                context,
+                _cache,
+                _cacheabilityValidator,
+                _cacheKeySuffixProvider);
 
             // Should we attempt any caching logic?
             if (cachingContext.RequestIsCacheable())

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingMiddleware.cs

@@ -18,6 +18,7 @@ public static IServiceCollection AddMemoryResponseCache(this IServiceCollection
             }
 
             services.AddMemoryCache();
+            services.AddResponseCachingServices();
             services.TryAdd(ServiceDescriptor.Singleton<IResponseCache, MemoryResponseCache>());
 
             return services;
@@ -31,9 +32,18 @@ public static IServiceCollection AddDistributedResponseCache(this IServiceCollec
             }
 
             services.AddDistributedMemoryCache();
+            services.AddResponseCachingServices();
             services.TryAdd(ServiceDescriptor.Singleton<IResponseCache, DistributedResponseCache>());
 
             return services;
         }
+
+        private static IServiceCollection AddResponseCachingServices(this IServiceCollection services)
+        {
+            services.TryAdd(ServiceDescriptor.Singleton<IResponseCachingCacheKeySuffixProvider, NoopCacheKeySuffixProvider>());
+            services.TryAdd(ServiceDescriptor.Singleton<IResponseCachingCacheabilityValidator, NoopCacheabilityValidator>());
+
+            return services;
+        }
     }
 }