Refactor to remove duplication

Author: JunTaoLuo

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

@@ -9,8 +9,9 @@ namespace Microsoft.AspNetCore.ResponseCaching.Internal
     public interface IResponseCache
     {
         IResponseCacheEntry Get(string key);
-        void Set(string key, IResponseCacheEntry entry, TimeSpan validFor);
         Task<IResponseCacheEntry> GetAsync(string key);
+
+        void Set(string key, IResponseCacheEntry entry, TimeSpan validFor);
         Task SetAsync(string key, IResponseCacheEntry entry, TimeSpan validFor);
     }
 }

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingMiddleware.cs

@@ -25,8 +25,6 @@ public class ResponseCachingMiddleware
         private readonly IResponseCachingPolicyProvider _policyProvider;
         private readonly IResponseCache _cache;
         private readonly IResponseCachingKeyProvider _keyProvider;
-        private readonly Action<object> _onStartingCallback;
-        private readonly Func<object, Task> _onStartingCallbackAsync;
 
         public ResponseCachingMiddleware(
             RequestDelegate next,
@@ -67,8 +65,6 @@ public ResponseCachingMiddleware(
             _policyProvider = policyProvider;
             _cache = cache;
             _keyProvider = keyProvider;
-            _onStartingCallback = state => OnResponseStarting((ResponseCachingContext)state);
-            _onStartingCallbackAsync = state => OnResponseStartingAsync((ResponseCachingContext)state);
         }
 
         public async Task Invoke(HttpContext httpContext)
@@ -218,10 +214,11 @@ internal async Task<bool> TryServeFromCacheAsync(ResponseCachingContext context)
             return false;
         }
 
-        internal void FinalizeCacheHeaders(ResponseCachingContext context)
+        private bool FinalizeCacheHeadersShouldStoreVaryByEntry(ResponseCachingContext context)
         {
             if (_policyProvider.IsResponseCacheable(context))
             {
+                var storeVaryByEntry = false;
                 context.ShouldCacheResponse = true;
 
                 // Create the cache entry now
@@ -261,7 +258,7 @@ internal void FinalizeCacheHeaders(ResponseCachingContext context)
 
                     // Always overwrite the CachedVaryByRules to update the expiry information
                     _logger.LogVaryByRulesUpdated(normalizedVaryHeaders, normalizedVaryQueryKeys);
-                    _cache.Set(context.BaseKey, context.CachedVaryByRules, context.CachedResponseValidFor);
+                    storeVaryByEntry = true;
 
                     context.StorageVaryKey = _keyProvider.CreateStorageVaryByKey(context);
                 }
@@ -289,89 +286,31 @@ internal void FinalizeCacheHeaders(ResponseCachingContext context)
                         context.CachedResponse.Headers.Add(header);
                     }
                 }
+
+                return storeVaryByEntry;
             }
             else
             {
                 context.ResponseCachingStream.DisableBuffering();
+                return false;
             }
         }
 
-        internal async Task FinalizeCacheHeadersAsync(ResponseCachingContext context)
+        internal void FinalizeCacheHeaders(ResponseCachingContext context)
         {
-            if (_policyProvider.IsResponseCacheable(context))
+            if (FinalizeCacheHeadersShouldStoreVaryByEntry(context))
             {
-                context.ShouldCacheResponse = true;
-
-                // Create the cache entry now
-                var response = context.HttpContext.Response;
-                var varyHeaders = new StringValues(response.Headers.GetCommaSeparatedValues(HeaderNames.Vary));
-                var varyQueryKeys = new StringValues(context.HttpContext.Features.Get<IResponseCachingFeature>()?.VaryByQueryKeys);
-                context.CachedResponseValidFor = context.ResponseSharedMaxAge ??
-                    context.ResponseMaxAge ??
-                    (context.ResponseExpires - context.ResponseTime.Value) ??
-                    DefaultExpirationTimeSpan;
-
-                // Generate a base key if none exist
-                if (string.IsNullOrEmpty(context.BaseKey))
-                {
-                    context.BaseKey = _keyProvider.CreateBaseKey(context);
-                }
-
-                // Check if any vary rules exist
-                if (!StringValues.IsNullOrEmpty(varyHeaders) || !StringValues.IsNullOrEmpty(varyQueryKeys))
-                {
-                    // Normalize order and casing of vary by rules
-                    var normalizedVaryHeaders = GetOrderCasingNormalizedStringValues(varyHeaders);
-                    var normalizedVaryQueryKeys = GetOrderCasingNormalizedStringValues(varyQueryKeys);
-
-                    // Update vary rules if they are different
-                    if (context.CachedVaryByRules == null ||
-                        !StringValues.Equals(context.CachedVaryByRules.QueryKeys, normalizedVaryQueryKeys) ||
-                        !StringValues.Equals(context.CachedVaryByRules.Headers, normalizedVaryHeaders))
-                    {
-                        context.CachedVaryByRules = new CachedVaryByRules
-                        {
-                            VaryByKeyPrefix = FastGuid.NewGuid().IdString,
-                            Headers = normalizedVaryHeaders,
-                            QueryKeys = normalizedVaryQueryKeys
-                        };
-                    }
-
-                    // Always overwrite the CachedVaryByRules to update the expiry information
-                    _logger.LogVaryByRulesUpdated(normalizedVaryHeaders, normalizedVaryQueryKeys);
-                    await _cache.SetAsync(context.BaseKey, context.CachedVaryByRules, context.CachedResponseValidFor);
-
-                    context.StorageVaryKey = _keyProvider.CreateStorageVaryByKey(context);
-                }
-
-                // Ensure date header is set
-                if (!context.ResponseDate.HasValue)
-                {
-                    context.ResponseDate = context.ResponseTime.Value;
-                    // Setting the date on the raw response headers.
-                    context.HttpContext.Response.Headers[HeaderNames.Date] = HeaderUtilities.FormatDate(context.ResponseDate.Value);
-                }
-
-                // Store the response on the state
-                context.CachedResponse = new CachedResponse
-                {
-                    Created = context.ResponseDate.Value,
-                    StatusCode = context.HttpContext.Response.StatusCode,
-                    Headers = new HeaderDictionary()
-                };
-
-                foreach (var header in context.HttpContext.Response.Headers)
-                {
-                    if (!string.Equals(header.Key, HeaderNames.Age, StringComparison.OrdinalIgnoreCase))
-                    {
-                        context.CachedResponse.Headers.Add(header);
-                    }
-                }
+                _cache.Set(context.BaseKey, context.CachedVaryByRules, context.CachedResponseValidFor);
             }
-            else
+        }
+
+        internal Task FinalizeCacheHeadersAsync(ResponseCachingContext context)
+        {
+            if (FinalizeCacheHeadersShouldStoreVaryByEntry(context))
             {
-                context.ResponseCachingStream.DisableBuffering();
+                return _cache.SetAsync(context.BaseKey, context.CachedVaryByRules, context.CachedResponseValidFor);
             }
+            return TaskCache.CompletedTask;
         }
 
         internal async Task FinalizeCacheBodyAsync(ResponseCachingContext context)
@@ -404,30 +343,33 @@ internal async Task FinalizeCacheBodyAsync(ResponseCachingContext context)
             }
         }
 
-        internal void OnResponseStarting(ResponseCachingContext context)
+        private bool OnResponseStartingShouldFinalizeHeaders(ResponseCachingContext context)
         {
             if (!context.ResponseStarted)
             {
                 context.ResponseStarted = true;
                 context.ResponseTime = _options.SystemClock.UtcNow;
 
+                return true;
+            }
+            return false;
+        }
+
+        internal void OnResponseStarting(ResponseCachingContext context)
+        {
+            if (OnResponseStartingShouldFinalizeHeaders(context))
+            {
                 FinalizeCacheHeaders(context);
             }
         }
 
         internal Task OnResponseStartingAsync(ResponseCachingContext context)
         {
-            if (!context.ResponseStarted)
+            if (OnResponseStartingShouldFinalizeHeaders(context))
             {
-                context.ResponseStarted = true;
-                context.ResponseTime = _options.SystemClock.UtcNow;
-
                 return FinalizeCacheHeadersAsync(context);
             }
-            else
-            {
-                return TaskCache.CompletedTask;
-            }
+            return TaskCache.CompletedTask;
         }
 
         internal static void AddResponseCachingFeature(HttpContext context)
@@ -443,7 +385,12 @@ internal void ShimResponseStream(ResponseCachingContext context)
         {
             // Shim response stream
             context.OriginalResponseStream = context.HttpContext.Response.Body;
-            context.ResponseCachingStream = new ResponseCachingStream(context.OriginalResponseStream, _options.MaximumBodySize, StreamUtilities.BodySegmentSize, () => OnResponseStarting(context), async () => await OnResponseStartingAsync(context));
+            context.ResponseCachingStream = new ResponseCachingStream(
+                context.OriginalResponseStream,
+                _options.MaximumBodySize,
+                StreamUtilities.BodySegmentSize,
+                () => OnResponseStarting(context),
+                async () => await OnResponseStartingAsync(context));
             context.HttpContext.Response.Body = context.ResponseCachingStream;
 
             // Shim IHttpSendFileFeature

src/Microsoft.AspNetCore.ResponseCaching/Streams/ResponseCachingStream.cs

@@ -47,11 +47,6 @@ public override long Position
             }
         }
 
-        private async Task OnWriteAsync()
-        {
-            await _onStartingCallbackAsync();
-        }
-
         internal Stream GetBufferStream()
         {
             if (!BufferingEnabled)
@@ -115,7 +110,7 @@ public override void Write(byte[] buffer, int offset, int count)
         {
             try
             {
-                _onStartingCallbackAsync().Wait();
+                _onStartingCallback();
                 _innerStream.Write(buffer, offset, count);
             }
             catch