Added Write/WriteLine ReadOnlySpan<char> override to HttpResponseStreamWriter

src/Http/WebUtilities/ref/Microsoft.AspNetCore.WebUtilities.netcoreapp.cs

@@ -161,10 +161,12 @@ public override void Flush() { }
         public override System.Threading.Tasks.Task FlushAsync() { throw null; }
         public override void Write(char value) { }
         public override void Write(char[] values, int index, int count) { }
+        public override void Write(System.ReadOnlySpan<char> values) { }
         public override void Write(string value) { }
         public override System.Threading.Tasks.Task WriteAsync(char value) { throw null; }
         public override System.Threading.Tasks.Task WriteAsync(char[] values, int index, int count) { throw null; }
         public override System.Threading.Tasks.Task WriteAsync(string value) { throw null; }
+        public override void WriteLine(System.ReadOnlySpan<char> values) { }
     }
     [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
     public partial struct KeyValueAccumulator

src/Http/WebUtilities/src/HttpResponseStreamWriter.cs

@@ -127,6 +127,30 @@ public override void Write(char[] values, int index, int count)
             }
         }
 
+        public override void Write(ReadOnlySpan<char> values)
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(nameof(HttpResponseStreamWriter));
+            }
+
+            int written = 0;
+            while (written < values.Length)
+            {
+                if (_charBufferCount == _charBufferSize)
+                {
+                    FlushInternal(flushEncoder: false);
+                }
+
+                written = CopyToCharBuffer(values);
+
+                if (written < values.Length)
+                {
+                    values = values.Slice(written);
+                }
+            };
+        }
+
         public override void Write(string value)
         {
             if (_disposed)
@@ -152,6 +176,17 @@ public override void Write(string value)
             }
         }
 
+        public override void WriteLine(ReadOnlySpan<char> values)
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(nameof(HttpResponseStreamWriter));
+            }
+
+            Write(values);
+            Write(NewLine);
+        }
+
         public override Task WriteAsync(char value)
         {
             if (_disposed)
@@ -423,6 +458,19 @@ private void CopyToCharBuffer(char[] values, ref int index, ref int count)
             count -= remaining;
         }
 
+        private int CopyToCharBuffer(ReadOnlySpan<char> values)
+        {
+            var remaining = Math.Min(_charBufferSize - _charBufferCount, values.Length);
+
+            var source = values.Slice(0, remaining);
+            var destination = new Span<char>(_charBuffer, _charBufferCount, remaining);
+            source.CopyTo(destination);
+
+            _charBufferCount += remaining;
+
+            return remaining;
+        }
+
         [MethodImpl(MethodImplOptions.NoInlining)]
         private static Task GetObjectDisposedTask()
         {

src/Http/WebUtilities/test/HttpResponseStreamWriterTest.cs

@@ -253,6 +253,62 @@ public void WriteCharArray_WritesToStream(int byteLength)
             Assert.Equal(byteLength, stream.Length);
         }
 
+        [Theory]
+        [InlineData(1023)]
+        [InlineData(1024)]
+        [InlineData(1050)]
+        [InlineData(2048)]
+        public void WriteReadOnlySpanChar_WritesToStream(int byteLength)
+        {
+            // Arrange
+            var stream = new TestMemoryStream();
+            var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
+
+            // Act
+            using (writer)
+            {
+                var array = new string('a', byteLength).ToCharArray();
+                var span = new ReadOnlySpan<char>(array);
+                writer.Write(span);
+            }
+
+            // Assert
+            Assert.Equal(byteLength, stream.Length);
+        }
+
+        [Theory]
+        [InlineData(1022, "\n")]
+        [InlineData(1023, "\n")]
+        [InlineData(1024, "\n")]
+        [InlineData(1050, "\n")]
+        [InlineData(2047, "\n")]
+        [InlineData(2048, "\n")]
+        [InlineData(1021, "\r\n")]
+        [InlineData(1022, "\r\n")]
+        [InlineData(1023, "\r\n")]
+        [InlineData(1024, "\r\n")]
+        [InlineData(1050, "\r\n")]
+        [InlineData(2046, "\r\n")]
+        [InlineData(2048, "\r\n")]
+        public void WriteLineReadOnlySpanChar_WritesToStream(int byteLength, string newLine)
+        {
+            // Arrange
+            var stream = new TestMemoryStream();
+            var writer = new HttpResponseStreamWriter(stream, Encoding.UTF8);
+
+            writer.NewLine = newLine;
+            // Act
+            using (writer)
+            {
+                var array = new string('a', byteLength).ToCharArray();
+                var span = new ReadOnlySpan<char>(array);
+                writer.WriteLine(span);
+            }
+
+            // Assert
+            Assert.Equal(byteLength + newLine.Length, stream.Length);
+        }
+
         [Theory]
         [InlineData(1023)]
         [InlineData(1024)]
@@ -539,11 +595,15 @@ public static IEnumerable<object[]> HttpResponseDisposeData()
             {
                  httpResponseStreamWriter.Write(new char[] { 'a', 'b' }, 0, 1);
             })};
-
             yield return new object[] { new Action<HttpResponseStreamWriter>((httpResponseStreamWriter) =>
             {
                 httpResponseStreamWriter.Write("hello");
             })};
+            yield return new object[] { new Action<HttpResponseStreamWriter>((httpResponseStreamWriter) =>
+            {
+                httpResponseStreamWriter.Write(new ReadOnlySpan<char>(new char[] { 'a', 'b' }));
+            })};
+
             yield return new object[] { new Action<HttpResponseStreamWriter>((httpResponseStreamWriter) =>
             {
                 httpResponseStreamWriter.Flush();