Add IAsyncConnection interface with async StateChanged event

Author: mikasoukhov

Net.SocketIO/ConnectionStateTracker.cs

@@ -1,16 +1,19 @@
 namespace Ecng.Net;
 
 /// <summary>
-/// Tracks the connection states of multiple IConnection instances and aggregates their overall state.
+/// Tracks the connection states of multiple <see cref="IAsyncConnection"/> instances and aggregates their overall state.
 /// </summary>
-public class ConnectionStateTracker : Disposable, IConnection
+public class ConnectionStateTracker : Disposable, IAsyncConnection,
+#pragma warning disable CS0618 // Type or member is obsolete
+	IConnection
+#pragma warning restore CS0618
 {
 	/// <summary>
-	/// Wraps an IConnection instance to listen for its state changes.
+	/// Wraps an <see cref="IAsyncConnection"/> instance to listen for its state changes.
 	/// </summary>
 	private class ConnectionWrapper : Disposable
 	{
-		private readonly IConnection _connection;
+		private readonly IAsyncConnection _connection;
 		private readonly Action _stateChanged;
 
 		/// <summary>
@@ -24,7 +27,7 @@ private class ConnectionWrapper : Disposable
 		/// <param name="connection">The connection to wrap.</param>
 		/// <param name="stateChanged">Callback invoked when the connection state changes.</param>
 		/// <exception cref="ArgumentNullException">Thrown when connection or stateChanged is null.</exception>
-		public ConnectionWrapper(IConnection connection, Action stateChanged)
+		public ConnectionWrapper(IAsyncConnection connection, Action stateChanged)
 		{
 			_connection = connection ?? throw new ArgumentNullException(nameof(connection));
 			_stateChanged = stateChanged ?? throw new ArgumentNullException(nameof(stateChanged));
@@ -46,22 +49,56 @@ protected override void DisposeManaged()
 		/// <summary>
 		/// Handles the state change event from the wrapped connection.
 		/// </summary>
-		/// <param name="newState">The new state of the connection.</param>
-		private void OnStateChanged(ConnectionStates newState)
+		private ValueTask OnStateChanged(ConnectionStates newState, CancellationToken cancellationToken)
 		{
 			State = newState;
 			_stateChanged();
+			return default;
 		}
 	}
 
-	private readonly CachedSynchronizedDictionary<IConnection, ConnectionWrapper> _connections = [];
+#pragma warning disable CS0618 // Type or member is obsolete
+	/// <summary>
+	/// Adapts an <see cref="IConnection"/> to <see cref="IAsyncConnection"/>.
+	/// </summary>
+	private sealed class ConnectionAdapter(IConnection connection) : IAsyncConnection
+	{
+		public event Func<ConnectionStates, CancellationToken, ValueTask> StateChanged
+		{
+			add => connection.StateChanged += state => value(state, default);
+			remove { }
+		}
+
+		public ValueTask ConnectAsync(CancellationToken cancellationToken)
+			=> connection.ConnectAsync(cancellationToken);
+
+		public void Disconnect()
+			=> connection.Disconnect();
+	}
+#pragma warning restore CS0618
+
+	private readonly CachedSynchronizedDictionary<IAsyncConnection, ConnectionWrapper> _connections = [];
 	private readonly Lock _currStateLock = new();
 	private ConnectionStates _currState = ConnectionStates.Disconnected;
 
-	/// <summary>
-	/// Occurs when the overall connection state changes.
-	/// </summary>
-	public event Action<ConnectionStates> StateChanged;
+	private event Func<ConnectionStates, CancellationToken, ValueTask> _asyncStateChanged;
+#pragma warning disable CS0618 // Type or member is obsolete
+	private event Action<ConnectionStates> _syncStateChanged;
+
+	/// <inheritdoc />
+	event Action<ConnectionStates> IConnection.StateChanged
+	{
+		add => _syncStateChanged += value;
+		remove => _syncStateChanged -= value;
+	}
+#pragma warning restore CS0618
+
+	/// <inheritdoc />
+	event Func<ConnectionStates, CancellationToken, ValueTask> IAsyncConnection.StateChanged
+	{
+		add => _asyncStateChanged += value;
+		remove => _asyncStateChanged -= value;
+	}
 
 	/// <summary>
 	/// Connects all tracked connections asynchronously.
@@ -89,15 +126,25 @@ public void Disconnect()
 	/// Adds a connection to be tracked.
 	/// </summary>
 	/// <param name="connection">The connection to add.</param>
-	public void Add(IConnection connection)
+	public void Add(IAsyncConnection connection)
 		=> _connections.Add(connection, new(connection, UpdateOverallState));
 
+	/// <summary>
+	/// Adds a connection to be tracked.
+	/// </summary>
+	/// <param name="connection">The connection to add.</param>
+	[Obsolete("Use Add(IAsyncConnection) instead.")]
+#pragma warning disable CS0618 // Type or member is obsolete
+	public void Add(IConnection connection)
+#pragma warning restore CS0618
+		=> Add(new ConnectionAdapter(connection));
+
 	/// <summary>
 	/// Removes a tracked connection.
 	/// </summary>
 	/// <param name="connection">The connection to remove.</param>
 	/// <returns>True if the connection was successfully removed; otherwise, false.</returns>
-	public bool Remove(IConnection connection)
+	public bool Remove(IAsyncConnection connection)
 	{
 		if (!_connections.TryGetAndRemove(connection, out var wrapper))
 			return false;
@@ -107,7 +154,24 @@ public bool Remove(IConnection connection)
 		return true;
 	}
 
-	private IConnection[] Connections => _connections.CachedKeys;
+	/// <summary>
+	/// Removes a tracked connection.
+	/// </summary>
+	/// <param name="connection">The connection to remove.</param>
+	/// <returns>True if the connection was successfully removed; otherwise, false.</returns>
+	[Obsolete("Use Remove(IAsyncConnection) instead.")]
+#pragma warning disable CS0618 // Type or member is obsolete
+	public bool Remove(IConnection connection)
+#pragma warning restore CS0618
+	{
+		var key = _connections.CachedPairs.FirstOrDefault(p => p.Key is ConnectionAdapter).Key;
+		if (key is null)
+			return false;
+
+		return Remove(key);
+	}
+
+	private IAsyncConnection[] Connections => _connections.CachedKeys;
 	private ConnectionWrapper[] Wrappers => _connections.CachedValues;
 
 	/// <summary>
@@ -161,6 +225,6 @@ private void UpdateOverallState()
 			_currState = newState;
 		}
 
-		StateChanged?.Invoke(newState);
+		_syncStateChanged?.Invoke(newState);
 	}
 }

Net.SocketIO/IAsyncConnection.cs

@@ -0,0 +1,24 @@
+namespace Ecng.Net;
+
+/// <summary>
+/// Defines an asynchronous contract for a connection that can be established and disconnected.
+/// </summary>
+public interface IAsyncConnection
+{
+	/// <summary>
+	/// Occurs when the connection state has changed.
+	/// </summary>
+	event Func<ConnectionStates, CancellationToken, ValueTask> StateChanged;
+
+	/// <summary>
+	/// Asynchronously connects to a target.
+	/// </summary>
+	/// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
+	/// <returns>A task representing the asynchronous operation.</returns>
+	ValueTask ConnectAsync(CancellationToken cancellationToken);
+
+	/// <summary>
+	/// Disconnects the current connection.
+	/// </summary>
+	void Disconnect();
+}

Net.SocketIO/IConnection.cs

@@ -3,6 +3,7 @@ namespace Ecng.Net;
 /// <summary>
 /// Defines a standard contract for a connection that can be established and disconnected.
 /// </summary>
+[Obsolete("Use IAsyncConnection instead.")]
 public interface IConnection
 {
 	/// <summary>

Net.SocketIO/WebSocketClient.cs

@@ -10,15 +10,17 @@
 /// <summary>
 /// Represents a client for WebSocket connections.
 /// </summary>
-public class WebSocketClient : Disposable, IConnection
+public class WebSocketClient : Disposable, IAsyncConnection,
+#pragma warning disable CS0618 // Type or member is obsolete
+	IConnection
+#pragma warning restore CS0618
 {
 	private ClientWebSocket _ws;
 	private CancellationTokenSource _source;
 
 	private readonly SynchronizedDictionary<CancellationTokenSource, bool> _disconnectionStates = [];
 
 	private readonly Func<Exception, CancellationToken, ValueTask> _error;
-	private readonly Func<ConnectionStates, CancellationToken, ValueTask> _stateChanged;
 	private readonly Func<WebSocketClient, WebSocketMessage, CancellationToken, ValueTask> _process;
 	private readonly Action<string, object> _infoLog;
 	private readonly Action<string, object> _errorLog;
@@ -38,6 +40,7 @@ public class WebSocketClient : Disposable, IConnection
 	/// <param name="errorLog">Action to log error messages.</param>
 	/// <param name="verboseLog">Action to log verbose messages.</param>
 	/// <exception cref="ArgumentNullException">If any required parameter is null.</exception>
+	[Obsolete("Use constructor with Func<T, CancellationToken, ValueTask> callbacks instead.")]
 	public WebSocketClient(string url, Action<ConnectionStates> stateChanged, Action<Exception> error,
 		Func<WebSocketMessage, CancellationToken, ValueTask> process,
 		Action<string, object> infoLog, Action<string, object> errorLog, Action<string, object> verboseLog)
@@ -58,6 +61,7 @@ public WebSocketClient(string url, Action<ConnectionStates> stateChanged, Action
 	/// <param name="errorLog">Action to log error messages.</param>
 	/// <param name="verboseLog">Action to log verbose messages.</param>
 	/// <exception cref="ArgumentNullException">If any required parameter is null.</exception>
+	[Obsolete("Use constructor with Func<T, CancellationToken, ValueTask> callbacks instead.")]
 	public WebSocketClient(string url, Action<ConnectionStates> stateChanged, Action<Exception> error,
 		Func<WebSocketClient, WebSocketMessage, CancellationToken, ValueTask> process,
 		Action<string, object> infoLog, Action<string, object> errorLog, Action<string, object> verboseLog)
@@ -180,10 +184,25 @@ public int ReconnectAttempts
 		}
 	}
 
-	/// <summary>
-	/// Occurs when the connection state changes.
-	/// </summary>
-	public event Action<ConnectionStates> StateChanged;
+#pragma warning disable CS0618 // Type or member is obsolete
+	private event Action<ConnectionStates> _syncStateChanged;
+
+	/// <inheritdoc />
+	event Action<ConnectionStates> IConnection.StateChanged
+	{
+		add => _syncStateChanged += value;
+		remove => _syncStateChanged -= value;
+	}
+#pragma warning restore CS0618
+
+	private event Func<ConnectionStates, CancellationToken, ValueTask> _stateChanged;
+
+	/// <inheritdoc />
+	event Func<ConnectionStates, CancellationToken, ValueTask> IAsyncConnection.StateChanged
+	{
+		add => _stateChanged += value;
+		remove => _stateChanged -= value;
+	}
 
 	/// <summary>
 	/// Occurs when the client web socket is initialized.
@@ -235,16 +254,18 @@ public async ValueTask ConnectAsync(CancellationToken cancellationToken)
 		await ConnectImpl(source, false, 0, linked.Token);
 	}
 
-	private ValueTask RaiseStateChangedAsync(ConnectionStates state, CancellationToken cancellationToken)
+	private async ValueTask RaiseStateChangedAsync(ConnectionStates state, CancellationToken cancellationToken)
 	{
 		if (state == ConnectionStates.Failed)
 			_errorLog("{0}", state);
 		else
 			_infoLog("{0}", state);
 
 		State = state;
-		StateChanged?.Invoke(state);
-		return _stateChanged(state, cancellationToken);
+		_syncStateChanged?.Invoke(state);
+
+		if (_stateChanged is { } handler)
+			await handler(state, cancellationToken);
 	}
 
 	private ValueTask RaiseErrorAsync(Exception ex, CancellationToken cancellationToken)