added ConfigureAwait(false) on awaited tasks.

zaptech\jun.zhu · darkl · commit 491fc97e3b1c · 2018-01-15T17:43:35.000-05:00
diff --git a/src/net45/Extensions/WampSharp.Owin/Owin/OwinWebSocketTransport.cs b/src/net45/Extensions/WampSharp.Owin/Owin/OwinWebSocketTransport.cs
@@ -81,7 +81,7 @@ private Task HttpHandler(IOwinContext context, Func<Task> next)
 
         private async Task EmptyHandler(IOwinContext owinContext, Func<Task> next)
         {
-            await next();
+            await next().ConfigureAwait(false);
         }
 
         private async Task WebSocketHandler(IOwinContext context, Func<Task> next)
@@ -110,7 +110,7 @@ private async Task WebSocketHandler(IOwinContext context, Func<Task> next)
                 }
             }
 
-            await next();
+            await next().ConfigureAwait(false);
         }
 
         private async Task OnAccept(IDictionary<string, object> webSocketContext, IOwinContext context, string subprotocol)
diff --git a/src/net45/Extensions/WampSharp.RawSocket/RawSocket/NetworkStreamExtensions.cs b/src/net45/Extensions/WampSharp.RawSocket/RawSocket/NetworkStreamExtensions.cs
@@ -18,7 +18,7 @@ public async static Task ReadExactAsync(this NetworkStream networkStream, byte[]
 
             while (readBytes != length)
             {
-                int currentlyRead = await networkStream.ReadAsync(buffer, currentPosition, length - readBytes);
+                int currentlyRead = await networkStream.ReadAsync(buffer, currentPosition, length - readBytes).ConfigureAwait(false);
 
                 // If we read 0 bytes, we have reached the end of the stream.
                 if (currentlyRead == 0)
diff --git a/src/net45/Extensions/WampSharp.RawSocket/RawSocket/RawSocketClientConnection.cs b/src/net45/Extensions/WampSharp.RawSocket/RawSocket/RawSocketClientConnection.cs
@@ -81,7 +81,7 @@ public async void Connect()
         {
             if (mConnection == null)
             {
-                await InnerConnect();
+                await InnerConnect().ConfigureAwait(false);
             }
         }
 
@@ -91,13 +91,13 @@ private async Task InnerConnect()
             {
                 mClient = mClientBuilder();
 
-                await mConnector(mClient);
+                await mConnector(mClient).ConfigureAwait(false);
 
                 Handshake handshakeRequest = GetHandshakeRequest();
 
-                await mHandshaker.SendHandshake(mClient, handshakeRequest);
+                await mHandshaker.SendHandshake(mClient, handshakeRequest).ConfigureAwait(false);
 
-                Handshake handshakeResponse = await mHandshaker.GetHandshakeMessage(mClient);
+                Handshake handshakeResponse = await mHandshaker.GetHandshakeMessage(mClient).ConfigureAwait(false);
 
                 if (handshakeResponse.IsError)
                 {
diff --git a/src/net45/Extensions/WampSharp.RawSocket/RawSocket/RawSocketTransport.cs b/src/net45/Extensions/WampSharp.RawSocket/RawSocket/RawSocketTransport.cs
@@ -81,7 +81,7 @@ private async Task<RawSocketTcpClient> AcceptClient()
             {
                 tcpClient = await mListener.AcceptTcpClientAsync().ConfigureAwait(false);
 
-                Handshake handshakeRequest = await mHandshaker.GetHandshakeMessage(tcpClient);
+                Handshake handshakeRequest = await mHandshaker.GetHandshakeMessage(tcpClient).ConfigureAwait(false);
 
                 Handshake handshakeResponse = GetHandshakeResponse(handshakeRequest);
 
diff --git a/src/net45/Extensions/WampSharp.RawSocket/RawSocket/TcpClientConnection.cs b/src/net45/Extensions/WampSharp.RawSocket/RawSocket/TcpClientConnection.cs
@@ -84,7 +84,7 @@ protected async override Task SendAsync(WampMessage<object> message)
                 mFrameHeaderParser.WriteHeader(FrameType.WampMessage, messageLength, buffer);
 
                 // Write the whole message to the wire
-                await TcpClient.GetStream().WriteAsync(buffer, 0, totalMessageLength);
+                await TcpClient.GetStream().WriteAsync(buffer, 0, totalMessageLength).ConfigureAwait(false);
 
                 mByteArrayPool.Return(buffer);
             }
@@ -125,7 +125,7 @@ await TcpClient.GetStream()
                     if (mFrameHeaderParser.TryParse(frameHeaderBytes, out frameType, out messageLength) &&
                         (messageLength <= mMaxAllowedMessageSize))
                     {
-                        await HandleFrame(frameType, messageLength);
+                        await HandleFrame(frameType, messageLength).ConfigureAwait(false);
                     }
                     else
                     {
@@ -146,20 +146,20 @@ private async Task HandleFrame(FrameType frameType, int messageLength)
             switch (frameType)
             {
                 case FrameType.WampMessage:
-                    await HandleWampMessage(messageLength);
+                    await HandleWampMessage(messageLength).ConfigureAwait(false);
                     break;
                 case FrameType.Ping:
-                    await HandlePing(messageLength);
+                    await HandlePing(messageLength).ConfigureAwait(false);
                     break;
                 case FrameType.Pong:
-                    await HandlePong(messageLength);
+                    await HandlePong(messageLength).ConfigureAwait(false);
                     break;
             }
         }
 
         private async Task HandleWampMessage(int messageLength)
         {
-            byte[] buffer = await ReadStream(messageLength);
+            byte[] buffer = await ReadStream(messageLength).ConfigureAwait(false);
 
             WampMessage<TMessage> parsed = mBinding.Parse(new MemoryStream(buffer));
 
@@ -174,14 +174,14 @@ private async Task<byte[]> ReadStream(int messageLength, int position = 0)
 
             byte[] array = mByteArrayPool.Rent(length);
 
-            await TcpClient.GetStream().ReadExactAsync(array, position, messageLength);
+            await TcpClient.GetStream().ReadExactAsync(array, position, messageLength).ConfigureAwait(false);
 
             return array;
         }
 
         private async Task HandlePong(int messageLength)
         {
-            byte[] buffer = await ReadStream(messageLength);
+            byte[] buffer = await ReadStream(messageLength).ConfigureAwait(false);
 
             ArraySegment<byte> arraySegment =
                 new ArraySegment<byte>(buffer, 0, messageLength);
@@ -193,15 +193,15 @@ private async Task HandlePong(int messageLength)
 
         private async Task HandlePing(int messageLength)
         {
-            byte[] buffer = await ReadStream(messageLength, FrameHeaderSize);
+            byte[] buffer = await ReadStream(messageLength, FrameHeaderSize).ConfigureAwait(false);
 
             mFrameHeaderParser.WriteHeader(FrameType.Pong, messageLength, buffer);
 
             NetworkStream networkStream = mTcpClient.GetStream();
 
             int frameSize = messageLength + FrameHeaderSize;
 
-            await networkStream.WriteAsync(buffer, 0, frameSize);
+            await networkStream.WriteAsync(buffer, 0, frameSize).ConfigureAwait(false);
 
             mByteArrayPool.Return(buffer);
         }
@@ -218,9 +218,9 @@ private async Task SendPing(byte[] message)
                 memoryStream.SetLength(FrameHeaderSize);
                 memoryStream.Position = FrameHeaderSize;
 
-                await memoryStream.WriteAsync(message, 0, message.Length);
+                await memoryStream.WriteAsync(message, 0, message.Length).ConfigureAwait(false);
 
-                await TcpClient.GetStream().WriteAsync(buffer, 0, frameSize);
+                await TcpClient.GetStream().WriteAsync(buffer, 0, frameSize).ConfigureAwait(false);
             }
 
             mByteArrayPool.Return(buffer);
diff --git a/src/net45/Extensions/WampSharp.SignalR/Client/SignalRTextConnection.cs b/src/net45/Extensions/WampSharp.SignalR/Client/SignalRTextConnection.cs
@@ -57,7 +57,7 @@ private void OnClosed()
 
         public async void Connect()
         {
-            await mConnection.Start(mTransport);
+            await mConnection.Start(mTransport).ConfigureAwait(false);
             RaiseConnectionOpen();
         }
 
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampBinaryConnection.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampBinaryConnection.cs
@@ -25,7 +25,7 @@ protected async override Task<WampMessage<TMessage>> ParseMessage(WebSocketMessa
         {
             using (MemoryStream memoryStream = new MemoryStream())
             {
-                await readStream.CopyToAsync(memoryStream);
+                await readStream.CopyToAsync(memoryStream).ConfigureAwait(false);
                 byte[] bytes = memoryStream.ToArray();
                 WampMessage<TMessage> result = mBinding.Parse(bytes);
                 return result;
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampConnection.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampConnection.cs
@@ -46,7 +46,7 @@ await mWebsocket.ReadMessageAsync(CancellationToken.None)
                     {
                         using (message)
                         {
-                            WampMessage<TMessage> parsed = await ParseMessage(message);
+                            WampMessage<TMessage> parsed = await ParseMessage(message).ConfigureAwait(false);
                             RaiseMessageArrived(parsed);
                         }
                     }
diff --git a/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampTextConnection.cs b/src/net45/Extensions/WampSharp.Vtortola/VtortolaWampTextConnection.cs
@@ -25,7 +25,7 @@ protected async override Task<WampMessage<TMessage>> ParseMessage(WebSocketMessa
         {
             using (StreamReader streamReader = new StreamReader(readStream))
             {
-                string raw = await streamReader.ReadToEndAsync();
+                string raw = await streamReader.ReadToEndAsync().ConfigureAwait(false);
                 WampMessage<TMessage> result = mBinding.Parse(raw);
                 return result;
             }
diff --git a/src/net45/Extensions/WampSharp.WebSockets/WebSockets/WebSocketWrapperConnection.cs b/src/net45/Extensions/WampSharp.WebSockets/WebSockets/WebSocketWrapperConnection.cs
@@ -95,7 +95,7 @@ data is very small.
                 {
                     // Reads data.
                     WebSocketReceiveResult webSocketReceiveResult =
-                        await ReadMessage(receivedDataBuffer, memoryStream);
+                        await ReadMessage(receivedDataBuffer, memoryStream).ConfigureAwait(false);
 
                     if (webSocketReceiveResult.MessageType != WebSocketMessageType.Close)
                     {
diff --git a/src/net45/WampSharp/Core/Listener/Connections/AsyncConnection/AsyncWampConnection.cs b/src/net45/WampSharp/Core/Listener/Connections/AsyncConnection/AsyncWampConnection.cs
@@ -144,7 +144,7 @@ async Task IAsyncDisposable.DisposeAsync()
             if (Interlocked.CompareExchange(ref mDisposeCalled, 1, 0) == 0)
             {
                 mSendBlock.Complete();
-                await mSendBlock.Completion;
+                await mSendBlock.Completion.ConfigureAwait(false);
                 this.Dispose();
             }
         }
diff --git a/src/net45/WampSharp/Core/Utilities/AsyncDisposable/AsyncDisposableExtensions.cs b/src/net45/WampSharp/Core/Utilities/AsyncDisposable/AsyncDisposableExtensions.cs
@@ -15,7 +15,7 @@ public static async Task<IAsyncDisposable> ToAsyncDisposableTask(
             this IEnumerable<Task<IAsyncDisposable>> disposableTasks)
         {
             IAsyncDisposable[] allDisposables =
-                await Task.WhenAll(disposableTasks);
+                await Task.WhenAll(disposableTasks).ConfigureAwait(false);
 
             IAsyncDisposable result = new CompositeAsyncDisposable(allDisposables);
 
diff --git a/src/net45/WampSharp/WAMP2/V2/Rpc/Callee/AsyncLocalRpcOperation.cs b/src/net45/WampSharp/WAMP2/V2/Rpc/Callee/AsyncLocalRpcOperation.cs
@@ -60,7 +60,7 @@ private async Task InnerInvokeAsync<TMessage>(IWampRawRpcOperationRouterCallback
                                 argumentsKeywords,
                                 cancellationToken);
 
-                object result = await task;
+                object result = await task.ConfigureAwait(false);
 
                 CallResult(caller, result);
             }
diff --git a/src/net45/WampSharp/WAMP2/V2/Transports/PingPongHandler.cs b/src/net45/WampSharp/WAMP2/V2/Transports/PingPongHandler.cs
@@ -54,8 +54,8 @@ private async void Ping()
                 try
                 {
                     byte[] ticks = GetCurrentTicks();
-                    await mPinger.SendPing(ticks);
-                    await Task.Delay(mAutoSendPingInterval.Value);
+                    await mPinger.SendPing(ticks).ConfigureAwait(false);
+                    await Task.Delay(mAutoSendPingInterval.Value).ConfigureAwait(false);
                 }
                 catch (Exception ex)
                 {

Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ private Task HttpHandler(IOwinContext context, Func<Task> next)`
`81`	`81`
`82`	`82`	`private async Task EmptyHandler(IOwinContext owinContext, Func<Task> next)`
`83`	`83`	`{`
`84`		`- await next();`
	`84`	`+ await next().ConfigureAwait(false);`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`private async Task WebSocketHandler(IOwinContext context, Func<Task> next)`
`@@ -110,7 +110,7 @@ private async Task WebSocketHandler(IOwinContext context, Func<Task> next)`
`110`	`110`	`}`
`111`	`111`	`}`
`112`	`112`
`113`		`- await next();`
	`113`	`+ await next().ConfigureAwait(false);`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`private async Task OnAccept(IDictionary<string, object> webSocketContext, IOwinContext context, string subprotocol)`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public async static Task ReadExactAsync(this NetworkStream networkStream, byte[]`
`18`	`18`
`19`	`19`	`while (readBytes != length)`
`20`	`20`	`{`
`21`		`- int currentlyRead = await networkStream.ReadAsync(buffer, currentPosition, length - readBytes);`
	`21`	`+ int currentlyRead = await networkStream.ReadAsync(buffer, currentPosition, length - readBytes).ConfigureAwait(false);`
`22`	`22`
`23`	`23`	`// If we read 0 bytes, we have reached the end of the stream.`
`24`	`24`	`if (currentlyRead == 0)`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ public async void Connect()`
`81`	`81`	`{`
`82`	`82`	`if (mConnection == null)`
`83`	`83`	`{`
`84`		`- await InnerConnect();`
	`84`	`+ await InnerConnect().ConfigureAwait(false);`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
`@@ -91,13 +91,13 @@ private async Task InnerConnect()`
`91`	`91`	`{`
`92`	`92`	`mClient = mClientBuilder();`
`93`	`93`
`94`		`- await mConnector(mClient);`
	`94`	`+ await mConnector(mClient).ConfigureAwait(false);`
`95`	`95`
`96`	`96`	`Handshake handshakeRequest = GetHandshakeRequest();`
`97`	`97`
`98`		`- await mHandshaker.SendHandshake(mClient, handshakeRequest);`
	`98`	`+ await mHandshaker.SendHandshake(mClient, handshakeRequest).ConfigureAwait(false);`
`99`	`99`
`100`		`- Handshake handshakeResponse = await mHandshaker.GetHandshakeMessage(mClient);`
	`100`	`+ Handshake handshakeResponse = await mHandshaker.GetHandshakeMessage(mClient).ConfigureAwait(false);`
`101`	`101`
`102`	`102`	`if (handshakeResponse.IsError)`
`103`	`103`	`{`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ private async Task<RawSocketTcpClient> AcceptClient()`
`81`	`81`	`{`
`82`	`82`	`tcpClient = await mListener.AcceptTcpClientAsync().ConfigureAwait(false);`
`83`	`83`
`84`		`- Handshake handshakeRequest = await mHandshaker.GetHandshakeMessage(tcpClient);`
	`84`	`+ Handshake handshakeRequest = await mHandshaker.GetHandshakeMessage(tcpClient).ConfigureAwait(false);`
`85`	`85`
`86`	`86`	`Handshake handshakeResponse = GetHandshakeResponse(handshakeRequest);`
`87`	`87`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ protected async override Task SendAsync(WampMessage<object> message)`
`84`	`84`	`mFrameHeaderParser.WriteHeader(FrameType.WampMessage, messageLength, buffer);`
`85`	`85`
`86`	`86`	`// Write the whole message to the wire`
`87`		`- await TcpClient.GetStream().WriteAsync(buffer, 0, totalMessageLength);`
	`87`	`+ await TcpClient.GetStream().WriteAsync(buffer, 0, totalMessageLength).ConfigureAwait(false);`
`88`	`88`
`89`	`89`	`mByteArrayPool.Return(buffer);`
`90`	`90`	`}`
`@@ -125,7 +125,7 @@ await TcpClient.GetStream()`
`125`	`125`	`if (mFrameHeaderParser.TryParse(frameHeaderBytes, out frameType, out messageLength) &&`
`126`	`126`	`(messageLength <= mMaxAllowedMessageSize))`
`127`	`127`	`{`
`128`		`- await HandleFrame(frameType, messageLength);`
	`128`	`+ await HandleFrame(frameType, messageLength).ConfigureAwait(false);`
`129`	`129`	`}`
`130`	`130`	`else`
`131`	`131`	`{`
`@@ -146,20 +146,20 @@ private async Task HandleFrame(FrameType frameType, int messageLength)`
`146`	`146`	`switch (frameType)`
`147`	`147`	`{`
`148`	`148`	`case FrameType.WampMessage:`
`149`		`- await HandleWampMessage(messageLength);`
	`149`	`+ await HandleWampMessage(messageLength).ConfigureAwait(false);`
`150`	`150`	`break;`
`151`	`151`	`case FrameType.Ping:`
`152`		`- await HandlePing(messageLength);`
	`152`	`+ await HandlePing(messageLength).ConfigureAwait(false);`
`153`	`153`	`break;`
`154`	`154`	`case FrameType.Pong:`
`155`		`- await HandlePong(messageLength);`
	`155`	`+ await HandlePong(messageLength).ConfigureAwait(false);`
`156`	`156`	`break;`
`157`	`157`	`}`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`private async Task HandleWampMessage(int messageLength)`
`161`	`161`	`{`
`162`		`- byte[] buffer = await ReadStream(messageLength);`
	`162`	`+ byte[] buffer = await ReadStream(messageLength).ConfigureAwait(false);`
`163`	`163`
`164`	`164`	`WampMessage<TMessage> parsed = mBinding.Parse(new MemoryStream(buffer));`
`165`	`165`
`@@ -174,14 +174,14 @@ private async Task<byte[]> ReadStream(int messageLength, int position = 0)`
`174`	`174`
`175`	`175`	`byte[] array = mByteArrayPool.Rent(length);`
`176`	`176`
`177`		`- await TcpClient.GetStream().ReadExactAsync(array, position, messageLength);`
	`177`	`+ await TcpClient.GetStream().ReadExactAsync(array, position, messageLength).ConfigureAwait(false);`
`178`	`178`
`179`	`179`	`return array;`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`private async Task HandlePong(int messageLength)`
`183`	`183`	`{`
`184`		`- byte[] buffer = await ReadStream(messageLength);`
	`184`	`+ byte[] buffer = await ReadStream(messageLength).ConfigureAwait(false);`
`185`	`185`
`186`	`186`	`ArraySegment<byte> arraySegment =`
`187`	`187`	`new ArraySegment<byte>(buffer, 0, messageLength);`
`@@ -193,15 +193,15 @@ private async Task HandlePong(int messageLength)`
`193`	`193`
`194`	`194`	`private async Task HandlePing(int messageLength)`
`195`	`195`	`{`
`196`		`- byte[] buffer = await ReadStream(messageLength, FrameHeaderSize);`
	`196`	`+ byte[] buffer = await ReadStream(messageLength, FrameHeaderSize).ConfigureAwait(false);`
`197`	`197`
`198`	`198`	`mFrameHeaderParser.WriteHeader(FrameType.Pong, messageLength, buffer);`
`199`	`199`
`200`	`200`	`NetworkStream networkStream = mTcpClient.GetStream();`
`201`	`201`
`202`	`202`	`int frameSize = messageLength + FrameHeaderSize;`
`203`	`203`
`204`		`- await networkStream.WriteAsync(buffer, 0, frameSize);`
	`204`	`+ await networkStream.WriteAsync(buffer, 0, frameSize).ConfigureAwait(false);`
`205`	`205`
`206`	`206`	`mByteArrayPool.Return(buffer);`
`207`	`207`	`}`
`@@ -218,9 +218,9 @@ private async Task SendPing(byte[] message)`
`218`	`218`	`memoryStream.SetLength(FrameHeaderSize);`
`219`	`219`	`memoryStream.Position = FrameHeaderSize;`
`220`	`220`
`221`		`- await memoryStream.WriteAsync(message, 0, message.Length);`
	`221`	`+ await memoryStream.WriteAsync(message, 0, message.Length).ConfigureAwait(false);`
`222`	`222`
`223`		`- await TcpClient.GetStream().WriteAsync(buffer, 0, frameSize);`
	`223`	`+ await TcpClient.GetStream().WriteAsync(buffer, 0, frameSize).ConfigureAwait(false);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`mByteArrayPool.Return(buffer);`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ private void OnClosed()`
`57`	`57`
`58`	`58`	`public async void Connect()`
`59`	`59`	`{`
`60`		`- await mConnection.Start(mTransport);`
	`60`	`+ await mConnection.Start(mTransport).ConfigureAwait(false);`
`61`	`61`	`RaiseConnectionOpen();`
`62`	`62`	`}`
`63`	`63`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ protected async override Task<WampMessage<TMessage>> ParseMessage(WebSocketMessa`
`25`	`25`	`{`
`26`	`26`	`using (MemoryStream memoryStream = new MemoryStream())`
`27`	`27`	`{`
`28`		`- await readStream.CopyToAsync(memoryStream);`
	`28`	`+ await readStream.CopyToAsync(memoryStream).ConfigureAwait(false);`
`29`	`29`	`byte[] bytes = memoryStream.ToArray();`
`30`	`30`	`WampMessage<TMessage> result = mBinding.Parse(bytes);`
`31`	`31`	`return result;`
Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ await mWebsocket.ReadMessageAsync(CancellationToken.None)`
`46`	`46`	`{`
`47`	`47`	`using (message)`
`48`	`48`	`{`
`49`		`- WampMessage<TMessage> parsed = await ParseMessage(message);`
	`49`	`+ WampMessage<TMessage> parsed = await ParseMessage(message).ConfigureAwait(false);`
`50`	`50`	`RaiseMessageArrived(parsed);`
`51`	`51`	`}`
`52`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ data is very small.`
`95`	`95`	`{`
`96`	`96`	`// Reads data.`
`97`	`97`	`WebSocketReceiveResult webSocketReceiveResult =`
`98`		`- await ReadMessage(receivedDataBuffer, memoryStream);`
	`98`	`+ await ReadMessage(receivedDataBuffer, memoryStream).ConfigureAwait(false);`
`99`	`99`
`100`	`100`	`if (webSocketReceiveResult.MessageType != WebSocketMessageType.Close)`
`101`	`101`	`{`