Use ObjectPool for StringBuilder

Author: JunTaoLuo

src/Microsoft.AspNetCore.ResponseCaching/ResponseCachingContext.cs

@@ -12,12 +12,22 @@
 using Microsoft.AspNetCore.ResponseCaching.Internal;
 using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
+using Microsoft.Extensions.ObjectPool;
 
 namespace Microsoft.AspNetCore.ResponseCaching
 {
     public class ResponseCachingContext
     {
         private static readonly CacheControlHeaderValue EmptyCacheControl = new CacheControlHeaderValue();
+
+        private readonly HttpContext _httpContext;
+        private readonly IResponseCache _cache;
+        private readonly ISystemClock _clock;
+        private readonly ObjectPool<StringBuilder> _builderPool;
+        private readonly IResponseCachingRequestCacheabilityValidator _requestCacheabilityValidator;
+        private readonly IResponseCachingResponseCacheabilityValidator _responseCacheabilityValidator;
+        private readonly IResponseCachingCacheKeySuffixProvider _cacheKeySuffixProvider;
+
         private string _cacheKey;
         private ResponseType? _responseType;
         private RequestHeaders _requestHeaders;
@@ -32,28 +42,31 @@ public class ResponseCachingContext
         public ResponseCachingContext(
             HttpContext httpContext,
             IResponseCache cache,
+            ObjectPool<StringBuilder> builderPool,
             IResponseCachingRequestCacheabilityValidator requestCacheabilityValidator,
             IResponseCachingResponseCacheabilityValidator responseCacheabilityValidator,
             IResponseCachingCacheKeySuffixProvider cacheKeySuffixProvider)
-            : this(httpContext, cache, new SystemClock(), requestCacheabilityValidator, responseCacheabilityValidator, cacheKeySuffixProvider)
+            : this(httpContext, cache, new SystemClock(), builderPool, requestCacheabilityValidator, responseCacheabilityValidator, cacheKeySuffixProvider)
         {
         }
 
         // Internal for testing
         internal ResponseCachingContext(
             HttpContext httpContext, 
-            IResponseCache cache,
+            IResponseCache cache, 
             ISystemClock clock,
+            ObjectPool<StringBuilder> builderPool,
             IResponseCachingRequestCacheabilityValidator requestCacheabilityValidator,
             IResponseCachingResponseCacheabilityValidator responseCacheabilityValidator,
             IResponseCachingCacheKeySuffixProvider cacheKeySuffixProvider)
         {
-            HttpContext = httpContext;
-            Cache = cache;
-            Clock = clock;
-            RequestCacheabilityValidator = requestCacheabilityValidator;
-            ResponseCacheabilityValidator = responseCacheabilityValidator;
-            CacheKeySuffixProvider = cacheKeySuffixProvider;
+            _httpContext = httpContext;
+            _cache = cache;
+            _clock = clock;
+            _builderPool = builderPool;
+            _requestCacheabilityValidator = requestCacheabilityValidator;
+            _responseCacheabilityValidator = responseCacheabilityValidator;
+            _cacheKeySuffixProvider = cacheKeySuffixProvider;
         }
 
         internal bool CacheResponse
@@ -73,18 +86,6 @@ internal bool CacheResponse
 
         internal bool ResponseStarted { get; set; }
 
-        private HttpContext HttpContext { get; }
-
-        private IResponseCache Cache { get; }
-
-        private ISystemClock Clock { get; }
-
-        private IResponseCachingRequestCacheabilityValidator RequestCacheabilityValidator { get; }
-
-        private IResponseCachingResponseCacheabilityValidator ResponseCacheabilityValidator { get; }
-
-        private IResponseCachingCacheKeySuffixProvider CacheKeySuffixProvider { get; }
-
         private Stream OriginalResponseStream { get; set; }
 
         private ResponseCacheStream ResponseCacheStream { get; set; }
@@ -97,7 +98,7 @@ private RequestHeaders RequestHeaders
             {
                 if (_requestHeaders == null)
                 {
-                    _requestHeaders = HttpContext.Request.GetTypedHeaders();
+                    _requestHeaders = _httpContext.Request.GetTypedHeaders();
                 }
                 return _requestHeaders;
             }
@@ -109,7 +110,7 @@ private ResponseHeaders ResponseHeaders
             {
                 if (_responseHeaders == null)
                 {
-                    _responseHeaders = HttpContext.Response.GetTypedHeaders();
+                    _responseHeaders = _httpContext.Response.GetTypedHeaders();
                 }
                 return _responseHeaders;
             }
@@ -148,49 +149,61 @@ internal string CreateCacheKey()
 
         internal string CreateCacheKey(CachedVaryBy varyBy)
         {
-            var request = HttpContext.Request;
-            var builder = new StringBuilder()
-                .Append(request.Method.ToUpperInvariant())
-                .Append(";")
-                .Append(request.Path.Value.ToUpperInvariant());
+            var request = _httpContext.Request;
+            var builder = _builderPool?.Get() ?? new StringBuilder();
 
-            if (varyBy?.Headers.Count > 0)
+            try
             {
-                // TODO: resolve key format and delimiters
-                foreach (var header in varyBy.Headers)
-                {
-                    // TODO: Normalization of order, case?
-                    var value = HttpContext.Request.Headers[header];
+                builder
+                    .Append(request.Method.ToUpperInvariant())
+                    .Append(";")
+                    .Append(request.Path.Value.ToUpperInvariant());
 
-                    // TODO: How to handle null/empty string?
-                    if (StringValues.IsNullOrEmpty(value))
+                if (varyBy?.Headers.Count > 0)
+                {
+                    // TODO: resolve key format and delimiters
+                    foreach (var header in varyBy.Headers)
                     {
-                        value = "null";
+                        // TODO: Normalization of order, case?
+                        var value = _httpContext.Request.Headers[header];
+
+                        // TODO: How to handle null/empty string?
+                        if (StringValues.IsNullOrEmpty(value))
+                        {
+                            value = "null";
+                        }
+
+                        builder.Append(";")
+                            .Append(header)
+                            .Append("=")
+                            .Append(value);
                     }
+                }
+                // TODO: Parse querystring params
 
+                // Append custom cache key segment
+                var customKey = _cacheKeySuffixProvider.CreateCustomKeySuffix(_httpContext);
+                if (!string.IsNullOrEmpty(customKey))
+                {
                     builder.Append(";")
-                        .Append(header)
-                        .Append("=")
-                        .Append(value);
+                        .Append(customKey);
                 }
-            }
-            // TODO: Parse querystring params
 
-            // Append custom cache key segment
-            var customKey = CacheKeySuffixProvider.CreateCustomKeySuffix(HttpContext);
-            if (!string.IsNullOrEmpty(customKey))
+                return builder.ToString();
+            }
+            finally
             {
-                builder.Append(";")
-                    .Append(customKey);
+                if (_builderPool != null)
+                {
+                    _builderPool.Return(builder);
+                }
             }
-
-            return builder.ToString();
         }
 
         internal bool RequestIsCacheable()
         {
             // Use optional override if specified by user
-            switch(RequestCacheabilityValidator.RequestIsCacheableOverride(HttpContext))
+            switch(_requestCacheabilityValidator.RequestIsCacheableOverride(_httpContext))
             {
                 case OverrideResult.UseDefaultLogic:
                     break;
@@ -199,12 +212,12 @@ internal bool RequestIsCacheable()
                 case OverrideResult.Cache:
                     return true;
                 default:
-                    throw new NotSupportedException($"Unrecognized result from {nameof(RequestCacheabilityValidator.RequestIsCacheableOverride)}.");
+                    throw new NotSupportedException($"Unrecognized result from {nameof(_requestCacheabilityValidator.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;
+            var request = _httpContext.Request;
             if (string.Equals("GET", request.Method, StringComparison.OrdinalIgnoreCase))
             {
                 _responseType = ResponseType.FullReponse;
@@ -254,7 +267,7 @@ internal bool RequestIsCacheable()
         internal bool ResponseIsCacheable()
         {
             // Use optional override if specified by user
-            switch (ResponseCacheabilityValidator.ResponseIsCacheableOverride(HttpContext))
+            switch (_responseCacheabilityValidator.ResponseIsCacheableOverride(_httpContext))
             {
                 case OverrideResult.UseDefaultLogic:
                     break;
@@ -263,7 +276,7 @@ internal bool ResponseIsCacheable()
                 case OverrideResult.Cache:
                     return true;
                 default:
-                    throw new NotSupportedException($"Unrecognized result from {nameof(ResponseCacheabilityValidator.ResponseIsCacheableOverride)}.");
+                    throw new NotSupportedException($"Unrecognized result from {nameof(_responseCacheabilityValidator.ResponseIsCacheableOverride)}.");
             }
 
             // Only cache pages explicitly marked with public
@@ -286,7 +299,7 @@ internal bool ResponseIsCacheable()
                 return false;
             }
 
-            var response = HttpContext.Response;
+            var response = _httpContext.Response;
 
             // Do not cache responses varying by *
             if (string.Equals(response.Headers[HeaderNames.Vary], "*", StringComparison.OrdinalIgnoreCase))
@@ -364,28 +377,28 @@ internal bool EntryIsFresh(ResponseHeaders responseHeaders, TimeSpan age, bool v
         internal async Task<bool> TryServeFromCacheAsync()
         {
             _cacheKey = CreateCacheKey();
-            var cacheEntry = Cache.Get(_cacheKey);
+            var cacheEntry = _cache.Get(_cacheKey);
             var responseServed = false;
 
             if (cacheEntry is CachedVaryBy)
             {
                 // Request contains VaryBy rules, recompute key and try again
                 _cacheKey = CreateCacheKey(cacheEntry as CachedVaryBy);
-                cacheEntry = Cache.Get(_cacheKey);
+                cacheEntry = _cache.Get(_cacheKey);
             }
 
             if (cacheEntry is CachedResponse)
             {
                 var cachedResponse = cacheEntry as CachedResponse;
                 var cachedResponseHeaders = new ResponseHeaders(cachedResponse.Headers);
 
-                _responseTime = Clock.UtcNow;
+                _responseTime = _clock.UtcNow;
                 var age = _responseTime - cachedResponse.Created;
                 age = age > TimeSpan.Zero ? age : TimeSpan.Zero;
 
                 if (EntryIsFresh(cachedResponseHeaders, age, verifyAgainstRequest: true))
                 {
-                    var response = HttpContext.Response;
+                    var response = _httpContext.Response;
                     // Copy the cached status code and response headers
                     response.StatusCode = cachedResponse.StatusCode;
                     foreach (var header in cachedResponse.Headers)
@@ -430,7 +443,7 @@ internal async Task<bool> TryServeFromCacheAsync()
 
             if (!responseServed && RequestCacheControl.OnlyIfCached)
             {
-                HttpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;
+                _httpContext.Response.StatusCode = StatusCodes.Status504GatewayTimeout;
 
                 responseServed = true;
             }
@@ -443,7 +456,7 @@ internal void FinalizeCachingHeaders()
             if (CacheResponse)
             {
                 // Create the cache entry now
-                var response = HttpContext.Response;
+                var response = _httpContext.Response;
                 var varyHeaderValue = response.Headers[HeaderNames.Vary];
                 _cachedResponseValidFor = ResponseCacheControl.SharedMaxAge
                     ?? ResponseCacheControl.MaxAge
@@ -462,7 +475,7 @@ internal void FinalizeCachingHeaders()
                     };
 
                     // TODO: Overwrite?
-                    Cache.Set(_cacheKey, cachedVaryBy, _cachedResponseValidFor);
+                    _cache.Set(_cacheKey, cachedVaryBy, _cachedResponseValidFor);
                     _cacheKey = CreateCacheKey(cachedVaryBy);
                 }
 
@@ -476,7 +489,7 @@ internal void FinalizeCachingHeaders()
                 _cachedResponse = new CachedResponse
                 {
                     Created = ResponseHeaders.Date.Value,
-                    StatusCode = HttpContext.Response.StatusCode
+                    StatusCode = _httpContext.Response.StatusCode
                 };
 
                 foreach (var header in ResponseHeaders.Headers)
@@ -500,7 +513,7 @@ internal void FinalizeCachingBody()
             {
                 _cachedResponse.Body = ResponseCacheStream.BufferedStream.ToArray();
 
-                Cache.Set(_cacheKey, _cachedResponse, _cachedResponseValidFor);
+                _cache.Set(_cacheKey, _cachedResponse, _cachedResponseValidFor);
             }
         }
 
@@ -509,7 +522,7 @@ internal void OnResponseStarting()
             if (!ResponseStarted)
             {
                 ResponseStarted = true;
-                _responseTime = Clock.UtcNow;
+                _responseTime = _clock.UtcNow;
 
                 FinalizeCachingHeaders();
             }
@@ -520,25 +533,25 @@ internal void ShimResponseStream()
             // TODO: Consider caching large responses on disk and serving them from there.
 
             // Shim response stream
-            OriginalResponseStream = HttpContext.Response.Body;
+            OriginalResponseStream = _httpContext.Response.Body;
             ResponseCacheStream = new ResponseCacheStream(OriginalResponseStream);
-            HttpContext.Response.Body = ResponseCacheStream;
+            _httpContext.Response.Body = ResponseCacheStream;
 
             // Shim IHttpSendFileFeature
-            OriginalSendFileFeature = HttpContext.Features.Get<IHttpSendFileFeature>();
+            OriginalSendFileFeature = _httpContext.Features.Get<IHttpSendFileFeature>();
             if (OriginalSendFileFeature != null)
             {
-                HttpContext.Features.Set<IHttpSendFileFeature>(new SendFileFeatureWrapper(OriginalSendFileFeature, ResponseCacheStream));
+                _httpContext.Features.Set<IHttpSendFileFeature>(new SendFileFeatureWrapper(OriginalSendFileFeature, ResponseCacheStream));
             }
         }
 
         internal void UnshimResponseStream()
         {
             // Unshim response stream
-            HttpContext.Response.Body = OriginalResponseStream;
+            _httpContext.Response.Body = OriginalResponseStream;
 
             // Unshim IHttpSendFileFeature
-            HttpContext.Features.Set(OriginalSendFileFeature);
+            _httpContext.Features.Set(OriginalSendFileFeature);
         }
 
         private enum ResponseType