Showing what Removing RequestCookieCollection would look like

Author: jkotalik

src/Http/Http/perf/Microbenchmarks/RequestCookieCollectionBenchmarks.cs

@@ -2,6 +2,7 @@
 // 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.Extensions.Primitives;
 
 namespace Microsoft.AspNetCore.Http
@@ -19,7 +20,7 @@ public void Setup()
         [Benchmark]
         public void Parse_TypicalCookie()
         {
-            RequestCookieCollection.Parse(_cookie);
+            var feature = RequestCookiesFeature.Parse(_cookie);
         }
     }
 }

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

@@ -2,7 +2,9 @@
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.Extensions.Primitives;
 using Microsoft.Net.Http.Headers;
 
@@ -11,14 +13,21 @@ namespace Microsoft.AspNetCore.Http.Features
     /// <summary>
     /// Default implementation for <see cref="IRequestCookiesFeature"/>.
     /// </summary>
-    public class RequestCookiesFeature : IRequestCookiesFeature
+    public class RequestCookiesFeature : IRequestCookiesFeature, IRequestCookieCollection
     {
         // Lambda hoisted to static readonly field to improve inlining https://github.com/dotnet/roslyn/issues/13624
         private readonly static Func<IFeatureCollection, IHttpRequestFeature?> _nullRequestFeature = f => null;
 
         private FeatureReferences<IHttpRequestFeature> _features;
         private StringValues _original;
-        private IRequestCookieCollection? _parsedValues;
+        private Dictionary<string, string>? _parsedValues;
+        private IRequestCookieCollection? _userPassed;
+
+        private static readonly string[] EmptyKeys = Array.Empty<string>();
+        private static readonly Enumerator EmptyEnumerator = new Enumerator();
+        // Pre-box
+        private static readonly IEnumerator<KeyValuePair<string, string>> EmptyIEnumeratorType = EmptyEnumerator;
+        private static readonly IEnumerator EmptyIEnumerator = EmptyEnumerator;
 
         /// <summary>
         /// Initializes a new instance of <see cref="RequestCookiesFeature"/>.
@@ -31,7 +40,7 @@ public RequestCookiesFeature(IRequestCookieCollection cookies)
                 throw new ArgumentNullException(nameof(cookies));
             }
 
-            _parsedValues = cookies;
+            _userPassed = cookies;
         }
 
         /// <summary>
@@ -48,6 +57,8 @@ public RequestCookiesFeature(IFeatureCollection features)
             _features.Initalize(features);
         }
 
+        private Dictionary<string, string>? Store { get; set; }
+
         private IHttpRequestFeature HttpRequestFeature =>
             _features.Fetch(ref _features.Cache, _nullRequestFeature)!;
 
@@ -60,9 +71,10 @@ public IRequestCookieCollection Cookies
                 {
                     if (_parsedValues == null)
                     {
-                        _parsedValues = RequestCookieCollection.Empty;
+                        _parsedValues = new Dictionary<string, string>();
                     }
-                    return _parsedValues;
+
+                    return this;
                 }
 
                 var headers = HttpRequestFeature.Headers;
@@ -75,25 +87,25 @@ public IRequestCookieCollection Cookies
                 if (_parsedValues == null || _original != current)
                 {
                     _original = current;
-                    _parsedValues = RequestCookieCollection.Parse(current);
+                    _parsedValues = Parse(current);
                 }
 
-                return _parsedValues;
+                return this;
             }
             set
             {
-                _parsedValues = value;
+                _userPassed = value;
                 _original = StringValues.Empty;
                 if (_features.Collection != null)
                 {
-                    if (_parsedValues == null || _parsedValues.Count == 0)
+                    if (_userPassed == null || _userPassed.Count == 0)
                     {
                         HttpRequestFeature.Headers.Remove(HeaderNames.Cookie);
                     }
                     else
                     {
-                        var headers = new List<string>(_parsedValues.Count);
-                        foreach (var pair in _parsedValues)
+                        var headers = new List<string>(_userPassed.Count);
+                        foreach (var pair in _userPassed)
                         {
                             headers.Add(new CookieHeaderValue(pair.Key, pair.Value).ToString());
                         }
@@ -103,5 +115,235 @@ public IRequestCookieCollection Cookies
                 }
             }
         }
+
+        /// <inheritdoc />
+        public string? this[string key]
+        {
+            get
+            {
+                if (key == null)
+                {
+                    throw new ArgumentNullException(nameof(key));
+                }
+
+                if (_userPassed != null)
+                {
+                    return _userPassed[key];
+                }
+
+                if (Store == null)
+                {
+                    return null;
+                }
+
+                if (TryGetValue(key, out var value))
+                {
+                    return value;
+                }
+                return null;
+            }
+        }
+
+        internal static Dictionary<string, string>? Parse(StringValues values)
+            => ParseInternal(values, AppContext.TryGetSwitch(ResponseCookies.EnableCookieNameEncoding, out var enabled) && enabled);
+
+        internal static Dictionary<string, string>? ParseInternal(StringValues values, bool enableCookieNameEncoding)
+        {
+            if (values.Count == 0)
+            {
+                return null;
+            }
+
+            var store = new Dictionary<string, string>(values.Count);
+
+            if (CookieHeaderValue.TryParseIntoDictionary(values, store, enableCookieNameEncoding))
+            {
+                if (store.Count == 0)
+                {
+                    return null;
+                }
+
+                return store;
+            }
+
+            return null;
+        }
+
+        /// <inheritdoc />
+        public int Count
+        {
+            get
+            {
+                if (_userPassed != null)
+                {
+                    return _userPassed.Count;
+                }
+
+                if (Store == null)
+                {
+                    return 0;
+                }
+                return Store.Count;
+            }
+        }
+
+        /// <inheritdoc />
+        public ICollection<string> Keys
+        {
+            get
+            {
+                if (_userPassed != null)
+                {
+                    return _userPassed.Keys;
+                }
+
+                if (Store == null)
+                {
+                    return EmptyKeys;
+                }
+                return Store.Keys;
+            }
+        }
+
+        /// <inheritdoc />
+        public bool ContainsKey(string key)
+        {
+            if (_userPassed != null)
+            {
+                return _userPassed.ContainsKey(key);
+            }
+
+            if (Store == null)
+            {
+                return false;
+            }
+            return Store.ContainsKey(key);
+        }
+
+        /// <inheritdoc />
+        public bool TryGetValue(string key, [MaybeNullWhen(false)] out string? value)
+        {
+            if (_userPassed != null)
+            {
+                return _userPassed.TryGetValue(key, out value);
+            }
+
+            if (Store == null)
+            {
+                value = null;
+                return false;
+            }
+            return Store.TryGetValue(key, out value);
+        }
+
+        /// <summary>
+        /// Returns an struct enumerator that iterates through a collection without boxing.
+        /// </summary>
+        /// <returns>An <see cref="Enumerator" /> object that can be used to iterate through the collection.</returns>
+        internal Enumerator GetEnumerator()
+        {
+            if (Store == null || Store.Count == 0)
+            {
+                // Non-boxed Enumerator
+                return EmptyEnumerator;
+            }
+            // Non-boxed Enumerator
+            return new Enumerator(Store.GetEnumerator());
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through a collection, boxes in non-empty path.
+        /// </summary>
+        /// <returns>An <see cref="IEnumerator{T}" /> object that can be used to iterate through the collection.</returns>
+        IEnumerator<KeyValuePair<string, string>> IEnumerable<KeyValuePair<string, string>>.GetEnumerator()
+        {
+            if (_userPassed != null)
+            {
+                return _userPassed.GetEnumerator();
+            }
+
+            if (Store == null || Store.Count == 0)
+            {
+                // Non-boxed Enumerator
+                return EmptyIEnumeratorType;
+            }
+            // Boxed Enumerator
+            return GetEnumerator();
+        }
+
+        /// <summary>
+        /// Returns an enumerator that iterates through a collection, boxes in non-empty path.
+        /// </summary>
+        /// <returns>An <see cref="IEnumerator" /> object that can be used to iterate through the collection.</returns>
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            if (_userPassed != null)
+            {
+                return _userPassed.GetEnumerator();
+            }
+
+            if (Store == null || Store.Count == 0)
+            {
+                // Non-boxed Enumerator
+                return EmptyIEnumerator;
+            }
+            // Boxed Enumerator
+            return GetEnumerator();
+        }
+
+        internal struct Enumerator : IEnumerator<KeyValuePair<string, string>>
+        {
+            // Do NOT make this readonly, or MoveNext will not work
+            private Dictionary<string, string>.Enumerator _dictionaryEnumerator;
+            private bool _notEmpty;
+
+            internal Enumerator(Dictionary<string, string>.Enumerator dictionaryEnumerator)
+            {
+                _dictionaryEnumerator = dictionaryEnumerator;
+                _notEmpty = true;
+            }
+
+            public bool MoveNext()
+            {
+                if (_notEmpty)
+                {
+                    return _dictionaryEnumerator.MoveNext();
+                }
+                return false;
+            }
+
+            public KeyValuePair<string, string> Current
+            {
+                get
+                {
+                    if (_notEmpty)
+                    {
+                        var current = _dictionaryEnumerator.Current;
+                        return new KeyValuePair<string, string>(current.Key, current.Value);
+                    }
+                    return default(KeyValuePair<string, string>);
+                }
+            }
+
+            object IEnumerator.Current
+            {
+                get
+                {
+                    return Current;
+                }
+            }
+
+            public void Dispose()
+            {
+            }
+
+            public void Reset()
+            {
+                if (_notEmpty)
+                {
+                    ((IEnumerator)_dictionaryEnumerator).Reset();
+                }
+            }
+        }
     }
 }