Merge branch 'master' of https://github.com/chkr1011/MQTTnet into feature/Reason_Code_In_Subscription_Interceptor

# Conflicts:
#	Build/MQTTnet.nuspec
#	Source/MQTTnet/Server/Internal/MqttClientSessionsManager.cs

Tests/MQTTnet.AspNetCore.Tests/Mockups/ConnectionHandlerMockup.cs

@@ -4,6 +4,7 @@ using MQTTnet.Formatter;
 using MQTTnet.Server;
 using System;
 using System.Threading.Tasks;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.AspNetCore.Tests.Mockups
 {
@@ -12,10 +13,6 @@ namespace MQTTnet.AspNetCore.Tests.Mockups
         public TaskCompletionSource<MqttConnectionContext> Context { get; } = new TaskCompletionSource<MqttConnectionContext>();
         public Func<IMqttChannelAdapter, Task> ClientHandler { get; set; }
 
-        public ConnectionHandlerMockup()
-        {
-        }
-
         public async Task OnConnectedAsync(ConnectionContext connection)
         {
             try
@@ -33,7 +30,7 @@ namespace MQTTnet.AspNetCore.Tests.Mockups
             }
         }
 
-        public Task StartAsync(MqttServerOptions options)
+        public Task StartAsync(MqttServerOptions options, IMqttNetLogger logger)
         {
             return Task.CompletedTask;
         }

Tests/MQTTnet.AspNetCore.Tests/MqttConnectionContextTest.cs

@@ -5,17 +5,16 @@ using Microsoft.Extensions.DependencyInjection;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 using System;
-using System.Linq;
+using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
 using MQTTnet.AspNetCore.Tests.Mockups;
-using MQTTnet.Client.Options;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
-using System.Net;
 using MQTTnet.AspNetCore.Extensions;
+using MQTTnet.Client;
 using MQTTnet.Protocol;
 using MQTTnet.Tests.Extensions;
 

Tests/MQTTnet.Benchmarks/ChannelAdapterBenchmark.cs

@@ -5,7 +5,7 @@ using MQTTnet.Packets;
 using System;
 using System.IO;
 using System.Threading;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 using MQTTnet.Formatter;
 
 namespace MQTTnet.Benchmarks

Tests/MQTTnet.Benchmarks/LoggerBenchmark.cs

@@ -1,6 +1,6 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Benchmarks
 {

Tests/MQTTnet.Benchmarks/MessageProcessingBenchmark.cs

@@ -1,7 +1,6 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
 using MQTTnet.Server;
 
 namespace MQTTnet.Benchmarks

Tests/MQTTnet.Benchmarks/MessageProcessingMqttConnectionContextBenchmark.cs

@@ -4,8 +4,7 @@ using Microsoft.AspNetCore;
 using Microsoft.AspNetCore.Hosting;
 using MQTTnet.AspNetCore.Client;
 using MQTTnet.AspNetCore.Extensions;
-using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Benchmarks
 {

Tests/MQTTnet.Benchmarks/MqttTcpChannelBenchmark.cs

@@ -1,11 +1,11 @@
 using BenchmarkDotNet.Attributes;
 using MQTTnet.Channel;
-using MQTTnet.Client.Options;
 using MQTTnet.Implementations;
 using MQTTnet.Server;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Benchmarks
 {
@@ -20,7 +20,7 @@ namespace MQTTnet.Benchmarks
         public void Setup()
         {
             var factory = new MqttFactory();
-            var tcpServer = new MqttTcpServerAdapter(new MqttNetEventLogger());
+            var tcpServer = new MqttTcpServerAdapter();
             tcpServer.ClientHandler += args =>
             {
                 _serverChannel =

Tests/MQTTnet.Benchmarks/Program.cs

@@ -1,7 +1,7 @@
 using System;
 using BenchmarkDotNet.Running;
 using MQTTnet.Benchmarks.Configurations;
-using MQTTnet.Diagnostics.Runtime;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Benchmarks
 {

Tests/MQTTnet.Benchmarks/SerializerBenchmark.cs

@@ -9,7 +9,7 @@ using MQTTnet.Channel;
 using MQTTnet.Formatter;
 using MQTTnet.Formatter.V3;
 using BenchmarkDotNet.Jobs;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Benchmarks
 {

Tests/MQTTnet.Benchmarks/TopicFilterComparerBenchmark.cs

@@ -1,7 +1,7 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using System;
-using MQTTnet.Server.Internal;
+using MQTTnet.Server;
 
 namespace MQTTnet.Benchmarks
 {

Tests/MQTTnet.Core.Tests/Client/LowLevelMqttClient_Tests.cs

@@ -1,11 +1,10 @@
 using System;
-using System.Collections.Generic;
 using System.Net.Sockets;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Client.Options;
+using MQTTnet.Client;
 using MQTTnet.Exceptions;
 using MQTTnet.LowLevelClient;
 using MQTTnet.Packets;

Tests/MQTTnet.Core.Tests/Client/ManagedMqttClient_Tests.cs

@@ -5,11 +5,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Receiving;
 using MQTTnet.Diagnostics;
-using MQTTnet.Diagnostics.Logger;
 using MQTTnet.Extensions.ManagedClient;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
@@ -73,10 +69,15 @@ namespace MQTTnet.Tests.Client
                     .WithClientOptions(clientOptions)
                     .Build());
 
-                var recievingClient = await testEnvironment.ConnectClient();
-                await recievingClient.SubscribeAsync("My/last/will");
-
-                recievingClient.UseApplicationMessageReceivedHandler(context => Interlocked.Increment(ref receivedMessagesCount));
+                var receivingClient = await testEnvironment.ConnectClient();
+                
+                receivingClient.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
+                
+                await receivingClient.SubscribeAsync("My/last/will");
 
                 dyingManagedClient.Dispose();
 
@@ -314,10 +315,11 @@ namespace MQTTnet.Tests.Client
 
                 var receivedManagedMessages = new List<MqttApplicationMessage>();
                 var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
-                managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c =>
+                managedClient.ApplicationMessageReceivedAsync += e =>
                 {
-                    receivedManagedMessages.Add(c.ApplicationMessage);
-                });
+                    receivedManagedMessages.Add(e.ApplicationMessage);
+                    return Task.CompletedTask;
+                };
 
                 await managedClient.SubscribeAsync("topic");
 
@@ -399,14 +401,16 @@ namespace MQTTnet.Tests.Client
             try
             {
                 var sendClient = await testEnvironment.ConnectClient(options);
-                sendClient.ApplicationMessageReceivedHandler = new MQTTnet.Client.Receiving.MqttApplicationMessageReceivedHandlerDelegate(e =>
+                sendClient.ApplicationMessageReceivedAsync += e =>
                 {
                     onReceive();
-                });
+                    return Task.CompletedTask;
+                };
+                
                 await sendClient.SubscribeAsync("aaa");
                 return sendClient;
             }
-            catch (System.Exception)
+            catch (Exception)
             {
                 return null;
             }
@@ -465,15 +469,17 @@ namespace MQTTnet.Tests.Client
             var receivedMessages = new List<MqttApplicationMessage>();
             var result = new TaskCompletionSource<List<MqttApplicationMessage>>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-            managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(r =>
+            managedClient.ApplicationMessageReceivedAsync += e =>
             {
-                receivedMessages.Add(r.ApplicationMessage);
+                receivedMessages.Add(e.ApplicationMessage);
 
                 if (receivedMessages.Count == expectedNumberOfMessages)
                 {
                     result.TrySetResult(receivedMessages);
                 }
-            });
+                
+                return Task.CompletedTask;
+            };
 
             return result.Task;
         }

Tests/MQTTnet.Core.Tests/Client/MqttClientOptionsBuilder_Tests.cs

@@ -1,7 +1,7 @@
 using System.Linq;
 using System.Text;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Client.Options;
+using MQTTnet.Client;
 using MQTTnet.Extensions;
 
 namespace MQTTnet.Tests.Client
@@ -15,6 +15,7 @@ namespace MQTTnet.Tests.Client
             var options = new MqttClientOptionsBuilder()
                 .WithConnectionUri("mqtt://user:password@127.0.0.1")
                 .Build();
+            
             Assert.AreEqual("user", options.Credentials.Username);
             Assert.IsTrue(Encoding.UTF8.GetBytes("password").SequenceEqual(options.Credentials.Password));
         }

Tests/MQTTnet.Core.Tests/Client/MqttClient_Tests.cs

@@ -7,17 +7,10 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Disconnecting;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Publishing;
-using MQTTnet.Client.Receiving;
-using MQTTnet.Client.Subscribing;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
 
 namespace MQTTnet.Tests.Client
@@ -142,9 +135,9 @@ namespace MQTTnet.Tests.Client
 
                 var replyReceived = false;
 
-                client.UseApplicationMessageReceivedHandler(c =>
+                client.ApplicationMessageReceivedAsync += e =>
                 {
-                    if (c.ApplicationMessage.Topic == "request")
+                    if (e.ApplicationMessage.Topic == "request")
                     {
 #pragma warning disable 4014
                         Task.Run(() => client.PublishAsync("reply", null, MqttQualityOfServiceLevel.AtLeastOnce));
@@ -154,7 +147,9 @@ namespace MQTTnet.Tests.Client
                     {
                         replyReceived = true;
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await client.PublishAsync("request", null, MqttQualityOfServiceLevel.AtLeastOnce);
 
@@ -178,24 +173,26 @@ namespace MQTTnet.Tests.Client
 
                 var replyReceived = false;
 
-                client1.UseApplicationMessageReceivedHandler(c =>
+                client1.ApplicationMessageReceivedAsync += e =>
                 {
-                    if (c.ApplicationMessage.Topic == "reply")
+                    if (e.ApplicationMessage.Topic == "reply")
                     {
                         replyReceived = true;
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
-                client2.UseApplicationMessageReceivedHandler(async c =>
+                client2.ApplicationMessageReceivedAsync += async e =>
                 {
-                    if (c.ApplicationMessage.Topic == "request")
+                    if (e.ApplicationMessage.Topic == "request")
                     {
                         // Use AtMostOnce here because with QoS 1 or even QoS 2 the process waits for 
                         // the ACK etc. The problem is that the SpinUntil below only waits until the 
                         // flag is set. It does not wait until the client has sent the ACK
                         await client2.PublishAsync("reply", null, MqttQualityOfServiceLevel.AtMostOnce);
                     }
-                });
+                };
 
                 await client1.PublishAsync("request", null, MqttQualityOfServiceLevel.AtLeastOnce);
 
@@ -463,7 +460,7 @@ namespace MQTTnet.Tests.Client
                     }
                 }
 
-                client1.UseApplicationMessageReceivedHandler(Handler1);
+                client1.ApplicationMessageReceivedAsync += Handler1;
 
                 var client2 = await testEnvironment.ConnectClient();
                 for (var i = MessagesCount; i > 0; i--)
@@ -512,7 +509,7 @@ namespace MQTTnet.Tests.Client
                     return Task.CompletedTask;
                 }
 
-                client1.UseApplicationMessageReceivedHandler(Handler1);
+                client1.ApplicationMessageReceivedAsync += Handler1;
 
                 var client2 = await testEnvironment.ConnectClient();
                 for (var i = MessagesCount; i > 0; i--)
@@ -544,22 +541,24 @@ namespace MQTTnet.Tests.Client
                     await client1.PublishAsync($"reply/{eventArgs.ApplicationMessage.Topic}");
                 }
 
-                client1.UseApplicationMessageReceivedHandler(Handler1);
+                client1.ApplicationMessageReceivedAsync += Handler1;
 
                 var client2 = await testEnvironment.ConnectClient();
                 await client2.SubscribeAsync("reply/#");
 
                 var replies = new List<string>();
 
-                void Handler2(MqttApplicationMessageReceivedEventArgs eventArgs)
+                Task Handler2(MqttApplicationMessageReceivedEventArgs eventArgs)
                 {
                     lock (replies)
                     {
                         replies.Add(eventArgs.ApplicationMessage.Topic);
                     }
+
+                    return Task.CompletedTask;
                 }
 
-                client2.UseApplicationMessageReceivedHandler((Action<MqttApplicationMessageReceivedEventArgs>)Handler2);
+                client2.ApplicationMessageReceivedAsync += Handler2;
 
                 await Task.Delay(500);
 
@@ -583,13 +582,15 @@ namespace MQTTnet.Tests.Client
                 var receivedMessages = new List<MqttApplicationMessage>();
 
                 var client1 = await testEnvironment.ConnectClient();
-                client1.UseApplicationMessageReceivedHandler(c =>
+                client1.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (receivedMessages)
                     {
-                        receivedMessages.Add(c.ApplicationMessage);
+                        receivedMessages.Add(e.ApplicationMessage);
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await client1.SubscribeAsync("a");
 
@@ -616,10 +617,10 @@ namespace MQTTnet.Tests.Client
                 const string expectedClient2Message = "hello client2";
 
                 var client1 = await testEnvironment.ConnectClient();
-                client1.UseApplicationMessageReceivedHandler(async c =>
+                client1.ApplicationMessageReceivedAsync += async e =>
                 {
                     await client1.PublishAsync(client2Topic, expectedClient2Message, MqttQualityOfServiceLevel.AtLeastOnce);
-                });
+                };
 
                 await client1.SubscribeAsync(client1Topic, MqttQualityOfServiceLevel.AtLeastOnce);
 
@@ -627,10 +628,11 @@ namespace MQTTnet.Tests.Client
 
                 var client2TopicResults = new List<string>();
 
-                client2.UseApplicationMessageReceivedHandler(c =>
+                client2.ApplicationMessageReceivedAsync += e =>
                 {
-                    client2TopicResults.Add(Encoding.UTF8.GetString(c.ApplicationMessage.Payload));
-                });
+                    client2TopicResults.Add(Encoding.UTF8.GetString(e.ApplicationMessage.Payload));
+                    return Task.CompletedTask;
+                };
 
                 await client2.SubscribeAsync(client2Topic);
 
@@ -669,13 +671,15 @@ namespace MQTTnet.Tests.Client
                     await client.PublishAsync(msg.Build());
                 });
 
-                client.UseApplicationMessageReceivedHandler(c =>
+                client.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (receivedMessages)
                     {
-                        receivedMessages.Add(c.ApplicationMessage);
+                        receivedMessages.Add(e.ApplicationMessage);
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort).Build());
 
@@ -744,10 +748,11 @@ namespace MQTTnet.Tests.Client
 
                 var receiveClient = clients[99];
                 object receivedPayload = null;
-                receiveClient.UseApplicationMessageReceivedHandler(e =>
+                receiveClient.ApplicationMessageReceivedAsync += e =>
                 {
                     receivedPayload = e.ApplicationMessage.ConvertPayloadToString();
-                });
+                    return Task.CompletedTask;
+                };
 
                 await receiveClient.SubscribeAsync("x");
 
@@ -779,7 +784,11 @@ namespace MQTTnet.Tests.Client
                 }, CancellationToken.None);
 
                 MqttApplicationMessage receivedMessage = null;
-                receiver.UseApplicationMessageReceivedHandler(e => receivedMessage = e.ApplicationMessage);
+                receiver.ApplicationMessageReceivedAsync += e =>
+                {
+                    receivedMessage = e.ApplicationMessage;
+                    return Task.CompletedTask;
+                };
 
                 await sender.PublishAsync(message.Build(), CancellationToken.None);
 
@@ -807,10 +816,11 @@ namespace MQTTnet.Tests.Client
                 });
 
                 var messageReceived = false;
-                client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c =>
+                client1.ApplicationMessageReceivedAsync += e =>
                 {
                     messageReceived = true;
-                });
+                    return Task.CompletedTask;
+                };
 
                 await client1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("topic1").WithExactlyOnceQoS().Build());
 
@@ -843,9 +853,9 @@ namespace MQTTnet.Tests.Client
                 var subscriber = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId(qos.ToString()));
                 await subscriber.SubscribeAsync("#", qos);
 
-                subscriber.UseApplicationMessageReceivedHandler(c =>
+                subscriber.ApplicationMessageReceivedAsync += e =>
                 {
-                    c.AutoAcknowledge = false;
+                    e.AutoAcknowledge = false;
 
                     async Task InvokeInternal()
                     {
@@ -856,7 +866,7 @@ namespace MQTTnet.Tests.Client
 
                     _ = InvokeInternal();
                     return Task.CompletedTask;
-                });
+                };
 
                 var publishes = Task.WhenAll(
                     publisher.PublishAsync("a", null, qos),

Tests/MQTTnet.Core.Tests/Factory/MqttFactory_Tests.cs

@@ -2,7 +2,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 using MQTTnet.Extensions.ManagedClient;
 using MQTTnet.Server;
 

Tests/MQTTnet.Core.Tests/Logger/Logger_Tests.cs

@@ -1,6 +1,6 @@
 using System;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Tests.Logger
 {

Tests/MQTTnet.Core.Tests/Logger/SourceLogger_Tests.cs

@@ -1,5 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Tests.Logger
 {

Tests/MQTTnet.Core.Tests/MQTTv5/Client_Tests.cs

@@ -2,13 +2,10 @@ using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Publishing;
-using MQTTnet.Client.Receiving;
-using MQTTnet.Client.Subscribing;
-using MQTTnet.Client.Unsubscribing;
 using MQTTnet.Formatter;
+using MQTTnet.Packets;
 using MQTTnet.Protocol;
+using MQTTnet.Tests.Mockups;
 
 namespace MQTTnet.Tests.MQTTv5
 {
@@ -37,7 +34,11 @@ namespace MQTTnet.Tests.MQTTv5
                 MqttApplicationMessage receivedMessage = null;
 
                 await client.SubscribeAsync("a");
-                client.UseApplicationMessageReceivedHandler(context => { receivedMessage = context.ApplicationMessage; });
+                client.ApplicationMessageReceivedAsync += e =>
+                {
+                    receivedMessage = e.ApplicationMessage;
+                    return Task.CompletedTask;
+                };
 
                 await client.PublishAsync(new MqttApplicationMessageBuilder()
                     .WithTopic("a")
@@ -202,17 +203,10 @@ namespace MQTTnet.Tests.MQTTv5
             using (var testEnvironment = CreateTestEnvironment())
             {
                 await testEnvironment.StartServer();
-
-                var receivedMessages = new List<MqttApplicationMessageReceivedEventArgs>();
-
+                
                 var client1 = await testEnvironment.ConnectClient(o => o.WithProtocolVersion(MqttProtocolVersion.V500).WithClientId("client1"));
-                client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
-                {
-                    lock (receivedMessages)
-                    {
-                        receivedMessages.Add(e);
-                    }
-                });
+
+                var testMessageHandler = new TestApplicationMessageReceivedHandler(client1);
 
                 await client1.SubscribeAsync("a");
 
@@ -224,10 +218,10 @@ namespace MQTTnet.Tests.MQTTv5
                 await client2.DisconnectAsync();
                 await client1.DisconnectAsync();
 
-                Assert.AreEqual(1, receivedMessages.Count);
-                Assert.AreEqual("Subscribe_And_Publish_client1", receivedMessages[0].ClientId);
-                Assert.AreEqual("a", receivedMessages[0].ApplicationMessage.Topic);
-                Assert.AreEqual("b", receivedMessages[0].ApplicationMessage.ConvertPayloadToString());
+                Assert.AreEqual(1, testMessageHandler.ReceivedEventArgs.Count);
+                Assert.AreEqual("Subscribe_And_Publish_client1", testMessageHandler.ReceivedEventArgs[0].ClientId);
+                Assert.AreEqual("a", testMessageHandler.ReceivedEventArgs[0].ApplicationMessage.Topic);
+                Assert.AreEqual("b", testMessageHandler.ReceivedEventArgs[0].ApplicationMessage.ConvertPayloadToString());
             }
         }
 
@@ -242,10 +236,11 @@ namespace MQTTnet.Tests.MQTTv5
                 await receiver.SubscribeAsync("#");
 
                 MqttApplicationMessage receivedMessage = null;
-                receiver.UseApplicationMessageReceivedHandler(c =>
+                receiver.ApplicationMessageReceivedAsync += e =>
                 {
-                    receivedMessage = c.ApplicationMessage;
-                });
+                    receivedMessage = e.ApplicationMessage;
+                    return Task.CompletedTask;
+                };
 
                 var sender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
 

Tests/MQTTnet.Core.Tests/MQTTv5/Server_Tests.cs

@@ -1,6 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
 using MQTTnet.Formatter;
 using MQTTnet.Tests.Mockups;
 using System.Threading;
@@ -27,7 +26,13 @@ namespace MQTTnet.Tests.MQTTv5
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage).WithProtocolVersion(MqttProtocolVersion.V500);
 
                 var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
-                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
+                
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
                 var c2 = await testEnvironment.ConnectClient(clientOptions);

Tests/MQTTnet.Core.Tests/Mockups/TestApplicationMessageReceivedHandler.cs

@@ -2,41 +2,46 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Client.Receiving;
+using MQTTnet.Client;
 using MQTTnet.Implementations;
 
 namespace MQTTnet.Tests.Mockups
 {
-    public sealed class TestApplicationMessageReceivedHandler : IMqttApplicationMessageReceivedHandler
+    public sealed class TestApplicationMessageReceivedHandler
     {
-        readonly List<MqttApplicationMessage> _messageReceivedEventArgs = new List<MqttApplicationMessage>();
+        readonly List<MqttApplicationMessageReceivedEventArgs> _receivedEventArgs = new List<MqttApplicationMessageReceivedEventArgs>();
 
-        public Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
+        public TestApplicationMessageReceivedHandler(IMqttClient mqttClient)
         {
-            lock (_messageReceivedEventArgs)
+            mqttClient.ApplicationMessageReceivedAsync += MqttClientOnApplicationMessageReceivedAsync;
+        }
+
+        Task MqttClientOnApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
+        {
+            lock (_receivedEventArgs)
             {
-                _messageReceivedEventArgs.Add(eventArgs.ApplicationMessage);
+                _receivedEventArgs.Add(eventArgs);
             }
             
             return PlatformAbstractionLayer.CompletedTask;
         }
-
-        public List<MqttApplicationMessage> ReceivedApplicationMessages
+        
+        public List<MqttApplicationMessageReceivedEventArgs> ReceivedEventArgs
         {
             get
             {
-                lock (_messageReceivedEventArgs)
+                lock (_receivedEventArgs)
                 {
-                    return _messageReceivedEventArgs.ToList();
+                    return _receivedEventArgs.ToList();
                 }
             }
         }
 
         public void AssertReceivedCountEquals(int expectedCount)
         {
-            lock (_messageReceivedEventArgs)
+            lock (_receivedEventArgs)
             {
-                Assert.AreEqual(expectedCount, _messageReceivedEventArgs.Count);
+                Assert.AreEqual(expectedCount, _receivedEventArgs.Count);
             }
         }
     }

Tests/MQTTnet.Core.Tests/Mockups/TestClientWrapper.cs

@@ -1,14 +1,6 @@
 using System;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Disconnecting;
-using MQTTnet.Client.ExtendedAuthenticationExchange;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Publishing;
-using MQTTnet.Client.Receiving;
-using MQTTnet.Client.Subscribing;
-using MQTTnet.Client.Unsubscribing;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -53,13 +45,7 @@ namespace MQTTnet.Tests.Mockups
             add => Implementation.DisconnectedAsync += value;
             remove => Implementation.DisconnectedAsync -= value;
         }
-
-        public IMqttApplicationMessageReceivedHandler ApplicationMessageReceivedHandler
-        {
-            get => Implementation.ApplicationMessageReceivedHandler;
-            set => Implementation.ApplicationMessageReceivedHandler = value;
-        }
-
+        
         public event Func<MqttApplicationMessageReceivedEventArgs, Task> ApplicationMessageReceivedAsync
         {
             add => Implementation.ApplicationMessageReceivedAsync += value;

Tests/MQTTnet.Core.Tests/Mockups/TestEnvironment.cs

@@ -1,6 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
 using MQTTnet.Server;
 using System;
 using System.Collections.Generic;
@@ -8,7 +7,7 @@ using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 using MQTTnet.Extensions.Rpc;
 using MQTTnet.Extensions.Rpc.Options;
 using MQTTnet.Formatter;
@@ -232,17 +231,7 @@ namespace MQTTnet.Tests.Mockups
         
         public TestApplicationMessageReceivedHandler CreateApplicationMessageHandler(IMqttClient mqttClient)
         {
-            if (mqttClient == null) throw new ArgumentNullException(nameof(mqttClient));
-
-            var handler = new TestApplicationMessageReceivedHandler();
-            if (mqttClient.ApplicationMessageReceivedHandler != null)
-            {
-                throw new InvalidOperationException("ApplicationMessageReceivedHandler is already set.");
-            }
-
-            mqttClient.ApplicationMessageReceivedHandler = handler;
-            
-            return handler;
+            return new TestApplicationMessageReceivedHandler(mqttClient);
         }
 
         public void ThrowIfLogErrors()

Tests/MQTTnet.Core.Tests/Mockups/TestLogger.cs

@@ -1,5 +1,5 @@
 using System;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Tests.Mockups
 {

Tests/MQTTnet.Core.Tests/Mockups/TestMqttCommunicationAdapterFactory.cs

@@ -1,5 +1,6 @@
 using MQTTnet.Adapter;
-using MQTTnet.Client.Options;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Tests.Mockups
 {
@@ -12,7 +13,7 @@ namespace MQTTnet.Tests.Mockups
             _adapter = adapter;
         }
 
-        public IMqttChannelAdapter CreateClientAdapter(IMqttClientOptions options)
+        public IMqttChannelAdapter CreateClientAdapter(IMqttClientOptions options, IMqttNetLogger logger)
         {
             return _adapter;
         }

Tests/MQTTnet.Core.Tests/MqttPacketSerializer_Tests.cs

@@ -5,7 +5,7 @@ using System.Text;
 using System.Threading;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Formatter.V3;

Tests/MQTTnet.Core.Tests/RPC_Tests.cs

@@ -4,11 +4,9 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Tests.Mockups;
 using MQTTnet.Client;
-using MQTTnet.Client.Receiving;
 using MQTTnet.Exceptions;
 using MQTTnet.Extensions.Rpc;
 using MQTTnet.Protocol;
-using MQTTnet.Client.Options;
 using MQTTnet.Formatter;
 using MQTTnet.Extensions.Rpc.Options;
 using MQTTnet.Extensions.Rpc.Options.TopicGeneration;
@@ -95,10 +93,7 @@ namespace MQTTnet.Tests
                 var responseSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(protocolVersion));
                 await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping", qosLevel);
 
-                responseSender.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(async e =>
-                {
-                    await responseSender.PublishAsync(e.ApplicationMessage.Topic + "/response", "pong");
-                });
+                responseSender.ApplicationMessageReceivedAsync += e => responseSender.PublishAsync(e.ApplicationMessage.Topic + "/response", "pong");
 
                 var requestSender = await testEnvironment.ConnectClient();
 

Tests/MQTTnet.Core.Tests/RoundtripTime_Tests.cs

@@ -26,10 +26,11 @@ namespace MQTTnet.Tests
                 
                 TaskCompletionSource<string> response = null;
 
-                receiverClient.UseApplicationMessageReceivedHandler(e => 
+                receiverClient.ApplicationMessageReceivedAsync += e => 
                 {
                     response?.SetResult(e.ApplicationMessage.ConvertPayloadToString());
-                });
+                    return Task.CompletedTask;
+                };
 
                 var times = new List<TimeSpan>();
                 var stopwatch = Stopwatch.StartNew();

Tests/MQTTnet.Core.Tests/Server/Assigned_Client_ID_Tests.cs

@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
 using MQTTnet.Formatter;
 using MQTTnet.Protocol;
 

Tests/MQTTnet.Core.Tests/Server/Events_Tests.cs

@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Receiving;
 using MQTTnet.Formatter;
 using MQTTnet.Protocol;
 using MQTTnet.Server;

Tests/MQTTnet.Core.Tests/Server/General.cs

@@ -7,11 +7,8 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
 using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Disconnecting;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Receiving;
 using MQTTnet.Formatter;
+using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
@@ -127,7 +124,13 @@ namespace MQTTnet.Tests.Server
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage);
 
                 var c1 = await testEnvironment.ConnectClient();
-                c1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c => Interlocked.Increment(ref receivedMessagesCount));
+                
+                c1.ApplicationMessageReceivedAsync +=  e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
+                
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
                 var c2 = await testEnvironment.ConnectClient(clientOptions);
@@ -150,7 +153,12 @@ namespace MQTTnet.Tests.Server
 
                 // C1 will receive the last will!
                 var c1 = await testEnvironment.ConnectClient();
-                c1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
+                
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
                 // C2 has the last will defined.
@@ -176,8 +184,6 @@ namespace MQTTnet.Tests.Server
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var receivedMessagesCount = 0;
-
                 await testEnvironment.StartServer();
 
                 var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build();
@@ -185,9 +191,19 @@ namespace MQTTnet.Tests.Server
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage);
 
                 var c1 = await testEnvironment.ConnectClient();
-                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                
+                var receivedMessagesCount = 0;
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
+                
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
+                // clientOptions.WithClientId("Client2");
+                // var c2 = await testEnvironment.ConnectClient(clientOptions);
+
                 var c2 = await testEnvironment.ConnectClient(clientOptions);
                 c2.Dispose(); // Dispose will not send a DISCONNECT pattern first so the will message must be sent.
 
@@ -207,7 +223,11 @@ namespace MQTTnet.Tests.Server
                 var receivedMessagesCount = 0;
 
                 var client = await testEnvironment.ConnectClient();
-                client.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                client.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
 
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
                 await client.SubscribeAsync(new MqttTopicFilter {Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce});
@@ -233,9 +253,17 @@ namespace MQTTnet.Tests.Server
                 var c2 = await testEnvironment.ConnectClient();
                 var c3 = await testEnvironment.ConnectClient();
 
-                c2.UseApplicationMessageReceivedHandler(c => { Interlocked.Increment(ref receivedMessagesCount); });
+                c2.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
 
-                c3.UseApplicationMessageReceivedHandler(c => { Interlocked.Increment(ref receivedMessagesCount); });
+                c3.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
 
                 await c2.SubscribeAsync(new MqttTopicFilter {Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce}).ConfigureAwait(false);
                 await c3.SubscribeAsync(new MqttTopicFilter {Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce}).ConfigureAwait(false);
@@ -293,13 +321,15 @@ namespace MQTTnet.Tests.Server
 
                 client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e => { await client.PublishAsync("Connected"); });
 
-                client.UseApplicationMessageReceivedHandler(c =>
+                client.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (receivedMessages)
                     {
-                        receivedMessages.Add(c.ApplicationMessage);
+                        receivedMessages.Add(e.ApplicationMessage);
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await Task.Delay(500);
 
@@ -327,13 +357,15 @@ namespace MQTTnet.Tests.Server
                 var client = await testEnvironment.ConnectClient();
                 var receivedMessages = new List<MqttApplicationMessage>();
 
-                client.UseApplicationMessageReceivedHandler(c =>
+                client.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (receivedMessages)
                     {
-                        receivedMessages.Add(c.ApplicationMessage);
+                        receivedMessages.Add(e.ApplicationMessage);
                     }
-                });
+
+                    return Task.CompletedTask;
+                };
 
                 await Task.Delay(500);
 
@@ -511,7 +543,12 @@ namespace MQTTnet.Tests.Server
                 string receivedTopic = null;
                 var c1 = await testEnvironment.ConnectClient();
                 await c1.SubscribeAsync("#");
-                c1.UseApplicationMessageReceivedHandler(a => { receivedTopic = a.ApplicationMessage.Topic; });
+                
+                c1.ApplicationMessageReceivedAsync += a =>
+                {
+                    receivedTopic = a.ApplicationMessage.Topic;
+                    return Task.CompletedTask;
+                };
 
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("original_topic").Build());
 
@@ -558,7 +595,12 @@ namespace MQTTnet.Tests.Server
                 string receivedTopic = null;
 
                 var c1 = await testEnvironment.ConnectClient();
-                c1.UseApplicationMessageReceivedHandler(e => { receivedTopic = e.ApplicationMessage.Topic; });
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    receivedTopic = e.ApplicationMessage.Topic;
+                    return Task.CompletedTask;
+                };
+                
                 await c1.SubscribeAsync("#");
 
                 await testEnvironment.ConnectClient();
@@ -589,10 +631,12 @@ namespace MQTTnet.Tests.Server
                 await c2.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("test").Build());
 
                 var isIntercepted = false;
-                c2.UseApplicationMessageReceivedHandler(c =>
+                c2.ApplicationMessageReceivedAsync += e =>
                 {
-                    isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(c.ApplicationMessage.Payload), StringComparison.Ordinal) == 0;
-                });
+                    isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(e.ApplicationMessage.Payload), StringComparison.Ordinal) == 0;
+                    
+                    return Task.CompletedTask;
+                };
 
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("test").Build());
                 await c1.DisconnectAsync();
@@ -631,7 +675,11 @@ namespace MQTTnet.Tests.Server
                 await testEnvironment.StartServer();
 
                 var client1 = await testEnvironment.ConnectClient();
-                client1.UseApplicationMessageReceivedHandler(c => { receivedBody = c.ApplicationMessage.Payload; });
+                client1.ApplicationMessageReceivedAsync += e =>
+                {
+                    receivedBody = e.ApplicationMessage.Payload;
+                    return Task.CompletedTask;
+                };
 
                 await client1.SubscribeAsync("string");
 
@@ -732,13 +780,15 @@ namespace MQTTnet.Tests.Server
                 });
 
 
-                c1.UseApplicationMessageReceivedHandler(_ =>
+                c1.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (events)
                     {
                         events.Add("r");
                     }
-                });
+
+                    return Task.CompletedTask;
+                };
 
                 c1.SubscribeAsync("topic").Wait();
 
@@ -825,13 +875,15 @@ namespace MQTTnet.Tests.Server
 
                 Assert.AreEqual("cdc", flow);
 
-                c2.UseApplicationMessageReceivedHandler(_ =>
+                c2.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (events)
                     {
                         events.Add("r");
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await c2.SubscribeAsync("topic");
 
@@ -941,13 +993,15 @@ namespace MQTTnet.Tests.Server
 
                 var buffer = new StringBuilder();
 
-                client2.UseApplicationMessageReceivedHandler(c =>
+                client2.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (buffer)
                     {
-                        buffer.Append(c.ApplicationMessage.Topic);
+                        buffer.Append(e.ApplicationMessage.Topic);
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await client2.SubscribeAsync(new MqttTopicFilter {Topic = "y"}, new MqttTopicFilter {Topic = "n"});
 
@@ -1016,7 +1070,7 @@ namespace MQTTnet.Tests.Server
                 await c1.UnsubscribeAsync(topicFilter);
                 await Task.Delay(500);
 
-                Assert.AreEqual(expectedReceivedMessagesCount, c1MessageHandler.ReceivedApplicationMessages.Count);
+                Assert.AreEqual(expectedReceivedMessagesCount, c1MessageHandler.ReceivedEventArgs.Count);
             }
         }
 

Tests/MQTTnet.Core.Tests/Server/MqttSubscriptionsManager_Tests.cs

@@ -5,7 +5,6 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
-using MQTTnet.Server.Internal;
 using MQTTnet.Tests.Mockups;
 
 namespace MQTTnet.Tests.Server
@@ -18,7 +17,7 @@ namespace MQTTnet.Tests.Server
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(new TestLogger()), new MqttRetainedMessagesManager());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilterBuilder().WithTopic("A/B/C").Build());
@@ -35,7 +34,7 @@ namespace MQTTnet.Tests.Server
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(new TestLogger()), new MqttRetainedMessagesManager());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilter { Topic = "A/B/C", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
@@ -52,7 +51,7 @@ namespace MQTTnet.Tests.Server
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(new TestLogger()), new MqttRetainedMessagesManager());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilter { Topic = "#", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
@@ -70,7 +69,7 @@ namespace MQTTnet.Tests.Server
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(new TestLogger()), new MqttRetainedMessagesManager());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilterBuilder().WithTopic("A/B/C").Build());
@@ -85,7 +84,7 @@ namespace MQTTnet.Tests.Server
         {
             var s = CreateSession();
 
-            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(new TestLogger()), new MqttRetainedMessagesManager());
+            var sm = new MqttClientSubscriptionsManager(s, new MqttServerOptions(), new MqttServerEventContainer(), new MqttRetainedMessagesManager());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new MqttTopicFilterBuilder().WithTopic("A/B/C").Build());
@@ -106,7 +105,7 @@ namespace MQTTnet.Tests.Server
             var logger = new TestLogger();
             var options = new MqttServerOptions();
             var retainedMessagesManager = new MqttRetainedMessagesManager();
-            var eventContainer = new MqttServerEventContainer(logger);
+            var eventContainer = new MqttServerEventContainer();
                 
             return new MqttClientSession(
                 "",

Tests/MQTTnet.Core.Tests/Server/Retain_As_Published_Tests.cs

@@ -37,7 +37,7 @@ namespace MQTTnet.Tests.Server
                 await LongTestDelay();
 
                 applicationMessageHandler.AssertReceivedCountEquals(1);
-                Assert.AreEqual(retainAsPublished, applicationMessageHandler.ReceivedApplicationMessages[0].Retain);
+                Assert.AreEqual(retainAsPublished, applicationMessageHandler.ReceivedEventArgs[0].ApplicationMessage.Retain);
             }
         }
     }

Tests/MQTTnet.Core.Tests/Server/Retained_Messages_Tests.cs

@@ -3,6 +3,7 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Formatter;
+using MQTTnet.Packets;
 using MQTTnet.Protocol;
 
 namespace MQTTnet.Tests.Server
@@ -18,6 +19,7 @@ namespace MQTTnet.Tests.Server
                 await testEnvironment.StartServer();
 
                 var client = testEnvironment.CreateClient();
+                
                 var connectResult = await client.ConnectAsync(testEnvironment.Factory.CreateClientOptionsBuilder()
                     .WithProtocolVersion(MqttProtocolVersion.V311)
                     .WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
@@ -114,7 +116,7 @@ namespace MQTTnet.Tests.Server
                 await Task.Delay(500);
 
                 messageHandler.AssertReceivedCountEquals(1);
-                Assert.IsTrue(messageHandler.ReceivedApplicationMessages.First().Retain);
+                Assert.IsTrue(messageHandler.ReceivedEventArgs.First().ApplicationMessage.Retain);
             }
         }
 

Tests/MQTTnet.Core.Tests/Server/Security_Tests.cs

@@ -2,8 +2,6 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
 using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Options;
 using MQTTnet.Exceptions;
 using MQTTnet.Protocol;
 

Tests/MQTTnet.Core.Tests/Server/Server_Reference_Tests.cs

@@ -2,8 +2,6 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
 using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Options;
 using MQTTnet.Formatter;
 using MQTTnet.Protocol;
 

Tests/MQTTnet.Core.Tests/Server/Session_Tests.cs

@@ -4,9 +4,6 @@ using System.Text;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Publishing;
-using MQTTnet.Client.Subscribing;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
@@ -57,10 +54,11 @@ namespace MQTTnet.Tests.Server
                 string receivedPayload = null;
 
                 var client = await testEnvironment.ConnectClient();
-                client.UseApplicationMessageReceivedHandler(delegate(MqttApplicationMessageReceivedEventArgs args)
+                client.ApplicationMessageReceivedAsync += e =>
                 {
-                    receivedPayload = args.ApplicationMessage.ConvertPayloadToString();
-                });
+                    receivedPayload = e.ApplicationMessage.ConvertPayloadToString();
+                    return Task.CompletedTask;
+                };
 
                 var subscribeResult = await client.SubscribeAsync("x");
 
@@ -170,8 +168,8 @@ namespace MQTTnet.Tests.Server
                 await LongTestDelay();
                 
                 // Assert 
-                Assert.AreEqual(1, messageReceivedHandler.ReceivedApplicationMessages.Count);
-                Assert.AreEqual("injected_one", messageReceivedHandler.ReceivedApplicationMessages[0].Topic);
+                Assert.AreEqual(1, messageReceivedHandler.ReceivedEventArgs.Count);
+                Assert.AreEqual("injected_one", messageReceivedHandler.ReceivedEventArgs[0].ApplicationMessage.Topic);
             }
         }
         
@@ -191,13 +189,13 @@ namespace MQTTnet.Tests.Server
                     .WithClientId(qos.ToString())
                     .WithCleanSession(false));
                 
-                subscriber.UseApplicationMessageReceivedHandler(c =>
+                subscriber.ApplicationMessageReceivedAsync += c =>
                 {
                     c.AutoAcknowledge = false;
                     ++count;
                     Console.WriteLine("process");
                     return Task.CompletedTask;
-                });
+                };
                 
                 await subscriber.SubscribeAsync("#", qos);
 

Tests/MQTTnet.Core.Tests/Server/Shared_Subscriptions_Tests.cs

@@ -1,7 +1,6 @@
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Subscribing;
 using MQTTnet.Formatter;
 
 namespace MQTTnet.Tests.Server

Tests/MQTTnet.Core.Tests/Server/Status_Tests.cs

@@ -2,7 +2,6 @@
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
@@ -141,7 +140,8 @@ namespace MQTTnet.Tests.Server
                     // At most once will send one packet to the client and the server will reply
                     // with an additional ACK packet.
                     await c1.PublishAsync("a", string.Empty, MqttQualityOfServiceLevel.AtLeastOnce);
-                    await Task.Delay(250);
+                    
+                    await Task.Delay(500);
 
                     var clientStatus = await server.GetClientStatusAsync();
 
@@ -150,8 +150,8 @@ namespace MQTTnet.Tests.Server
                     // + 1 because CONNECT is also counted.
                     Assert.AreEqual(i + 1, clientStatus.First().SentPacketsCount, "SPC invalid!");
 
-                    // +1 because ConnACK package is already counted.
-                    Assert.AreEqual(i + 1, clientStatus.First().ReceivedPacketsCount, "RPC invalid!");
+                    // +2 because ConnACK + PubAck package is already counted.
+                    Assert.AreEqual(i + 2, clientStatus.First().ReceivedPacketsCount, "RPC invalid!");
                 }
             }
         }

Tests/MQTTnet.Core.Tests/Server/Subscribe_Tests.cs

@@ -3,9 +3,8 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Subscribing;
 using MQTTnet.Formatter;
+using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 
@@ -33,17 +32,19 @@ namespace MQTTnet.Tests.Server
                 var topicBReceived = false;
 
                 var client = await testEnvironment.ConnectClient();
-                client.UseApplicationMessageReceivedHandler(c =>
+                client.ApplicationMessageReceivedAsync += e =>
                 {
-                    if (c.ApplicationMessage.Topic == "a")
+                    if (e.ApplicationMessage.Topic == "a")
                     {
                         topicAReceived = true;
                     }
-                    else if (c.ApplicationMessage.Topic == "b")
+                    else if (e.ApplicationMessage.Topic == "b")
                     {
                         topicBReceived = true;
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await client.SubscribeAsync("b");
 
@@ -66,7 +67,11 @@ namespace MQTTnet.Tests.Server
                 var server = await testEnvironment.StartServer();
 
                 var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("c1"));
-                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
 
                 var c2 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithClientId("c2"));
 
@@ -122,7 +127,12 @@ namespace MQTTnet.Tests.Server
                 await testEnvironment.StartServer();
 
                 var c1 = await testEnvironment.ConnectClient();
-                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
+                
                 await c1.SubscribeAsync(new MqttClientSubscribeOptionsBuilder()
                     .WithTopicFilter("a")
                     .WithTopicFilter("b")
@@ -155,7 +165,11 @@ namespace MQTTnet.Tests.Server
                 await testEnvironment.StartServer();
 
                 var c1 = await testEnvironment.ConnectClient();
-                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
 
                 var optionsBuilder = new MqttClientSubscribeOptionsBuilder();
                 for (var i = 0; i < 500; i++)
@@ -191,7 +205,11 @@ namespace MQTTnet.Tests.Server
                 await testEnvironment.StartServer();
 
                 var c1 = await testEnvironment.ConnectClient();
-                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
 
                 for (var i = 0; i < 500; i++)
                 {
@@ -231,7 +249,12 @@ namespace MQTTnet.Tests.Server
                 await testEnvironment.StartServer();
 
                 var c1 = await testEnvironment.ConnectClient();
-                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.ApplicationMessageReceivedAsync += e =>
+                {
+                    Interlocked.Increment(ref receivedMessagesCount);
+                    return Task.CompletedTask;
+                };
+                
                 await c1.SubscribeAsync(new MqttClientSubscribeOptionsBuilder()
                     .WithTopicFilter("a")
                     .Build());

Tests/MQTTnet.Core.Tests/Server/Subscription_Identifier_Tests.cs

@@ -47,7 +47,7 @@ namespace MQTTnet.Tests.Server
 
                 applicationMessageHandler.AssertReceivedCountEquals(1);
 
-                applicationMessageHandler.ReceivedApplicationMessages[0].SubscriptionIdentifiers.Contains(456);
+                applicationMessageHandler.ReceivedEventArgs[0].ApplicationMessage.SubscriptionIdentifiers.Contains(456);
             }
         }
         
@@ -81,8 +81,8 @@ namespace MQTTnet.Tests.Server
 
                 applicationMessageHandler.AssertReceivedCountEquals(1);
 
-                applicationMessageHandler.ReceivedApplicationMessages[0].SubscriptionIdentifiers.Contains(456);
-                applicationMessageHandler.ReceivedApplicationMessages[0].SubscriptionIdentifiers.Contains(789);
+                applicationMessageHandler.ReceivedEventArgs[0].ApplicationMessage.SubscriptionIdentifiers.Contains(456);
+                applicationMessageHandler.ReceivedEventArgs[0].ApplicationMessage.SubscriptionIdentifiers.Contains(789);
             }
         }
     }

Tests/MQTTnet.Core.Tests/Server/TopicFilterComparer_Tests.cs

@@ -1,5 +1,5 @@
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Server.Internal;
+using MQTTnet.Server;
 
 namespace MQTTnet.Tests.Server
 {

Tests/MQTTnet.Core.Tests/Server/Topic_Alias_Tests.cs

@@ -3,7 +3,6 @@ using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
 using MQTTnet.Formatter;
 
 namespace MQTTnet.Tests.Server
@@ -39,13 +38,15 @@ namespace MQTTnet.Tests.Server
                 var receivedTopics = new List<string>();
 
                 var c1 = await testEnvironment.ConnectClient(options => options.WithProtocolVersion(MqttProtocolVersion.V500));
-                c1.UseApplicationMessageReceivedHandler(e =>
+                c1.ApplicationMessageReceivedAsync += e =>
                 {
                     lock (receivedTopics)
                     {
                         receivedTopics.Add(e.ApplicationMessage.Topic);
                     }
-                });
+                    
+                    return Task.CompletedTask;
+                };
 
                 await c1.SubscribeAsync("#");
 

Tests/MQTTnet.Core.Tests/Server/User_Properties_Tests.cs

@@ -3,9 +3,8 @@ using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Subscribing;
 using MQTTnet.Formatter;
+using MQTTnet.Packets;
 using MQTTnet.Tests.Mockups;
 
 namespace MQTTnet.Tests.Server
@@ -41,7 +40,11 @@ namespace MQTTnet.Tests.Server
                 }, CancellationToken.None);
 
                 MqttApplicationMessage receivedMessage = null;
-                receiver.UseApplicationMessageReceivedHandler(e => receivedMessage = e.ApplicationMessage);
+                receiver.ApplicationMessageReceivedAsync += e =>
+                {
+                    receivedMessage = e.ApplicationMessage;
+                    return Task.CompletedTask;
+                };
 
                 await sender.PublishAsync(message.Build(), CancellationToken.None);
 

Tests/MQTTnet.Test.BlazorApp/Client/Pages/Counter.razor

@@ -1,6 +1,6 @@
 @page "/counter"
-@using MQTTnet.Client.Options
 @using System.Threading
+@using MQTTnet.Client
 
 <h1>Counter</h1>
 

Tests/MQTTnet.TestApp.NetCore/ClientFlowTest.cs

@@ -1,8 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.TestApp.NetCore
 {

Tests/MQTTnet.TestApp.NetCore/ClientTest.cs

@@ -1,13 +1,11 @@
 using MQTTnet.Client;
-using MQTTnet.Client.Connecting;
-using MQTTnet.Client.Disconnecting;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Receiving;
 using MQTTnet.Protocol;
 using System;
 using System.Text;
 using System.Threading.Tasks;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
+using MQTTnet.Implementations;
+using MQTTnet.Packets;
 
 namespace MQTTnet.TestApp.NetCore
 {
@@ -30,7 +28,7 @@ namespace MQTTnet.TestApp.NetCore
                     }
                 };
 
-                client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
+                client.ApplicationMessageReceivedAsync += e =>
                 {
                     Console.WriteLine("### RECEIVED APPLICATION MESSAGE ###");
                     Console.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
@@ -38,7 +36,9 @@ namespace MQTTnet.TestApp.NetCore
                     Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
                     Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
                     Console.WriteLine();
-                });
+                    
+                    return PlatformAbstractionLayer.CompletedTask;
+                };
 
                 client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e =>
                 {

Tests/MQTTnet.TestApp.NetCore/ManagedClientTest.cs

@@ -3,9 +3,10 @@ using System.Threading.Tasks;
 using System.IO;
 using Newtonsoft.Json;
 using System.Collections.Generic;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Receiving;
+using MQTTnet.Client;
 using MQTTnet.Extensions.ManagedClient;
+using MQTTnet.Implementations;
+using MQTTnet.Packets;
 using MQTTnet.Protocol;
 
 namespace MQTTnet.TestApp.NetCore
@@ -35,10 +36,11 @@ namespace MQTTnet.TestApp.NetCore
             try
             {
                 var managedClient = new MqttFactory().CreateManagedMqttClient();
-                managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
+                managedClient.ApplicationMessageReceivedAsync += e =>
                 {
                     Console.WriteLine(">> RECEIVED: " + e.ApplicationMessage.Topic);
-                });
+                    return PlatformAbstractionLayer.CompletedTask;
+                };
 
                 await managedClient.StartAsync(options);
 
@@ -69,7 +71,7 @@ namespace MQTTnet.TestApp.NetCore
 
         public class ClientRetainedMessageHandler : IManagedMqttClientStorage
         {
-            private const string Filename = @"RetainedMessages.json";
+            const string Filename = @"RetainedMessages.json";
 
             public Task SaveQueuedMessagesAsync(IList<ManagedMqttApplicationMessage> messages)
             {

Tests/MQTTnet.TestApp.NetCore/MqttNetConsoleLogger.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Text;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.TestApp.NetCore
 {

Tests/MQTTnet.TestApp.NetCore/Program.cs

@@ -1,5 +1,4 @@
-using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics;
 using MQTTnet.Server;
 using Newtonsoft.Json;
 using System;
@@ -9,7 +8,7 @@ using System.Net.Security;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Client;
-using MQTTnet.Diagnostics.Runtime;
+using MQTTnet.Implementations;
 
 namespace MQTTnet.TestApp.NetCore
 {
@@ -110,10 +109,11 @@ namespace MQTTnet.TestApp.NetCore
                 .Build();
 
             //mqttClient.ApplicationMessageReceived += (s, e) =>    // version 2.8.5
-            mqttClient.UseApplicationMessageReceivedHandler(e =>    // version 3.0.0+
+            mqttClient.ApplicationMessageReceivedAsync += e =>    // version 3.0.0+
             {
                 Interlocked.Increment(ref _count);
-            });
+                return PlatformAbstractionLayer.CompletedTask;
+            };
 
             //mqttClient.Connected += async (s, e) =>               // version 2.8.5
             mqttClient.UseConnectedHandler(async e =>               // version 3.0.0+

Tests/MQTTnet.TestApp.NetCore/PublicBrokerTest.cs

@@ -1,13 +1,10 @@
 using MQTTnet.Client;
 using System;
-using System.IO;
-using System.Net;
 using System.Security.Authentication;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Client.Options;
-using MQTTnet.Client.Receiving;
 using MQTTnet.Formatter;
+using MQTTnet.Implementations;
 using MQTTnet.Protocol;
 
 namespace MQTTnet.TestApp.NetCore
@@ -129,7 +126,7 @@ namespace MQTTnet.TestApp.NetCore
             Console.ReadLine();
         }
 
-        private static async Task ExecuteTestAsync(string name, IMqttClientOptions options)
+        static async Task ExecuteTestAsync(string name, IMqttClientOptions options)
         {
             try
             {
@@ -140,7 +137,11 @@ namespace MQTTnet.TestApp.NetCore
                 var topic = Guid.NewGuid().ToString();
 
                 MqttApplicationMessage receivedMessage = null;
-                client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e => receivedMessage = e.ApplicationMessage);
+                client.ApplicationMessageReceivedAsync += e =>
+                {
+                    receivedMessage = e.ApplicationMessage;
+                    return PlatformAbstractionLayer.CompletedTask;
+                };
 
                 await client.ConnectAsync(options);
                 await client.SubscribeAsync(topic, MqttQualityOfServiceLevel.AtLeastOnce);
@@ -164,7 +165,7 @@ namespace MQTTnet.TestApp.NetCore
             }
         }
 
-        private static void Write(string message, ConsoleColor color)
+        static void Write(string message, ConsoleColor color)
         {
             Console.ForegroundColor = color;
             Console.Write(message);

Tests/MQTTnet.TestApp.NetCore/ServerAndClientTest.cs

@@ -1,8 +1,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Client;
-using MQTTnet.Client.Options;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 using MQTTnet.Server;
 
 namespace MQTTnet.TestApp.NetCore

Tests/MQTTnet.TestApp.NetCore/ServerTest.cs

@@ -1,11 +1,10 @@
 using System;
 using System.Text;
 using System.Threading.Tasks;
-using MQTTnet.Diagnostics.Logger;
+using MQTTnet.Diagnostics;
 using MQTTnet.Implementations;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
-using MQTTnet.Server.Internal;
 
 namespace MQTTnet.TestApp.NetCore
 {