Minor changes related to ConfigureAwait(false).

theRainbird · Dec 9, 2024 · 87eaa96 · 87eaa96
1 parent 2552117
commit 87eaa96
Show file tree

Hide file tree

Showing 9 changed files with 136 additions and 59 deletions.
diff --git a/CoreRemoting.Tests/CoreRemoting.Tests.csproj b/CoreRemoting.Tests/CoreRemoting.Tests.csproj
@@ -9,6 +9,7 @@
     <!-- Exclude the unnecessary tests to save Github Actions time -->
     <!-- WatsonTcp is the default channel, WebSocketSharp is optional -->
     <ItemGroup>
+      <Compile Remove="DisposableTests.Async.cs" />
       <Compile Remove="RpcTests_WatsonTcp.cs" />
       <Compile Remove="RpcTests_WebsocketSharp.cs" />
       <Compile Remove="RpcTests_WsClientWsharpServer.cs" />

diff --git a/CoreRemoting.Tests/DisposableTests.cs → CoreRemoting.Tests/DisposableTests.Async.cs b/CoreRemoting.Tests/DisposableTests.cs → CoreRemoting.Tests/DisposableTests.Async.cs
@@ -4,22 +4,8 @@
 
 namespace CoreRemoting.Tests
 {
-    public class DisposableTests
+    partial class DisposableTests
     {
-        [Fact]
-        public void Disposable_executes_action_on_Dispose()
-        {
-            var disposed = false;
-
-            void Dispose() =>
-                disposed = true;
-
-            using (Disposable.Create(Dispose))
-                Assert.False(disposed);
-
-            Assert.True(disposed);
-        }
-
         [Fact]
         public async Task AsyncDisposable_executes_action_on_DisposeAsync()
         {

diff --git a/CoreRemoting.Tests/DisposableTests.Sync.cs b/CoreRemoting.Tests/DisposableTests.Sync.cs
@@ -0,0 +1,52 @@
+using CoreRemoting.Toolbox;
+using System;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace CoreRemoting.Tests
+{
+    public partial class DisposableTests
+    {
+        [Fact]
+        public void Disposable_executes_action_on_Dispose()
+        {
+            var disposed = false;
+
+            void Dispose() =>
+                disposed = true;
+
+            using (Disposable.Create(Dispose))
+                Assert.False(disposed);
+
+            Assert.True(disposed);
+        }
+
+        [Fact]
+        public void Disposable_ignores_nulls()
+        {
+            Action dispose = null;
+
+            using (Disposable.Create(dispose))
+            {
+                // doesn't throw
+            }
+        }
+
+        [Fact]
+        public void Disposable_combines_disposables()
+        {
+            var count = 0;
+            void Dispose() =>
+                count++;
+
+            var d1 = Disposable.Create(Dispose);
+            var d2 = Disposable.Create(Dispose);
+            var d3 = Disposable.Create(Dispose);
+
+            using (Disposable.Create(d1, d2, d3))
+                Assert.Equal(0, count);
+
+            Assert.Equal(3, count);
+        }
+    }
+}
diff --git a/CoreRemoting/Channels/Websocket/WebsocketClientChannel.cs b/CoreRemoting/Channels/Websocket/WebsocketClientChannel.cs
@@ -14,6 +14,7 @@ public class WebsocketClientChannel : IClientChannel, IRawMessageTransport
 {
     // note: LOH threshold is ~85 kilobytes
     private const int BufferSize = 16 * 1024;
+    private static ArraySegment<byte> EmptyMessage = new ArraySegment<byte>([]);
 
     /// <summary>
     /// Gets or sets the URL this channel is connected to.
@@ -83,17 +84,21 @@ public void Connect()
     {
         ConnectTask = ConnectTask ?? Task.Factory.StartNew(async () =>
         {
-            await WebSocket.ConnectAsync(new Uri(Url), CancellationToken.None);
+            await WebSocket.ConnectAsync(
+                new Uri(Url), CancellationToken.None)
+                    .ConfigureAwait(false);
+
             IsConnected = true;
             Connected?.Invoke();
 
-            await WebSocket.SendAsync(new ArraySegment<byte>(Array.Empty<byte>()), WebSocketMessageType.Binary, true, CancellationToken.None);
+            await WebSocket.SendAsync(EmptyMessage, 
+                WebSocketMessageType.Binary, true, CancellationToken.None)
+                    .ConfigureAwait(false);
+
             _ = StartListening();
         });
 
-        ConnectTask.ConfigureAwait(false)
-            .GetAwaiter()
-            .GetResult();
+        ConnectTask.GetAwaiter().GetResult();
     }
 
     private Task ConnectTask { get; set; }
@@ -111,13 +116,15 @@ private async Task StartListening()
                 var ms = new SmallBlockMemoryStream();
                 while (true)
                 {
-                    var result = await webSocket.ReceiveAsync(segment,
-                        CancellationToken.None).ConfigureAwait(false);
+                    var result = await webSocket.ReceiveAsync(
+                        segment, CancellationToken.None)
+                            .ConfigureAwait(false);
 
                     if (result.MessageType == WebSocketMessageType.Close)
                     {
                         await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
-                            string.Empty, CancellationToken.None).ConfigureAwait(false);
+                            string.Empty, CancellationToken.None)
+                                .ConfigureAwait(false);
 
                         Disconnected?.Invoke();
                     }
@@ -160,10 +167,9 @@ public bool SendMessage(byte[] rawMessage)
         try
         {
             var segment = new ArraySegment<byte>(rawMessage);
-            WebSocket.SendAsync(segment, WebSocketMessageType.Binary, true, CancellationToken.None)
-                .ConfigureAwait(false)
-                .GetAwaiter()
-                .GetResult();
+            WebSocket.SendAsync(segment, 
+                WebSocketMessageType.Binary, true, CancellationToken.None)
+                    .GetAwaiter().GetResult();
 
             return true;
         }
@@ -184,7 +190,10 @@ public void Disconnect()
     {
         DisconnectTask = DisconnectTask ?? Task.Factory.StartNew(async () =>
         {
-            await WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Ok", CancellationToken.None);
+            await WebSocket.CloseAsync(
+                WebSocketCloseStatus.NormalClosure, "Ok", CancellationToken.None)
+                    .ConfigureAwait(false);
+
             IsConnected = false;
             Disconnected?.Invoke();
         });
@@ -201,8 +210,7 @@ public void Dispose()
 
         var task = DisconnectTask;
         if (task != null)
-            task.ConfigureAwait(false)
-                .GetAwaiter()
+            task.GetAwaiter()
                 .GetResult();
 
         WebSocket.Dispose();

diff --git a/CoreRemoting/Channels/Websocket/WebsocketServerChannel.cs b/CoreRemoting/Channels/Websocket/WebsocketServerChannel.cs
@@ -46,7 +46,9 @@ public void StartListening()
     private async Task ReceiveConnection()
     {
         // check if it's a websocket request
-        var context = await HttpListener.GetContextAsync();
+        var context = await HttpListener.GetContextAsync()
+            .ConfigureAwait(false);
+
         if (!context.Request.IsWebSocketRequest)
         {
             context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
@@ -55,7 +57,9 @@ private async Task ReceiveConnection()
         }
 
         // accept websocket request and start a new session
-        var websocketContext = await context.AcceptWebSocketAsync(null);
+        var websocketContext = await context.AcceptWebSocketAsync(null)
+            .ConfigureAwait(false);
+
         var websocket = websocketContext.WebSocket;
         var connection = new WebsocketServerConnection(
             context.Request.RemoteEndPoint.ToString(),

diff --git a/CoreRemoting/Channels/Websocket/WebsocketServerConnection.cs b/CoreRemoting/Channels/Websocket/WebsocketServerConnection.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Net;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -56,10 +55,9 @@ public bool SendMessage(byte[] rawMessage)
         try
         {
             var segment = new ArraySegment<byte>(rawMessage);
-            WebSocket.SendAsync(segment, WebSocketMessageType.Binary, true, CancellationToken.None)
-                .ConfigureAwait(false)
-                .GetAwaiter()
-                .GetResult();
+            WebSocket.SendAsync(segment, 
+                WebSocketMessageType.Binary, true, CancellationToken.None)
+                    .GetAwaiter().GetResult();
 
             return true;
         }
@@ -109,20 +107,21 @@ private async Task ReadIncomingMessages()
     {
         var buffer = new byte[BufferSize];
         var segment = new ArraySegment<byte>(buffer);
+        var webSocket = WebSocket;
 
         try
         {
-            while (WebSocket.State == WebSocketState.Open)
+            while (webSocket.State == WebSocketState.Open)
             {
                 var ms = new SmallBlockMemoryStream();
                 while (true)
                 {
-                    var result = await WebSocket.ReceiveAsync(segment,
+                    var result = await webSocket.ReceiveAsync(segment,
                         CancellationToken.None).ConfigureAwait(false);
 
                     if (result.MessageType == WebSocketMessageType.Close)
                     {
-                        await WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
+                        await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
                             string.Empty, CancellationToken.None).ConfigureAwait(false);
 
                         Disconnected?.Invoke();
@@ -142,7 +141,7 @@ await WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
                     var message = new byte[(int)ms.Length];
                     ms.Position = 0;
                     ms.Read(message, 0, message.Length);
-                    ReceiveMessage(message);
+                    ReceiveMessage?.Invoke(message);
                 }
             }
         }
@@ -156,7 +155,7 @@ await WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
         }
         finally
         {
-            WebSocket?.Dispose();
+            webSocket?.Dispose();
         }
     }
 }
diff --git a/CoreRemoting/CoreRemoting.csproj b/CoreRemoting/CoreRemoting.csproj
@@ -61,5 +61,9 @@
     <ItemGroup>
       <Protobuf Include="**/*.proto" />
     </ItemGroup>
+
+    <ItemGroup>
+      <Compile Remove="Toolbox\Disposable.Async.cs" />
+    </ItemGroup>
 
 </Project>
diff --git a/CoreRemoting/Toolbox/Disposable.cs → CoreRemoting/Toolbox/Disposable.Async.cs b/CoreRemoting/Toolbox/Disposable.cs → CoreRemoting/Toolbox/Disposable.Async.cs
@@ -3,24 +3,8 @@
 
 namespace CoreRemoting.Toolbox
 {
-    /// <summary>
-    /// Helper class to create disposable primitives.
-    /// </summary>
-    public static class Disposable
+    static partial class Disposable
     {
-        private class SyncDisposable(Action disposeAction) : IDisposable
-        {
-            void IDisposable.Dispose() =>
-                disposeAction?.Invoke();
-        }
-
-        /// <summary>
-        /// Creates a disposable object.
-        /// </summary>
-        /// <param name="disposeAction">An action to invoke on disposal.</param>
-        public static IDisposable Create(Action disposeAction) =>
-            new SyncDisposable(disposeAction);
-
         private class AsyncDisposable(
             Func<ValueTask> disposeAsync,
             Func<Task> disposeTaskAsync) : IAsyncDisposable

diff --git a/CoreRemoting/Toolbox/Disposable.Sync.cs b/CoreRemoting/Toolbox/Disposable.Sync.cs
@@ -0,0 +1,39 @@
+using System;
+
+namespace CoreRemoting.Toolbox
+{
+    /// <summary>
+    /// Helper class to create disposable primitives.
+    /// </summary>
+    public static partial class Disposable
+    {
+        private class SyncDisposable(Action disposeAction) : IDisposable
+        {
+            void IDisposable.Dispose() =>
+                disposeAction?.Invoke();
+        }
+
+        /// <summary>
+        /// Creates a disposable object.
+        /// </summary>
+        /// <param name="disposeAction">An action to invoke on disposal.</param>
+        public static IDisposable Create(Action disposeAction) =>
+            new SyncDisposable(disposeAction);
+
+        private class ParamsDisposable(params IDisposable[] disposables) : IDisposable
+        {
+            void IDisposable.Dispose()
+            {
+                foreach (var disposable in disposables ?? [])
+                    disposable?.Dispose();
+            }
+        }
+
+        /// <summary>
+        /// Creates a disposable object.
+        /// </summary>
+        /// <param name="disposables">Disposable items to dispose on disposal.</param>
+        public static IDisposable Create(params IDisposable[] disposables) =>
+            new ParamsDisposable(disposables);
+    }
+}