Add more function mappings for MQTTnet Server.

Source/MQTTnet/Server/IMqttServer.cs

@@ -11,16 +11,9 @@ namespace MQTTnet.Server
         event EventHandler Stopped;
 
         IMqttServerClientConnectedHandler ClientConnectedHandler { get; set; }
-        [Obsolete("Use ClientConnectedHandler instead.")]
-        event EventHandler<MqttServerClientConnectedEventArgs> ClientConnected;
-
         IMqttServerClientDisconnectedHandler ClientDisconnectedHandler { get; set; }
-        [Obsolete("Use ClientDisconnectedHandler instead.")]
-        event EventHandler<MqttServerClientDisconnectedEventArgs> ClientDisconnected;
-
-        event EventHandler<MqttClientSubscribedTopicEventArgs> ClientSubscribedTopic;
-
-        event EventHandler<MqttClientUnsubscribedTopicEventArgs> ClientUnsubscribedTopic;
+        IMqttServerClientSubscribedTopicHandler ClientSubscribedTopicHandler { get; set; }
+        IMqttServerClientUnsubscribedTopicHandler ClientUnsubscribedTopicHandler { get; set; }
         
         IMqttServerOptions Options { get; }
 

Source/MQTTnet/Server/IMqttServerClientSubscribedTopicHandler.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace MQTTnet.Server
+{
+    public interface IMqttServerClientSubscribedTopicHandler
+    {
+        Task HandleClientSubscribedTopicAsync(MqttServerClientSubscribedTopicEventArgs eventArgs);
+    }
+}

Source/MQTTnet/Server/IMqttServerClientUnsubscribedTopicHandler.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace MQTTnet.Server
+{
+    public interface IMqttServerClientUnsubscribedTopicHandler
+    {
+        Task HandleClientUnsubscribedTopicAsync(MqttServerClientUnsubscribedTopicEventArgs eventArgs);
+    }
+}

Source/MQTTnet/Server/MqttClientSessionsManager.cs

@@ -196,7 +196,7 @@ namespace MQTTnet.Server
                     applicationMessage = interceptorContext.ApplicationMessage;
                 }
 
-                _eventDispatcher.OnApplicationMessageReceived(sender?.ClientId, applicationMessage);
+                await _eventDispatcher.HandleApplicationMessageReceivedAsync(sender?.ClientId, applicationMessage).ConfigureAwait(false);
 
                 if (applicationMessage.Retain)
                 {
@@ -258,7 +258,7 @@ namespace MQTTnet.Server
 
                 var connection = await CreateConnectionAsync(channelAdapter, connectPacket).ConfigureAwait(false);
 
-                _eventDispatcher.OnClientConnected(clientId);
+                await _eventDispatcher.HandleClientConnectedAsync(clientId).ConfigureAwait(false);
                 
                 disconnectType = await connection.RunAsync().ConfigureAwait(false);
             }
@@ -288,7 +288,7 @@ namespace MQTTnet.Server
 
                 await TryCleanupChannelAsync(channelAdapter).ConfigureAwait(false);
 
-                _eventDispatcher.OnClientDisconnected(clientId, disconnectType);
+                await _eventDispatcher.HandleClientDisconnectedAsync(clientId, disconnectType).ConfigureAwait(false);
             }
         }
 

Source/MQTTnet/Server/MqttClientSubscriptionsManager.cs

@@ -61,7 +61,7 @@ namespace MQTTnet.Server
                         _subscriptions[topicFilter.Topic] = topicFilter.QualityOfServiceLevel;
                     }
 
-                    _eventDispatcher.OnClientSubscribedTopic(_clientId, topicFilter);
+                    await _eventDispatcher.HandleClientSubscribedTopicAsync(_clientId, topicFilter).ConfigureAwait(false);
                 }
             }
 
@@ -85,12 +85,12 @@ namespace MQTTnet.Server
                         _subscriptions[topicFilter.Topic] = topicFilter.QualityOfServiceLevel;
                     }
 
-                    _eventDispatcher.OnClientSubscribedTopic(_clientId, topicFilter);
+                    await _eventDispatcher.HandleClientSubscribedTopicAsync(_clientId, topicFilter).ConfigureAwait(false);
                 }
             }
         }
 
-        public Task<MqttUnsubAckPacket> UnsubscribeAsync(MqttUnsubscribePacket unsubscribePacket)
+        public async Task<MqttUnsubAckPacket> UnsubscribeAsync(MqttUnsubscribePacket unsubscribePacket)
         {
             if (unsubscribePacket == null) throw new ArgumentNullException(nameof(unsubscribePacket));
 
@@ -111,12 +111,15 @@ namespace MQTTnet.Server
                     {
                         unsubAckPacket.ReasonCodes.Add(MqttUnsubscribeReasonCode.NoSubscriptionExisted);
                     }
-
-                    _eventDispatcher.OnClientUnsubscribedTopic(_clientId, topicFilter);
                 }
             }
 
-            return Task.FromResult(unsubAckPacket);
+            foreach (var topicFilter in unsubscribePacket.TopicFilters)
+            {
+                await _eventDispatcher.HandleClientUnsubscribedTopicAsync(_clientId, topicFilter).ConfigureAwait(false);
+            }
+            
+            return unsubAckPacket;
         }
 
         public Task UnsubscribeAsync(IEnumerable<string> topicFilters)

Source/MQTTnet/Server/MqttServer.cs

@@ -28,40 +28,40 @@ namespace MQTTnet.Server
 
             if (logger == null) throw new ArgumentNullException(nameof(logger));
             _logger = logger.CreateChildLogger(nameof(MqttServer));
-
-            _eventDispatcher.ClientConnected += (s, e) => ClientConnected?.Invoke(s, e);
-            _eventDispatcher.ClientDisconnected += (s, e) => ClientDisconnected?.Invoke(s, e);
-            _eventDispatcher.ClientSubscribedTopic += (s, e) => ClientSubscribedTopic?.Invoke(s, e);
-            _eventDispatcher.ClientUnsubscribedTopic += (s, e) => ClientUnsubscribedTopic?.Invoke(s, e);
-            _eventDispatcher.ApplicationMessageReceived += async (s, e) =>
-            {
-                // TODO: Migrate EventDispatcher to proper handlers and no events anymore.
-                ApplicationMessageReceived?.Invoke(s, e);
-
-                var handler = ReceivedApplicationMessageHandler;
-                if (handler != null)
-                {
-                    await handler.HandleApplicationMessageAsync(
-                        new MqttApplicationMessageHandlerContext(e.ClientId, e.ApplicationMessage)).ConfigureAwait(false);
-                }
-            };
         }
 
         public event EventHandler Started;
         public event EventHandler Stopped;
 
-        public IMqttServerClientConnectedHandler ClientConnectedHandler { get; set; }
-        public event EventHandler<MqttServerClientConnectedEventArgs> ClientConnected;
+        public IMqttServerClientConnectedHandler ClientConnectedHandler
+        {
+            get => _eventDispatcher.ClientConnectedHandler;
+            set => _eventDispatcher.ClientConnectedHandler = value;
+        }
 
-        public IMqttServerClientDisconnectedHandler ClientDisconnectedHandler { get; set; }
-        public event EventHandler<MqttServerClientDisconnectedEventArgs> ClientDisconnected;
+        public IMqttServerClientDisconnectedHandler ClientDisconnectedHandler
+        {
+            get => _eventDispatcher.ClientDisconnectedHandler;
+            set => _eventDispatcher.ClientDisconnectedHandler = value;
+        }
+        
+        public IMqttServerClientSubscribedTopicHandler ClientSubscribedTopicHandler
+        {
+            get => _eventDispatcher.ClientSubscribedTopicHandler;
+            set => _eventDispatcher.ClientSubscribedTopicHandler = value;
+        }
 
-        public event EventHandler<MqttClientSubscribedTopicEventArgs> ClientSubscribedTopic;
-
-        public event EventHandler<MqttClientUnsubscribedTopicEventArgs> ClientUnsubscribedTopic;
-
-        public IMqttApplicationMessageHandler ReceivedApplicationMessageHandler { get; set; }
-        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+        public IMqttServerClientUnsubscribedTopicHandler ClientUnsubscribedTopicHandler
+        {
+            get => _eventDispatcher.ClientUnsubscribedTopicHandler;
+            set => _eventDispatcher.ClientUnsubscribedTopicHandler = value;
+        }
+        
+        public IMqttApplicationMessageHandler ApplicationMessageReceivedHandler
+        {
+            get => _eventDispatcher.ApplicationMessageReceivedHandler;
+            set => _eventDispatcher.ApplicationMessageReceivedHandler = value;
+        }
 
         public IMqttServerOptions Options { get; private set; }
 
@@ -123,7 +123,7 @@ namespace MQTTnet.Server
 
             foreach (var adapter in _adapters)
             {
-                adapter.ClientAccepted += OnClientAccepted;
+                adapter.ClientAcceptedHandler = OnClientAccepted;
                 await adapter.StartAsync(Options).ConfigureAwait(false);
             }
 
@@ -146,7 +146,7 @@ namespace MQTTnet.Server
 
                 foreach (var adapter in _adapters)
                 {
-                    adapter.ClientAccepted -= OnClientAccepted;
+                    adapter.ClientAcceptedHandler = null;
                     await adapter.StopAsync().ConfigureAwait(false);
                 }
 
@@ -170,7 +170,7 @@ namespace MQTTnet.Server
             return _retainedMessagesManager?.ClearMessagesAsync();
         }
 
-        private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs eventArgs)
+        private void OnClientAccepted(MqttServerAdapterClientAcceptedEventArgs eventArgs)
         {
             eventArgs.SessionTask = _clientSessionsManager.HandleConnectionAsync(eventArgs.Client);
         }

Source/MQTTnet/Server/MqttServerClientConnectedHandlerDelegate.cs

@@ -11,9 +11,9 @@ namespace MQTTnet.Server
         {
             if (handler == null) throw new ArgumentNullException(nameof(handler));
 
-            _handler = context =>
+            _handler = eventArgs =>
             {
-                handler(context);
+                handler(eventArgs);
                 return Task.FromResult(0);
             };
         }

Source/MQTTnet/Server/MqttServerClientDisconnectedHandlerDelegate.cs

@@ -11,9 +11,9 @@ namespace MQTTnet.Server
         {
             if (handler == null) throw new ArgumentNullException(nameof(handler));
 
-            _handler = context =>
+            _handler = eventArgs =>
             {
-                handler(context);
+                handler(eventArgs);
                 return Task.FromResult(0);
             };
         }

Source/MQTTnet/Server/MqttServerClientSubscribedTopicEventArgs.cs

@@ -2,9 +2,9 @@
 
 namespace MQTTnet.Server
 {
-    public class MqttClientSubscribedTopicEventArgs : EventArgs
+    public class MqttServerClientSubscribedTopicEventArgs : EventArgs
     {
-        public MqttClientSubscribedTopicEventArgs(string clientId, TopicFilter topicFilter)
+        public MqttServerClientSubscribedTopicEventArgs(string clientId, TopicFilter topicFilter)
         {
             ClientId = clientId ?? throw new ArgumentNullException(nameof(clientId));
             TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter));

Source/MQTTnet/Server/MqttServerClientSubscribedTopicHandlerDelegate.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Server
+{
+    public class MqttServerClientSubscribedHandlerDelegate : IMqttServerClientSubscribedTopicHandler
+    {
+        private readonly Func<MqttServerClientSubscribedTopicEventArgs, Task> _handler;
+
+        public MqttServerClientSubscribedHandlerDelegate(Action<MqttServerClientSubscribedTopicEventArgs> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            _handler = eventArgs =>
+            {
+                handler(eventArgs);
+                return Task.FromResult(0);
+            };
+        }
+
+        public MqttServerClientSubscribedHandlerDelegate(Func<MqttServerClientSubscribedTopicEventArgs, Task> handler)
+        {
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        public Task HandleClientSubscribedTopicAsync(MqttServerClientSubscribedTopicEventArgs eventArgs)
+        {
+            return _handler(eventArgs);
+        }
+    }
+}

Source/MQTTnet/Server/MqttServerClientUnsubscribedTopicEventArgs.cs

@@ -2,9 +2,9 @@
 
 namespace MQTTnet.Server
 {
-    public class MqttClientUnsubscribedTopicEventArgs : EventArgs
+    public class MqttServerClientUnsubscribedTopicEventArgs : EventArgs
     {
-        public MqttClientUnsubscribedTopicEventArgs(string clientId, string topicFilter)
+        public MqttServerClientUnsubscribedTopicEventArgs(string clientId, string topicFilter)
         {
             ClientId = clientId ?? throw new ArgumentNullException(nameof(clientId));
             TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter));

Source/MQTTnet/Server/MqttServerClientUnsubscribedTopicHandlerDelegate.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Server
+{
+    public class MqttServerClientUnsubscribedTopicHandlerDelegate : IMqttServerClientUnsubscribedTopicHandler
+    {
+        private readonly Func<MqttServerClientUnsubscribedTopicEventArgs, Task> _handler;
+
+        public MqttServerClientUnsubscribedTopicHandlerDelegate(Action<MqttServerClientUnsubscribedTopicEventArgs> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            _handler = eventArgs =>
+            {
+                handler(eventArgs);
+                return Task.FromResult(0);
+            };
+        }
+
+        public MqttServerClientUnsubscribedTopicHandlerDelegate(Func<MqttServerClientUnsubscribedTopicEventArgs, Task> handler)
+        {
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        public Task HandleClientUnsubscribedTopicAsync(MqttServerClientUnsubscribedTopicEventArgs eventArgs)
+        {
+            return _handler(eventArgs);
+        }
+    }
+}

Source/MQTTnet/Server/MqttServerEventDispatcher.cs

@@ -1,42 +1,73 @@
-using System;
+using System.Threading.Tasks;
+using MQTTnet.Client.Receiving;
 
 namespace MQTTnet.Server
 {
     public class MqttServerEventDispatcher
     {
-        public event EventHandler<MqttClientSubscribedTopicEventArgs> ClientSubscribedTopic;
+        public IMqttServerClientConnectedHandler ClientConnectedHandler { get; set; }
 
-        public event EventHandler<MqttClientUnsubscribedTopicEventArgs> ClientUnsubscribedTopic;
+        public IMqttServerClientDisconnectedHandler ClientDisconnectedHandler { get; set; }
 
-        public event EventHandler<MqttServerClientConnectedEventArgs> ClientConnected;
+        public IMqttServerClientSubscribedTopicHandler ClientSubscribedTopicHandler { get; set; }
 
-        public event EventHandler<MqttServerClientDisconnectedEventArgs> ClientDisconnected;
+        public IMqttServerClientUnsubscribedTopicHandler ClientUnsubscribedTopicHandler { get; set; }
 
-        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+        public IMqttApplicationMessageHandler ApplicationMessageReceivedHandler { get; set; }
 
-        public void OnClientSubscribedTopic(string clientId, TopicFilter topicFilter)
+        public Task HandleClientConnectedAsync(string clientId)
         {
-            ClientSubscribedTopic?.Invoke(this, new MqttClientSubscribedTopicEventArgs(clientId, topicFilter));
+            var handler = ClientConnectedHandler;
+            if (handler == null)
+            {
+                return Task.FromResult(0);
+            }
+
+            return handler.HandleClientConnectedAsync(new MqttServerClientConnectedEventArgs(clientId));
         }
 
-        public void OnClientUnsubscribedTopic(string clientId, string topicFilter)
+        public Task HandleClientDisconnectedAsync(string clientId, MqttClientDisconnectType disconnectType)
         {
-            ClientUnsubscribedTopic?.Invoke(this, new MqttClientUnsubscribedTopicEventArgs(clientId, topicFilter));
+            var handler = ClientDisconnectedHandler;
+            if (handler == null)
+            {
+                return Task.FromResult(0);
+            }
+
+            return handler.HandleClientDisconnectedAsync(new MqttServerClientDisconnectedEventArgs(clientId, disconnectType));
         }
 
-        public void OnClientDisconnected(string clientId, MqttClientDisconnectType disconnectType)
+        public Task HandleClientSubscribedTopicAsync(string clientId, TopicFilter topicFilter)
         {
-            ClientDisconnected?.Invoke(this, new MqttServerClientDisconnectedEventArgs(clientId, disconnectType));
+            var handler = ClientSubscribedTopicHandler;
+            if (handler == null)
+            {
+                return Task.FromResult(0);
+            }
+
+            return handler.HandleClientSubscribedTopicAsync(new MqttServerClientSubscribedTopicEventArgs(clientId, topicFilter));
         }
 
-        public void OnApplicationMessageReceived(string senderClientId, MqttApplicationMessage applicationMessage)
+        public Task HandleClientUnsubscribedTopicAsync(string clientId, string topicFilter)
         {
-            ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(senderClientId, applicationMessage));
+            var handler = ClientUnsubscribedTopicHandler;
+            if (handler == null)
+            {
+                return Task.FromResult(0);
+            }
+
+            return handler.HandleClientUnsubscribedTopicAsync(new MqttServerClientUnsubscribedTopicEventArgs(clientId, topicFilter));
         }
 
-        public void OnClientConnected(string clientId)
+        public Task HandleApplicationMessageReceivedAsync(string senderClientId, MqttApplicationMessage applicationMessage)
         {
-            ClientConnected?.Invoke(this, new MqttServerClientConnectedEventArgs(clientId));
+            var handler = ApplicationMessageReceivedHandler;
+            if (handler == null)
+            {
+                return Task.FromResult(0);
+            }
+
+            return handler.HandleApplicationMessageAsync(new MqttApplicationMessageReceivedEventArgs(senderClientId, applicationMessage));
         }
     }
 }