Made handler project compatible with .NET Standard 2.0

Author: TalAloni

StandardSocketsHttpHandler/Net/Http/SocketsHttpHandler/ChunkedEncodingReadStream.cs

@@ -30,40 +30,46 @@ private sealed class ChunkedEncodingReadStream : HttpContentReadStream
 
             public ChunkedEncodingReadStream(HttpConnection connection) : base(connection) { }
 
-            public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
+            public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            {
+                ValidateBufferArgs(buffer, offset, count);
+                return ReadAsyncInternal(new Memory<byte>(buffer, offset, count), cancellationToken);
+            }
+
+            private Task<int> ReadAsyncInternal(Memory<byte> buffer, CancellationToken cancellationToken)
             {
                 if (cancellationToken.IsCancellationRequested)
                 {
                     // Cancellation requested.
-                    return new ValueTask<int>(Task.FromCanceled<int>(cancellationToken));
+                    return Task.FromCanceled<int>(cancellationToken);
                 }
 
                 if (_connection == null || buffer.Length == 0)
                 {
                     // Response body fully consumed or the caller didn't ask for any data.
-                    return new ValueTask<int>(0);
+                    return Task.FromResult(0);
                 }
 
                 // Try to consume from data we already have in the buffer.
-                int bytesRead = ReadChunksFromConnectionBuffer(buffer.Span, cancellationRegistration: default);
+                int bytesRead = ReadChunksFromConnectionBuffer(buffer.Span, cancellationRegistration: default, cancellationToken);
                 if (bytesRead > 0)
                 {
-                    return new ValueTask<int>(bytesRead);
+                    return Task.FromResult(bytesRead);
                 }
 
                 // We may have just consumed the remainder of the response (with no actual data
                 // available), so check again.
                 if (_connection == null)
                 {
                     Debug.Assert(_state == ParsingState.Done);
-                    return new ValueTask<int>(0);
+                    return Task.FromResult(0);
                 }
 
                 // Nothing available to consume.  Fall back to I/O.
                 return ReadAsyncCore(buffer, cancellationToken);
             }
 
-            private async ValueTask<int> ReadAsyncCore(Memory<byte> buffer, CancellationToken cancellationToken)
+            private async Task<int> ReadAsyncCore(Memory<byte> buffer, CancellationToken cancellationToken)
             {
                 // Should only be called if ReadChunksFromConnectionBuffer returned 0.
 
@@ -108,7 +114,7 @@ private async ValueTask<int> ReadAsyncCore(Memory<byte> buffer, CancellationToke
 
                         // Now that we have more, see if we can get any response data, and if
                         // we can we're done.
-                        int bytesCopied = ReadChunksFromConnectionBuffer(buffer.Span, ctr);
+                        int bytesCopied = ReadChunksFromConnectionBuffer(buffer.Span, ctr, cancellationToken);
                         if (bytesCopied > 0)
                         {
                             return bytesCopied;
@@ -144,7 +150,7 @@ private async Task CopyToAsyncCore(Stream destination, CancellationToken cancell
                     {
                         while (true)
                         {
-                            ReadOnlyMemory<byte> bytesRead = ReadChunkFromConnectionBuffer(int.MaxValue, ctr);
+                            ReadOnlyMemory<byte> bytesRead = ReadChunkFromConnectionBuffer(int.MaxValue, ctr, cancellationToken);
                             if (bytesRead.Length == 0)
                             {
                                 break;
@@ -171,12 +177,12 @@ private async Task CopyToAsyncCore(Stream destination, CancellationToken cancell
                 }
             }
 
-            private int ReadChunksFromConnectionBuffer(Span<byte> buffer, CancellationTokenRegistration cancellationRegistration)
+            private int ReadChunksFromConnectionBuffer(Span<byte> buffer, CancellationTokenRegistration cancellationRegistration, CancellationToken cancellationToken)
             {
                 int totalBytesRead = 0;
                 while (buffer.Length > 0)
                 {
-                    ReadOnlyMemory<byte> bytesRead = ReadChunkFromConnectionBuffer(buffer.Length, cancellationRegistration);
+                    ReadOnlyMemory<byte> bytesRead = ReadChunkFromConnectionBuffer(buffer.Length, cancellationRegistration, cancellationToken);
                     Debug.Assert(bytesRead.Length <= buffer.Length);
                     if (bytesRead.Length == 0)
                     {
@@ -190,7 +196,7 @@ private int ReadChunksFromConnectionBuffer(Span<byte> buffer, CancellationTokenR
                 return totalBytesRead;
             }
 
-            private ReadOnlyMemory<byte> ReadChunkFromConnectionBuffer(int maxBytesToRead, CancellationTokenRegistration cancellationRegistration)
+            private ReadOnlyMemory<byte> ReadChunkFromConnectionBuffer(int maxBytesToRead, CancellationTokenRegistration cancellationRegistration, CancellationToken cancellationToken = default)
             {
                 Debug.Assert(maxBytesToRead > 0);
 
@@ -295,7 +301,7 @@ private ReadOnlyMemory<byte> ReadChunkFromConnectionBuffer(int maxBytesToRead, C
                                     // (e.g. if a timer is used and has already queued its callback but the
                                     // callback hasn't yet run).
                                     cancellationRegistration.Dispose();
-                                    CancellationHelper.ThrowIfCancellationRequested(cancellationRegistration.Token);
+                                    CancellationHelper.ThrowIfCancellationRequested(cancellationToken);
 
                                     _state = ParsingState.Done;
                                     _connection.CompleteResponse();

StandardSocketsHttpHandler/Net/Http/SocketsHttpHandler/ChunkedEncodingWriteStream.cs

@@ -18,19 +18,24 @@ public ChunkedEncodingWriteStream(HttpConnection connection) : base(connection)
             {
             }
 
-            public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken ignored)
+            public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken ignored)
+            {
+                return WriteAsyncInternal(new ReadOnlyMemory<byte>(buffer, offset, count), ignored);
+            }
+
+            private Task WriteAsyncInternal(ReadOnlyMemory<byte> buffer, CancellationToken ignored)
             {
                 Debug.Assert(_connection._currentRequest != null);
 
                 // The token is ignored because it's coming from SendAsync and the only operations
                 // here are those that are already covered by the token having been registered with
                 // to close the connection.
 
-                ValueTask task = buffer.Length == 0 ?
+                Task task = buffer.Length == 0 ?
                     // Don't write if nothing was given, especially since we don't want to accidentally send a 0 chunk,
                     // which would indicate end of body.  Instead, just ensure no content is stuck in the buffer.
                     _connection.FlushAsync() :
-                    new ValueTask(WriteChunkAsync(buffer));
+                    WriteChunkAsync(buffer);
 
                 return task;
             }

StandardSocketsHttpHandler/Net/Http/SocketsHttpHandler/ConnectHelper.cs

@@ -37,7 +37,7 @@ public CertificateCallbackMapper(Func<HttpRequestMessage, X509Certificate2, X509
             }
         }
 
-        public static async ValueTask<(Socket, Stream)> ConnectAsync(string host, int port, CancellationToken cancellationToken)
+        public static async Task<(Socket, Stream)> ConnectAsync(string host, int port, CancellationToken cancellationToken)
         {
             // Rather than creating a new Socket and calling ConnectAsync on it, we use the static
             // Socket.ConnectAsync with a SocketAsyncEventArgs, as we can then use Socket.CancelConnectAsync
@@ -139,7 +139,7 @@ protected override void OnCompleted(SocketAsyncEventArgs _)
             }
         }
 
-        public static ValueTask<SslStream> EstablishSslConnectionAsync(SslClientAuthenticationOptions sslOptions, HttpRequestMessage request, Stream stream, CancellationToken cancellationToken)
+        public static Task<SslStream> EstablishSslConnectionAsync(SslClientAuthenticationOptions sslOptions, HttpRequestMessage request, Stream stream, CancellationToken cancellationToken)
         {
             // If there's a cert validation callback, and if it came from HttpClientHandler,
             // wrap the original delegate in order to change the sender to be the request message (expected by HttpClientHandler's delegate).
@@ -157,7 +157,7 @@ public static ValueTask<SslStream> EstablishSslConnectionAsync(SslClientAuthenti
             return EstablishSslConnectionAsyncCore(stream, sslOptions, cancellationToken);
         }
 
-        private static async ValueTask<SslStream> EstablishSslConnectionAsyncCore(Stream stream, SslClientAuthenticationOptions sslOptions, CancellationToken cancellationToken)
+        private static async Task<SslStream> EstablishSslConnectionAsyncCore(Stream stream, SslClientAuthenticationOptions sslOptions, CancellationToken cancellationToken)
         {
             SslStream sslStream = new SslStream(stream, false, sslOptions.RemoteCertificateValidationCallback, sslOptions.LocalCertificateSelectionCallback, sslOptions.EncryptionPolicy);
 

StandardSocketsHttpHandler/Net/Http/SocketsHttpHandler/ConnectionCloseReadStream.cs

@@ -16,7 +16,13 @@ public ConnectionCloseReadStream(HttpConnection connection) : base(connection)
             {
             }
 
-            public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
+            public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            {
+                ValidateBufferArgs(buffer, offset, count);
+                return ReadAsyncInternal(new Memory<byte>(buffer, offset, count), cancellationToken);
+            }
+
+            private async Task<int> ReadAsyncInternal(Memory<byte> buffer, CancellationToken cancellationToken)
             {
                 CancellationHelper.ThrowIfCancellationRequested(cancellationToken);
 
@@ -26,9 +32,9 @@ public override async ValueTask<int> ReadAsync(Memory<byte> buffer, Cancellation
                     return 0;
                 }
 
-                ValueTask<int> readTask = _connection.ReadAsync(buffer);
+                Task<int> readTask = _connection.ReadAsync(buffer);
                 int bytesRead;
-                if (readTask.IsCompletedSuccessfully)
+                if (readTask.IsCompletedSuccessfully())
                 {
                     bytesRead = readTask.Result;
                 }

StandardSocketsHttpHandler/Net/Http/SocketsHttpHandler/ContentLengthReadStream.cs

@@ -21,7 +21,13 @@ public ContentLengthReadStream(HttpConnection connection, ulong contentLength) :
                 _contentBytesRemaining = contentLength;
             }
 
-            public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken)
+            public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            {
+                ValidateBufferArgs(buffer, offset, count);
+                return ReadAsyncInternal(new Memory<byte>(buffer, offset, count), cancellationToken);
+            }
+
+            private async Task<int> ReadAsyncInternal(Memory<byte> buffer, CancellationToken cancellationToken)
             {
                 CancellationHelper.ThrowIfCancellationRequested(cancellationToken);
 
@@ -38,9 +44,9 @@ public override async ValueTask<int> ReadAsync(Memory<byte> buffer, Cancellation
                     buffer = buffer.Slice(0, (int)_contentBytesRemaining);
                 }
 
-                ValueTask<int> readTask = _connection.ReadAsync(buffer);
+                Task<int> readTask = _connection.ReadAsync(buffer);
                 int bytesRead;
-                if (readTask.IsCompletedSuccessfully)
+                if (readTask.IsCompletedSuccessfully())
                 {
                     bytesRead = readTask.Result;
                 }
@@ -198,7 +204,10 @@ public override async Task<bool> DrainAsync(int maxDrainBytes)
                             // (e.g. if a timer is used and has already queued its callback but the
                             // callback hasn't yet run).
                             ctr.Dispose();
-                            CancellationHelper.ThrowIfCancellationRequested(ctr.Token);
+                            if (cts != null)
+                            {
+                                CancellationHelper.ThrowIfCancellationRequested(cts.Token);
+                            }
 
                             Finish();
                             return true;

StandardSocketsHttpHandler/Net/Http/SocketsHttpHandler/ContentLengthWriteStream.cs

@@ -16,14 +16,19 @@ public ContentLengthWriteStream(HttpConnection connection) : base(connection)
             {
             }
 
-            public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken ignored) // token ignored as it comes from SendAsync
+            public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken ignored) // token ignored as it comes from SendAsync
+            {
+                return WriteAsyncInternal(new ReadOnlyMemory<byte>(buffer, offset, count), ignored);
+            }
+
+            private Task WriteAsyncInternal(ReadOnlyMemory<byte> buffer, CancellationToken ignored) // token ignored as it comes from SendAsync
             {
                 Debug.Assert(_connection._currentRequest != null);
 
                 // Have the connection write the data, skipping the buffer. Importantly, this will
                 // force a flush of anything already in the buffer, i.e. any remaining request headers
                 // that are still buffered.
-                return new ValueTask(_connection.WriteAsync(buffer));
+                return _connection.WriteAsync(buffer);
             }
 
             public override Task FinishAsync()

StandardSocketsHttpHandler/Net/Http/SocketsHttpHandler/EmptyReadStream.cs

@@ -22,11 +22,11 @@ public override void Close() { /* nop */ }
 
             public override int ReadByte() => -1;
 
-            public override int Read(Span<byte> buffer) => 0;
-
-            public override ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken) =>
-                cancellationToken.IsCancellationRequested ? new ValueTask<int>(Task.FromCanceled<int>(cancellationToken)) :
-                new ValueTask<int>(0);
+            public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            {
+                ValidateBufferArgs(buffer, offset, count);
+                return cancellationToken.IsCancellationRequested? Task.FromCanceled<int>(cancellationToken) : Task.FromResult<int>(0);
+            }
         }
     }
 }