Use pooled StringBuilder to reduce allocations when adding response cookies

- #561
- new `SetCookieHeaderValue.AppendToStringBuilder()` method; avoids per-call `StringBuilder` allocation
- `ResponseCookies` uses `ObjectPool<StringBuilder>` that `ResponseCookiesFeature` provides
- `ResponseCookiesFeature` creates an `ObjectPoolProvider` instance if none in DI
- `IResponseCookiesFeature` exposes `int` properties supporting middleware overrides of the pool policy

nit: Add some doc comments

Author: dougbu

src/Microsoft.AspNetCore.Http.Features/IResponseCookiesFeature.cs

@@ -3,8 +3,33 @@
 
 namespace Microsoft.AspNetCore.Http.Features
 {
+    /// <summary>
+    /// Feature containing cookies which will be returned with the response.
+    /// </summary>
     public interface IResponseCookiesFeature
     {
+        /// <summary>
+        /// Initial capacity of instances used in the implementation of this feature, in <see cref="char"/>s.
+        /// </summary>
+        /// <remarks>
+        /// For example, the initial capacity of <see cref="System.Text.StringBuilder"/> instances obtained
+        /// from an object pool.
+        /// </remarks>
+        int InitialPooledInstanceCapacity { get; set; }
+
+        /// <summary>
+        /// Maximum retained capacity of instances used in the implementation of this feature, in <see cref="char"/>s.
+        /// Instances larger than this will be deleted rather than preserved in the pool.
+        /// </summary>
+        /// <remarks>
+        /// For example, the maximum retained capacity of <see cref="System.Text.StringBuilder"/> instances obtained
+        /// from an object pool.
+        /// </remarks>
+        int MaximumRetainedPooledInstanceCapacity { get; set; }
+
+        /// <summary>
+        /// Cookies which will be returned with the response.
+        /// </summary>
         IResponseCookies Cookies { get; }
     }
 }

src/Microsoft.AspNetCore.Http/Features/ResponseCookiesFeature.cs

@@ -2,31 +2,64 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using Microsoft.AspNetCore.Http.Internal;
+using Microsoft.Extensions.ObjectPool;
 
 namespace Microsoft.AspNetCore.Http.Features.Internal
 {
+    /// <summary>
+    /// Default implementation of <see cref="IResponseCookiesFeature"/>.
+    /// </summary>
     public class ResponseCookiesFeature : IResponseCookiesFeature
     {
         private FeatureReferences<IHttpResponseFeature> _features;
+        private FeatureReferences<IServiceProvidersFeature> _services;
         private IResponseCookies _cookiesCollection;
 
+        /// <summary>
+        /// Initializes a new <see cref="ResponseCookiesFeature"/> instance.
+        /// </summary>
+        /// <param name="features">
+        /// <see cref="IFeatureCollection"/> containing all defined features, including this
+        /// <see cref="IResponseCookiesFeature"/> and the <see cref="IHttpResponseFeature"/>.
+        /// </param>
         public ResponseCookiesFeature(IFeatureCollection features)
         {
             _features = new FeatureReferences<IHttpResponseFeature>(features);
+            _services = new FeatureReferences<IServiceProvidersFeature>(features);
         }
 
-        private IHttpResponseFeature HttpResponseFeature =>
-            _features.Fetch(ref _features.Cache, f => null);
+        /// <inheritdoc />
+        /// <value>Default is <c>100</c> <see cref="char"/>s.</value>
+        public int InitialPooledInstanceCapacity { get; set; } = new StringBuilderPooledObjectPolicy().InitialCapacity;
 
+        /// <inheritdoc />
+        /// <value>Default is <c>4048</c> <see cref="char"/>s.</value>
+        public int MaximumRetainedPooledInstanceCapacity { get; set; } =
+            new StringBuilderPooledObjectPolicy().MaximumRetainedCapacity;
+
+        private IHttpResponseFeature HttpResponseFeature => _features.Fetch(ref _features.Cache, f => null);
+
+        private IServiceProvidersFeature ServiceProvidersFeature => _services.Fetch(ref _services.Cache, f => null);
+
+        /// <inheritdoc />
         public IResponseCookies Cookies
         {
             get
             {
                 if (_cookiesCollection == null)
                 {
                     var headers = HttpResponseFeature.Headers;
-                    _cookiesCollection = new ResponseCookies(headers);
+
+                    var serviceProvider = ServiceProvidersFeature.RequestServices;
+                    var provider = (ObjectPoolProvider)serviceProvider.GetService(typeof(ObjectPoolProvider)) ??
+                        new DefaultObjectPoolProvider();
+                    var pool = provider.CreateStringBuilderPool(
+                        InitialPooledInstanceCapacity,
+                        MaximumRetainedPooledInstanceCapacity);
+
+                    _cookiesCollection = new ResponseCookies(headers, pool);
                 }
+
                 return _cookiesCollection;
             }
         }

src/Microsoft.AspNetCore.Http/ResponseCookies.cs

@@ -2,8 +2,9 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
-using System.Text.Encodings.Web;
 using System.Collections.Generic;
+using System.Text;
+using Microsoft.Extensions.ObjectPool;
 using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
 
@@ -14,18 +15,26 @@ namespace Microsoft.AspNetCore.Http.Internal
     /// </summary>
     public class ResponseCookies : IResponseCookies
     {
+        private readonly ObjectPool<StringBuilder> _builderPool;
+
         /// <summary>
         /// Create a new wrapper
         /// </summary>
-        /// <param name="headers"></param>
-        public ResponseCookies(IHeaderDictionary headers)
+        /// <param name="headers">The <see cref="IHeaderDictionary"/> for the response.</param>
+        /// <param name="builderPool">The <see cref="ObjectPool{T}"/> used.</param>
+        public ResponseCookies(IHeaderDictionary headers, ObjectPool<StringBuilder> builderPool)
         {
             if (headers == null)
             {
                 throw new ArgumentNullException(nameof(headers));
             }
+            if (builderPool == null)
+            {
+                throw new ArgumentNullException(nameof(builderPool));
+            }
 
             Headers = headers;
+            _builderPool = builderPool;
         }
 
         private IHeaderDictionary Headers { get; set; }
@@ -38,13 +47,25 @@ public ResponseCookies(IHeaderDictionary headers)
         public void Append(string key, string value)
         {
             var setCookieHeaderValue = new SetCookieHeaderValue(
-                    Uri.EscapeDataString(key),
-                    Uri.EscapeDataString(value))
+                Uri.EscapeDataString(key),
+                Uri.EscapeDataString(value))
             {
                 Path = "/"
             };
 
-            Headers[HeaderNames.SetCookie] = StringValues.Concat(Headers[HeaderNames.SetCookie], setCookieHeaderValue.ToString());
+            string cookieValue;
+            var stringBuilder = _builderPool.Get();
+            try
+            {
+                setCookieHeaderValue.AppendToStringBuilder(stringBuilder);
+                cookieValue = stringBuilder.ToString();
+            }
+            finally
+            {
+                _builderPool.Return(stringBuilder);
+            }
+
+            Headers[HeaderNames.SetCookie] = StringValues.Concat(Headers[HeaderNames.SetCookie], cookieValue);
         }
 
         /// <summary>
@@ -61,8 +82,8 @@ public void Append(string key, string value, CookieOptions options)
             }
 
             var setCookieHeaderValue = new SetCookieHeaderValue(
-                    Uri.EscapeDataString(key),
-                    Uri.EscapeDataString(value))
+                Uri.EscapeDataString(key),
+                Uri.EscapeDataString(value))
             {
                 Domain = options.Domain,
                 Path = options.Path,
@@ -71,7 +92,19 @@ public void Append(string key, string value, CookieOptions options)
                 HttpOnly = options.HttpOnly,
             };
 
-            Headers[HeaderNames.SetCookie] = StringValues.Concat(Headers[HeaderNames.SetCookie], setCookieHeaderValue.ToString());
+            string cookieValue;
+            var stringBuilder = _builderPool.Get();
+            try
+            {
+                setCookieHeaderValue.AppendToStringBuilder(stringBuilder);
+                cookieValue = stringBuilder.ToString();
+            }
+            finally
+            {
+                _builderPool.Return(stringBuilder);
+            }
+
+            Headers[HeaderNames.SetCookie] = StringValues.Concat(Headers[HeaderNames.SetCookie], cookieValue);
         }
 
         /// <summary>
@@ -94,7 +127,7 @@ public void Delete(string key, CookieOptions options)
             {
                 throw new ArgumentNullException(nameof(options));
             }
-            
+
             var encodedKeyPlusEquals = Uri.EscapeDataString(key) + "=";
             bool domainHasValue = !string.IsNullOrEmpty(options.Domain);
             bool pathHasValue = !string.IsNullOrEmpty(options.Path);
@@ -130,7 +163,7 @@ public void Delete(string key, CookieOptions options)
                         newValues.Add(values[i]);
                     }
                 }
-                
+
                 Headers[HeaderNames.SetCookie] = new StringValues(newValues.ToArray());
             }
 

src/Microsoft.AspNetCore.Http/project.json

@@ -17,6 +17,7 @@
   "dependencies": {
     "Microsoft.AspNetCore.Http.Abstractions": "1.0.0-*",
     "Microsoft.AspNetCore.WebUtilities": "1.0.0-*",
+    "Microsoft.Extensions.ObjectPool": "1.0.0-*",
     "Microsoft.Net.Http.Headers": "1.0.0-*"
   },
   "frameworks": {

src/Microsoft.Net.Http.Headers/SetCookieHeaderValue.cs

@@ -90,42 +90,54 @@ public string Value
         public override string ToString()
         {
             StringBuilder header = new StringBuilder();
+            AppendToStringBuilder(header);
 
-            header.Append(_name);
-            header.Append("=");
-            header.Append(_value);
+            return header.ToString();
+        }
+
+        /// <summary>
+        /// Append string representation of this <see cref="SetCookieHeaderValue"/> to given
+        /// <paramref name="builder"/>.
+        /// </summary>
+        /// <param name="builder">
+        /// The <see cref="StringBuilder"/> to receive the string representation of this
+        /// <see cref="SetCookieHeaderValue"/>.
+        /// </param>
+        public void AppendToStringBuilder(StringBuilder builder)
+        {
+            builder.Append(_name);
+            builder.Append("=");
+            builder.Append(_value);
 
             if (Expires.HasValue)
             {
-                AppendSegment(header, ExpiresToken, HeaderUtilities.FormatDate(Expires.Value));
+                AppendSegment(builder, ExpiresToken, HeaderUtilities.FormatDate(Expires.Value));
             }
 
             if (MaxAge.HasValue)
             {
-                AppendSegment(header, MaxAgeToken, HeaderUtilities.FormatInt64((long)MaxAge.Value.TotalSeconds));
+                AppendSegment(builder, MaxAgeToken, HeaderUtilities.FormatInt64((long)MaxAge.Value.TotalSeconds));
             }
 
             if (Domain != null)
             {
-                AppendSegment(header, DomainToken, Domain);
+                AppendSegment(builder, DomainToken, Domain);
             }
 
             if (Path != null)
             {
-                AppendSegment(header, PathToken, Path);
+                AppendSegment(builder, PathToken, Path);
             }
 
             if (Secure)
             {
-                AppendSegment(header, SecureToken, null);
+                AppendSegment(builder, SecureToken, null);
             }
 
             if (HttpOnly)
             {
-                AppendSegment(header, HttpOnlyToken, null);
+                AppendSegment(builder, HttpOnlyToken, null);
             }
-
-            return header.ToString();
         }
 
         private static void AppendSegment(StringBuilder builder, string name, string value)

test/Microsoft.AspNetCore.Http.Tests/ResponseCookiesTest.cs

@@ -1,19 +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 Xunit;
-using Microsoft.Net.Http.Headers;
+using System.Text;
 using Microsoft.AspNetCore.Http.Internal;
+using Microsoft.Extensions.ObjectPool;
+using Microsoft.Net.Http.Headers;
+using Xunit;
 
 namespace Microsoft.AspNetCore.Http.Tests
 {
     public class ResponseCookiesTest
     {
+        private static readonly ObjectPool<StringBuilder> _builderPool =
+            new DefaultObjectPoolProvider().Create<StringBuilder>(new StringBuilderPooledObjectPolicy());
+
         [Fact]
         public void DeleteCookieShouldSetDefaultPath()
         {
             var headers = new HeaderDictionary();
-            var cookies = new ResponseCookies(headers);
+            var cookies = new ResponseCookies(headers, _builderPool);
             var testcookie = "TestCookie";
 
             cookies.Delete(testcookie);
@@ -29,7 +34,7 @@ public void DeleteCookieShouldSetDefaultPath()
         public void NoParamsDeleteRemovesCookieCreatedByAdd()
         {
             var headers = new HeaderDictionary();
-            var cookies = new ResponseCookies(headers);
+            var cookies = new ResponseCookies(headers, _builderPool);
             var testcookie = "TestCookie";
 
             cookies.Append(testcookie, testcookie);
@@ -49,7 +54,7 @@ public void NoParamsDeleteRemovesCookieCreatedByAdd()
         public void EscapesKeyValuesBeforeSettingCookie(string key, string value, string expected)
         {
             var headers = new HeaderDictionary();
-            var cookies = new ResponseCookies(headers);
+            var cookies = new ResponseCookies(headers, _builderPool);
 
             cookies.Append(key, value);
 

test/Microsoft.Net.Http.Headers.Tests/SetCookieHeaderValueTest.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using Xunit;
 
 namespace Microsoft.Net.Http.Headers
@@ -264,6 +265,17 @@ public void SetCookieHeaderValue_ToString(SetCookieHeaderValue input, string exp
             Assert.Equal(expectedValue, input.ToString());
         }
 
+        [Theory]
+        [MemberData(nameof(SetCookieHeaderDataSet))]
+        public void SetCookieHeaderValue_AppendToStringBuilder(SetCookieHeaderValue input, string expectedValue)
+        {
+            var builder = new StringBuilder();
+
+            input.AppendToStringBuilder(builder);
+
+            Assert.Equal(expectedValue, builder.ToString());
+        }
+
         [Theory]
         [MemberData(nameof(SetCookieHeaderDataSet))]
         public void SetCookieHeaderValue_Parse_AcceptsValidValues(SetCookieHeaderValue cookie, string expectedValue)