Merge branch 'feature/server-project-bootstrap' into develop

Tests/MQTTnet.Benchmarks/MqttTcpChannelBenchmark.cs

@@ -1,6 +1,5 @@
 using BenchmarkDotNet.Attributes;
 using MQTTnet.Channel;
-using MQTTnet.Client;
 using MQTTnet.Diagnostics;
 using MQTTnet.Implementations;
 using MQTTnet.Server;
@@ -22,7 +21,7 @@ namespace MQTTnet.Benchmarks
         {
             var factory = new MqttFactory();
             var tcpServer = new MqttTcpServerAdapter(new MqttNetLogger().CreateChildLogger());
-            tcpServer.ClientAccepted += (sender, args) => _serverChannel = (IMqttChannel)args.Client.GetType().GetField("_channel", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(args.Client);
+            tcpServer.ClientAcceptedHandler += args => _serverChannel = (IMqttChannel)args.Client.GetType().GetField("_channel", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance).GetValue(args.Client);
 
             _mqttServer = factory.CreateMqttServer(new[] { tcpServer }, new MqttNetLogger());
 

Tests/MQTTnet.Benchmarks/SerializerBenchmark.cs

@@ -73,7 +73,9 @@ namespace MQTTnet.Benchmarks
                 _position = _buffer.Offset;
             }
 
-            public string Endpoint { get; }
+            public string Endpoint { get; } = string.Empty;
+
+            public bool IsSecureConnection { get; } = false;
 
             public void Reset()
             {

Tests/MQTTnet.Core.Tests/MQTTnet.Tests.csproj

@@ -14,6 +14,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.csproj" />
+    <ProjectReference Include="..\..\Source\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj" />
     <ProjectReference Include="..\..\Source\MQTTnet\MQTTnet.csproj" />
   </ItemGroup>
 

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

@@ -4,6 +4,7 @@ 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;
@@ -213,13 +214,13 @@ namespace MQTTnet.Tests.MQTTv5
                 var receivedMessages = new List<MqttApplicationMessageReceivedEventArgs>();
 
                 await client1.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithClientId("client1").WithProtocolVersion(MqttProtocolVersion.V500).Build());
-                client1.ApplicationMessageReceived += (s, e) =>
+                client1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
                 {
                     lock (receivedMessages)
                     {
                         receivedMessages.Add(e);
                     }
-                };
+                });
 
                 await client1.SubscribeAsync("a");
 

Tests/MQTTnet.Core.Tests/Mockups/TestMqttCommunicationAdapter.cs

@@ -14,7 +14,9 @@ namespace MQTTnet.Tests.Mockups
 
         public TestMqttCommunicationAdapter Partner { get; set; }
 
-        public string Endpoint { get; }
+        public string Endpoint { get; } = string.Empty;
+
+        public bool IsSecureConnection { get; } = false;
 
         public MqttPacketFormatterAdapter PacketFormatterAdapter { get; } = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311);
 

Tests/MQTTnet.Core.Tests/Mockups/TestMqttServerAdapter.cs

@@ -11,7 +11,7 @@ namespace MQTTnet.Tests.Mockups
 {
     public class TestMqttServerAdapter : IMqttServerAdapter
     {
-        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+        public Action<MqttServerAdapterClientAcceptedEventArgs> ClientAcceptedHandler { get; set; }
         
         public async Task<IMqttClient> ConnectTestClient(string clientId, MqttApplicationMessage willMessage = null)
         {
@@ -41,7 +41,7 @@ namespace MQTTnet.Tests.Mockups
         
         private void FireClientAcceptedEvent(IMqttChannelAdapter adapter)
         {
-            ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(adapter));
+            ClientAcceptedHandler?.Invoke(new MqttServerAdapterClientAcceptedEventArgs(adapter));
         }
 
         public Task StartAsync(IMqttServerOptions options)

Tests/MQTTnet.Core.Tests/Mockups/TestServerExtensions.cs

@@ -1,38 +0,0 @@
-using System.Threading.Tasks;
-using MQTTnet.Client;
-using MQTTnet.Server;
-
-namespace MQTTnet.Tests.Mockups
-{
-    public static class TestServerExtensions
-    {
-        /// <summary>
-        /// publishes a message with a client and waits in the server until a message with the same topic is received
-        /// </summary>
-        /// <returns></returns>
-        public static async Task PublishAndWaitForAsync(this IMqttClient client, IMqttServer server, MqttApplicationMessage message)
-        {
-            var tcs = new TaskCompletionSource<object>();
-
-            void Handler(object sender, MqttApplicationMessageReceivedEventArgs args)
-            {
-                if (args.ApplicationMessage.Topic == message.Topic)
-                {
-                    tcs.SetResult(true);
-                }
-            }
-
-            server.ApplicationMessageReceived += Handler;
-
-            try
-            {
-                await client.PublishAsync(message).ConfigureAwait(false);
-                await tcs.Task.ConfigureAwait(false);
-            }
-            finally
-            {
-                server.ApplicationMessageReceived -= Handler;
-            }
-        }
-    }
-}

Tests/MQTTnet.Core.Tests/MqttClientTests.cs

@@ -5,8 +5,9 @@ using System.Net.Sockets;
 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.Receiving;
 using MQTTnet.Exceptions;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
@@ -45,10 +46,10 @@ namespace MQTTnet.Tests
             using (var client = factory.CreateMqttClient())
             {
                 Exception ex = null;
-                client.Disconnected += (s, e) =>
+                client.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(e =>
                 {
                     ex = e.Exception;
-                };
+                });
 
                 try
                 {
@@ -81,9 +82,9 @@ namespace MQTTnet.Tests
 
                 var receivedValues = new List<int>();
 
-                async Task Handler1(MqttApplicationMessageHandlerContext context)
+                async Task Handler1(MqttApplicationMessageReceivedEventArgs eventArgs)
                 {
-                    var value = int.Parse(context.ApplicationMessage.ConvertPayloadToString());
+                    var value = int.Parse(eventArgs.ApplicationMessage.ConvertPayloadToString());
                     await Task.Delay(value);
 
                     lock (receivedValues)
@@ -92,7 +93,7 @@ namespace MQTTnet.Tests
                     }
                 }
 
-                client1.UseReceivedApplicationMessageHandler(Handler1);
+                client1.UseApplicationMessageReceivedHandler(Handler1);
 
                 var client2 = await testEnvironment.ConnectClientAsync();
                 for (var i = MessagesCount; i > 0; i--)
@@ -119,27 +120,27 @@ namespace MQTTnet.Tests
                 var client1 = await testEnvironment.ConnectClientAsync();
                 await client1.SubscribeAsync("request/+");
 
-                async Task Handler1(MqttApplicationMessageHandlerContext context)
+                async Task Handler1(MqttApplicationMessageReceivedEventArgs eventArgs)
                 {
-                    await client1.PublishAsync($"reply/{context.ApplicationMessage.Topic}");
+                    await client1.PublishAsync($"reply/{eventArgs.ApplicationMessage.Topic}");
                 }
 
-                client1.UseReceivedApplicationMessageHandler(Handler1);
+                client1.UseApplicationMessageReceivedHandler(Handler1);
 
                 var client2 = await testEnvironment.ConnectClientAsync();
                 await client2.SubscribeAsync("reply/#");
 
                 var replies = new List<string>();
 
-                void Handler2(MqttApplicationMessageHandlerContext context)
+                void Handler2(MqttApplicationMessageReceivedEventArgs eventArgs)
                 {
                     lock (replies)
                     {
-                        replies.Add(context.ApplicationMessage.Topic);
+                        replies.Add(eventArgs.ApplicationMessage.Topic);
                     }
                 }
 
-                client2.UseReceivedApplicationMessageHandler((Action<MqttApplicationMessageHandlerContext>)Handler2);
+                client2.UseApplicationMessageReceivedHandler((Action<MqttApplicationMessageReceivedEventArgs>)Handler2);
 
                 await Task.Delay(500);
 
@@ -163,7 +164,7 @@ namespace MQTTnet.Tests
                 var receivedMessages = new List<MqttApplicationMessage>();
 
                 var client1 = await testEnvironment.ConnectClientAsync();
-                client1.UseReceivedApplicationMessageHandler(c =>
+                client1.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (receivedMessages)
                     {
@@ -195,7 +196,7 @@ namespace MQTTnet.Tests
 
                 var client = testEnvironment.CreateClient();
 
-                client.Connected += async (s, e) =>
+                client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e =>
                 {
                     await client.SubscribeAsync("RCU/P1/H0001/R0003");
 
@@ -204,9 +205,9 @@ namespace MQTTnet.Tests
                         .WithTopic("RCU/P1/H0001/R0003");
 
                     await client.PublishAsync(msg.Build());
-                };
+                });
 
-                client.UseReceivedApplicationMessageHandler(c =>
+                client.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (receivedMessages)
                     {
@@ -241,7 +242,7 @@ namespace MQTTnet.Tests
 
                 var retries = 0;
 
-                async Task Handler1(MqttApplicationMessageHandlerContext context)
+                async Task Handler1(MqttApplicationMessageReceivedEventArgs eventArgs)
                 {
                     retries++;
 
@@ -249,7 +250,7 @@ namespace MQTTnet.Tests
                     throw new Exception("Broken!");
                 }
 
-                client1.UseReceivedApplicationMessageHandler(Handler1);
+                client1.UseApplicationMessageReceivedHandler(Handler1);
 
                 var client2 = await testEnvironment.ConnectClientAsync();
                 await client2.PublishAsync("x");

Tests/MQTTnet.Core.Tests/MqttFactoryTests.cs

@@ -59,7 +59,7 @@ namespace MQTTnet.Tests
 
                 //wait at least connect timeout or we have some log messages
                 var tcs = new TaskCompletionSource<object>();
-                managedClient.ConnectingFailed += (s, e) => tcs.TrySetResult(null);
+                managedClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(e => tcs.TrySetResult(null));
                 await Task.WhenAny(Task.Delay(managedClient.Options.ClientOptions.CommunicationTimeout), tcs.Task);
             }
             finally

Tests/MQTTnet.Core.Tests/RPC_Tests.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Text;
+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;
+
+namespace MQTTnet.Tests
+{
+    [TestClass]
+    public class RPC_Tests
+    {
+        [TestMethod]
+        public async Task Execute_Success()
+        {
+            using (var testEnvironment = new TestEnvironment())
+            {
+                await testEnvironment.StartServerAsync();
+                var responseSender = await testEnvironment.ConnectClientAsync();
+                await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping");
+
+                responseSender.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(async e =>
+                {
+                    await responseSender.PublishAsync(e.ApplicationMessage.Topic + "/response", "pong");
+                });
+
+                var requestSender = await testEnvironment.ConnectClientAsync();
+
+                var rpcClient = new MqttRpcClient(requestSender);
+                var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
+
+                Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
+            }
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(MqttCommunicationTimedOutException))]
+        public async Task Execute_Timeout()
+        {
+            using (var testEnvironment = new TestEnvironment())
+            {
+                await testEnvironment.StartServerAsync();
+                
+                var requestSender = await testEnvironment.ConnectClientAsync();
+
+                var rpcClient = new MqttRpcClient(requestSender);
+                await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
+            }
+        }
+    }
+}

Tests/MQTTnet.Core.Tests/RoundtripTimeTests.cs

@@ -5,6 +5,7 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Client.Options;
+using MQTTnet.Client.Receiving;
 using MQTTnet.Server;
 
 namespace MQTTnet.Tests
@@ -29,10 +30,10 @@ namespace MQTTnet.Tests
 
             TaskCompletionSource<string> response = null;
 
-            receiverClient.ApplicationMessageReceived += (sender, args) =>
+            receiverClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(args =>
             {
                 response?.SetResult(args.ApplicationMessage.ConvertPayloadToString());
-            };
+            });
 
             var times = new List<TimeSpan>();
             var stopwatch = Stopwatch.StartNew();

Tests/MQTTnet.Core.Tests/Server_Tests.cs

@@ -9,7 +9,9 @@ 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.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
@@ -66,7 +68,7 @@ namespace MQTTnet.Tests
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage);
 
                 var c1 = await testEnvironment.ConnectClientAsync();
-                c1.UseReceivedApplicationMessageHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new TopicFilterBuilder().WithTopic("#").Build());
 
                 var c2 = await testEnvironment.ConnectClientAsync(clientOptions);
@@ -92,7 +94,7 @@ namespace MQTTnet.Tests
                 var clientOptions = new MqttClientOptionsBuilder().WithWillMessage(willMessage);
 
                 var c1 = await testEnvironment.ConnectClientAsync();
-                c1.UseReceivedApplicationMessageHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new TopicFilterBuilder().WithTopic("#").Build());
 
                 var c2 = await testEnvironment.ConnectClientAsync(clientOptions);
@@ -114,7 +116,7 @@ namespace MQTTnet.Tests
                 var server = await testEnvironment.StartServerAsync();
 
                 var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("c1"));
-                c1.UseReceivedApplicationMessageHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
 
                 var c2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("c2"));
 
@@ -125,10 +127,10 @@ namespace MQTTnet.Tests
                 Assert.AreEqual(0, receivedMessagesCount);
 
                 var subscribeEventCalled = false;
-                server.ClientSubscribedTopic += (_, e) =>
+                server.ClientSubscribedTopicHandler = new MqttServerClientSubscribedHandlerDelegate(e =>
                 {
                     subscribeEventCalled = e.TopicFilter.Topic == "a" && e.ClientId == "c1";
-                };
+                });
 
                 await c1.SubscribeAsync(new TopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
                 await Task.Delay(250);
@@ -139,10 +141,10 @@ namespace MQTTnet.Tests
                 Assert.AreEqual(1, receivedMessagesCount);
 
                 var unsubscribeEventCalled = false;
-                server.ClientUnsubscribedTopic += (_, e) =>
+                server.ClientUnsubscribedTopicHandler = new MqttServerClientUnsubscribedTopicHandlerDelegate(e => 
                 {
                     unsubscribeEventCalled = e.TopicFilter == "a" && e.ClientId == "c1";
-                };
+                });
 
                 await c1.UnsubscribeAsync("a");
                 await Task.Delay(250);
@@ -168,7 +170,7 @@ namespace MQTTnet.Tests
                 var receivedMessagesCount = 0;
 
                 var client = await testEnvironment.ConnectClientAsync();
-                client.UseReceivedApplicationMessageHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                client.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
 
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
                 await client.SubscribeAsync(new TopicFilter { Topic = "a", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce });
@@ -194,7 +196,7 @@ namespace MQTTnet.Tests
                 var c1 = await testEnvironment.ConnectClientAsync();
                 var c2 = await testEnvironment.ConnectClientAsync();
 
-                c1.UseReceivedApplicationMessageHandler(c =>
+                c1.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (locked)
                     {
@@ -202,7 +204,7 @@ namespace MQTTnet.Tests
                     }
                 });
 
-                c2.UseReceivedApplicationMessageHandler(c =>
+                c2.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (locked)
                     {
@@ -258,12 +260,12 @@ namespace MQTTnet.Tests
                 var client = await testEnvironment.ConnectClientAsync();
                 var receivedMessages = new List<MqttApplicationMessage>();
 
-                client.Connected += async (s, e) =>
+                client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e =>
                 {
                     await client.PublishAsync("Connected");
-                };
+                });
 
-                client.UseReceivedApplicationMessageHandler(c =>
+                client.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (receivedMessages)
                     {
@@ -287,15 +289,12 @@ namespace MQTTnet.Tests
             using (var testEnvironment = new TestEnvironment())
             {
                 var server = await testEnvironment.StartServerAsync();
-                server.ClientConnected += async (s, e) =>
-                {
-                    await server.SubscribeAsync(e.ClientId, "topic1");
-                };
+                server.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(e  => server.SubscribeAsync(e.ClientId, "topic1"));
 
                 var client = await testEnvironment.ConnectClientAsync();
                 var receivedMessages = new List<MqttApplicationMessage>();
 
-                client.UseReceivedApplicationMessageHandler(c =>
+                client.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (receivedMessages)
                     {
@@ -325,7 +324,7 @@ namespace MQTTnet.Tests
                 var disconnectCalled = 0;
 
                 var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder());
-                c1.Disconnected += (sender, args) => disconnectCalled++;
+                c1.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(e => disconnectCalled++);
 
                 await Task.Delay(100);
 
@@ -347,8 +346,8 @@ namespace MQTTnet.Tests
                 var clientConnectedCalled = 0;
                 var clientDisconnectedCalled = 0;
 
-                server.ClientConnected += (_, __) => Interlocked.Increment(ref clientConnectedCalled);
-                server.ClientDisconnected += (_, __) => Interlocked.Increment(ref clientDisconnectedCalled);
+                server.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(_ => Interlocked.Increment(ref clientConnectedCalled));
+                server.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(_ => Interlocked.Increment(ref clientDisconnectedCalled));
 
                 var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder());
 
@@ -462,7 +461,7 @@ namespace MQTTnet.Tests
                 var receivedMessages = 0;
 
                 var c2 = await testEnvironment.ConnectClientAsync();
-                c2.UseReceivedApplicationMessageHandler(c =>
+                c2.UseApplicationMessageReceivedHandler(c =>
                 {
                     Interlocked.Increment(ref receivedMessages);
                 });
@@ -500,7 +499,7 @@ namespace MQTTnet.Tests
                 var receivedMessagesCount = 0;
 
                 var c2 = await testEnvironment.ConnectClientAsync();
-                c2.UseReceivedApplicationMessageHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c2.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("retained_other").Build());
 
                 await Task.Delay(500);
@@ -523,7 +522,7 @@ namespace MQTTnet.Tests
                 var receivedMessages = new List<MqttApplicationMessage>();
 
                 var c2 = await testEnvironment.ConnectClientAsync();
-                c2.UseReceivedApplicationMessageHandler(c =>
+                c2.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (receivedMessages)
                     {
@@ -558,7 +557,7 @@ namespace MQTTnet.Tests
 
                 var c2 = await testEnvironment.ConnectClientAsync();
 
-                c2.UseReceivedApplicationMessageHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c2.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
 
                 await Task.Delay(200);
                 await c2.SubscribeAsync(new TopicFilter { Topic = "retained", QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce });
@@ -604,7 +603,7 @@ namespace MQTTnet.Tests
                 await c2.SubscribeAsync(new TopicFilterBuilder().WithTopic("test").Build());
 
                 var isIntercepted = false;
-                c2.UseReceivedApplicationMessageHandler(c =>
+                c2.UseApplicationMessageReceivedHandler(c =>
                 {
                     isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(c.ApplicationMessage.Payload), StringComparison.Ordinal) == 0;
                 });
@@ -645,7 +644,7 @@ namespace MQTTnet.Tests
 
                 await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
                 var client1 = await testEnvironment.ConnectClientAsync();
-                client1.UseReceivedApplicationMessageHandler(c =>
+                client1.UseApplicationMessageReceivedHandler(c =>
                 {
                     receivedBody = c.ApplicationMessage.Payload;
                 });
@@ -703,21 +702,21 @@ namespace MQTTnet.Tests
 
                 var events = new List<string>();
 
-                server.ClientConnected += (_, __) =>
+                server.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(_ => 
                 {
                     lock (events)
                     {
                         events.Add("c");
                     }
-                };
+                });
 
-                server.ClientDisconnected += (_, __) =>
+                server.ClientDisconnectedHandler = new MqttServerClientDisconnectedHandlerDelegate(_ =>
                 {
                     lock (events)
                     {
                         events.Add("d");
                     }
-                };
+                });
 
                 var clientOptions = new MqttClientOptionsBuilder()
                     .WithClientId("same_id");
@@ -888,7 +887,7 @@ namespace MQTTnet.Tests
 
                 var buffer = new StringBuilder();
                 
-                client2.UseReceivedApplicationMessageHandler(c =>
+                client2.UseApplicationMessageReceivedHandler(c =>
                 {
                     lock (buffer)
                     {
@@ -952,7 +951,7 @@ namespace MQTTnet.Tests
                 await testEnvironment.StartServerAsync(new MqttServerOptionsBuilder());
 
                 var c1 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("receiver"));
-                c1.UseReceivedApplicationMessageHandler(c => Interlocked.Increment(ref receivedMessagesCount));
+                c1.UseApplicationMessageReceivedHandler(c => Interlocked.Increment(ref receivedMessagesCount));
                 await c1.SubscribeAsync(new TopicFilterBuilder().WithTopic(topicFilter).WithQualityOfServiceLevel(filterQualityOfServiceLevel).Build());
 
                 var c2 = await testEnvironment.ConnectClientAsync(new MqttClientOptionsBuilder().WithClientId("sender"));

Tests/MQTTnet.TestApp.AspNetCore2/Startup.cs

@@ -5,7 +5,6 @@ using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.FileProviders;
-using MQTTnet;
 using MQTTnet.AspNetCore;
 using MQTTnet.Server;
 
@@ -36,7 +35,7 @@ namespace MQTTnet.TestApp.AspNetCore2
             //app.UseMqttEndpoint();
             app.UseMqttServer(server =>
             {
-                server.Started += async (sender, args) =>
+                server.StartedHandler = new MqttServerStartedHandlerDelegate(async args =>
                 {
                     var msg = new MqttApplicationMessageBuilder()
                         .WithPayload("Mqtt is awesome")
@@ -58,7 +57,7 @@ namespace MQTTnet.TestApp.AspNetCore2
                             await Task.Delay(TimeSpan.FromSeconds(2));
                         }
                     }
-                };
+                });
             });
 
             app.Use((context, next) =>

Tests/MQTTnet.TestApp.AspNetCore2/package.json

@@ -2,13 +2,11 @@
   "version": "1.0.0",
   "name": "mqtt.test",
   "private": true,
-  "devDependencies": {
-  },
-
+  "devDependencies": {},
   "dependencies": {
     "mqtt": "2.15.1",
     "@types/node": "8.0.46",
     "systemjs": "0.20.19",
     "typescript": "2.3.4"
   }
-}
+}

Tests/MQTTnet.TestApp.NetCore/ClientTest.cs

@@ -2,7 +2,10 @@
 using System.Text;
 using System.Threading.Tasks;
 using MQTTnet.Client;
+using MQTTnet.Client.Connecting;
+using MQTTnet.Client.Disconnecting;
 using MQTTnet.Client.Options;
+using MQTTnet.Client.Receiving;
 using MQTTnet.Protocol;
 
 namespace MQTTnet.TestApp.NetCore
@@ -25,7 +28,7 @@ namespace MQTTnet.TestApp.NetCore
                     }
                 };
 
-                client.ApplicationMessageReceived += (s, e) =>
+                client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
                 {
                     Console.WriteLine("### RECEIVED APPLICATION MESSAGE ###");
                     Console.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
@@ -33,18 +36,18 @@ namespace MQTTnet.TestApp.NetCore
                     Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
                     Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
                     Console.WriteLine();
-                };
+                });
 
-                client.Connected += async (s, e) =>
+                client.ConnectedHandler = new MqttClientConnectedHandlerDelegate(async e =>
                 {
                     Console.WriteLine("### CONNECTED WITH SERVER ###");
 
                     await client.SubscribeAsync(new TopicFilterBuilder().WithTopic("#").Build());
 
                     Console.WriteLine("### SUBSCRIBED ###");
-                };
+                });
 
-                client.Disconnected += async (s, e) =>
+                client.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(async e => 
                 {
                     Console.WriteLine("### DISCONNECTED FROM SERVER ###");
                     await Task.Delay(TimeSpan.FromSeconds(5));
@@ -57,7 +60,7 @@ namespace MQTTnet.TestApp.NetCore
                     {
                         Console.WriteLine("### RECONNECTING FAILED ###");
                     }
-                };
+                });
 
                 try
                 {

Tests/MQTTnet.TestApp.NetCore/ManagedClientTest.cs

@@ -4,6 +4,7 @@ using System.IO;
 using Newtonsoft.Json;
 using System.Collections.Generic;
 using MQTTnet.Client.Options;
+using MQTTnet.Client.Receiving;
 using MQTTnet.Extensions.ManagedClient;
 using MQTTnet.Protocol;
 
@@ -34,10 +35,10 @@ namespace MQTTnet.TestApp.NetCore
             try
             {
                 var managedClient = new MqttFactory().CreateManagedMqttClient();
-                managedClient.ApplicationMessageReceived += (s, e) =>
+                managedClient.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
                 {
                     Console.WriteLine(">> RECEIVED: " + e.ApplicationMessage.Topic);
-                };
+                });
 
                 await managedClient.PublishAsync(builder => builder.WithTopic("Step").WithPayload("1"));
                 await managedClient.PublishAsync(builder => builder.WithTopic("Step").WithPayload("2").WithAtLeastOnceQoS());

Tests/MQTTnet.TestApp.NetCore/PublicBrokerTest.cs

@@ -4,6 +4,7 @@ using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Client.Options;
+using MQTTnet.Client.Receiving;
 using MQTTnet.Formatter;
 using MQTTnet.Protocol;
 using Newtonsoft.Json;
@@ -80,7 +81,7 @@ namespace MQTTnet.TestApp.NetCore
                 var topic = Guid.NewGuid().ToString();
 
                 MqttApplicationMessage receivedMessage = null;
-                client.ApplicationMessageReceived += (s, e) => receivedMessage = e.ApplicationMessage;
+                client.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e => receivedMessage = e.ApplicationMessage);
 
                 await client.ConnectAsync(options);
                 await client.SubscribeAsync(topic, MqttQualityOfServiceLevel.AtLeastOnce);

Tests/MQTTnet.TestApp.NetCore/ServerTest.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Text;
 using System.Threading.Tasks;
+using MQTTnet.Client.Receiving;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 
@@ -78,12 +79,12 @@ namespace MQTTnet.TestApp.NetCore
 
                 var mqttServer = new MqttFactory().CreateMqttServer();
 
-                mqttServer.ApplicationMessageReceived += (s, e) =>
+                mqttServer.ApplicationMessageReceivedHandler = new MqttApplicationMessageReceivedHandlerDelegate(e =>
                 {
                     MqttNetConsoleLogger.PrintToConsole(
                         $"'{e.ClientId}' reported '{e.ApplicationMessage.Topic}' > '{Encoding.UTF8.GetString(e.ApplicationMessage.Payload ?? new byte[0])}'",
                         ConsoleColor.Magenta);
-                };
+                });
 
                 //options.ApplicationMessageInterceptor = c =>
                 //{
@@ -107,10 +108,10 @@ namespace MQTTnet.TestApp.NetCore
                 //    }
                 //};
 
-                mqttServer.ClientDisconnected += (s, e) =>
+                mqttServer.ClientConnectedHandler = new MqttServerClientConnectedHandlerDelegate(e =>
                 {
                     Console.Write("Client disconnected event fired.");
-                };
+                });
 
                 await mqttServer.StartAsync(options);
 

Tests/MQTTnet.TestApp.UniversalWindows/MainPage.xaml.cs

@@ -7,7 +7,10 @@ using Windows.Security.Cryptography.Certificates;
 using Windows.UI.Core;
 using Windows.UI.Xaml;
 using MQTTnet.Client;
+using MQTTnet.Client.Connecting;
+using MQTTnet.Client.Disconnecting;
 using MQTTnet.Client.Options;
+using MQTTnet.Client.Receiving;
 using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Extensions.ManagedClient;
@@ -144,9 +147,9 @@ namespace MQTTnet.TestApp.UniversalWindows
                 if (_mqttClient != null)
                 {
                     await _mqttClient.DisconnectAsync();
-                    _mqttClient.ApplicationMessageReceived -= OnApplicationMessageReceived;
-                    _mqttClient.Connected -= OnConnected;
-                    _mqttClient.Disconnected -= OnDisconnected;
+                    _mqttClient.UseApplicationMessageReceivedHandler(HandleReceivedApplicationMessage);
+                    _mqttClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(x => OnConnected(x));
+                    _mqttClient.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(x => OnDisconnected(x));
                 }
 
                 var factory = new MqttFactory();
@@ -154,9 +157,9 @@ namespace MQTTnet.TestApp.UniversalWindows
                 if (UseManagedClient.IsChecked == true)
                 {
                     _managedMqttClient = factory.CreateManagedMqttClient();
-                    _managedMqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
-                    _managedMqttClient.Connected += OnConnected;
-                    _managedMqttClient.Disconnected += OnDisconnected;
+                    _managedMqttClient.UseApplicationMessageReceivedHandler(HandleReceivedApplicationMessage);
+                    _managedMqttClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(x => OnConnected(x));
+                    _managedMqttClient.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(x => OnDisconnected(x));
 
                     await _managedMqttClient.StartAsync(new ManagedMqttClientOptions
                     {
@@ -166,9 +169,9 @@ namespace MQTTnet.TestApp.UniversalWindows
                 else
                 {
                     _mqttClient = factory.CreateMqttClient();
-                    _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
-                    _mqttClient.Connected += OnConnected;
-                    _mqttClient.Disconnected += OnDisconnected;
+                    _mqttClient.UseApplicationMessageReceivedHandler(HandleReceivedApplicationMessage);
+                    _mqttClient.ConnectedHandler = new MqttClientConnectedHandlerDelegate(x => OnConnected(x));
+                    _mqttClient.DisconnectedHandler = new MqttClientDisconnectedHandlerDelegate(x => OnDisconnected(x));
 
                     await _mqttClient.ConnectAsync(options);
                 }
@@ -179,7 +182,7 @@ namespace MQTTnet.TestApp.UniversalWindows
             }
         }
 
-        private void OnDisconnected(object sender, MqttClientDisconnectedEventArgs e)
+        private void OnDisconnected(MqttClientDisconnectedEventArgs e)
         {
             _traceMessages.Enqueue(new MqttNetLogMessage("", DateTime.Now, -1,
                 "", MqttNetLogLevel.Info, "! DISCONNECTED EVENT FIRED", null));
@@ -187,7 +190,7 @@ namespace MQTTnet.TestApp.UniversalWindows
             Task.Run(UpdateLogAsync);
         }
 
-        private void OnConnected(object sender, MqttClientConnectedEventArgs e)
+        private void OnConnected(MqttClientConnectedEventArgs e)
         {
             _traceMessages.Enqueue(new MqttNetLogMessage("", DateTime.Now, -1,
                 "", MqttNetLogLevel.Info, "! CONNECTED EVENT FIRED", null));
@@ -195,7 +198,7 @@ namespace MQTTnet.TestApp.UniversalWindows
             Task.Run(UpdateLogAsync);
         }
 
-        private async void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
+        private async Task HandleReceivedApplicationMessage(MqttApplicationMessageReceivedEventArgs eventArgs)
         {
             var item = $"Timestamp: {DateTime.Now:O} | Topic: {eventArgs.ApplicationMessage.Topic} | Payload: {Encoding.UTF8.GetString(eventArgs.ApplicationMessage.Payload)} | QoS: {eventArgs.ApplicationMessage.QualityOfServiceLevel}";