Reduce allocations for Cookies.

src/Http/Headers/src/CookieHeaderParser.cs

@@ -1,6 +1,8 @@
 // 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 System;
+using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 using Microsoft.Extensions.Primitives;
 
@@ -13,7 +15,7 @@ internal CookieHeaderParser(bool supportsMultipleValues)
  {
  }
 
- public override bool TryParseValue(StringSegment value, ref int index, out CookieHeaderValue? parsedValue)
+ public bool TryParseValue(StringSegment value, ref int index, out (StringSegment, StringSegment)? parsedValue)
  {
  parsedValue = null;
 
@@ -61,6 +63,66 @@ public override bool TryParseValue(StringSegment value, ref int index, out Cooki
  return true;
  }
 
+ public bool TryParseValues(StringValues values, Dictionary<string, string> store, bool enableCookieNameEncoding)
+ {
+ // If a parser returns an empty list, it means there was no value, but that's valid (e.g. "Accept: "). The caller
+ // can ignore the value.
+ if (values.Count == 0)
+ {
+ return false;
+ }
+ bool hasFoundValue = false;
+
+ for (var i = 0; i < values.Count; i++)
+ {
+ var value = values[i];
+ var index = 0;
+
+ while (!string.IsNullOrEmpty(value) && index < value.Length)
+ {
+ (StringSegment, StringSegment)? output;
+ if (TryParseValue(value, ref index, out output))
+ {
+ // The entry may not contain an actual value, like " , "
+ if (output != null)
+ {
+ var cookie = output.Value;
+ var name = enableCookieNameEncoding ? Uri.UnescapeDataString(cookie.Item1.Value) : cookie.Item1.Value;
+ var valueString = Uri.UnescapeDataString(cookie.Item2.Value);
+ store[name] = valueString;
+ hasFoundValue = true;
+ }
+ }
+ else
+ {
+ // Skip the invalid values and keep trying.
+ index++;
+ }
+ }
+ }
+
+ return hasFoundValue;
+ }
+
+ public override bool TryParseValue(StringSegment value, ref int index, out CookieHeaderValue? parsedValue)
+ {
+ parsedValue = null;
+
+ if (!TryParseValue(value, ref index, out var stringSegments))
+ {
+ return false;
+ }
+
+ if (stringSegments == null)
+ {
+ return false;
+ }
+
+ parsedValue = new CookieHeaderValue(stringSegments.Value.Item1, stringSegments.Value.Item2);
+
+ return true;
+ }
+
  private static int GetNextNonEmptyOrWhitespaceIndex(StringSegment input, int startIndex, bool skipEmptyValues, out bool separatorFound)
  {
  Contract.Requires(startIndex <= input.Length); // it's OK if index == value.Length.

src/Http/Headers/src/CookieHeaderValue.cs

@@ -165,20 +165,31 @@ public static bool TryParseStrictList(IList<string>? inputs, [NotNullWhen(true)]
  return MultipleValueParser.TryParseStrictValues(inputs, out parsedValues);
  }
 
+ /// <summary>
+ /// Attempts to parse the sequence of values into a dictionary of cookies using string parsing rules.
+ /// </summary>
+ /// <param name="inputs">The values to parse.</param>
+ /// <param name="store"></param>
+ /// <param name="enableCookieNameEncoding"></param>
+ /// <returns></returns>
+ public static bool TryParseIntoDictionary(StringValues inputs, Dictionary<string, string> store, bool enableCookieNameEncoding)
+ {
+ return MultipleValueParser.TryParseValues(inputs, store, enableCookieNameEncoding);
+ }
+
  // name=value; name="value"
- internal static bool TryGetCookieLength(StringSegment input, ref int offset, [NotNullWhen(true)] out CookieHeaderValue? parsedValue)
+ internal static bool TryGetCookieLength(StringSegment input, ref int offset, [NotNullWhen(true)] out (StringSegment, StringSegment)? parsedValue)
  {
  Contract.Requires(offset >= 0);
 
  parsedValue = null;
+ (StringSegment, StringSegment) result = default;
 
  if (StringSegment.IsNullOrEmpty(input) || (offset >= input.Length))
  {
  return false;
  }
 
- var result = new CookieHeaderValue();
-
  // The caller should have already consumed any leading whitespace, commas, etc..
 
  // Name=value;
@@ -189,7 +200,8 @@ internal static bool TryGetCookieLength(StringSegment input, ref int offset, [No
  {
  return false;
  }
- result._name = input.Subsegment(offset, itemLength);
+
+ result.Item1 = input.Subsegment(offset, itemLength);
  offset += itemLength;
 
  // = (no spaces)
@@ -200,7 +212,7 @@ internal static bool TryGetCookieLength(StringSegment input, ref int offset, [No
 
  // value or "quoted value"
  // The value may be empty
- result._value = GetCookieValue(input, ref offset);
+ result.Item2 = GetCookieValue(input, ref offset);
 
  parsedValue = result;
  return true;

src/Http/Headers/src/PublicAPI.Unshipped.txt

@@ -2,5 +2,6 @@
 *REMOVED*Microsoft.Net.Http.Headers.RangeConditionHeaderValue.RangeConditionHeaderValue(Microsoft.Net.Http.Headers.EntityTagHeaderValue? entityTag) -> void
 Microsoft.Net.Http.Headers.MediaTypeHeaderValue.MatchesMediaType(Microsoft.Extensions.Primitives.StringSegment otherMediaType) -> bool
 Microsoft.Net.Http.Headers.RangeConditionHeaderValue.RangeConditionHeaderValue(Microsoft.Net.Http.Headers.EntityTagHeaderValue! entityTag) -> void
+static Microsoft.Net.Http.Headers.CookieHeaderValue.TryParseIntoDictionary(Microsoft.Extensions.Primitives.StringValues inputs, System.Collections.Generic.Dictionary<string!, string!>! store, bool enableCookieNameEncoding) -> bool
 static readonly Microsoft.Net.Http.Headers.HeaderNames.Baggage -> string!
 static readonly Microsoft.Net.Http.Headers.HeaderNames.ProxyConnection -> string!

src/Http/Http/src/Features/RequestCookiesFeature.cs

@@ -75,7 +75,7 @@ public IRequestCookieCollection Cookies
  if (_parsedValues == null || _original != current)
  {
  _original = current;
- _parsedValues = RequestCookieCollection.Parse(current.ToArray());
+ _parsedValues = RequestCookieCollection.Parse(current);
  }
 
  return _parsedValues;

src/Http/Http/src/Internal/RequestCookieCollection.cs

@@ -5,6 +5,7 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
+using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
 
 namespace Microsoft.AspNetCore.Http
@@ -56,33 +57,25 @@ public string? this[string key]
  }
  }
 
- public static RequestCookieCollection Parse(IList<string> values)
-  => ParseInternal(values, AppContext.TryGetSwitch(ResponseCookies.EnableCookieNameEncoding, out var enabled) && enabled);
+ public static RequestCookieCollection Parse(StringValues values)
+ => ParseInternal(values, AppContext.TryGetSwitch(ResponseCookies.EnableCookieNameEncoding, out var enabled) && enabled);
 
- internal static RequestCookieCollection ParseInternal(IList<string> values, bool enableCookieNameEncoding)
+ internal static RequestCookieCollection ParseInternal(StringValues values, bool enableCookieNameEncoding)
  {
  if (values.Count == 0)
  {
  return Empty;
  }
+ var collection = new RequestCookieCollection(new Dictionary<string, string>());
+ var store = collection.Store!;
 
- if (CookieHeaderValue.TryParseList(values, out var cookies))
+ if (CookieHeaderValue.TryParseIntoDictionary(values, store, enableCookieNameEncoding))
  {
- if (cookies.Count == 0)
+ if (store.Count == 0)
  {
  return Empty;
  }
 
- var collection = new RequestCookieCollection(cookies.Count);
- var store = collection.Store!;
- for (var i = 0; i < cookies.Count; i++)
- {
- var cookie = cookies[i];
- var name = enableCookieNameEncoding ? Uri.UnescapeDataString(cookie.Name.Value) : cookie.Name.Value;
- var value = Uri.UnescapeDataString(cookie.Value.Value);
- store[name] = value;
- }
-
  return collection;
  }
  return Empty;