Feedback

Author: JunTaoLuo

src/Microsoft.AspNetCore.ResponseCaching/Internal/Interfaces/IResponseCachingPolicyProvider.cs

@@ -6,25 +6,35 @@ namespace Microsoft.AspNetCore.ResponseCaching.Internal
     public interface IResponseCachingPolicyProvider
     {
         /// <summary>
-        /// Determine wehther the response cache middleware should be executed for the incoming HTTP request.
+        /// Determine whether the response caching logic should be attempted for the incoming HTTP request.
         /// </summary>
         /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
-        /// <returns><c>true</c> if the request is cacheable; otherwise <c>false</c>.</returns>
-        bool AllowResponseCaching(ResponseCachingContext context);
+        /// <returns><c>true</c> if response caching logic should be attempted; otherwise <c>false</c>.</returns>
+        bool AttemptResponseCaching(ResponseCachingContext context);
 
+        /// <summary>
+        /// Determine whether a cache lookup is allowed for the incoming HTTP request.
+        /// </summary>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
+        /// <returns><c>true</c> if cache lookup for this request is allowed; otherwise <c>false</c>.</returns>
         bool AllowCacheLookup(ResponseCachingContext context);
 
+        /// <summary>
+        /// Determine whether storage of the response is allowed for the incoming HTTP request.
+        /// </summary>
+        /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
+        /// <returns><c>true</c> if storage of the response for this request is allowed; otherwise <c>false</c>.</returns>
         bool AllowCacheStorage(ResponseCachingContext context);
 
         /// <summary>
-        /// Determine whether the response received by the middleware be cached for future requests.
+        /// Determine whether the response received by the middleware can be cached for future requests.
         /// </summary>
         /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns><c>true</c> if the response is cacheable; otherwise <c>false</c>.</returns>
         bool IsResponseCacheable(ResponseCachingContext context);
 
         /// <summary>
-        /// Determine whether the response retrieved from the response cache is fresh and be served.
+        /// Determine whether the response retrieved from the response cache is fresh and can be served.
         /// </summary>
         /// <param name="context">The <see cref="ResponseCachingContext"/>.</param>
         /// <returns><c>true</c> if the cached entry is fresh; otherwise <c>false</c>.</returns>

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

@@ -37,8 +37,6 @@ internal ResponseCachingContext(HttpContext httpContext, ILogger logger)
 
         internal ILogger Logger { get; }
 
-        internal bool AllowResponseCapture { get; set; }
-
         internal bool ShouldCacheResponse { get; set; }
 
         internal string BaseKey { get;  set; }

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

@@ -10,7 +10,7 @@ namespace Microsoft.AspNetCore.ResponseCaching.Internal
 {
     public class ResponseCachingPolicyProvider : IResponseCachingPolicyProvider
     {
-        public virtual bool AllowResponseCaching(ResponseCachingContext context)
+        public virtual bool AttemptResponseCaching(ResponseCachingContext context)
         {
             var request = context.HttpContext.Request;
 
@@ -212,7 +212,7 @@ public virtual bool IsCachedEntryFresh(ResponseCachingContext context)
                     var maxStaleExist = HeaderUtilities.ContainsCacheDirective(requestCacheControlHeaders, CacheControlHeaderValue.MaxStaleString);
                     HeaderUtilities.TryParseSeconds(requestCacheControlHeaders, CacheControlHeaderValue.MaxStaleString, out requestMaxStale);
 
-                    // Request allows stale values no age limit
+                    // Request allows stale values with no age limit
                     if (maxStaleExist && !requestMaxStale.HasValue)
                     {
                         context.Logger.LogExpirationInfiniteMaxStaleSatisfied(age, lowestMaxAge.Value);

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingMiddleware.cs

@@ -74,50 +74,52 @@ public async Task Invoke(HttpContext httpContext)
             var context = new ResponseCachingContext(httpContext, _logger);
 
             // Should we attempt any caching logic?
-            if (_policyProvider.AllowResponseCaching(context))
+            if (_policyProvider.AttemptResponseCaching(context))
             {
                 // Can this request be served from cache?
                 if (_policyProvider.AllowCacheLookup(context) && await TryServeFromCacheAsync(context))
                 {
                     return;
                 }
 
-                context.AllowResponseCapture = _policyProvider.AllowCacheStorage(context);
+                // Should we store the response to this request?
+                if (_policyProvider.AllowCacheStorage(context))
+                {
+                    // Hook up to listen to the response stream
+                    ShimResponseStream(context);
 
-                // Hook up to listen to the response stream
-                ShimResponseStream(context);
+                    try
+                    {
+                        // Subscribe to OnStarting event
+                        httpContext.Response.OnStarting(_onStartingCallback, context);
 
-                try
-                {
-                    // Subscribe to OnStarting event
-                    httpContext.Response.OnStarting(_onStartingCallback, context);
+                        await _next(httpContext);
 
-                    await _next(httpContext);
+                        // If there was no response body, check the response headers now. We can cache things like redirects.
+                        await OnResponseStartingAsync(context);
 
-                    // If there was no response body, check the response headers now. We can cache things like redirects.
-                    await OnResponseStartingAsync(context);
+                        // Finalize the cache entry
+                        await FinalizeCacheBodyAsync(context);
+                    }
+                    finally
+                    {
+                        UnshimResponseStream(context);
+                    }
 
-                    // Finalize the cache entry
-                    await FinalizeCacheBodyAsync(context);
-                }
-                finally
-                {
-                    UnshimResponseStream(context);
+                    return;
                 }
             }
-            else
-            {
-                // Add IResponseCachingFeature which may be required when the response is generated
-                AddResponseCachingFeature(httpContext);
 
-                try
-                {
-                    await _next(httpContext);
-                }
-                finally
-                {
-                    RemoveResponseCachingFeature(httpContext);
-                }
+            // Response should not be captured but add IResponseCachingFeature which may be required when the response is generated
+            AddResponseCachingFeature(httpContext);
+
+            try
+            {
+                await _next(httpContext);
+            }
+            finally
+            {
+                RemoveResponseCachingFeature(httpContext);
             }
         }
 
@@ -327,7 +329,7 @@ internal async Task FinalizeCacheBodyAsync(ResponseCachingContext context)
 
         internal Task OnResponseStartingAsync(ResponseCachingContext context)
         {
-            if (context.AllowResponseCapture && !context.ResponseStarted)
+            if (!context.ResponseStarted)
             {
                 context.ResponseStarted = true;
                 context.ResponseTime = _options.SystemClock.UtcNow;
@@ -351,19 +353,16 @@ internal static void AddResponseCachingFeature(HttpContext context)
 
         internal void ShimResponseStream(ResponseCachingContext context)
         {
-            if (context.AllowResponseCapture)
+            // Shim response stream
+            context.OriginalResponseStream = context.HttpContext.Response.Body;
+            context.ResponseCachingStream = new ResponseCachingStream(context.OriginalResponseStream, _options.MaximumBodySize, StreamUtilities.BodySegmentSize);
+            context.HttpContext.Response.Body = context.ResponseCachingStream;
+
+            // Shim IHttpSendFileFeature
+            context.OriginalSendFileFeature = context.HttpContext.Features.Get<IHttpSendFileFeature>();
+            if (context.OriginalSendFileFeature != null)
             {
-                // Shim response stream
-                context.OriginalResponseStream = context.HttpContext.Response.Body;
-                context.ResponseCachingStream = new ResponseCachingStream(context.OriginalResponseStream, _options.MaximumBodySize, StreamUtilities.BodySegmentSize);
-                context.HttpContext.Response.Body = context.ResponseCachingStream;
-
-                // Shim IHttpSendFileFeature
-                context.OriginalSendFileFeature = context.HttpContext.Features.Get<IHttpSendFileFeature>();
-                if (context.OriginalSendFileFeature != null)
-                {
-                    context.HttpContext.Features.Set<IHttpSendFileFeature>(new SendFileFeatureWrapper(context.OriginalSendFileFeature, context.ResponseCachingStream));
-                }
+                context.HttpContext.Features.Set<IHttpSendFileFeature>(new SendFileFeatureWrapper(context.OriginalSendFileFeature, context.ResponseCachingStream));
             }
 
             // Add IResponseCachingFeature
@@ -375,14 +374,11 @@ internal static void RemoveResponseCachingFeature(HttpContext context) =>
 
         internal static void UnshimResponseStream(ResponseCachingContext context)
         {
-            if (context.AllowResponseCapture)
-            {
-                // Unshim response stream
-                context.HttpContext.Response.Body = context.OriginalResponseStream;
+            // Unshim response stream
+            context.HttpContext.Response.Body = context.OriginalResponseStream;
 
-                // Unshim IHttpSendFileFeature
-                context.HttpContext.Features.Set(context.OriginalSendFileFeature);
-            }
+            // Unshim IHttpSendFileFeature
+            context.HttpContext.Features.Set(context.OriginalSendFileFeature);
 
             // Remove IResponseCachingFeature
             RemoveResponseCachingFeature(context.HttpContext);