Refactor event handler namings.

Source/MQTTnet.Extensions.ManagedClient/ApplicationMessageProcessedHandlerDelegate.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ApplicationMessageProcessedHandlerDelegate : IApplicationMessageProcessedHandler
+    {
+        private readonly Func<ApplicationMessageProcessedEventArgs, Task> _handler;
+
+        public ApplicationMessageProcessedHandlerDelegate(Action<ApplicationMessageProcessedEventArgs> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            _handler = context =>
+            {
+                handler(context);
+                return Task.FromResult(0);
+            };
+        }
+
+        public ApplicationMessageProcessedHandlerDelegate(Func<ApplicationMessageProcessedEventArgs, Task> handler)
+        {
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        public Task HandleApplicationMessageProcessedAsync(ApplicationMessageProcessedEventArgs eventArgs)
+        {
+            return _handler(eventArgs);
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ApplicationMessageSkippedHandlerDelegate.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ApplicationMessageSkippedHandlerDelegate : IApplicationMessageSkippedHandler
+    {
+        private readonly Func<ApplicationMessageSkippedEventArgs, Task> _handler;
+
+        public ApplicationMessageSkippedHandlerDelegate(Action<ApplicationMessageSkippedEventArgs> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            _handler = eventArgs =>
+            {
+                handler(eventArgs);
+                return Task.FromResult(0);
+            };
+        }
+
+        public ApplicationMessageSkippedHandlerDelegate(Func<ApplicationMessageSkippedEventArgs, Task> handler)
+        {
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        public Task HandleApplicationMessageSkippedAsync(ApplicationMessageSkippedEventArgs eventArgs)
+        {
+            return _handler(eventArgs);
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ConnectingFailedHandlerDelegate.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ConnectingFailedHandlerDelegate : IConnectingFailedHandler
+    {
+        private readonly Func<ManagedProcessFailedEventArgs, Task> _handler;
+
+        public ConnectingFailedHandlerDelegate(Action<ManagedProcessFailedEventArgs> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            _handler = eventArgs =>
+            {
+                handler(eventArgs);
+                return Task.FromResult(0);
+            };
+        }
+
+        public ConnectingFailedHandlerDelegate(Func<ManagedProcessFailedEventArgs, Task> handler)
+        {
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        public Task HandleConnectingFailedAsync(ManagedProcessFailedEventArgs eventArgs)
+        {
+            return _handler(eventArgs);
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/IApplicationMessageProcessedHandler.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public interface IApplicationMessageProcessedHandler
+    {
+        Task HandleApplicationMessageProcessedAsync(ApplicationMessageProcessedEventArgs eventArgs);
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/IApplicationMessageSkippedHandler.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public interface IApplicationMessageSkippedHandler
+    {
+        Task HandleApplicationMessageSkippedAsync(ApplicationMessageSkippedEventArgs eventArgs);
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/IConnectingFailedHandler.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public interface IConnectingFailedHandler
+    {
+        Task HandleConnectingFailedAsync(ManagedProcessFailedEventArgs eventArgs);
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/IManagedMqttClient.cs

@@ -15,13 +15,13 @@ namespace MQTTnet.Extensions.ManagedClient
 
         IMqttClientConnectedHandler ConnectedHandler { get; set; }
         IMqttClientDisconnectedHandler DisconnectedHandler { get; set; }
+
+        IApplicationMessageProcessedHandler ApplicationMessageProcessedHandler { get; set; }
+        IApplicationMessageSkippedHandler ApplicationMessageSkippedHandler { get; set; }
+
+        IConnectingFailedHandler ConnectingFailedHandler { get; set; }
+        ISynchronizingSubscriptionsFailedHandler SynchronizingSubscriptionsFailedHandler { get; set; }
         
-        event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
-        event EventHandler<ApplicationMessageSkippedEventArgs> ApplicationMessageSkipped;
-
-        event EventHandler<MqttManagedProcessFailedEventArgs> ConnectingFailed;
-        event EventHandler<MqttManagedProcessFailedEventArgs> SynchronizingSubscriptionsFailed;
-
         Task StartAsync(IManagedMqttClientOptions options);
         Task StopAsync();
 

Source/MQTTnet.Extensions.ManagedClient/IManagedMqttClientOptions.cs

@@ -1,5 +1,4 @@
 using System;
-using MQTTnet.Client;
 using MQTTnet.Client.Options;
 using MQTTnet.Server;
 

Source/MQTTnet.Extensions.ManagedClient/ISynchronizingSubscriptionsFailedHandler.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public interface ISynchronizingSubscriptionsFailedHandler
+    {
+        Task HandleSynchronizingSubscriptionsFailedAsync(ManagedProcessFailedEventArgs eventArgs);
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClient.cs

@@ -57,17 +57,19 @@ namespace MQTTnet.Extensions.ManagedClient
             set => _mqttClient.DisconnectedHandler = value;
         }
 
-        public IMqttApplicationMessageHandler ApplicationMessageReceivedHandler
+        public IMqttApplicationMessageReceivedHandler ApplicationMessageReceivedHandler
         {
             get => _mqttClient.ApplicationMessageReceivedHandler;
             set => _mqttClient.ApplicationMessageReceivedHandler = value;
         }
 
-        public event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
-        public event EventHandler<ApplicationMessageSkippedEventArgs> ApplicationMessageSkipped;
+        public IApplicationMessageProcessedHandler ApplicationMessageProcessedHandler { get; set; }
 
-        public event EventHandler<MqttManagedProcessFailedEventArgs> ConnectingFailed;
-        public event EventHandler<MqttManagedProcessFailedEventArgs> SynchronizingSubscriptionsFailed;
+        public IApplicationMessageSkippedHandler ApplicationMessageSkippedHandler { get; set; }
+
+        public IConnectingFailedHandler ConnectingFailedHandler { get; set; }
+
+        public ISynchronizingSubscriptionsFailedHandler SynchronizingSubscriptionsFailedHandler { get; set; }
 
         public async Task StartAsync(IManagedMqttClientOptions options)
         {
@@ -126,28 +128,45 @@ namespace MQTTnet.Extensions.ManagedClient
             if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
 
             ManagedMqttApplicationMessage removedMessage = null;
-            lock (_messageQueue)
+            ApplicationMessageSkippedEventArgs applicationMessageSkippedEventArgs = null;
+
+            try
             {
-                if (_messageQueue.Count >= Options.MaxPendingMessages)
+                lock (_messageQueue)
                 {
-                    if (Options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropNewMessage)
+                    if (_messageQueue.Count >= Options.MaxPendingMessages)
                     {
-                        _logger.Verbose("Skipping publish of new application message because internal queue is full.");
-                        ApplicationMessageSkipped?.Invoke(this, new ApplicationMessageSkippedEventArgs(applicationMessage));
-                        return;
+                        if (Options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropNewMessage)
+                        {
+                            _logger.Verbose("Skipping publish of new application message because internal queue is full.");
+                            applicationMessageSkippedEventArgs = new ApplicationMessageSkippedEventArgs(applicationMessage);
+                            return;
+                        }
+
+                        if (Options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
+                        {
+                            removedMessage = _messageQueue.RemoveFirst();
+                            _logger.Verbose("Removed oldest application message from internal queue because it is full.");
+                            applicationMessageSkippedEventArgs = new ApplicationMessageSkippedEventArgs(removedMessage);
+                        }
                     }
 
-                    if (Options.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
+                    _messageQueue.Enqueue(applicationMessage);
+                }
+            }
+            finally
+            {
+                if (applicationMessageSkippedEventArgs != null)
+                {
+                    var applicationMessageSkippedHandler = ApplicationMessageSkippedHandler;
+                    if (applicationMessageSkippedHandler != null)
                     {
-                        removedMessage = _messageQueue.RemoveFirst();
-                        _logger.Verbose("Removed oldest application message from internal queue because it is full.");
-                        ApplicationMessageSkipped?.Invoke(this, new ApplicationMessageSkippedEventArgs(removedMessage));
+                        await applicationMessageSkippedHandler.HandleApplicationMessageSkippedAsync(applicationMessageSkippedEventArgs).ConfigureAwait(false);
                     }
                 }
 
-                _messageQueue.Enqueue(applicationMessage);
             }
-
+            
             if (_storageManager != null)
             {
                 if (removedMessage != null)
@@ -352,7 +371,7 @@ namespace MQTTnet.Extensions.ManagedClient
             }
             finally
             {
-                ApplicationMessageProcessed?.Invoke(this, new ApplicationMessageProcessedEventArgs(message, transmitException));
+                ApplicationMessageProcessedHandler?.HandleApplicationMessageProcessedAsync(new ApplicationMessageProcessedEventArgs(message, transmitException)).GetAwaiter().GetResult();
             }
         }
 
@@ -395,7 +414,11 @@ namespace MQTTnet.Extensions.ManagedClient
                 _logger.Warning(exception, "Synchronizing subscriptions failed.");
                 _subscriptionsNotPushed = true;
 
-                SynchronizingSubscriptionsFailed?.Invoke(this, new MqttManagedProcessFailedEventArgs(exception));
+                var synchronizingSubscriptionsFailedHandler = SynchronizingSubscriptionsFailedHandler;
+                if (SynchronizingSubscriptionsFailedHandler != null)
+                {
+                    await synchronizingSubscriptionsFailedHandler.HandleSynchronizingSubscriptionsFailedAsync(new ManagedProcessFailedEventArgs(exception)).ConfigureAwait(false);
+                }
             }
         }
 
@@ -413,7 +436,12 @@ namespace MQTTnet.Extensions.ManagedClient
             }
             catch (Exception exception)
             {
-                ConnectingFailed?.Invoke(this, new MqttManagedProcessFailedEventArgs(exception));
+                var connectingFailedHandler = ConnectingFailedHandler;
+                if (connectingFailedHandler != null)
+                {
+                    await connectingFailedHandler.HandleConnectingFailedAsync(new ManagedProcessFailedEventArgs(exception)).ConfigureAwait(false);
+                }
+
                 return ReconnectionResult.NotConnected;
             }
         }

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClientExtensions.cs

@@ -68,7 +68,7 @@ namespace MQTTnet.Extensions.ManagedClient
                 return client;
             }
 
-            client.ApplicationMessageReceivedHandler = new MqttApplicationMessageHandlerDelegate(handler);
+            client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(handler);
 
             return client;
         }
@@ -81,7 +81,7 @@ namespace MQTTnet.Extensions.ManagedClient
                 return client;
             }
 
-            client.ApplicationMessageReceivedHandler = new MqttApplicationMessageHandlerDelegate(handler);
+            client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(handler);
 
             return client;
         }

Source/MQTTnet.Extensions.ManagedClient/ManagedProcessFailedEventArgs.cs

@@ -2,9 +2,9 @@
 
 namespace MQTTnet.Extensions.ManagedClient
 {
-    public class MqttManagedProcessFailedEventArgs : EventArgs
+    public class ManagedProcessFailedEventArgs : EventArgs
     {
-        public MqttManagedProcessFailedEventArgs(Exception exception)
+        public ManagedProcessFailedEventArgs(Exception exception)
         {
             Exception = exception;
         }

Source/MQTTnet.Extensions.ManagedClient/MqttFactoryExtensions.cs

@@ -1,19 +1,18 @@
 using System;
-using MQTTnet.Client;
 using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Extensions.ManagedClient
 {
     public static class MqttFactoryExtensions
     {
-        public static IManagedMqttClient CreateManagedMqttClient(this IMqttClientFactory factory)
+        public static IManagedMqttClient CreateManagedMqttClient(this IMqttFactory factory)
         {
             if (factory == null) throw new ArgumentNullException(nameof(factory));
 
-            return new ManagedMqttClient(factory.CreateMqttClient(), new MqttNetLogger().CreateChildLogger());
+            return new ManagedMqttClient(factory.CreateMqttClient(), factory.DefaultLogger.CreateChildLogger());
         }
 
-        public static IManagedMqttClient CreateManagedMqttClient(this IMqttClientFactory factory, IMqttNetLogger logger)
+        public static IManagedMqttClient CreateManagedMqttClient(this IMqttFactory factory, IMqttNetLogger logger)
         {
             if (factory == null) throw new ArgumentNullException(nameof(factory));
             if (logger == null) throw new ArgumentNullException(nameof(logger));

Source/MQTTnet.Extensions.ManagedClient/SynchronizingSubscriptionsFailedHandlerDelegate.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class SynchronizingSubscriptionsFailedHandlerDelegate : ISynchronizingSubscriptionsFailedHandler
+    {
+        private readonly Func<ManagedProcessFailedEventArgs, Task> _handler;
+
+        public SynchronizingSubscriptionsFailedHandlerDelegate(Action<ManagedProcessFailedEventArgs> handler)
+        {
+            if (handler == null) throw new ArgumentNullException(nameof(handler));
+
+            _handler = context =>
+            {
+                handler(context);
+                return Task.FromResult(0);
+            };
+        }
+
+        public SynchronizingSubscriptionsFailedHandlerDelegate(Func<ManagedProcessFailedEventArgs, Task> handler)
+        {
+            _handler = handler ?? throw new ArgumentNullException(nameof(handler));
+        }
+
+        public Task HandleSynchronizingSubscriptionsFailedAsync(ManagedProcessFailedEventArgs eventArgs)
+        {
+            return _handler(eventArgs);
+        }
+    }
+}