Add (force) reconnect method

src/NATS.Client.Core/INatsClient.cs

@@ -115,4 +115,12 @@ ValueTask<NatsMsg<TReply>> RequestAsync<TReply>(
         INatsDeserialize<TReply>? replySerializer = default,
         NatsSubOpts? replyOpts = default,
         CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Force a reconnection to the NATS server.
+    /// </summary>
+    /// <remarks>
+    /// This method doesn't wait for the connection to be established.
+    /// </remarks>
+    ValueTask ReconnectAsync();
 }

src/NATS.Client.Core/NatsConnection.Reconnect.cs

@@ -0,0 +1,18 @@
+using Microsoft.Extensions.Logging;
+
+namespace NATS.Client.Core;
+
+public partial class NatsConnection
+{
+    /// <inheritdoc/>
+    public async ValueTask ReconnectAsync()
+    {
+        if (ConnectionState != NatsConnectionState.Open)
+        {
+            return;
+        }
+
+        _logger.LogInformation(NatsLogEvents.Connection, "Forcing reconnection to NATS server");
+        await _socket!.AbortConnectionAsync(CancellationToken.None).ConfigureAwait(false);
+    }
+}

src/NATS.Client.Simplified/NatsClient.cs

@@ -101,6 +101,9 @@ public ValueTask<NatsMsg<TReply>> RequestAsync<TRequest, TReply>(string subject,
     public ValueTask<NatsMsg<TReply>> RequestAsync<TReply>(string subject, INatsDeserialize<TReply>? replySerializer = default, NatsSubOpts? replyOpts = default, CancellationToken cancellationToken = default)
         => Connection.RequestAsync(subject, replySerializer, replyOpts, cancellationToken);
 
+    /// <inheritdoc />
+    public ValueTask ReconnectAsync() => Connection.ReconnectAsync();
+
     /// <inheritdoc />
     public ValueTask DisposeAsync() => Connection.DisposeAsync();
 }

tests/NATS.Client.Core.Tests/NatsConnectionTest.cs

@@ -466,6 +466,45 @@ public async Task OnSocketAvailableAsync_ShouldBeInvokedOnReconnection()
         // Assert
         Assert.Equal(2, invocationCount);
     }
+
+    [Fact]
+    public async Task ReconnectOnOpenConnection_ShouldDisconnectAndOpenNewConnection()
+    {
+        // Arrange
+        await using var server = NatsServer.Start(_output, _transportType);
+        await using var connection = server.CreateClientConnection();
+        await connection.ConnectAsync(); // wait first connection open
+
+        var openedCount = 0;
+        var disconnectedCount = 0;
+
+        var openSignal = new WaitSignal();
+        var disconnectSignal = new WaitSignal();
+
+        connection.ConnectionOpened += (_, _) =>
+        {
+            Interlocked.Increment(ref openedCount);
+            openSignal.Pulse();
+            return default;
+        };
+        connection.ConnectionDisconnected += (_, _) =>
+        {
+            Interlocked.Increment(ref disconnectedCount);
+            disconnectSignal.Pulse();
+            return default;
+        };
+
+        // Act
+        await connection.ReconnectAsync();
+        await disconnectSignal;
+        await openSignal;
+
+        // Assert
+        // First connection is not taken into account, so one invocation of
+        // disconnected event and open connection event are expected
+        openedCount.ShouldBe(1);
+        disconnectedCount.ShouldBe(1);
+    }
 }
 
 [JsonSerializable(typeof(SampleClass))]

tests/NATS.Client.JetStream.Tests/NatsJsContextFactoryTest.cs

@@ -159,6 +159,8 @@ public ValueTask<NatsSub<TReply>> CreateRequestSubAsync<TRequest, TReply>(string
 
         public ValueTask ConnectAsync() => throw new NotImplementedException();
 
+        public ValueTask ReconnectAsync() => throw new NotImplementedException();
+
         public ValueTask DisposeAsync() => throw new NotImplementedException();
     }
 }