.ConfigureAwait(false) in SignalR client libraries

Author: halter73

src/SignalR/clients/csharp/.editorconfig

@@ -0,0 +1,4 @@
+[*.{cs,vb}]
+
+# CA2007: Consider calling ConfigureAwait on the awaited task
+dotnet_diagnostic.CA2007.severity = warning

src/SignalR/clients/csharp/Client.Core/src/HubConnection.cs

@@ -274,7 +274,7 @@ public static async Task<TResult> InvokeCoreAsync<TResult>(this HubConnection hu
             throw new ArgumentNullException(nameof(hubConnection));
         }
 
-        return (TResult)(await hubConnection.InvokeCoreAsync(methodName, typeof(TResult), args, cancellationToken))!;
+        return (TResult)(await hubConnection.InvokeCoreAsync(methodName, typeof(TResult), args, cancellationToken).ConfigureAwait(false))!;
     }
 
 }

src/SignalR/clients/csharp/Client.Core/src/HubConnectionExtensions.InvokeAsyncGeneric.cs

@@ -275,7 +275,7 @@ public static async Task<ChannelReader<TResult>> StreamAsChannelCoreAsync<TResul
             throw new ArgumentNullException(nameof(hubConnection));
         }
 
-        var inputChannel = await hubConnection.StreamAsChannelCoreAsync(methodName, typeof(TResult), args, cancellationToken);
+        var inputChannel = await hubConnection.StreamAsChannelCoreAsync(methodName, typeof(TResult), args, cancellationToken).ConfigureAwait(false);
         var outputChannel = Channel.CreateUnbounded<TResult>();
 
         // Intentionally avoid passing the CancellationToken to RunChannel. The token is only meant to cancel the intial setup, not the enumeration.
@@ -290,13 +290,13 @@ private static async Task RunChannel<TResult>(ChannelReader<object?> inputChanne
     {
         try
         {
-            while (await inputChannel.WaitToReadAsync())
+            while (await inputChannel.WaitToReadAsync().ConfigureAwait(false))
             {
                 while (inputChannel.TryRead(out var item))
                 {
                     while (!outputChannel.Writer.TryWrite((TResult)item!))
                     {
-                        if (!await outputChannel.Writer.WaitToWriteAsync())
+                        if (!await outputChannel.Writer.WaitToWriteAsync().ConfigureAwait(false))
                         {
                             // Failed to write to the output channel because it was closed. Nothing really we can do but abort here.
                             return;
@@ -306,7 +306,7 @@ private static async Task RunChannel<TResult>(ChannelReader<object?> inputChanne
             }
 
             // Manifest any errors in the completion task
-            await inputChannel.Completion;
+            await inputChannel.Completion.ConfigureAwait(false);
         }
         catch (Exception ex)
         {

src/SignalR/clients/csharp/Client.Core/src/HubConnectionExtensions.StreamAsChannelAsync.cs

@@ -106,7 +106,7 @@ public override async ValueTask<bool> StreamItem(object? item)
             {
                 while (!_channel.Writer.TryWrite(item))
                 {
-                    if (!await _channel.Writer.WaitToWriteAsync())
+                    if (!await _channel.Writer.WaitToWriteAsync().ConfigureAwait(false))
                     {
                         return false;
                     }

src/SignalR/clients/csharp/Client.Core/src/Internal/InvocationRequest.cs

@@ -0,0 +1,4 @@
+[*.{cs,vb}]
+
+# CA2007: Consider calling ConfigureAwait on the awaited task
+dotnet_diagnostic.CA2007.severity = silent

src/SignalR/clients/csharp/Client/test/.editorconfig

@@ -204,7 +204,7 @@ public async Task StartAsync(TransferFormat transferFormat, CancellationToken ca
     {
         using (_logger.BeginScope(_logScope))
         {
-            await StartAsyncCore(transferFormat, cancellationToken);
+            await StartAsyncCore(transferFormat, cancellationToken).ConfigureAwait(false);
         }
     }
 
@@ -218,7 +218,7 @@ private async Task StartAsyncCore(TransferFormat transferFormat, CancellationTok
             return;
         }
 
-        await _connectionLock.WaitAsync(cancellationToken);
+        await _connectionLock.WaitAsync(cancellationToken).ConfigureAwait(false);
         try
         {
             CheckDisposed();
@@ -231,7 +231,7 @@ private async Task StartAsyncCore(TransferFormat transferFormat, CancellationTok
 
             Log.Starting(_logger);
 
-            await SelectAndStartTransport(transferFormat, cancellationToken);
+            await SelectAndStartTransport(transferFormat, cancellationToken).ConfigureAwait(false);
 
             _started = true;
             Log.Started(_logger);
@@ -254,7 +254,7 @@ public override async ValueTask DisposeAsync()
     {
         using (_logger.BeginScope(_logScope))
         {
-            await DisposeAsyncCore();
+            await DisposeAsyncCore().ConfigureAwait(false);
         }
     }
 
@@ -265,7 +265,7 @@ private async Task DisposeAsyncCore()
             return;
         }
 
-        await _connectionLock.WaitAsync();
+        await _connectionLock.WaitAsync().ConfigureAwait(false);
         try
         {
             if (!_disposed && _started)
@@ -276,7 +276,7 @@ private async Task DisposeAsyncCore()
                 // The transport should also have completed the pipe with this exception.
                 try
                 {
-                    await _transport!.StopAsync();
+                    await _transport!.StopAsync().ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {
@@ -317,7 +317,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat, Cancel
             if (_httpConnectionOptions.Transports == HttpTransportType.WebSockets)
             {
                 Log.StartingTransport(_logger, _httpConnectionOptions.Transports, uri);
-                await StartTransport(uri, _httpConnectionOptions.Transports, transferFormat, cancellationToken);
+                await StartTransport(uri, _httpConnectionOptions.Transports, transferFormat, cancellationToken).ConfigureAwait(false);
             }
             else
             {
@@ -331,7 +331,7 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat, Cancel
 
             do
             {
-                negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken);
+                negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken).ConfigureAwait(false);
 
                 if (negotiationResponse.Url != null)
                 {
@@ -402,12 +402,12 @@ private async Task SelectAndStartTransport(TransferFormat transferFormat, Cancel
                         // The negotiation response gets cleared in the fallback scenario.
                         if (negotiationResponse == null)
                         {
-                            negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken);
+                            negotiationResponse = await GetNegotiationResponseAsync(uri, cancellationToken).ConfigureAwait(false);
                             connectUrl = CreateConnectUrl(uri, negotiationResponse.ConnectionToken);
                         }
 
                         Log.StartingTransport(_logger, transportType, uri);
-                        await StartTransport(connectUrl, transportType, transferFormat, cancellationToken);
+                        await StartTransport(connectUrl, transportType, transferFormat, cancellationToken).ConfigureAwait(false);
                         break;
                     }
                 }
@@ -468,11 +468,11 @@ private async Task<NegotiationResponse> NegotiateAsync(Uri url, HttpClient httpC
                 // rather than buffer the entire response. This gives a small perf boost.
                 // Note that it is important to dispose of the response when doing this to
                 // avoid leaving the connection open.
-                using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken))
+                using (var response = await httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))
                 {
                     response.EnsureSuccessStatusCode();
 #pragma warning disable CA2016 // Forward the 'CancellationToken' parameter to methods
-                    var responseBuffer = await response.Content.ReadAsByteArrayAsync();
+                    var responseBuffer = await response.Content.ReadAsByteArrayAsync().ConfigureAwait(false);
 #pragma warning restore CA2016 // Forward the 'CancellationToken' parameter to methods
                     var negotiateResponse = NegotiateProtocol.ParseResponse(responseBuffer);
                     if (!string.IsNullOrEmpty(negotiateResponse.Error))
@@ -509,7 +509,7 @@ private async Task StartTransport(Uri connectUrl, HttpTransportType transportTyp
         // Start the transport, giving it one end of the pipe
         try
         {
-            await transport.StartAsync(connectUrl, transferFormat, cancellationToken);
+            await transport.StartAsync(connectUrl, transferFormat, cancellationToken).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
@@ -683,7 +683,7 @@ private static bool IsWebSocketsSupported()
 
     private async Task<NegotiationResponse> GetNegotiationResponseAsync(Uri uri, CancellationToken cancellationToken)
     {
-        var negotiationResponse = await NegotiateAsync(uri, _httpClient!, _logger, cancellationToken);
+        var negotiationResponse = await NegotiateAsync(uri, _httpClient!, _logger, cancellationToken).ConfigureAwait(false);
         // If the negotiationVersion is greater than zero then we know that the negotiation response contains a
         // connectionToken that will be required to conenct. Otherwise we just set the connectionId and the
         // connectionToken on the client to the same value.

src/SignalR/clients/csharp/Http.Connections.Client/src/HttpConnection.cs

@@ -68,13 +68,13 @@ public async ValueTask<ConnectionContext> ConnectAsync(EndPoint endPoint, Cancel
 
         try
         {
-            await connection.StartAsync(cancellationToken);
+            await connection.StartAsync(cancellationToken).ConfigureAwait(false);
             return connection;
         }
         catch
         {
             // Make sure the connection is disposed, in case it allocated any resources before failing.
-            await connection.DisposeAsync();
+            await connection.DisposeAsync().ConfigureAwait(false);
             throw;
         }
     }

src/SignalR/clients/csharp/Http.Connections.Client/src/HttpConnectionFactory.cs

@@ -19,13 +19,13 @@ public AccessTokenHttpMessageHandler(HttpMessageHandler inner, HttpConnection ht
 
     protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
     {
-        var accessToken = await _httpConnection.GetAccessTokenAsync();
+        var accessToken = await _httpConnection.GetAccessTokenAsync().ConfigureAwait(false);
 
         if (!string.IsNullOrEmpty(accessToken))
         {
             request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
         }
 
-        return await base.SendAsync(request, cancellationToken);
+        return await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
     }
 }

src/SignalR/clients/csharp/Http.Connections.Client/src/Internal/AccessTokenHttpMessageHandler.cs

@@ -28,7 +28,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
     {
         Log.SendingHttpRequest(_logger, request.Method, request.RequestUri!);
 
-        var response = await base.SendAsync(request, cancellationToken);
+        var response = await base.SendAsync(request, cancellationToken).ConfigureAwait(false);
 
         if (!response.IsSuccessStatusCode)
         {