Add usage samples.

Add prepared headers.

Author: scalablecory

HttpPrimitives/HttpPrimitives.csproj renamed to NetworkToolkit.Examples/NetworkToolkit.Examples.csproj

@@ -11,6 +11,12 @@ namespace HttpPrimitives
     class Program
     {
         static async Task Main(string[] args)
+        {
+            await RequestSimpleAsync();
+            await PreparedHeadersAsync();
+        }
+
+        static async Task RequestSimpleAsync()
         {
             await using ConnectionFactory connectionFactory = new SocketConnectionFactory();
             await using Connection connection = await connectionFactory.ConnectAsync(new DnsEndPoint("microsoft.com", 80));
@@ -69,6 +75,35 @@ static async Task Main(string[] args)
             }
         }
 
+        static async Task PreparedHeadersAsync()
+        {
+            PreparedHeaderSet preparedHeaders =
+                new PreparedHeaderSetBuilder()
+                .AddHeader("User-Agent", "NetworkToolkit")
+                .AddHeader("Accept", "text/html")
+                .Build();
+
+            await using ConnectionFactory connectionFactory = new SocketConnectionFactory();
+            await using Connection connection = await connectionFactory.ConnectAsync(new DnsEndPoint("microsoft.com", 80));
+            await using HttpConnection httpConnection = new Http1Connection(connection);
+
+            int requestCounter = 0;
+            await SingleRequest();
+            await SingleRequest();
+
+            async Task SingleRequest()
+            {
+                await using ValueHttpRequest request = (await httpConnection.CreateNewRequestAsync(HttpPrimitiveVersion.Version11, HttpVersionPolicy.RequestVersionExact)).Value;
+
+                request.ConfigureRequest(contentLength: 0, hasTrailingHeaders: false);
+                request.WriteRequest(HttpMethod.Get, new Uri("http://microsoft.com"));
+                request.WriteHeader(preparedHeaders);
+                request.WriteHeader("X-Example-RequestNo", requestCounter++.ToString());
+                await request.CompleteRequestAsync();
+                await request.DrainAsync();
+            }
+        }
+
         sealed class PrintingHeadersSink : IHttpHeadersSink
         {
             public void OnHeader(object state, ReadOnlySpan<byte> headerName, ReadOnlySpan<byte> headerValue)

HttpPrimitives/Program.cs renamed to NetworkToolkit.Examples/Program.cs

@@ -7,7 +7,7 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetworkToolkit", "NetworkTo
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{8E172989-D93E-4746-A1A0-39978742AE5F}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "HttpPrimitives", "HttpPrimitives\HttpPrimitives.csproj", "{72B32DEA-6CEA-476F-9A38-B3C89A028127}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NetworkToolkit.Examples", "NetworkToolkit.Examples\NetworkToolkit.Examples.csproj", "{72B32DEA-6CEA-476F-9A38-B3C89A028127}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{1E40D58A-9500-4F40-AED4-39078E5B6C55}"
 EndProject

NetworkToolkit.sln

@@ -276,6 +276,30 @@ internal void WriteHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value)
             _writeBuffer.Commit(len);
         }
 
+        internal void WriteHeader(PreparedHeaderSet headers)
+        {
+            if (headers == null) throw new ArgumentNullException(nameof(headers));
+
+            switch (_writeState)
+            {
+                case WriteState.Unstarted:
+                    throw new InvalidOperationException($"Must call {nameof(ValueHttpRequest)}.{nameof(HttpRequest.WriteRequest)} prior to writing headers.");
+                case WriteState.RequestWritten:
+                    _writeState = WriteState.HeadersWritten;
+                    break;
+                case WriteState.HeadersWritten:
+                    break;
+                default:
+                    throw new InvalidOperationException("Can not write headers after headers have been flushed.");
+            }
+
+            byte[] headersBuffer = headers.Http1Value;
+
+            _writeBuffer.EnsureAvailableSpace(headersBuffer.Length);
+            headersBuffer.AsSpan().CopyTo(_writeBuffer.AvailableSpan);
+            _writeBuffer.Commit(headersBuffer.Length);
+        }
+
         internal void WriteTrailingHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value)
         {
             if (!_requestIsChunked)
@@ -321,7 +345,7 @@ internal static int GetEncodeHeaderLength(ReadOnlySpan<byte> name, ReadOnlySpan<
             return name.Length + value.Length + 4; // {name}: {value}\r\n
         }
 
-        internal static unsafe void EncodeHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value, Span<byte> buffer)
+        internal static unsafe int EncodeHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value, Span<byte> buffer)
         {
             Debug.Assert(name.Length > 0);
             Debug.Assert(buffer.Length >= GetEncodeHeaderLength(name, value));
@@ -345,6 +369,8 @@ internal static unsafe void EncodeHeader(ReadOnlySpan<byte> name, ReadOnlySpan<b
 
             int length = (int)(void*)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(buffer), ref pBuf);
             Debug.Assert(length == GetEncodeHeaderLength(name, value));
+
+            return length;
         }
 
         private void WriteCRLF()

NetworkToolkit/Http/Primitives/Http1Connection.cs

@@ -77,6 +77,12 @@ protected internal override void WriteHeader(int version, ReadOnlySpan<byte> nam
             _connection.WriteHeader(name, value);
         }
 
+        protected internal override void WriteHeader(int version, PreparedHeaderSet headers)
+        {
+            ThrowIfDisposed(version);
+            _connection.WriteHeader(headers);
+        }
+
         protected internal override void WriteTrailingHeader(int version, ReadOnlySpan<byte> name, ReadOnlySpan<byte> value)
         {
             ThrowIfDisposed(version);

NetworkToolkit/Http/Primitives/Http1Request.cs

@@ -127,6 +127,13 @@ public ValueHttpRequest GetValueRequest()
         /// <param name="value">The value of the header to write.</param>
         protected internal abstract void WriteHeader(int version, ReadOnlySpan<byte> name, ReadOnlySpan<byte> value);
 
+        /// <summary>
+        /// Writes a set of headers.
+        /// </summary>
+        /// <param name="version">The version of the request to operate on. This must be validated by implementations.</param>
+        /// <param name="headers">A set of headers to write to the request.</param>
+        protected internal abstract void WriteHeader(int version, PreparedHeaderSet headers);
+
         /// <summary>
         /// Writes a trailing header.
         /// To use, trailing headers must be enabled during <see cref="ConfigureRequest(int, long?, bool)"/>.

NetworkToolkit/Http/Primitives/HttpRequest.cs

@@ -452,6 +452,12 @@ protected internal override void WriteHeader(int version, ReadOnlySpan<byte> nam
                 _request.WriteHeader(name, value);
             }
 
+            protected internal override void WriteHeader(int version, PreparedHeaderSet headers)
+            {
+                ThrowIfDisposed(version);
+                _request.WriteHeader(headers);
+            }
+
             protected internal override void WriteHeader(int version, string name, string value)
             {
                 ThrowIfDisposed(version);
@@ -487,6 +493,12 @@ protected internal override void WriteRequest(int version, ReadOnlySpan<byte> me
                 ThrowIfDisposed(version);
                 _request.WriteRequest(method, scheme, authority, pathAndQuery);
             }
+
+            protected internal override void WriteRequest(int version, HttpMethod method, Uri uri)
+            {
+                ThrowIfDisposed(version);
+                _request.WriteRequest(method, uri);
+            }
         }
     }
 }

NetworkToolkit/Http/Primitives/PooledHttpConnection.cs

@@ -0,0 +1,38 @@
+using System;
+using System.Text;
+
+namespace NetworkToolkit.Http.Primitives
+{
+    /// <summary>
+    /// A prepared header.
+    /// </summary>
+    public sealed class PreparedHeader
+    {
+        internal readonly byte[] _headerName, _headerValue;
+
+        /// <summary>
+        /// Instantiates a new <see cref="PreparedHeader"/>.
+        /// </summary>
+        /// <param name="headerName">The header's name.</param>
+        /// <param name="headerValue">The header's value.</param>
+        public PreparedHeader(ReadOnlySpan<byte> headerName, ReadOnlySpan<byte> headerValue)
+        {
+            _headerName = headerName.ToArray();
+            _headerValue = headerValue.ToArray();
+        }
+
+        /// <summary>
+        /// Instantiates a new <see cref="PreparedHeader"/>.
+        /// </summary>
+        /// <param name="headerName">The header's name.</param>
+        /// <param name="headerValue">The header's value.</param>
+        public PreparedHeader(string headerName, string headerValue)
+        {
+            _headerName = Encoding.ASCII.GetBytes(headerName);
+            _headerValue = Encoding.ASCII.GetBytes(headerValue);
+        }
+
+        /// <inheritdoc/>
+        public override string ToString() => Encoding.ASCII.GetString(_headerName) + ": " + Encoding.ASCII.GetString(_headerValue);
+    }
+}

NetworkToolkit/Http/Primitives/PreparedHeader.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace NetworkToolkit.Http.Primitives
+{
+    /// <summary>
+    /// A set of prepared headers, used to more efficiently write frequently reused headers.
+    /// </summary>
+    public sealed class PreparedHeaderSet
+    {
+        readonly PreparedHeader[] _headers;
+
+        byte[]? _http1Value;
+        internal byte[] Http1Value => _http1Value ?? GetHttp1ValueSlow();
+
+        internal PreparedHeaderSet(List<PreparedHeader> headers)
+        {
+            _headers = headers.ToArray();
+        }
+
+        /// <inheritdoc/>
+        public override string ToString() => Encoding.ASCII.GetString(Http1Value);
+
+        private byte[] GetHttp1ValueSlow()
+        {
+            int totalLen = 0;
+            foreach (PreparedHeader header in _headers)
+            {
+                int headerLen = Http1Connection.GetEncodeHeaderLength(header._headerName, header._headerValue);
+                totalLen = checked(totalLen + headerLen);
+            }
+
+            var buffer = new byte[totalLen];
+            Span<byte> writePos = buffer;
+
+            foreach (PreparedHeader header in _headers)
+            {
+                int len = Http1Connection.EncodeHeader(header._headerName, header._headerValue, writePos);
+                writePos = writePos.Slice(len);
+            }
+
+            Volatile.Write(ref _http1Value, buffer);
+            return buffer;
+        }
+    }
+}

NetworkToolkit/Http/Primitives/PreparedHeaderSet.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace NetworkToolkit.Http.Primitives
+{
+    /// <summary>
+    /// A builder used to create a <see cref="PreparedHeaderSet"/>.
+    /// </summary>
+    public sealed class PreparedHeaderSetBuilder
+    {
+        private readonly List<PreparedHeader> _headers = new List<PreparedHeader>();
+
+        /// <summary>
+        /// Adds a header to the builder.
+        /// </summary>
+        /// <param name="header">The header to add.</param>
+        public PreparedHeaderSetBuilder AddHeader(PreparedHeader header)
+        {
+            _headers.Add(header);
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a header to the builder.
+        /// </summary>
+        /// <param name="name">The name of the header to add.</param>
+        /// <param name="value">The value of the header to add.</param>
+        public PreparedHeaderSetBuilder AddHeader(ReadOnlySpan<byte> name, ReadOnlySpan<byte> value)
+        {
+            _headers.Add(new PreparedHeader(name, value));
+            return this;
+        }
+
+        /// <summary>
+        /// Adds a header to the builder.
+        /// </summary>
+        /// <param name="name">The name of the header to add.</param>
+        /// <param name="value">The value of the header to add.</param>
+        public PreparedHeaderSetBuilder AddHeader(string name, string value)
+        {
+            _headers.Add(new PreparedHeader(name, value));
+            return this;
+        }
+
+        /// <summary>
+        /// Builds a <see cref="PreparedHeaderSet"/>.
+        /// </summary>
+        /// <returns>A <see cref="PreparedHeaderSet"/> instance representing the given headers</returns>
+        public PreparedHeaderSet Build() => new PreparedHeaderSet(_headers);
+    }
+}