feat: WIP request/response message handler (not done yet)

Author: insthync

SimpleNetworkManager.NET/Messages/BaseRequestMessage.cs

@@ -14,6 +14,6 @@ public abstract class BaseRequestMessage : BaseMessage
         /// Generated automatically when the request is created.
         /// </summary>
         [Key(0)]
-        public Guid RequestId { get; set; }
+        public Guid RequestId { get; internal set; }
     }
 }

SimpleNetworkManager.NET/Messages/BaseRequestResponseMessageHandler.cs

@@ -0,0 +1,39 @@
+using Cysharp.Threading.Tasks;
+using Insthync.SimpleNetworkManager.NET.Network;
+using System;
+
+namespace Insthync.SimpleNetworkManager.NET.Messages
+{
+    public abstract class BaseRequestResponseMessageHandler<TRequest, TResponse> : BaseMessageHandler<TRequest>, IResponseMessageHandler
+        where TRequest : BaseRequestMessage
+        where TResponse : BaseResponseMessage
+    {
+        private static TResponse? s_responseMessageInstance;
+
+        public virtual BaseMessage GetResponseMessageInstance()
+        {
+            if (s_responseMessageInstance == null)
+                s_responseMessageInstance = Activator.CreateInstance<TResponse>();
+            return s_responseMessageInstance;
+        }
+
+        protected override sealed async UniTask HandleAsync(BaseClientConnection clientConnection, TRequest data)
+        {
+            Guid requestId = data.RequestId;
+            var response = await HandleRequestAsync(clientConnection, data);
+            response.RequestId = requestId;
+            await clientConnection.SendMessageAsync(data);
+        }
+
+        protected abstract UniTask<TResponse> HandleRequestAsync(BaseClientConnection clientConnection, TRequest request);
+
+        public UniTask HandleResponseDataAsync(BaseClientConnection clientConnection, object? data)
+        {
+            if (data == null)
+                throw new ArgumentNullException(nameof(data));
+            return HandleResponseAsync(clientConnection, (TResponse)data);
+        }
+
+        protected abstract UniTask HandleResponseAsync(BaseClientConnection clientConnection, TResponse request);
+    }
+}

SimpleNetworkManager.NET/Messages/BaseResponseMessage.cs

@@ -13,7 +13,7 @@ public abstract class BaseResponseMessage : BaseMessage
         /// Correlation ID that matches the original request's RequestId
         /// </summary>
         [Key(0)]
-        public Guid RequestId { get; set; }
+        public Guid RequestId { get; internal set; }
 
         /// <summary>
         /// Indicates if the request was successful

SimpleNetworkManager.NET/Messages/IResponseMessageHandler.cs

@@ -0,0 +1,11 @@
+using Cysharp.Threading.Tasks;
+using Insthync.SimpleNetworkManager.NET.Network;
+
+namespace Insthync.SimpleNetworkManager.NET.Messages
+{
+    internal interface IResponseMessageHandler : IMessageHandler
+    {
+        BaseMessage GetResponseMessageInstance();
+        public UniTask HandleResponseDataAsync(BaseClientConnection clientConnection, object? data);
+    }
+}

SimpleNetworkManager.NET/Services/MessageRouter.cs

@@ -16,11 +16,15 @@ public class MessageRouter
     {
         private readonly ILogger<MessageRouter> _logger;
         private readonly ConcurrentDictionary<uint, IMessageHandler> _handlers;
+        private readonly ConcurrentDictionary<uint, IMessageHandler> _requestHandlers;
+        private readonly ConcurrentDictionary<uint, IResponseMessageHandler> _responseHandlers;
 
         public MessageRouter(ILogger<MessageRouter> logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _handlers = new ConcurrentDictionary<uint, IMessageHandler>();
+            _requestHandlers = new ConcurrentDictionary<uint, IMessageHandler>();
+            _responseHandlers = new ConcurrentDictionary<uint, IResponseMessageHandler>();
         }
 
         /// <summary>
@@ -52,6 +56,53 @@ public void RegisterHandler<T>(BaseMessageHandler<T> handler)
             }
         }
 
+        /// <summary>
+        /// Registers a request message handler for a specific message type
+        /// </summary>
+        /// <typeparam name="TRequest">Type of request message the handler processes</typeparam>
+        /// <typeparam name="TResponse">Type of response message the handler processes</typeparam>
+        /// <param name="handler">Handler instance to register</param>
+        /// <exception cref="ArgumentNullException">Thrown when handler is null</exception>
+        public void RegisterHandler<TRequest, TResponse>(BaseRequestResponseMessageHandler<TRequest, TResponse> handler)
+            where TRequest : BaseRequestMessage
+            where TResponse : BaseResponseMessage
+        {
+            if (handler == null)
+                throw new ArgumentNullException(nameof(handler));
+
+            // Get the request message type from the generic type parameter
+            var requestInstance = handler.GetMessageInstance();
+            var requestType = requestInstance.GetMessageType();
+
+            if (_requestHandlers.TryAdd(requestType, handler))
+            {
+                _logger.LogDebug("Registered handler for message type {MessageType} ({TypeName})",
+                    requestType, typeof(TRequest).Name);
+            }
+            else
+            {
+                _logger.LogWarning("Handler for message type {MessageType} ({TypeName}) already registered, replacing",
+                    requestType, typeof(TRequest).Name);
+                _requestHandlers[requestType] = handler;
+            }
+
+            // Get the response message type from the generic type parameter
+            var responseInstance = handler.GetResponseMessageInstance();
+            var responseType = responseInstance.GetMessageType();
+
+            if (_responseHandlers.TryAdd(responseType, handler))
+            {
+                _logger.LogDebug("Registered handler for message type {MessageType} ({TypeName})",
+                    responseType, typeof(TResponse).Name);
+            }
+            else
+            {
+                _logger.LogWarning("Handler for message type {MessageType} ({TypeName}) already registered, replacing",
+                    responseType, typeof(TResponse).Name);
+                _responseHandlers[responseType] = handler;
+            }
+        }
+
         /// <summary>
         /// Routes a message to the appropriate handler
         /// </summary>
@@ -67,16 +118,26 @@ public async UniTask RouteMessageAsync(BaseClientConnection clientConnection, by
                 throw new ArgumentNullException(nameof(message));
 
             var data = BaseMessage.ExtractMessageData(message, out var messageType);
-            if (!_handlers.TryGetValue(messageType, out var handler))
+            if (_handlers.TryGetValue(messageType, out var handler))
             {
-                _logger.LogWarning("No handler registered for message type {MessageType} from client {ConnectionId}",
-                    messageType, clientConnection.ConnectionId);
-                return;
+                var messageInstance = handler.GetMessageInstance();
+                var dataType = messageInstance.GetType();
+                await handler.HandleDataAsync(clientConnection, MessagePackSerializer.Deserialize(messageInstance.GetType(), data, messageInstance.GetMessagePackOptions()));
             }
 
-            var messageInstance = handler.GetMessageInstance();
-            var dataType = messageInstance.GetType();
-            await handler.HandleDataAsync(clientConnection, MessagePackSerializer.Deserialize(messageInstance.GetType(), data, messageInstance.GetMessagePackOptions()));
+            if (_requestHandlers.TryGetValue(messageType, out var requestHandler))
+            {
+                var messageInstance = requestHandler.GetMessageInstance();
+                var dataType = messageInstance.GetType();
+                await requestHandler.HandleDataAsync(clientConnection, MessagePackSerializer.Deserialize(messageInstance.GetType(), data, messageInstance.GetMessagePackOptions()));
+            }
+
+            if (_responseHandlers.TryGetValue(messageType, out var responseHandler))
+            {
+                var messageInstance = responseHandler.GetMessageInstance();
+                var dataType = messageInstance.GetType();
+                await responseHandler.HandleResponseDataAsync(clientConnection, MessagePackSerializer.Deserialize(messageInstance.GetType(), data, messageInstance.GetMessagePackOptions()));
+            }
         }
     }
 }