Deduplicate header Separator logic (#100179)

MihaZupan · web-flow · commit b42c51612c3c · 2024-03-26T09:29:37.000-07:00
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/HPackEncoder.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http2/Hpack/HPackEncoder.cs
@@ -285,12 +285,7 @@ private static bool EncodeLiteralHeaderNewNameCore(byte mask, string name, strin
         }
 
         /// <summary>Encodes a "Literal Header Field without Indexing - New Name".</summary>
-        public static bool EncodeLiteralHeaderFieldWithoutIndexingNewName(string name, ReadOnlySpan<string> values, string separator, Span<byte> destination, out int bytesWritten)
-        {
-            return EncodeLiteralHeaderFieldWithoutIndexingNewName(name, values, separator, valueEncoding: null, destination, out bytesWritten);
-        }
-
-        public static bool EncodeLiteralHeaderFieldWithoutIndexingNewName(string name, ReadOnlySpan<string> values, string separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)
+        public static bool EncodeLiteralHeaderFieldWithoutIndexingNewName(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)
         {
             // From https://tools.ietf.org/html/rfc7541#section-6.2.2
             // ------------------------------------------------------
@@ -515,12 +510,7 @@ public static bool EncodeDynamicTableSizeUpdate(int value, Span<byte> destinatio
             return false;
         }
 
-        public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? separator, Span<byte> destination, out int bytesWritten)
-        {
-            return EncodeStringLiterals(values, separator, valueEncoding: null, destination, out bytesWritten);
-        }
-
-        public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)
+        public static bool EncodeStringLiterals(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)
         {
             bytesWritten = 0;
 
@@ -536,23 +526,22 @@ public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? sep
             if (destination.Length != 0)
             {
                 Debug.Assert(separator != null);
-                int valueLength;
+                Debug.Assert(Ascii.IsValid(separator));
+                int valueLength = checked((values.Length - 1) * separator.Length);
 
-                // Calculate length of all parts and separators.
+                // Calculate length of all values.
                 if (valueEncoding is null || ReferenceEquals(valueEncoding, Encoding.Latin1))
                 {
-                    valueLength = checked((int)(values.Length - 1) * separator.Length);
                     foreach (string part in values)
                     {
-                        valueLength = checked((int)(valueLength + part.Length));
+                        valueLength = checked(valueLength + part.Length);
                     }
                 }
                 else
                 {
-                    valueLength = checked((int)(values.Length - 1) * valueEncoding.GetByteCount(separator));
                     foreach (string part in values)
                     {
-                        valueLength = checked((int)(valueLength + valueEncoding.GetByteCount(part)));
+                        valueLength = checked(valueLength + valueEncoding.GetByteCount(part));
                     }
                 }
 
@@ -571,7 +560,7 @@ public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? sep
 
                             for (int i = 1; i < values.Length; i++)
                             {
-                                EncodeValueStringPart(separator, destination);
+                                separator.CopyTo(destination);
                                 destination = destination.Slice(separator.Length);
 
                                 value = values[i];
@@ -586,8 +575,8 @@ public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? sep
 
                             for (int i = 1; i < values.Length; i++)
                             {
-                                written = valueEncoding.GetBytes(separator, destination);
-                                destination = destination.Slice(written);
+                                separator.CopyTo(destination);
+                                destination = destination.Slice(separator.Length);
 
                                 written = valueEncoding.GetBytes(values[i], destination);
                                 destination = destination.Slice(written);
diff --git a/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackEncoder.cs b/src/libraries/Common/src/System/Net/Http/aspnetcore/Http3/QPack/QPackEncoder.cs
@@ -144,14 +144,9 @@ public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, str
         /// <summary>
         /// Encodes a Literal Header Field Without Name Reference, building the value by concatenating a collection of strings with separators.
         /// </summary>
-        public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, string valueSeparator, Span<byte> destination, out int bytesWritten)
+        public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)
         {
-            return EncodeLiteralHeaderFieldWithoutNameReference(name, values, valueSeparator, valueEncoding: null, destination, out bytesWritten);
-        }
-
-        public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, string valueSeparator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)
-        {
-            if (EncodeNameString(name, destination, out int nameLength) && EncodeValueString(values, valueSeparator, valueEncoding, destination.Slice(nameLength), out int valueLength))
+            if (EncodeNameString(name, destination, out int nameLength) && EncodeValueString(values, separator, valueEncoding, destination.Slice(nameLength), out int valueLength))
             {
                 bytesWritten = nameLength + valueLength;
                 return true;
@@ -222,12 +217,7 @@ private static bool EncodeValueString(string s, Encoding? valueEncoding, Span<by
         /// <summary>
         /// Encodes a value by concatenating a collection of strings, separated by a separator string.
         /// </summary>
-        public static bool EncodeValueString(ReadOnlySpan<string> values, string? separator, Span<byte> buffer, out int length)
-        {
-            return EncodeValueString(values, separator, valueEncoding: null, buffer, out length);
-        }
-
-        public static bool EncodeValueString(ReadOnlySpan<string> values, string? separator, Encoding? valueEncoding, Span<byte> buffer, out int length)
+        public static bool EncodeValueString(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, Span<byte> buffer, out int length)
         {
             if (values.Length == 1)
             {
@@ -243,18 +233,18 @@ public static bool EncodeValueString(ReadOnlySpan<string> values, string? separa
             if (buffer.Length > 0)
             {
                 Debug.Assert(separator != null);
-                int valueLength;
+                Debug.Assert(Ascii.IsValid(separator));
+                int valueLength = separator.Length * (values.Length - 1);
+
                 if (valueEncoding is null || ReferenceEquals(valueEncoding, Encoding.Latin1))
                 {
-                    valueLength = separator.Length * (values.Length - 1);
                     foreach (string part in values)
                     {
                         valueLength += part.Length;
                     }
                 }
                 else
                 {
-                    valueLength = valueEncoding.GetByteCount(separator) * (values.Length - 1);
                     foreach (string part in values)
                     {
                         valueLength += valueEncoding.GetByteCount(part);
@@ -275,7 +265,7 @@ public static bool EncodeValueString(ReadOnlySpan<string> values, string? separa
 
                             for (int i = 1; i < values.Length; i++)
                             {
-                                EncodeValueStringPart(separator, buffer);
+                                separator.CopyTo(buffer);
                                 buffer = buffer.Slice(separator.Length);
 
                                 value = values[i];
@@ -290,8 +280,8 @@ public static bool EncodeValueString(ReadOnlySpan<string> values, string? separa
 
                             for (int i = 1; i < values.Length; i++)
                             {
-                                written = valueEncoding.GetBytes(separator, buffer);
-                                buffer = buffer.Slice(written);
+                                separator.CopyTo(buffer);
+                                buffer = buffer.Slice(separator.Length);
 
                                 written = valueEncoding.GetBytes(values[i], buffer);
                                 buffer = buffer.Slice(written);
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderDescriptor.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderDescriptor.cs
@@ -277,5 +277,9 @@ private static bool TryDecodeUtf8(ReadOnlySpan<byte> input, [NotNullWhen(true)]
             decoded = null;
             return false;
         }
+
+        public string Separator => Parser is { } parser ? parser.Separator : HttpHeaderParser.DefaultSeparator;
+
+        public byte[] SeparatorBytes => Parser is { } parser ? parser.SeparatorBytes : HttpHeaderParser.DefaultSeparatorBytes;
     }
 }
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderStringValues.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HeaderStringValues.cs
@@ -45,7 +45,7 @@ internal HeaderStringValues(HeaderDescriptor descriptor, string[] values)
         public override string ToString() => _value switch
         {
             string value => value,
-            string[] values => string.Join(_header.Parser is HttpHeaderParser parser && parser.SupportsMultipleValues ? parser.Separator : HttpHeaderParser.DefaultSeparator, values),
+            string[] values => string.Join(_header.Separator, values),
             _ => string.Empty,
         };
 
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaderParser.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaderParser.cs
@@ -4,53 +4,42 @@
 using System.Collections;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Text;
 
 namespace System.Net.Http.Headers
 {
     internal abstract class HttpHeaderParser
     {
-        internal const string DefaultSeparator = ", ";
+        public const string DefaultSeparator = ", ";
+        public static readonly byte[] DefaultSeparatorBytes = ", "u8.ToArray();
 
-        private readonly bool _supportsMultipleValues;
-        private readonly string? _separator;
+        public bool SupportsMultipleValues { get; private set; }
 
-        public bool SupportsMultipleValues
-        {
-            get { return _supportsMultipleValues; }
-        }
+        public string Separator { get; private set; }
 
-        public string? Separator
-        {
-            get
-            {
-                Debug.Assert(_supportsMultipleValues);
-                return _separator;
-            }
-        }
+        public byte[] SeparatorBytes { get; private set; }
 
         // If ValueType implements Equals() as required, there is no need to provide a comparer. A comparer is needed
         // e.g. if we want to compare strings using case-insensitive comparison.
-        public virtual IEqualityComparer? Comparer
-        {
-            get { return null; }
-        }
+        public virtual IEqualityComparer? Comparer => null;
 
         protected HttpHeaderParser(bool supportsMultipleValues)
         {
-            _supportsMultipleValues = supportsMultipleValues;
-
-            if (supportsMultipleValues)
-            {
-                _separator = DefaultSeparator;
-            }
+            SupportsMultipleValues = supportsMultipleValues;
+            Separator = DefaultSeparator;
+            SeparatorBytes = DefaultSeparatorBytes;
         }
 
-        protected HttpHeaderParser(bool supportsMultipleValues, string separator)
+        protected HttpHeaderParser(bool supportsMultipleValues, string separator) : this(supportsMultipleValues)
         {
             Debug.Assert(!string.IsNullOrEmpty(separator));
+            Debug.Assert(Ascii.IsValid(separator));
 
-            _supportsMultipleValues = supportsMultipleValues;
-            _separator = separator;
+            if (supportsMultipleValues)
+            {
+                Separator = separator;
+                SeparatorBytes = Encoding.ASCII.GetBytes(separator);
+            }
         }
 
         // If a parser supports multiple values, a call to ParseValue/TryParseValue should return a value for 'index'
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaders.cs b/src/libraries/System.Net.Http/src/System/Net/Http/Headers/HttpHeaders.cs
@@ -258,7 +258,7 @@ public override string ToString()
                 {
                     // Note that if we get multiple values for a header that doesn't support multiple values, we'll
                     // just separate the values using a comma (default separator).
-                    string? separator = entry.Key.Parser is HttpHeaderParser parser && parser.SupportsMultipleValues ? parser.Separator : HttpHeaderParser.DefaultSeparator;
+                    string separator = entry.Key.Separator;
 
                     Debug.Assert(multiValue is not null && multiValue.Length > 0);
                     vsb.Append(multiValue[0]);
@@ -289,8 +289,7 @@ internal string GetHeaderString(HeaderDescriptor descriptor)
 
                 // Note that if we get multiple values for a header that doesn't support multiple values, we'll
                 // just separate the values using a comma (default separator).
-                string? separator = descriptor.Parser != null && descriptor.Parser.SupportsMultipleValues ? descriptor.Parser.Separator : HttpHeaderParser.DefaultSeparator;
-                return string.Join(separator, multiValue!);
+                return string.Join(descriptor.Separator, multiValue!);
             }
 
             return string.Empty;
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
@@ -1365,17 +1365,17 @@ private void WriteLiteralHeader(string name, ReadOnlySpan<string> values, Encodi
             if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(name)}={name}, {nameof(values)}={string.Join(", ", values.ToArray())}");
 
             int bytesWritten;
-            while (!HPackEncoder.EncodeLiteralHeaderFieldWithoutIndexingNewName(name, values, HttpHeaderParser.DefaultSeparator, valueEncoding, headerBuffer.AvailableSpan, out bytesWritten))
+            while (!HPackEncoder.EncodeLiteralHeaderFieldWithoutIndexingNewName(name, values, HttpHeaderParser.DefaultSeparatorBytes, valueEncoding, headerBuffer.AvailableSpan, out bytesWritten))
             {
                 headerBuffer.Grow();
             }
 
             headerBuffer.Commit(bytesWritten);
         }
 
-        private void WriteLiteralHeaderValues(ReadOnlySpan<string> values, string? separator, Encoding? valueEncoding, ref ArrayBuffer headerBuffer)
+        private void WriteLiteralHeaderValues(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, ref ArrayBuffer headerBuffer)
         {
-            if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(values)}={string.Join(separator, values.ToArray())}");
+            if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(values)}={string.Join(Encoding.ASCII.GetString(separator ?? []), values.ToArray())}");
 
             int bytesWritten;
             while (!HPackEncoder.EncodeStringLiterals(values, separator, valueEncoding, headerBuffer.AvailableSpan, out bytesWritten))
@@ -1464,19 +1464,8 @@ private int WriteHeaderCollection(HttpRequestMessage request, HttpHeaders header
 
                         // For all other known headers, send them via their pre-encoded name and the associated value.
                         WriteBytes(knownHeader.Http2EncodedName, ref headerBuffer);
-                        string? separator = null;
-                        if (headerValues.Length > 1)
-                        {
-                            HttpHeaderParser? parser = header.Key.Parser;
-                            if (parser != null && parser.SupportsMultipleValues)
-                            {
-                                separator = parser.Separator;
-                            }
-                            else
-                            {
-                                separator = HttpHeaderParser.DefaultSeparator;
-                            }
-                        }
+
+                        byte[]? separator = headerValues.Length > 1 ? header.Key.SeparatorBytes : null;
 
                         WriteLiteralHeaderValues(headerValues, separator, valueEncoding, ref headerBuffer);
                     }
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3RequestStream.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http3RequestStream.cs
@@ -707,27 +707,16 @@ private int BufferHeaderCollection(HttpHeaders headers)
 
                         // For all other known headers, send them via their pre-encoded name and the associated value.
                         BufferBytes(knownHeader.Http3EncodedName);
-                        string? separator = null;
-                        if (headerValues.Length > 1)
-                        {
-                            HttpHeaderParser? parser = header.Key.Parser;
-                            if (parser != null && parser.SupportsMultipleValues)
-                            {
-                                separator = parser.Separator;
-                            }
-                            else
-                            {
-                                separator = HttpHeaderParser.DefaultSeparator;
-                            }
-                        }
+
+                        byte[]? separator = headerValues.Length > 1 ? header.Key.SeparatorBytes : null;
 
                         BufferLiteralHeaderValues(headerValues, separator, valueEncoding);
                     }
                 }
                 else
                 {
                     // The header is not known: fall back to just encoding the header name and value(s).
-                    BufferLiteralHeaderWithoutNameReference(header.Key.Name, headerValues, HttpHeaderParser.DefaultSeparator, valueEncoding);
+                    BufferLiteralHeaderWithoutNameReference(header.Key.Name, headerValues, HttpHeaderParser.DefaultSeparatorBytes, valueEncoding);
                 }
             }
 
@@ -754,7 +743,7 @@ private void BufferLiteralHeaderWithStaticNameReference(int nameIndex, string va
             _sendBuffer.Commit(bytesWritten);
         }
 
-        private void BufferLiteralHeaderWithoutNameReference(string name, ReadOnlySpan<string> values, string separator, Encoding? valueEncoding)
+        private void BufferLiteralHeaderWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding)
         {
             int bytesWritten;
             while (!QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(name, values, separator, valueEncoding, _sendBuffer.AvailableSpan, out bytesWritten))
@@ -774,7 +763,7 @@ private void BufferLiteralHeaderWithoutNameReference(string name, string value,
             _sendBuffer.Commit(bytesWritten);
         }
 
-        private void BufferLiteralHeaderValues(ReadOnlySpan<string> values, string? separator, Encoding? valueEncoding)
+        private void BufferLiteralHeaderValues(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding)
         {
             int bytesWritten;
             while (!QPackEncoder.EncodeValueString(values, separator, valueEncoding, _sendBuffer.AvailableSpan, out bytesWritten))
diff --git a/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs b/src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs
@@ -414,16 +414,11 @@ private void WriteHeaderCollection(HttpHeaders headers, string? cookiesFromConta
                 // Some headers such as User-Agent and Server use space as a separator (see: ProductInfoHeaderParser)
                 if (headerValuesCount > 1)
                 {
-                    HttpHeaderParser? parser = header.Key.Parser;
-                    string separator = HttpHeaderParser.DefaultSeparator;
-                    if (parser != null && parser.SupportsMultipleValues)
-                    {
-                        separator = parser.Separator!;
-                    }
+                    byte[] separator = header.Key.SeparatorBytes;
 
                     for (int i = 1; i < headerValuesCount; i++)
                     {
-                        WriteAsciiString(separator);
+                        WriteBytes(separator);
                         WriteString(headerValues[i], valueEncoding);
                     }
                 }
diff --git a/src/libraries/System.Net.Http/tests/UnitTests/HPack/HPackRoundtripTests.cs b/src/libraries/System.Net.Http/tests/UnitTests/HPack/HPackRoundtripTests.cs

Original file line number	Diff line number	Diff line change
`@@ -285,12 +285,7 @@ private static bool EncodeLiteralHeaderNewNameCore(byte mask, string name, strin`
`285`	`285`	`}`
`286`	`286`
`287`	`287`	`/// <summary>Encodes a "Literal Header Field without Indexing - New Name".</summary>`
`288`		`- public static bool EncodeLiteralHeaderFieldWithoutIndexingNewName(string name, ReadOnlySpan<string> values, string separator, Span<byte> destination, out int bytesWritten)`
`289`		`- {`
`290`		`- return EncodeLiteralHeaderFieldWithoutIndexingNewName(name, values, separator, valueEncoding: null, destination, out bytesWritten);`
`291`		`- }`
`292`		`-`
`293`		`- public static bool EncodeLiteralHeaderFieldWithoutIndexingNewName(string name, ReadOnlySpan<string> values, string separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)`
	`288`	`+ public static bool EncodeLiteralHeaderFieldWithoutIndexingNewName(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)`
`294`	`289`	`{`
`295`	`290`	`// From https://tools.ietf.org/html/rfc7541#section-6.2.2`
`296`	`291`	`// ------------------------------------------------------`
`@@ -515,12 +510,7 @@ public static bool EncodeDynamicTableSizeUpdate(int value, Span<byte> destinatio`
`515`	`510`	`return false;`
`516`	`511`	`}`
`517`	`512`
`518`		`- public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? separator, Span<byte> destination, out int bytesWritten)`
`519`		`- {`
`520`		`- return EncodeStringLiterals(values, separator, valueEncoding: null, destination, out bytesWritten);`
`521`		`- }`
`522`		`-`
`523`		`- public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)`
	`513`	`+ public static bool EncodeStringLiterals(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)`
`524`	`514`	`{`
`525`	`515`	`bytesWritten = 0;`
`526`	`516`
`@@ -536,23 +526,22 @@ public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? sep`
`536`	`526`	`if (destination.Length != 0)`
`537`	`527`	`{`
`538`	`528`	`Debug.Assert(separator != null);`
`539`		`- int valueLength;`
	`529`	`+ Debug.Assert(Ascii.IsValid(separator));`
	`530`	`+ int valueLength = checked((values.Length - 1) * separator.Length);`
`540`	`531`
`541`		`- // Calculate length of all parts and separators.`
	`532`	`+ // Calculate length of all values.`
`542`	`533`	`if (valueEncoding is null \|\| ReferenceEquals(valueEncoding, Encoding.Latin1))`
`543`	`534`	`{`
`544`		`- valueLength = checked((int)(values.Length - 1) * separator.Length);`
`545`	`535`	`foreach (string part in values)`
`546`	`536`	`{`
`547`		`- valueLength = checked((int)(valueLength + part.Length));`
	`537`	`+ valueLength = checked(valueLength + part.Length);`
`548`	`538`	`}`
`549`	`539`	`}`
`550`	`540`	`else`
`551`	`541`	`{`
`552`		`- valueLength = checked((int)(values.Length - 1) * valueEncoding.GetByteCount(separator));`
`553`	`542`	`foreach (string part in values)`
`554`	`543`	`{`
`555`		`- valueLength = checked((int)(valueLength + valueEncoding.GetByteCount(part)));`
	`544`	`+ valueLength = checked(valueLength + valueEncoding.GetByteCount(part));`
`556`	`545`	`}`
`557`	`546`	`}`
`558`	`547`
`@@ -571,7 +560,7 @@ public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? sep`
`571`	`560`
`572`	`561`	`for (int i = 1; i < values.Length; i++)`
`573`	`562`	`{`
`574`		`- EncodeValueStringPart(separator, destination);`
	`563`	`+ separator.CopyTo(destination);`
`575`	`564`	`destination = destination.Slice(separator.Length);`
`576`	`565`
`577`	`566`	`value = values[i];`
`@@ -586,8 +575,8 @@ public static bool EncodeStringLiterals(ReadOnlySpan<string> values, string? sep`
`586`	`575`
`587`	`576`	`for (int i = 1; i < values.Length; i++)`
`588`	`577`	`{`
`589`		`- written = valueEncoding.GetBytes(separator, destination);`
`590`		`- destination = destination.Slice(written);`
	`578`	`+ separator.CopyTo(destination);`
	`579`	`+ destination = destination.Slice(separator.Length);`
`591`	`580`
`592`	`581`	`written = valueEncoding.GetBytes(values[i], destination);`
`593`	`582`	`destination = destination.Slice(written);`
Original file line number	Diff line number	Diff line change
`@@ -144,14 +144,9 @@ public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, str`
`144`	`144`	`/// <summary>`
`145`	`145`	`/// Encodes a Literal Header Field Without Name Reference, building the value by concatenating a collection of strings with separators.`
`146`	`146`	`/// </summary>`
`147`		`- public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, string valueSeparator, Span<byte> destination, out int bytesWritten)`
	`147`	`+ public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)`
`148`	`148`	`{`
`149`		`- return EncodeLiteralHeaderFieldWithoutNameReference(name, values, valueSeparator, valueEncoding: null, destination, out bytesWritten);`
`150`		`- }`
`151`		`-`
`152`		`- public static bool EncodeLiteralHeaderFieldWithoutNameReference(string name, ReadOnlySpan<string> values, string valueSeparator, Encoding? valueEncoding, Span<byte> destination, out int bytesWritten)`
`153`		`- {`
`154`		`- if (EncodeNameString(name, destination, out int nameLength) && EncodeValueString(values, valueSeparator, valueEncoding, destination.Slice(nameLength), out int valueLength))`
	`149`	`+ if (EncodeNameString(name, destination, out int nameLength) && EncodeValueString(values, separator, valueEncoding, destination.Slice(nameLength), out int valueLength))`
`155`	`150`	`{`
`156`	`151`	`bytesWritten = nameLength + valueLength;`
`157`	`152`	`return true;`
`@@ -222,12 +217,7 @@ private static bool EncodeValueString(string s, Encoding? valueEncoding, Span<by`
`222`	`217`	`/// <summary>`
`223`	`218`	`/// Encodes a value by concatenating a collection of strings, separated by a separator string.`
`224`	`219`	`/// </summary>`
`225`		`- public static bool EncodeValueString(ReadOnlySpan<string> values, string? separator, Span<byte> buffer, out int length)`
`226`		`- {`
`227`		`- return EncodeValueString(values, separator, valueEncoding: null, buffer, out length);`
`228`		`- }`
`229`		`-`
`230`		`- public static bool EncodeValueString(ReadOnlySpan<string> values, string? separator, Encoding? valueEncoding, Span<byte> buffer, out int length)`
	`220`	`+ public static bool EncodeValueString(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding, Span<byte> buffer, out int length)`
`231`	`221`	`{`
`232`	`222`	`if (values.Length == 1)`
`233`	`223`	`{`
`@@ -243,18 +233,18 @@ public static bool EncodeValueString(ReadOnlySpan<string> values, string? separa`
`243`	`233`	`if (buffer.Length > 0)`
`244`	`234`	`{`
`245`	`235`	`Debug.Assert(separator != null);`
`246`		`- int valueLength;`
	`236`	`+ Debug.Assert(Ascii.IsValid(separator));`
	`237`	`+ int valueLength = separator.Length * (values.Length - 1);`
	`238`	`+`
`247`	`239`	`if (valueEncoding is null \|\| ReferenceEquals(valueEncoding, Encoding.Latin1))`
`248`	`240`	`{`
`249`		`- valueLength = separator.Length * (values.Length - 1);`
`250`	`241`	`foreach (string part in values)`
`251`	`242`	`{`
`252`	`243`	`valueLength += part.Length;`
`253`	`244`	`}`
`254`	`245`	`}`
`255`	`246`	`else`
`256`	`247`	`{`
`257`		`- valueLength = valueEncoding.GetByteCount(separator) * (values.Length - 1);`
`258`	`248`	`foreach (string part in values)`
`259`	`249`	`{`
`260`	`250`	`valueLength += valueEncoding.GetByteCount(part);`
`@@ -275,7 +265,7 @@ public static bool EncodeValueString(ReadOnlySpan<string> values, string? separa`
`275`	`265`
`276`	`266`	`for (int i = 1; i < values.Length; i++)`
`277`	`267`	`{`
`278`		`- EncodeValueStringPart(separator, buffer);`
	`268`	`+ separator.CopyTo(buffer);`
`279`	`269`	`buffer = buffer.Slice(separator.Length);`
`280`	`270`
`281`	`271`	`value = values[i];`
`@@ -290,8 +280,8 @@ public static bool EncodeValueString(ReadOnlySpan<string> values, string? separa`
`290`	`280`
`291`	`281`	`for (int i = 1; i < values.Length; i++)`
`292`	`282`	`{`
`293`		`- written = valueEncoding.GetBytes(separator, buffer);`
`294`		`- buffer = buffer.Slice(written);`
	`283`	`+ separator.CopyTo(buffer);`
	`284`	`+ buffer = buffer.Slice(separator.Length);`
`295`	`285`
`296`	`286`	`written = valueEncoding.GetBytes(values[i], buffer);`
`297`	`287`	`buffer = buffer.Slice(written);`
Original file line number	Diff line number	Diff line change
`@@ -277,5 +277,9 @@ private static bool TryDecodeUtf8(ReadOnlySpan<byte> input, [NotNullWhen(true)]`
`277`	`277`	`decoded = null;`
`278`	`278`	`return false;`
`279`	`279`	`}`
	`280`	`+`
	`281`	`+ public string Separator => Parser is { } parser ? parser.Separator : HttpHeaderParser.DefaultSeparator;`
	`282`	`+`
	`283`	`+ public byte[] SeparatorBytes => Parser is { } parser ? parser.SeparatorBytes : HttpHeaderParser.DefaultSeparatorBytes;`
`280`	`284`	`}`
`281`	`285`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ internal HeaderStringValues(HeaderDescriptor descriptor, string[] values)`
`45`	`45`	`public override string ToString() => _value switch`
`46`	`46`	`{`
`47`	`47`	`string value => value,`
`48`		`- string[] values => string.Join(_header.Parser is HttpHeaderParser parser && parser.SupportsMultipleValues ? parser.Separator : HttpHeaderParser.DefaultSeparator, values),`
	`48`	`+ string[] values => string.Join(_header.Separator, values),`
`49`	`49`	`_ => string.Empty,`
`50`	`50`	`};`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -707,27 +707,16 @@ private int BufferHeaderCollection(HttpHeaders headers)`
`707`	`707`
`708`	`708`	`// For all other known headers, send them via their pre-encoded name and the associated value.`
`709`	`709`	`BufferBytes(knownHeader.Http3EncodedName);`
`710`		`- string? separator = null;`
`711`		`- if (headerValues.Length > 1)`
`712`		`- {`
`713`		`- HttpHeaderParser? parser = header.Key.Parser;`
`714`		`- if (parser != null && parser.SupportsMultipleValues)`
`715`		`- {`
`716`		`- separator = parser.Separator;`
`717`		`- }`
`718`		`- else`
`719`		`- {`
`720`		`- separator = HttpHeaderParser.DefaultSeparator;`
`721`		`- }`
`722`		`- }`
	`710`	`+`
	`711`	`+ byte[]? separator = headerValues.Length > 1 ? header.Key.SeparatorBytes : null;`
`723`	`712`
`724`	`713`	`BufferLiteralHeaderValues(headerValues, separator, valueEncoding);`
`725`	`714`	`}`
`726`	`715`	`}`
`727`	`716`	`else`
`728`	`717`	`{`
`729`	`718`	`// The header is not known: fall back to just encoding the header name and value(s).`
`730`		`- BufferLiteralHeaderWithoutNameReference(header.Key.Name, headerValues, HttpHeaderParser.DefaultSeparator, valueEncoding);`
	`719`	`+ BufferLiteralHeaderWithoutNameReference(header.Key.Name, headerValues, HttpHeaderParser.DefaultSeparatorBytes, valueEncoding);`
`731`	`720`	`}`
`732`	`721`	`}`
`733`	`722`
`@@ -754,7 +743,7 @@ private void BufferLiteralHeaderWithStaticNameReference(int nameIndex, string va`
`754`	`743`	`_sendBuffer.Commit(bytesWritten);`
`755`	`744`	`}`
`756`	`745`
`757`		`- private void BufferLiteralHeaderWithoutNameReference(string name, ReadOnlySpan<string> values, string separator, Encoding? valueEncoding)`
	`746`	`+ private void BufferLiteralHeaderWithoutNameReference(string name, ReadOnlySpan<string> values, byte[] separator, Encoding? valueEncoding)`
`758`	`747`	`{`
`759`	`748`	`int bytesWritten;`
`760`	`749`	`while (!QPackEncoder.EncodeLiteralHeaderFieldWithoutNameReference(name, values, separator, valueEncoding, _sendBuffer.AvailableSpan, out bytesWritten))`
`@@ -774,7 +763,7 @@ private void BufferLiteralHeaderWithoutNameReference(string name, string value,`
`774`	`763`	`_sendBuffer.Commit(bytesWritten);`
`775`	`764`	`}`
`776`	`765`
`777`		`- private void BufferLiteralHeaderValues(ReadOnlySpan<string> values, string? separator, Encoding? valueEncoding)`
	`766`	`+ private void BufferLiteralHeaderValues(ReadOnlySpan<string> values, byte[]? separator, Encoding? valueEncoding)`
`778`	`767`	`{`
`779`	`768`	`int bytesWritten;`
`780`	`769`	`while (!QPackEncoder.EncodeValueString(values, separator, valueEncoding, _sendBuffer.AvailableSpan, out bytesWritten))`
Original file line number	Diff line number	Diff line change
`@@ -414,16 +414,11 @@ private void WriteHeaderCollection(HttpHeaders headers, string? cookiesFromConta`
`414`	`414`	`// Some headers such as User-Agent and Server use space as a separator (see: ProductInfoHeaderParser)`
`415`	`415`	`if (headerValuesCount > 1)`
`416`	`416`	`{`
`417`		`- HttpHeaderParser? parser = header.Key.Parser;`
`418`		`- string separator = HttpHeaderParser.DefaultSeparator;`
`419`		`- if (parser != null && parser.SupportsMultipleValues)`
`420`		`- {`
`421`		`- separator = parser.Separator!;`
`422`		`- }`
	`417`	`+ byte[] separator = header.Key.SeparatorBytes;`
`423`	`418`
`424`	`419`	`for (int i = 1; i < headerValuesCount; i++)`
`425`	`420`	`{`
`426`		`- WriteAsciiString(separator);`
	`421`	`+ WriteBytes(separator);`
`427`	`422`	`WriteString(headerValues[i], valueEncoding);`
`428`	`423`	`}`
`429`	`424`	`}`