Reduce allocations in QueryCollection

src/Http/Http/perf/Microbenchmarks/QueryCollectionBenchmarks.cs

@@ -0,0 +1,52 @@
+// 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 BenchmarkDotNet.Attributes;
+using Microsoft.AspNetCore.Http.Features;
+using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Extensions.Primitives;
+using static Microsoft.AspNetCore.Http.Features.QueryFeature;
+
+namespace Microsoft.AspNetCore.Http
+{
+    public class QueryCollectionBenchmarks
+    {
+        private string _queryString;
+        private string _singleValue;
+
+        [IterationSetup]
+        public void Setup()
+        {
+            _queryString = "?key1=value1&key2=value2&key3=value3&key4=&key5=";
+            _singleValue = "?key1=value1";
+        }
+
+        [Benchmark]
+        public void ParseNew()
+        {
+            var dict = QueryFeature.ParseNullableQueryInternal(_queryString);
+        }
+
+        [Benchmark]
+        public void ParseNewSingle()
+        {
+            var dict = QueryFeature.ParseNullableQueryInternal(_singleValue);
+        }
+
+        [Benchmark]
+        public void Parse()
+        {
+            var dict = QueryHelpers.ParseNullableQuery(_queryString);
+        }
+
+        [Benchmark]
+        public void Constructor()
+        {
+            var dict = new KvpAccumulator();
+            if (dict.HasValues)
+            {
+                return;
+            }
+        }
+    }
+}

src/Http/Http/src/Features/QueryFeature.cs

@@ -2,7 +2,10 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Internal;
 using Microsoft.AspNetCore.WebUtilities;
+using Microsoft.Extensions.Primitives;
 
 namespace Microsoft.AspNetCore.Http.Features
 {
@@ -69,15 +72,15 @@ public IQueryCollection Query
                 {
                     _original = current;
 
-                    var result = QueryHelpers.ParseNullableQuery(current);
+                    var result = ParseNullableQueryInternal(current);
 
                     if (result == null)
                     {
                         _parsedValues = QueryCollection.Empty;
                     }
                     else
                     {
-                        _parsedValues = new QueryCollection(result);
+                        _parsedValues = new QueryCollectionInternal(result);
                     }
                 }
                 return _parsedValues;
@@ -100,5 +103,170 @@ public IQueryCollection Query
                 }
             }
         }
+
+        /// <summary>
+        /// Parse a query string into its component key and value parts.
+        /// </summary>
+        /// <param name="queryString">The raw query string value, with or without the leading '?'.</param>
+        /// <returns>A collection of parsed keys and values, null if there are no entries.</returns>
+        internal static AdaptiveCapacityDictionary<string, StringValues>? ParseNullableQueryInternal(string? queryString)
+        {
+            var accumulator = new KvpAccumulator();
+
+            if (string.IsNullOrEmpty(queryString) || queryString == "?")
+            {
+                return null;
+            }
+
+            int scanIndex = 0;
+            if (queryString[0] == '?')
+            {
+                scanIndex = 1;
+            }
+
+            int textLength = queryString.Length;
+            int equalIndex = queryString.IndexOf('=');
+            if (equalIndex == -1)
+            {
+                equalIndex = textLength;
+            }
+            while (scanIndex < textLength)
+            {
+                int delimiterIndex = queryString.IndexOf('&', scanIndex);
+                if (delimiterIndex == -1)
+                {
+                    delimiterIndex = textLength;
+                }
+                if (equalIndex < delimiterIndex)
+                {
+                    while (scanIndex != equalIndex && char.IsWhiteSpace(queryString[scanIndex]))
+                    {
+                        ++scanIndex;
+                    }
+                    string name = queryString.Substring(scanIndex, equalIndex - scanIndex);
+                    string value = queryString.Substring(equalIndex + 1, delimiterIndex - equalIndex - 1);
+                    accumulator.Append(
+                        Uri.UnescapeDataString(name.Replace('+', ' ')),
+                        Uri.UnescapeDataString(value.Replace('+', ' ')));
+                    equalIndex = queryString.IndexOf('=', delimiterIndex);
+                    if (equalIndex == -1)
+                    {
+                        equalIndex = textLength;
+                    }
+                }
+                else
+                {
+                    if (delimiterIndex > scanIndex)
+                    {
+                        accumulator.Append(queryString.Substring(scanIndex, delimiterIndex - scanIndex), string.Empty);
+                    }
+                }
+                scanIndex = delimiterIndex + 1;
+            }
+
+            if (!accumulator.HasValues)
+            {
+                return null;
+            }
+
+            return accumulator.GetResults();
+        }
+
+        internal struct KvpAccumulator
+        {
+            /// <summary>
+            /// This API supports infrastructure and is not intended to be used
+            /// directly from your code. This API may change or be removed in future releases.
+            /// </summary>
+            private AdaptiveCapacityDictionary<string, StringValues> _accumulator;
+            private AdaptiveCapacityDictionary<string, List<string>> _expandingAccumulator;
+
+            /// <summary>
+            /// This API supports infrastructure and is not intended to be used
+            /// directly from your code. This API may change or be removed in future releases.
+            /// </summary>
+            public void Append(string key, string value)
+            {
+                if (_accumulator == null)
+                {
+                    _accumulator = new AdaptiveCapacityDictionary<string, StringValues>(StringComparer.OrdinalIgnoreCase);
+                }
+
+                StringValues values;
+                if (_accumulator.TryGetValue(key, out values))
+                {
+                    if (values.Count == 0)
+                    {
+                        // Marker entry for this key to indicate entry already in expanding list dictionary
+                        _expandingAccumulator[key].Add(value);
+                    }
+                    else if (values.Count == 1)
+                    {
+                        _accumulator[key] = StringValues.Concat(values, value);
+                    }
+                    else
+                    {
+                        // Add zero count entry and move to data to expanding list dictionary
+                        _accumulator[key] = default(StringValues);
+
+                        if (_expandingAccumulator == null)
+                        {
+                            _expandingAccumulator = new AdaptiveCapacityDictionary<string, List<string>>(5, StringComparer.OrdinalIgnoreCase);
+                        }
+
+                        // Already 5 entries so use starting allocated as 10; then use List's expansion mechanism for more
+                        var list = new List<string>(10);
+
+                        list.AddRange(values);
+                        list.Add(value);
+
+                        _expandingAccumulator[key] = list;
+                    }
+                }
+                else
+                {
+                    // First value for this key
+                    _accumulator[key] = new StringValues(value);
+                }
+
+                ValueCount++;
+            }
+
+            /// <summary>
+            /// This API supports infrastructure and is not intended to be used
+            /// directly from your code. This API may change or be removed in future releases.
+            /// </summary>
+            public bool HasValues => ValueCount > 0;
+
+            /// <summary>
+            /// This API supports infrastructure and is not intended to be used
+            /// directly from your code. This API may change or be removed in future releases.
+            /// </summary>
+            public int KeyCount => _accumulator?.Count ?? 0;
+
+            /// <summary>
+            /// This API supports infrastructure and is not intended to be used
+            /// directly from your code. This API may change or be removed in future releases.
+            /// </summary>
+            public int ValueCount { get; private set; }
+
+            /// <summary>
+            /// This API supports infrastructure and is not intended to be used
+            /// directly from your code. This API may change or be removed in future releases.
+            /// </summary>
+            public AdaptiveCapacityDictionary<string, StringValues> GetResults()
+            {
+                if (_expandingAccumulator != null)
+                {
+                    // Coalesce count 3+ multi-value entries into _accumulator dictionary
+                    foreach (var entry in _expandingAccumulator)
+                    {
+                        _accumulator[entry.Key] = new StringValues(entry.Value.ToArray());
+                    }
+                }
+
+                return _accumulator ?? new AdaptiveCapacityDictionary<string, StringValues>(0, StringComparer.OrdinalIgnoreCase);
+            }
+        }
     }
 }

src/Http/Http/src/Microsoft.AspNetCore.Http.csproj

@@ -13,6 +13,7 @@
 
   <ItemGroup>
     <Compile Include="$(SharedSourceRoot)CopyOnWriteDictionary\*.cs" />
+    <Compile Include="$(SharedSourceRoot)UrlDecoder\**\*.cs" />
     <Compile Include="$(SharedSourceRoot)ValueTaskExtensions\**\*.cs" />
     <Compile Include="..\..\Shared\StreamCopyOperationInternal.cs" Link="Internal\StreamCopyOperationInternal.cs" />
     <Compile Include="..\..\Shared\CookieHeaderParserShared.cs" Link="Internal\CookieHeaderParserShared.cs" />