TryAddWithoutValidation for multiple values could be more efficient

src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaders.cs

@@ -169,6 +169,15 @@ internal bool TryAddWithoutValidation(HeaderDescriptor descriptor, IEnumerable<s
         {
             ArgumentNullException.ThrowIfNull(values);
 
+            if (values is string?[] valuesArray)
+            {
+                return SpecializedTryAddWithoutValidation(descriptor, valuesArray, null);
+            }
+            else if (values is IList<string?> valuesList)
+            {
+                return SpecializedTryAddWithoutValidation(descriptor, null, valuesList);
+            }
+
             using IEnumerator<string?> enumerator = values.GetEnumerator();
             if (enumerator.MoveNext())
             {
@@ -196,6 +205,63 @@ internal bool TryAddWithoutValidation(HeaderDescriptor descriptor, IEnumerable<s
             return true;
         }
 
+        private bool SpecializedTryAddWithoutValidation(HeaderDescriptor descriptor, string?[]? valuesArray, IList<string?>? valuesList)
+        {
+            Debug.Assert(valuesArray != null || valuesList != null);
+            int count = valuesArray != null ? valuesArray.Length : valuesList!.Count;
+
+            if (count == 0)
+            {
+                return true;
+            }
+
+            ref object? storeValueRef = ref GetValueRefOrAddDefault(descriptor);
+            object? storeValue = storeValueRef;
+
+            if (storeValue is not null || count > 1)
+            {
+                if (storeValue is not HeaderStoreItemInfo info)
+                {
+                    storeValueRef = info = new HeaderStoreItemInfo { RawValue = storeValue };
+                }
+
+                object? rawValue = info.RawValue;
+                if (rawValue is not List<string> rawValues)
+                {
+                    info.RawValue = rawValues = new List<string>();
+                    if (rawValue is not null)
+                    {
+                        rawValues.EnsureCapacity(count + 1);
+                        rawValues.Add((string)rawValue);
+                    }
+                }
+
+                rawValues.EnsureCapacity(count);
+
+                if (valuesArray != null)
+                {
+                    for (int i = 0; i < valuesArray.Length; i++)
+                    {
+                        rawValues.Add(valuesArray[i] ?? string.Empty);
+                    }
+                }
+                else
+                {
+                    for (int i = 0; i < valuesList!.Count; i++)
+                    {
+                        rawValues.Add(valuesList[i] ?? string.Empty);
+                    }
+                }
+            }
+            else
+            {
+                Debug.Assert(count == 1 && storeValue is null);
+                storeValueRef = (valuesArray != null ? valuesArray[0] : valuesList![0]) ?? string.Empty;
+            }
+
+            return true;
+        }
+
         public IEnumerable<string> GetValues(string name) => GetValues(GetHeaderDescriptor(name));
 
         internal IEnumerable<string> GetValues(HeaderDescriptor descriptor)

src/libraries/System.Net.Http/tests/UnitTests/Headers/HttpHeadersTest.cs

@@ -2544,6 +2544,66 @@ public void TryGetValues_InvalidValuesContainingNewLines_ShouldNotRemoveInvalidV
             Assert.Equal(value, values.Single());
         }
 
+        [Fact]
+        public void TryAddWithoutValidation_OneValidValueHeader_UseSpecialListImplementation()
+        {
+            const string Name = "customHeader1";
+            const string Value = "Value1";
+
+            var response = new HttpResponseMessage();
+            Assert.True(response.Headers.TryAddWithoutValidation(Name, new List<string> { Value }));
+
+            Assert.True(response.Headers.Contains(Name));
+
+            Assert.True(response.Headers.TryGetValues(Name, out IEnumerable<string> values));
+            Assert.Equal(Value, values.Single());
+        }
+
+        [Fact]
+        public void TryAddWithoutValidation_ThreeValidValueHeader_UseSpecialListImplementation()
+        {
+            const string Name = "customHeader1";
+            List<string> expectedValues = [ "Value1", "Value2", "Value3" ];
+
+            var response = new HttpResponseMessage();
+            Assert.True(response.Headers.TryAddWithoutValidation(Name, expectedValues));
+
+            Assert.True(response.Headers.Contains(Name));
+
+            Assert.True(response.Headers.TryGetValues(Name, out IEnumerable<string> values));
+            Assert.True(expectedValues.SequenceEqual(values));
+        }
+
+        [Fact]
+        public void TryAddWithoutValidation_OneValidValueHeader_UseSpecialArrayImplementation()
+        {
+            const string Name = "customHeader1";
+            const string Value = "Value1";
+
+            var response = new HttpResponseMessage();
+            Assert.True(response.Headers.TryAddWithoutValidation(Name, new [] { Value }));
+
+            Assert.True(response.Headers.Contains(Name));
+
+            Assert.True(response.Headers.TryGetValues(Name, out IEnumerable<string> values));
+            Assert.Equal(Value, values.Single());
+        }
+
+        [Fact]
+        public void TryAddWithoutValidation_ThreeValidValueHeader_UseSpecialArrayImplementation()
+        {
+            const string Name = "customHeader1";
+            string[] expectedValues = ["Value1", "Value2", "Value3"];
+
+            var response = new HttpResponseMessage();
+            Assert.True(response.Headers.TryAddWithoutValidation(Name, expectedValues));
+
+            Assert.True(response.Headers.Contains(Name));
+
+            Assert.True(response.Headers.TryGetValues(Name, out IEnumerable<string> values));
+            Assert.True(expectedValues.SequenceEqual(values));
+        }
+
         public static IEnumerable<object[]> NumberOfHeadersUpToArrayThreshold_AddNonValidated_EnumerateNonValidated()
         {
             for (int i = 0; i <= HttpHeaders.ArrayThreshold; i++)