#307 cancel reconnecting when calling Disconnect or Dispose

Author: doghappy

src/SocketIOClient/SocketIO.cs

@@ -546,24 +546,23 @@ private void OnMessageReceived(IMessage msg)
 
         public async Task DisconnectAsync()
         {
-            if (Connected)
+            _connCts.TryCancel();
+            _connCts.TryDispose();
+            var msg = new DisconnectedMessage
+            {
+                Namespace = _namespace
+            };
+            try
+            {
+                await Transport.SendAsync(msg, CancellationToken.None).ConfigureAwait(false);
+            }
+            catch (Exception e)
             {
-                var msg = new DisconnectedMessage
-                {
-                    Namespace = _namespace
-                };
-                try
-                {
-                    await Transport.SendAsync(msg, CancellationToken.None).ConfigureAwait(false);
-                }
-                catch (Exception e)
-                {
 #if DEBUG
-                    Debug.WriteLine(e);
+                Debug.WriteLine(e);
 #endif
-                }
-                await InvokeDisconnect(DisconnectReason.IOClientDisconnect);
             }
+            await InvokeDisconnect(DisconnectReason.IOClientDisconnect);
         }
 
         /// <summary>
@@ -797,6 +796,8 @@ public void AddExpectedException(Type type)
 
         public void Dispose()
         {
+            _connCts.TryCancel();
+            _connCts.TryDispose();
             Transport.TryDispose();
             _ackHandlers.Clear();
             _onAnyHandlers.Clear();

tests/SocketIOClient.UnitTest/SocketIOTest.cs

@@ -575,5 +575,50 @@ public async Task Should_be_able_to_add_header()
 
             mockWs.Verify(w => w.AddHeader("h1", "v1"), Times.Once());
         }
+
+        private static async Task Should_be_able_to_cancel_reconnecting(Func<SocketIO,Task> action)
+        {
+            using var io = new SocketIO("http://localhost:11003", new SocketIOOptions
+            {
+                Transport = TransportProtocol.WebSocket,
+                ConnectionTimeout = TimeSpan.FromSeconds(1),
+                ReconnectionAttempts = 4,
+            });
+            var mockTransport = new Mock<ITransport>();
+            mockTransport
+                .Setup(m=>m.ConnectAsync(It.IsAny<Uri>(), It.IsAny<CancellationToken>()))
+                .Throws<TimeoutException>();
+            io.Transport = mockTransport.Object;
+
+            int attempts = 0;
+            io.OnReconnectAttempt += (s, e) => attempts = e;
+            var task = io.ConnectAsync();
+            await Task.Delay(2000);
+            await action(io);
+            int r1 = attempts;
+            await Task.Delay(1000);
+            int r2 = attempts;
+
+            attempts.Should().BeGreaterThan(0);
+            r1.Should().Be(attempts);
+            r2.Should().Be(attempts);
+            task.Status.Should().Be(TaskStatus.Faulted);
+        }
+        
+        [TestMethod]
+        public async Task Should_be_able_to_cancel_reconnecting_after_disposed()
+        {
+            await Should_be_able_to_cancel_reconnecting(io =>
+            {
+                io.Dispose();
+                return Task.CompletedTask;
+            });
+        }
+        
+        [TestMethod]
+        public async Task Should_be_able_to_cancel_reconnecting_after_disconnected()
+        {
+            await Should_be_able_to_cancel_reconnecting(async io => await io.DisconnectAsync());
+        }
     }
 }