Synchronously write HTTP responses

Author: Kaliumhexacyanoferrat

Engine/Internal/Protocol/ChunkedStream.cs

@@ -1,6 +1,4 @@
-using GenHTTP.Modules.IO.Streaming;
-
-namespace GenHTTP.Engine.Internal.Protocol;
+namespace GenHTTP.Engine.Internal.Protocol;
 
 /// <summary>
 /// Implements chunked transfer encoding by letting the client
@@ -11,18 +9,8 @@ namespace GenHTTP.Engine.Internal.Protocol;
 /// soon as there is no known content length. To avoid this overhead,
 /// specify the length of your content whenever possible.
 /// </remarks>
-public sealed class ChunkedStream : Stream
+public sealed class ChunkedStream(Stream target) : Stream
 {
-    private static readonly string NL = "\r\n";
-
-    #region Initialization
-
-    public ChunkedStream(Stream target)
-    {
-        Target = target;
-    }
-
-    #endregion
 
     #region Get-/Setters
 
@@ -36,7 +24,7 @@ public ChunkedStream(Stream target)
 
     public override long Position { get => throw new NotSupportedException(); set => throw new NotSupportedException(); }
 
-    private Stream Target { get; }
+    private Stream Target { get; } = target;
 
     #endregion
 
@@ -59,37 +47,37 @@ public override void Write(byte[] buffer, int offset, int count)
 
             Target.Write(buffer, offset, count);
 
-            NL.Write(Target);
+            Target.Write("\r\n"u8);
         }
     }
 
     public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
     {
         if (count > 0)
         {
-            await WriteAsync(count);
+            Write(count);
 
             await Target.WriteAsync(buffer.AsMemory(offset, count), cancellationToken);
 
-            await WriteAsync(NL);
+            Target.Write("\r\n"u8);
         }
     }
 
     public override async ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
     {
         if (!buffer.IsEmpty)
         {
-            await WriteAsync(buffer.Length);
+            Write(buffer.Length);
 
             await Target.WriteAsync(buffer, cancellationToken);
 
-            await WriteAsync(NL);
+            Target.Write("\r\n"u8);
         }
     }
 
-    public async ValueTask FinishAsync()
+    public void Finish()
     {
-        await WriteAsync("0\r\n\r\n");
+        Target.Write("0\r\n\r\n"u8);
     }
 
     public override void Flush()
@@ -99,11 +87,22 @@ public override void Flush()
 
     public override Task FlushAsync(CancellationToken cancellationToken) => Target.FlushAsync(cancellationToken);
 
-    private void Write(int value) => $"{value:X}\r\n".Write(Target);
+    private void Write(int value)
+    {
+        Span<byte> buffer = stackalloc byte[8 + 2];
 
-    private ValueTask WriteAsync(string text) => text.WriteAsync(Target);
+        if (value.TryFormat(buffer, out var written, "X"))
+        {
+            buffer[written++] = (byte)'\r';
+            buffer[written++] = (byte)'\n';
 
-    private ValueTask WriteAsync(int value) => $"{value:X}\r\n".WriteAsync(Target);
+            Target.Write(buffer[..written]);
+        }
+        else
+        {
+            throw new InvalidOperationException("Failed to format chunk size");
+        }
+    }
 
     #endregion