1889 no service for type mqttnetservermqttserver has been registered (#1892 )

* Add missing service to service collection * Update ReleaseNotes.md * Restore service registrations
1883 in a weak network environment the mqtt broker is unable to detect disconnections (#1891 )
2026-10-15 17:00:03 +08:00 · 2023-12-08 18:01:19 +01:00 · 2023-12-07 17:49:03 +01:00 · 2023-12-07 17:48:14 +01:00 · 2023-12-07 17:47:57 +01:00 · 2023-12-06 18:02:48 +01:00
321 changed files with 14033 additions and 5975 deletions
@@ -24,7 +24,7 @@ A clear and concise description of what the bug is.
 <!-- Remove the items which don't apply from the following list. -->
 - Client
 - ManagedClient
- RcpClient
+- RpcClient
 - Server

 ### To Reproduce
@@ -14,6 +14,5 @@ A clear and concise description of what you want to know.
 <!-- Remove the items which don't apply from the following list -->
 - Client
 - ManagedClient
- MQTTnet.Server standalone
 - Server
 - Generic
@@ -15,7 +15,6 @@ A clear and concise description of what the problem is. Example. I'm am trying t
 <!-- Remove the items which don't apply from the following list -->
 - Client
 - ManagedClient
- MQTTnet.Server standalone
 - Server
 - Generic

@@ -1,32 +1,3 @@
-We have joined the .NET Foundation!
-
-Version 4 comes with a new API so a lot of breaking changes should be expected.
-Checkout the upgrade guide (https://github.com/dotnet/MQTTnet/wiki/Upgrading-guide) for an overview of the changes.
-Checkout the new samples (https://github.com/dotnet/MQTTnet/tree/feature/master/Samples) how to use the new API. The wiki only remains for version 3 of this library.
-
-Preview builds of this library are available at: https://www.myget.org/feed/mqttnet/package/nuget/MQTTnet
-
-* [Core] Improved memory management when working with large payloads.
-* [Core] Added support for .NET 6.0.
-* [Core] nuget packages are now created by MSBuild including more information (i.e. commit hash).
-* [Client] Exposed socket linger state in options.
-* [Client] The OS will now choose the best TLS version to use. It is no longer fixed to 1.3 etc. (thanks to @patagonaa, #1271).
-* [Client] Added support for _ServerKeepAlive_ (MQTTv5).
-* [Client] Exposed user properties and reason string in subscribe result.
-* [Client] Exposed user properties and reason string in unsubscribe result.
-* [Client] Migrated application message handler to a regular .NET event (BREAKING CHANGE!).
-* [Client] The will message is longer a regular application message due to not supported properties by the will message (BREAKING CHANGE!).
-* [Client] Timeouts are no longer handled inside the library. Each method (Connect, Publish etc.) supports a cancellation token so that custom timeouts can and must be used (BREAKING CHANGE!).
-* [Client] Exposed certificate revocation mode on options (@andyolivares).
-* [Server] Exposed socket linger state in options.
-* [Server] Added support for returning individual subscription errors (#80 thanks to @jimch)
-* [Server] Improved topic filter comparisons (support for $).
-* [Server] Added more MQTTv5 response information to all interceptors (BREAKING CHANGE!).
-* [Server] Improved session management for MQTT v5 (#1294, thanks to @logicaloud).
-* [Server] All interceptors and events are migrated from interfaces to simple events. All existing APIs are availble but must be migrated to corresponding events (BREAKING CHANGE!).
-* [Server] Removed all interceptor and event interfaces including the delegate implementations etc. (BREAKING CHANGE!).
-* [Server] Renamed a lot of classes and adjusted namespaces (BREAKING CHANGE!).
-* [Server] Introduced a new queueing approach for internal message process (packet bus).
-* [Server] For security reasons the default endpoint (1883) is no longer enabled by default (BREAKING CHANGE!).
-* [Server] Added support for choosing the cipher suite (thanks to @TimSiefert).
-* [Nuget] Added method summaries etc. to nuget packages (thanks to @SpringHgui).
+* [Server] Added new events for delivered and dropped messages (#1866, thanks to @kallayj).
+* [Server] The server will no longer treat a client which is receiving a large payload as alive. The packet must be received completely within the keep alive boundaries (BREAKING CHANGE!, #1883).
+* [Server] Fixed "service not registered" exception in ASP.NET integration (#1889).
@@ -3,8 +3,7 @@ name: CI
 on: [push, pull_request]

 env:
-  ASSEMBLY_VERSION: "4.0.0.${{github.run_number}}"
-  NUGET_VERSION:  "4.0.0.${{github.run_number}}"
+  VERSION: "4.3.3.${{github.run_number}}"

 jobs:
  build:
@@ -23,6 +22,7 @@ jobs:
          dotnet-version: |
            3.1.x
            6.0.x
+            7.0.x

      - name: Setup MSBuild
        uses: microsoft/setup-msbuild@v1.1
@@ -40,7 +40,7 @@ jobs:
        run: msbuild MQTTnet.sln /t:Restore /p:Configuration="Release" /verbosity:m

      - name: Build solution
-        run: msbuild MQTTnet.sln /t:Build /p:Configuration="Release" /verbosity:m /p:FileVersion=${{ env.ASSEMBLY_VERSION }} /p:AssemblyVersion=${{ env.ASSEMBLY_VERSION }} /p:PackageVersion=${{ env.NUGET_VERSION }} /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=${{ github.workspace }}\certificate.snk
+        run: msbuild MQTTnet.sln /t:Build /p:Configuration="Release" /verbosity:m /p:FileVersion=${{ env.VERSION }} /p:AssemblyVersion=${{ env.VERSION }} /p:PackageVersion=${{ env.VERSION }} /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=${{ github.workspace }}\certificate.snk

      - name: Collect nuget Packages
        uses: actions/upload-artifact@v2
@@ -54,15 +54,11 @@ jobs:
        uses: darenm/Setup-VSTest@v1

      - name: Core Tests
-        run: vstest.console.exe Source\MQTTnet.Tests\bin\Release\net6.0\MQTTnet.Tests.dll
+        run: vstest.console.exe Source\MQTTnet.Tests\bin\Release\net7.0\MQTTnet.Tests.dll

      - name: ASP.NET Tests
        run: vstest.console.exe Source\MQTTnet.AspNetCore.Tests\bin\Release\netcoreapp3.1\MQTTnet.AspNetCore.Tests.dll

      - name: Publish MyGet nugets
        if: ${{ github.event_name == 'push' }}
-        run: dotnet nuget push **/*.nupkg -k ${{ secrets.MYGET_API_KEY }} -s https://www.myget.org/F/mqttnet/api/v3/index.json --skip-duplicate
-
-#      - name: Publish nugets
-#        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
-#        run: dotnet nuget push **/*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json --skip-duplicate
+        run: dotnet nuget push **/*.nupkg -k ${{ secrets.MYGET_API_KEY }} -s https://www.myget.org/F/mqttnet/api/v3/index.json --skip-duplicate
@@ -29,7 +29,7 @@
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/XmlDocFormatter/ProcessingInstructionAttributesFormat/@EntryValue">OnDifferentLines</s:String>
 	<s:String x:Key="/Default/CodeStyle/CodeFormatting/XmlDocFormatter/TagAttributesFormat/@EntryValue">OnDifferentLines</s:String>
 	<s:String x:Key="/Default/CodeStyle/CSharpFileLayoutPatterns/Pattern/@EntryValue">&lt;?xml version="1.0" encoding="utf-16"?&gt;
-&lt;Patterns xmlns="urn:schemas-jetbrains-com:member-reordering-patterns"&gt;
+&lt;Patterns xmlns="urn:schemas-jetbrains-com:member-reordering-patterns"&gt;    
  &lt;TypePattern DisplayName="Non-reorderable types"&gt;
    &lt;TypePattern.Match&gt;
      &lt;Or&gt;
@@ -210,6 +210,7 @@
        &lt;/Or&gt;
      &lt;/Entry.Match&gt;
        &lt;Entry.SortBy&gt;
+            &lt;Access Order="Public Internal Protected Private" /&gt;
            &lt;Name /&gt;
        &lt;/Entry.SortBy&gt;
    &lt;/Entry&gt;
@@ -226,6 +227,9 @@
    &lt;/Entry&gt;
  &lt;/TypePattern&gt;
 &lt;/Patterns&gt;</s:String>
+	<s:String x:Key="/Default/CodeStyle/FileHeader/FileHeaderText/@EntryValue">Licensed to the .NET Foundation under one or more agreements.
+The .NET Foundation licenses this file to you under the MIT license.
+See the LICENSE file in the project root for more information.</s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpAttributeForSingleLineMethodUpgrade/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpKeepExistingMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ECSharpPlaceEmbeddedOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
@@ -236,6 +240,15 @@
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=catched/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=CONNACK/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=PINGREQ/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=PINGRESP/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=PUBACK/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=PUBCOMP/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=PUBREC/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=PUBREL/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=SUBACK/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Tnet/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=unsub/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=unsub/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=UNSUBACK/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
@@ -4,7 +4,7 @@
 </p>

 [![NuGet Badge](https://buildstats.info/nuget/MQTTnet)](https://www.nuget.org/packages/MQTTnet)
-[![CI](https://github.com/dotnet/MQTTnet/actions/workflows/ci.yml/badge.svg)](https://github.com/dotnet/MQTTnet/actions/workflows/ci.yml)
+[![CI](https://github.com/dotnet/MQTTnet/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/dotnet/MQTTnet/actions/workflows/ci.yml)
 [![MyGet](https://img.shields.io/myget/mqttnet/v/mqttnet?color=orange&label=MyGet-Preview)](https://www.myget.org/feed/mqttnet/package/nuget/MQTTnet)
 ![Size](https://img.shields.io/github/repo-size/dotnet/MQTTnet.svg)
 [![Join the chat at https://gitter.im/MQTTnet/community](https://badges.gitter.im/MQTTnet/community.svg)](https://gitter.im/MQTTnet/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
@@ -12,7 +12,7 @@

 # MQTTnet

-MQTTnet is a high performance .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker) and supports the MQTT protocol up to version 5.
+MQTTnet is a high performance .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker) and supports the MQTT protocol up to version 5. It is compatible with mostly any supported .NET Framework version and CPU architecture.

 ## Features

@@ -50,38 +50,21 @@ MQTTnet is a high performance .NET library for MQTT based communication. It prov
 * A custom message interceptor can be added which allows transforming or extending every received application message
 * Validate subscriptions and deny subscribing of certain topics depending on requesting clients

-## Supported frameworks
+## Getting Started

-| Framwork           | Version     |
-| ------------------ | ----------- |
-|.NET                | 5.0+        |
-|.NET Framework      | 4.5.2+      |
-|.NET Standard       | 1.3+        |
-|.NET Core           | 1.1+        |
-|.NET Core App       | 1.1+        |
-| Mono               | 5.2+        |
-| UWP                | 10.0.10240+ |
-| Xamarin.Android    | 7.5+        |
-| Xamarin.iOS        | 10.14+      |
-| Blazor WebAssembly | 3.2.0+      |
+MQTTnet is delivered via <b>NuGet</b> package manager. You can find the packages here: https://www.nuget.org/packages/MQTTnet/

-## References
+Use these command in the Package Manager console to install MQTTnet manually:
+```
+Install-Package MQTTnet
+```

-This library is used in the following projects:
+Samples for using MQTTnet are part of this repository. For starters these samples are recommended:

-* Azure Functions MQTT Bindings, <https://github.com/keesschollaart81/CaseOnline.Azure.WebJobs.Extensions.Mqtt>)
-* HA4IoT (Open Source Home Automation system for .NET, <https://github.com/chkr1011/HA4IoT>)
-* MQTT Client Rx (Wrapper for Reactive Extensions, <https://github.com/1iveowl/MQTTClient.rx>)
-* MQTT Client Rx (Managed Client Wrapper for Reactive Extensions, <https://github.com/mmuecke/RxMQTTnet>)
-* MQTT Tester (MQTT client test app for [Android](https://play.google.com/store/apps/details?id=com.liveowl.mqtttester) and [iOS](https://itunes.apple.com/us/app/mqtt-tester/id1278621826?mt=8))
-* MQTTnet App (Cross platform client application for MQTT debugging, inspection etc., <https://github.com/chkr1011/MQTTnetApp>)
-* Wirehome.Core (Open Source Home Automation system for .NET Core, <https://github.com/chkr1011/Wirehome.Core>)
-* SparkplugNet (Sparkplug library for .Net, <https://github.com/SeppPenner/SparkplugNet>)
-* Silverback (Framework to build event-driven applications - support for MQTT, Kafka & RabbitMQ) <https://github.com/BEagle1984/silverback>
-
-Further projects using this project can be found under https://github.com/dotnet/MQTTnet/network/dependents.
-
-If you use this library and want to see your project here please create a pull request.
+- [Connect with a broker](https://github.com/dotnet/MQTTnet/blob/master/Samples/Client/Client_Connection_Samples.cs)
+- [Subscribing to data](https://github.com/dotnet/MQTTnet/blob/master/Samples/Client/Client_Subscribe_Samples.cs)
+- [Publishing data](https://github.com/dotnet/MQTTnet/blob/master/Samples/Client/Client_Publish_Samples.cs)
+- [Host own broker](https://github.com/dotnet/MQTTnet/blob/master/Samples/Server/Server_Simple_Samples.cs)

 ## Code of Conduct

@@ -2,8 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
 using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
 using MQTTnet.Client;
+using MQTTnet.Extensions.WebSocket4Net;
 using MQTTnet.Formatter;
 using MQTTnet.Samples.Helpers;

@@ -11,6 +17,28 @@ namespace MQTTnet.Samples.Client;

 public static class Client_Connection_Samples
 {
+    public static async Task Clean_Disconnect()
+    {
+        /*
+         * This sample disconnects in a clean way. This will send a MQTT DISCONNECT packet
+         * to the server and close the connection afterwards.
+         *
+         * See sample _Connect_Client_ for more details.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            // This will send the DISCONNECT packet. Calling _Dispose_ without DisconnectAsync the 
+            // connection is closed in a "not clean" way. See MQTT specification for more details.
+            await mqttClient.DisconnectAsync(new MqttClientDisconnectOptionsBuilder().WithReason(MqttClientDisconnectOptionsReason.NormalDisconnection).Build());
+        }
+    }
+
    public static async Task Connect_Client()
    {
        /*
@@ -108,16 +136,48 @@ public static class Client_Connection_Samples
        using (var mqttClient = mqttFactory.CreateMqttClient())
        {
            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("mqtt.fluux.io")
-                .WithTls(
+                .WithTlsOptions(
                    o =>
                    {
-                        o.SslProtocol = SslProtocols.Tls12;
+                        // The used public broker sometimes has invalid certificates. This sample accepts all
+                        // certificates. This should not be used in live environments.
+                        o.WithCertificateValidationHandler(_ => true);
+
+                        // The default value is determined by the OS. Set manually to force version.
+                        o.WithSslProtocols(SslProtocols.Tls12);
                    })
                .Build();

-            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+            using (var timeout = new CancellationTokenSource(5000))
+            {
+                await mqttClient.ConnectAsync(mqttClientOptions, timeout.Token);
+
+                Console.WriteLine("The MQTT client is connected.");
+            }
+        }
+    }
+
+    public static async Task Connect_Client_Using_WebSocket4Net()
+    {
+        /*
+         * This sample creates a simple MQTT client and connects to a public broker using a WebSocket connection.
+         * Instead of the .NET implementation of WebSockets the implementation from WebSocket4Net is used. It provides more
+         * encryption algorithms and supports more platforms.
+         * 
+         * This is a modified version of the sample _Connect_Client_! See other sample for more details.
+         */
+
+        var mqttFactory = new MqttFactory().UseWebSocket4Net();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).Build();
+
+            var response = await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);

            Console.WriteLine("The MQTT client is connected.");
+
+            response.DumpToConsole();
        }
    }

@@ -133,7 +193,7 @@ public static class Client_Connection_Samples

        using (var mqttClient = mqttFactory.CreateMqttClient())
        {
-            var mqttClientOptions = new MqttClientOptionsBuilder().WithWebSocketServer("broker.hivemq.com:8000/mqtt").Build();
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).Build();

            var response = await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);

@@ -156,19 +216,126 @@ public static class Client_Connection_Samples
        using (var mqttClient = mqttFactory.CreateMqttClient())
        {
            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883)
-                .WithTls(
+                .WithTlsOptions(
+                    o => o.WithCertificateValidationHandler(
+                        // The used public broker sometimes has invalid certificates. This sample accepts all
+                        // certificates. This should not be used in live environments.
+                        _ => true))
+                .Build();
+
+            // In MQTTv5 the response contains much more information.
+            using (var timeout = new CancellationTokenSource(5000))
+            {
+                var response = await mqttClient.ConnectAsync(mqttClientOptions, timeout.Token);
+
+                Console.WriteLine("The MQTT client is connected.");
+
+                response.DumpToConsole();
+            }
+        }
+    }
+
+    public static async Task Connect_With_Amazon_AWS()
+    {
+        /*
+         * This sample creates a simple MQTT client and connects to an Amazon Web Services broker.
+         *
+         * The broker requires special settings which are set here.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("amazon.web.services.broker")
+                // Disabling packet fragmentation is very important!  
+                .WithoutPacketFragmentation()
+                .Build();
+
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            Console.WriteLine("The MQTT client is connected.");
+
+            await mqttClient.DisconnectAsync();
+        }
+    }
+
+    public static async Task Disconnect_Clean()
+    {
+        /*
+         * This sample disconnects from the server with sending a DISCONNECT packet.
+         * This way of disconnecting is treated as a clean disconnect which will not
+         * trigger sending the last will etc.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();
+
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            // Calling _DisconnectAsync_ will send a DISCONNECT packet before closing the connection.
+            // Using a reason code requires MQTT version 5.0.0!
+            await mqttClient.DisconnectAsync(MqttClientDisconnectOptionsReason.ImplementationSpecificError);
+        }
+    }
+
+    public static async Task Disconnect_Non_Clean()
+    {
+        /*
+         * This sample disconnects from the server without sending a DISCONNECT packet.
+         * This way of disconnecting is treated as a non clean disconnect which will
+         * trigger sending the last will etc.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        var mqttClient = mqttFactory.CreateMqttClient();
+
+        var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();
+
+        await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+        // Calling _Dispose_ or use of a _using_ statement will close the transport connection
+        // without sending a DISCONNECT packet to the server.
+        mqttClient.Dispose();
+    }
+
+    public static async Task Inspect_Certificate_Validation_Errors()
+    {
+        /*
+         * This sample prints the certificate information while connection. This data can be used to decide whether a connection is secure or not
+         * including the reason for that status.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("mqtt.fluux.io", 8883)
+                .WithTlsOptions(
                    o =>
                    {
-                        o.SslProtocol = SslProtocols.Tls12; // The default value is determined by the OS. Set manually to force version.
+                        o.WithCertificateValidationHandler(
+                            eventArgs =>
+                            {
+                                eventArgs.Certificate.Subject.DumpToConsole();
+                                eventArgs.Certificate.GetExpirationDateString().DumpToConsole();
+                                eventArgs.Chain.ChainPolicy.RevocationMode.DumpToConsole();
+                                eventArgs.Chain.ChainStatus.DumpToConsole();
+                                eventArgs.SslPolicyErrors.DumpToConsole();
+                                return true;
+                            });
                    })
                .Build();

            // In MQTTv5 the response contains much more information.
-            var response = await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
-
-            Console.WriteLine("The MQTT client is connected.");
-
-            response.DumpToConsole();
+            using (var timeout = new CancellationTokenSource(5000))
+            {
+                await mqttClient.ConnectAsync(mqttClientOptions, timeout.Token);
+            }
        }
    }

@@ -177,7 +344,7 @@ public static class Client_Connection_Samples
        /*
         * This sample sends a PINGREQ packet to the server and waits for a reply.
         *
-         * This is only supported in METTv5.0.0+.
+         * This is only supported in MQTTv5.0.0+.
         */

        var mqttFactory = new MqttFactory();
@@ -244,14 +411,12 @@ public static class Client_Connection_Samples
                    {
                        try
                        {
-                            // This code will also do the very first connect! So no call to _ConnectAsync_ is required
-                            // in the first place.
-                            if (!mqttClient.IsConnected)
+                            // This code will also do the very first connect! So no call to _ConnectAsync_ is required in the first place.
+                            if (!await mqttClient.TryPingAsync())
                            {
                                await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);

                                // Subscribe to topics when session is clean etc.
-
                                Console.WriteLine("The MQTT client is connected.");
                            }
                        }
@@ -266,6 +431,59 @@ public static class Client_Connection_Samples
                        }
                    }
                });
+
+            Console.WriteLine("Press <Enter> to exit");
+            Console.ReadLine();
        }
    }
+
+    public static async Task ConnectTls_WithCaFile()
+    {
+        var mqttFactory = new MqttFactory();
+
+        X509Certificate2Collection caChain = new X509Certificate2Collection();
+        caChain.ImportFromPem(mosquitto_org); // from https://test.mosquitto.org/ssl/mosquitto.org.crt
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder()
+                .WithTcpServer("test.mosquitto.org", 8883)
+                .WithTlsOptions(new MqttClientTlsOptionsBuilder()
+                    .WithTrustChain(caChain) 
+                    .Build())
+                .Build();
+
+            var connAck = await mqttClient.ConnectAsync(mqttClientOptions);
+            Console.WriteLine("Connected to test.moquitto.org:8883 with CaFile mosquitto.org.crt: " + connAck.ResultCode);
+        }
+
+
+    }
+    const string mosquitto_org = @"
+-----BEGIN CERTIFICATE-----
+MIIEAzCCAuugAwIBAgIUBY1hlCGvdj4NhBXkZ/uLUZNILAwwDQYJKoZIhvcNAQEL
+BQAwgZAxCzAJBgNVBAYTAkdCMRcwFQYDVQQIDA5Vbml0ZWQgS2luZ2RvbTEOMAwG
+A1UEBwwFRGVyYnkxEjAQBgNVBAoMCU1vc3F1aXR0bzELMAkGA1UECwwCQ0ExFjAU
+BgNVBAMMDW1vc3F1aXR0by5vcmcxHzAdBgkqhkiG9w0BCQEWEHJvZ2VyQGF0Y2hv
+by5vcmcwHhcNMjAwNjA5MTEwNjM5WhcNMzAwNjA3MTEwNjM5WjCBkDELMAkGA1UE
+BhMCR0IxFzAVBgNVBAgMDlVuaXRlZCBLaW5nZG9tMQ4wDAYDVQQHDAVEZXJieTES
+MBAGA1UECgwJTW9zcXVpdHRvMQswCQYDVQQLDAJDQTEWMBQGA1UEAwwNbW9zcXVp
+dHRvLm9yZzEfMB0GCSqGSIb3DQEJARYQcm9nZXJAYXRjaG9vLm9yZzCCASIwDQYJ
+KoZIhvcNAQEBBQADggEPADCCAQoCggEBAME0HKmIzfTOwkKLT3THHe+ObdizamPg
+UZmD64Tf3zJdNeYGYn4CEXbyP6fy3tWc8S2boW6dzrH8SdFf9uo320GJA9B7U1FW
+Te3xda/Lm3JFfaHjkWw7jBwcauQZjpGINHapHRlpiCZsquAthOgxW9SgDgYlGzEA
+s06pkEFiMw+qDfLo/sxFKB6vQlFekMeCymjLCbNwPJyqyhFmPWwio/PDMruBTzPH
+3cioBnrJWKXc3OjXdLGFJOfj7pP0j/dr2LH72eSvv3PQQFl90CZPFhrCUcRHSSxo
+E6yjGOdnz7f6PveLIB574kQORwt8ePn0yidrTC1ictikED3nHYhMUOUCAwEAAaNT
+MFEwHQYDVR0OBBYEFPVV6xBUFPiGKDyo5V3+Hbh4N9YSMB8GA1UdIwQYMBaAFPVV
+6xBUFPiGKDyo5V3+Hbh4N9YSMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
+BQADggEBAGa9kS21N70ThM6/Hj9D7mbVxKLBjVWe2TPsGfbl3rEDfZ+OKRZ2j6AC
+6r7jb4TZO3dzF2p6dgbrlU71Y/4K0TdzIjRj3cQ3KSm41JvUQ0hZ/c04iGDg/xWf
+pp58nfPAYwuerruPNWmlStWAXf0UTqRtg4hQDWBuUFDJTuWuuBvEXudz74eh/wK
+sMwfu1HFvjy5Z0iMDU8PUDepjVolOCue9ashlS4EB5IECdSR2TItnAIiIwimx839
+LdUdRudafMu5T5Xma182OC0/u/xRlEm+tvKGGmfFcN0piqVl8OrSPBgIlb+1IKJE
+m/XriWr/Cq4h/JfB7NTsezVslgkBaoU=
+-----END CERTIFICATE-----
+";
+
 }
@@ -2,6 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
 using MQTTnet.Client;

 namespace MQTTnet.Samples.Client;
@@ -36,6 +40,53 @@ public static class Client_Publish_Samples

            await mqttClient.PublishAsync(applicationMessage, CancellationToken.None);

+            await mqttClient.DisconnectAsync();
+            
+            Console.WriteLine("MQTT application message is published.");
+        }
+    }
+    
+    public static async Task Publish_Multiple_Application_Messages()
+    {
+        /*
+         * This sample pushes multiple simple application message including a topic and a payload.
+         *
+         * See sample _Publish_Application_Message_ for more details.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder()
+                .WithTcpServer("broker.hivemq.com")
+                .Build();
+
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            var applicationMessage = new MqttApplicationMessageBuilder()
+                .WithTopic("samples/temperature/living_room")
+                .WithPayload("19.5")
+                .Build();
+
+            await mqttClient.PublishAsync(applicationMessage, CancellationToken.None);
+            
+            applicationMessage = new MqttApplicationMessageBuilder()
+                .WithTopic("samples/temperature/living_room")
+                .WithPayload("20.0")
+                .Build();
+            
+            await mqttClient.PublishAsync(applicationMessage, CancellationToken.None);
+
+            applicationMessage = new MqttApplicationMessageBuilder()
+                .WithTopic("samples/temperature/living_room")
+                .WithPayload("21.0")
+                .Build();
+            
+            await mqttClient.PublishAsync(applicationMessage, CancellationToken.None);
+
+            await mqttClient.DisconnectAsync();
+            
            Console.WriteLine("MQTT application message is published.");
        }
    }
@@ -2,7 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+// ReSharper disable UnusedMember.Local
+
 using MQTTnet.Client;
+using MQTTnet.Packets;
+using MQTTnet.Protocol;
 using MQTTnet.Samples.Helpers;

 namespace MQTTnet.Samples.Client;
@@ -19,9 +26,7 @@ public static class Client_Subscribe_Samples

        using (var mqttClient = mqttFactory.CreateMqttClient())
        {
-            var mqttClientOptions = new MqttClientOptionsBuilder()
-                .WithTcpServer("broker.hivemq.com")
-                .Build();
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();

            // Setup message handling before connecting so that queued messages
            // are also handled properly. When there is no event handler attached all
@@ -37,7 +42,11 @@ public static class Client_Subscribe_Samples
            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);

            var mqttSubscribeOptions = mqttFactory.CreateSubscribeOptionsBuilder()
-                .WithTopicFilter(f => { f.WithTopic("mqttnet/samples/topic/2"); })
+                .WithTopicFilter(
+                    f =>
+                    {
+                        f.WithTopic("mqttnet/samples/topic/2");
+                    })
                .Build();

            await mqttClient.SubscribeAsync(mqttSubscribeOptions, CancellationToken.None);
@@ -49,6 +58,95 @@ public static class Client_Subscribe_Samples
        }
    }

+    public static async Task Send_Responses()
+    {
+        /*
+         * This sample subscribes to a topic and sends a response to the broker. This requires at least QoS level 1 to work!
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            mqttClient.ApplicationMessageReceivedAsync += delegate(MqttApplicationMessageReceivedEventArgs args)
+            {
+                // Do some work with the message...
+
+                // Now respond to the broker with a reason code other than success.
+                args.ReasonCode = MqttApplicationMessageReceivedReasonCode.ImplementationSpecificError;
+                args.ResponseReasonString = "That did not work!";
+
+                // User properties require MQTT v5!
+                args.ResponseUserProperties.Add(new MqttUserProperty("My", "Data"));
+
+                // Now the broker will resend the message again.
+                return Task.CompletedTask;
+            };
+
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();
+
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            var mqttSubscribeOptions = mqttFactory.CreateSubscribeOptionsBuilder()
+                .WithTopicFilter(
+                    f =>
+                    {
+                        f.WithTopic("mqttnet/samples/topic/1");
+                    })
+                .Build();
+
+            var response = await mqttClient.SubscribeAsync(mqttSubscribeOptions, CancellationToken.None);
+
+            Console.WriteLine("MQTT client subscribed to topic.");
+
+            // The response contains additional data sent by the server after subscribing.
+            response.DumpToConsole();
+        }
+    }
+
+    public static async Task Subscribe_Multiple_Topics()
+    {
+        /*
+         * This sample subscribes to several topics in a single request.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();
+
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            // Create the subscribe options including several topics with different options.
+            // It is also possible to all of these topics using a dedicated call of _SubscribeAsync_ per topic.
+            var mqttSubscribeOptions = mqttFactory.CreateSubscribeOptionsBuilder()
+                .WithTopicFilter(
+                    f =>
+                    {
+                        f.WithTopic("mqttnet/samples/topic/1");
+                    })
+                .WithTopicFilter(
+                    f =>
+                    {
+                        f.WithTopic("mqttnet/samples/topic/2").WithNoLocal();
+                    })
+                .WithTopicFilter(
+                    f =>
+                    {
+                        f.WithTopic("mqttnet/samples/topic/3").WithRetainHandling(MqttRetainHandling.SendAtSubscribe);
+                    })
+                .Build();
+
+            var response = await mqttClient.SubscribeAsync(mqttSubscribeOptions, CancellationToken.None);
+
+            Console.WriteLine("MQTT client subscribed to topics.");
+
+            // The response contains additional data sent by the server after subscribing.
+            response.DumpToConsole();
+        }
+    }
+
    public static async Task Subscribe_Topic()
    {
        /*
@@ -59,14 +157,16 @@ public static class Client_Subscribe_Samples

        using (var mqttClient = mqttFactory.CreateMqttClient())
        {
-            var mqttClientOptions = new MqttClientOptionsBuilder()
-                .WithTcpServer("broker.hivemq.com")
-                .Build();
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();

            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);

            var mqttSubscribeOptions = mqttFactory.CreateSubscribeOptionsBuilder()
-                .WithTopicFilter(f => { f.WithTopic("mqttnet/samples/topic/1"); })
+                .WithTopicFilter(
+                    f =>
+                    {
+                        f.WithTopic("mqttnet/samples/topic/1");
+                    })
                .Build();

            var response = await mqttClient.SubscribeAsync(mqttSubscribeOptions, CancellationToken.None);
@@ -77,4 +177,62 @@ public static class Client_Subscribe_Samples
            response.DumpToConsole();
        }
    }
+
+    static void ConcurrentProcessingDisableAutoAcknowledge(CancellationToken shutdownToken, IMqttClient mqttClient)
+    {
+        /*
+         * This sample shows how to achieve concurrent processing and not have message AutoAcknowledged
+         * This to have a proper QoS1 (at-least-once) experience for what at least MQTT specification can provide
+         */
+        mqttClient.ApplicationMessageReceivedAsync += ea =>
+        {
+            ea.AutoAcknowledge = false;
+
+            async Task ProcessAsync()
+            {
+                // DO YOUR WORK HERE!
+                await Task.Delay(1000, shutdownToken);
+                await ea.AcknowledgeAsync(shutdownToken);
+                // WARNING: If process failures are not transient the message will be retried on every restart of the client
+                //          A failed message will not be dispatched again to the client as MQTT does not have a NACK packet to let
+                //          the broker know processing failed
+                //
+                // Optionally: Use a framework like Polly to create a retry policy: https://github.com/App-vNext/Polly#retry
+            }
+
+            _ = Task.Run(ProcessAsync, shutdownToken);
+
+            return Task.CompletedTask;
+        };
+    }
+
+    static void ConcurrentProcessingWithLimit(CancellationToken shutdownToken, IMqttClient mqttClient)
+    {
+        /*
+         * This sample shows how to achieve concurrent processing, with:
+         * - a maximum concurrency limit based on Environment.ProcessorCount
+         */
+
+        var concurrent = new SemaphoreSlim(Environment.ProcessorCount);
+
+        mqttClient.ApplicationMessageReceivedAsync += async ea =>
+        {
+            await concurrent.WaitAsync(shutdownToken).ConfigureAwait(false);
+
+            async Task ProcessAsync()
+            {
+                try
+                {
+                    // DO YOUR WORK HERE!
+                    await Task.Delay(1000, shutdownToken);
+                }
+                finally
+                {
+                    concurrent.Release();
+                }
+            }
+
+            _ = Task.Run(ProcessAsync, shutdownToken);
+        };
+    }
 }
@@ -2,6 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
 using System.Text;
 using MQTTnet.Diagnostics;

@@ -2,6 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
 using MQTTnet.Diagnostics;

 namespace MQTTnet.Samples.Diagnostics;
@@ -22,7 +26,7 @@ public static class PackageInspection_Samples
                .WithTcpServer("broker.hivemq.com")
                .Build();
            
-            mqttClient.InspectPackage += OnInspectPackage;
+            mqttClient.InspectPacketAsync += OnInspectPacket;
            
            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
            
@@ -35,7 +39,7 @@ public static class PackageInspection_Samples
        }
    }

-    static Task OnInspectPackage(InspectMqttPacketEventArgs eventArgs)
+    static Task OnInspectPacket(InspectMqttPacketEventArgs eventArgs)
    {
        if (eventArgs.Direction == MqttPacketFlowDirection.Inbound)
        {
@@ -2,21 +2,18 @@

    <PropertyGroup>
        <OutputType>Exe</OutputType>
-        <TargetFramework>net6.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
        <ImplicitUsings>enable</ImplicitUsings>
        <Nullable>enable</Nullable>
        <IsPackable>false</IsPackable>
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
        <EnableNETAnalyzers>false</EnableNETAnalyzers>
        <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
-        <NoWarn>1591</NoWarn>
+        <NoWarn>1591;NETSDK1138</NoWarn>
    </PropertyGroup>

    <ItemGroup>
-        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
-        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
-        <PackageReference Include="MSTest.TestFramework" Version="2.1.2" />
-        
+
        <ProjectReference Include="..\Source\MQTTnet.AspnetCore\MQTTnet.AspNetCore.csproj" />
        <ProjectReference Include="..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.csproj" />
        <ProjectReference Include="..\Source\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj" />
@@ -1,3 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
 using MQTTnet.Client;
 using MQTTnet.Extensions.ManagedClient;

@@ -4,7 +4,13 @@

 using System.Reflection;

-Console.WriteLine("Welcome to MQTTnet samples!");
+Console.BackgroundColor = ConsoleColor.White;
+Console.BackgroundColor = ConsoleColor.Red;
+Console.Title = "Samples - MQTTnet";
+Console.WriteLine("----------------------------------------------");
+Console.WriteLine("-         Welcome to MQTTnet samples!        -");
+Console.WriteLine("----------------------------------------------");
+Console.ResetColor();
 Console.WriteLine();

 var sampleClasses = Assembly.GetExecutingAssembly().GetExportedTypes().OrderBy(c => c.Name).ToList();
@@ -16,7 +22,11 @@ foreach (var sampleClass in sampleClasses)
    index++;
 }

+Console.WriteLine();
+Console.ForegroundColor = ConsoleColor.Green;
 Console.Write("Please choose sample class (press Enter to continue): ");
+Console.ResetColor();
+
 var input = Console.ReadLine();
 var selectedIndex = int.Parse(input ?? "0");
 var selectedSampleClass = sampleClasses[selectedIndex];
@@ -29,20 +39,33 @@ foreach (var sampleMethod in sampleMethods)
    index++;
 }

+Console.WriteLine();
+Console.ForegroundColor = ConsoleColor.Green;
 Console.Write("Please choose sample (press Enter to continue): ");
+Console.ResetColor();
+
 input = Console.ReadLine();
 selectedIndex = int.Parse(input ?? "0");
 var selectedSampleMethod = sampleMethods[selectedIndex];

+Console.WriteLine();
+Console.ForegroundColor = ConsoleColor.White;
 Console.WriteLine("Executing sample...");
+Console.ResetColor();
 Console.WriteLine();

 try
 {
-    var task = selectedSampleMethod.Invoke(null, null) as Task;
-    task?.Wait();
+    if (selectedSampleMethod.Invoke(null, null) is Task task)
+    {
+        await task;    
+    }
 }
 catch (Exception exception)
 {
    Console.WriteLine(exception.ToString());
-}
+}
+
+Console.WriteLine();
+Console.WriteLine("Press Enter to exit.");
+Console.ReadLine();
@@ -2,13 +2,17 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
 using MQTTnet.Client;
 using MQTTnet.Extensions.Rpc;
 using MQTTnet.Protocol;

 namespace MQTTnet.Samples.RpcClient;

-public static class RcpClient_Samples
+public static class RpcClient_Samples
 {
    /*
     * The extension MQTTnet.Extensions.Rpc (available as nuget) allows sending a request and waiting for the matching reply.
@@ -33,7 +37,7 @@ public static class RcpClient_Samples
            
            using (var mqttRpcClient = mqttFactory.CreateMqttRpcClient(mqttClient))
            {
-                // Access to a fully featured application message is not supported for RCP calls!
+                // Access to a fully featured application message is not supported for RPC calls!
                // The method will throw an exception when the response was not received in time.
                await mqttRpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
            }
@@ -81,4 +85,4 @@ public static class RcpClient_Samples
        // ! Do not send response message with the _retain_ flag set to true.
        // ! All required data for a RPC call and the result must be placed into the payload.
     */
-}
+}
@@ -0,0 +1,110 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+// ReSharper disable EmptyConstructor
+// ReSharper disable MemberCanBeMadeStatic.Local
+
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using MQTTnet.AspNetCore;
+using MQTTnet.Server;
+
+namespace MQTTnet.Samples.Server;
+
+public static class Server_ASP_NET_Samples
+{
+    public static Task Start_Server_With_WebSockets_Support()
+    {
+        /*
+         * This sample starts a minimal ASP.NET Webserver including a hosted MQTT server.
+         */
+        var host = Host.CreateDefaultBuilder(Array.Empty<string>())
+            .ConfigureWebHostDefaults(
+                webBuilder =>
+                {
+                    webBuilder.UseKestrel(
+                        o =>
+                        {
+                            // This will allow MQTT connections based on TCP port 1883.
+                            o.ListenAnyIP(1883, l => l.UseMqtt());
+
+                            // This will allow MQTT connections based on HTTP WebSockets with URI "localhost:5000/mqtt"
+                            // See code below for URI configuration.
+                            o.ListenAnyIP(5000); // Default HTTP pipeline
+                        });
+
+                    webBuilder.UseStartup<Startup>();
+                });
+
+        return host.RunConsoleAsync();
+    }
+
+    sealed class MqttController
+    {
+        public MqttController()
+        {
+            // Inject other services via constructor.
+        }
+        
+        public Task OnClientConnected(ClientConnectedEventArgs eventArgs)
+        {
+            Console.WriteLine($"Client '{eventArgs.ClientId}' connected.");
+            return Task.CompletedTask;
+        }
+
+
+        public Task ValidateConnection(ValidatingConnectionEventArgs eventArgs)
+        {
+            Console.WriteLine($"Client '{eventArgs.ClientId}' wants to connect. Accepting!");
+            return Task.CompletedTask;
+        }
+    }
+
+    sealed class Startup
+    {
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment environment, MqttController mqttController)
+        {
+            app.UseRouting();
+
+            app.UseEndpoints(
+                endpoints =>
+                {
+                    endpoints.MapConnectionHandler<MqttConnectionHandler>(
+                        "/mqtt",
+                        httpConnectionDispatcherOptions => httpConnectionDispatcherOptions.WebSockets.SubProtocolSelector =
+                            protocolList => protocolList.FirstOrDefault() ?? string.Empty);
+                });
+
+            app.UseMqttServer(
+                server =>
+                {
+                    /*
+                     * Attach event handlers etc. if required.
+                     */
+
+                    server.ValidatingConnectionAsync += mqttController.ValidateConnection;
+                    server.ClientConnectedAsync += mqttController.OnClientConnected;
+                });
+        }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddHostedMqttServer(
+                optionsBuilder =>
+                {
+                    optionsBuilder.WithDefaultEndpoint();
+                });
+
+            services.AddMqttConnectionHandler();
+            services.AddConnections();
+
+            services.AddSingleton<MqttController>();
+        }
+    }
+}
@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+using MQTTnet.Server;
+
+namespace MQTTnet.Samples.Server;
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+// ReSharper disable EmptyConstructor
+// ReSharper disable MemberCanBeMadeStatic.Local
+
+public static class Server_Diagnostics_Samples
+{
+    public static async Task Get_Notified_When_Client_Received_Message()
+    {
+        /*
+         * This sample starts a MQTT server and attaches an event which gets fired whenever
+         * a client received and acknowledged a PUBLISH packet.
+         */
+        
+        var mqttFactory = new MqttFactory();
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
+        
+        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
+        {
+            // Attach the event handler.
+            mqttServer.ClientAcknowledgedPublishPacketAsync += e =>
+            {
+                Console.WriteLine($"Client '{e.ClientId}' acknowledged packet {e.PublishPacket.PacketIdentifier} with topic '{e.PublishPacket.Topic}'");
+                
+                // It is also possible to read additional data from the client response. This requires casting the response packet.
+                var qos1AcknowledgePacket = e.AcknowledgePacket as MqttPubAckPacket;
+                Console.WriteLine($"QoS 1 reason code: {qos1AcknowledgePacket?.ReasonCode}");
+                
+                var qos2AcknowledgePacket = e.AcknowledgePacket as MqttPubCompPacket;
+                Console.WriteLine($"QoS 2 reason code: {qos1AcknowledgePacket?.ReasonCode}");
+                return CompletedTask.Instance;
+            };
+            
+            await mqttServer.StartAsync();
+
+            Console.WriteLine("Press Enter to exit.");
+            Console.ReadLine();
+
+            await mqttServer.StopAsync();
+        }
+    }
+}
@@ -0,0 +1,47 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+// ReSharper disable EmptyConstructor
+// ReSharper disable MemberCanBeMadeStatic.Local
+
+using MQTTnet.Internal;
+using MQTTnet.Server;
+
+namespace MQTTnet.Samples.Server;
+
+public static class Server_Intercepting_Samples
+{
+    public static async Task Intercept_Application_Messages()
+    {
+        /*
+         * This sample starts a simple MQTT server which manipulate all processed application messages.
+         * Please see _Server_Simple_Samples_ for more details on how to start a server.
+         */
+
+        var mqttFactory = new MqttFactory();
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
+
+        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
+        {
+            mqttServer.InterceptingPublishAsync += args =>
+            {
+                // Here we only change the topic of the received application message.
+                // but also changing the payload etc. is required. Changing the QoS after
+                // transmitting is not supported and makes no sense at all.
+                args.ApplicationMessage.Topic += "/manipulated";
+
+                return CompletedTask.Instance;
+            };
+
+            await mqttServer.StartAsync();
+
+            Console.WriteLine("Press Enter to exit.");
+            Console.ReadLine();
+            await mqttServer.StopAsync();
+        }
+    }
+}
@@ -0,0 +1,144 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
+using System.Text.Json;
+using MQTTnet.Packets;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Samples.Server;
+
+public static class Server_Retained_Messages_Samples
+{
+    public static async Task Persist_Retained_Messages()
+    {
+        /*
+         * This sample starts a simple MQTT server which will store all retained messages in a file.
+         */
+
+        var storePath = Path.Combine(Path.GetTempPath(), "RetainedMessages.json");
+
+        var mqttFactory = new MqttFactory();
+
+        // Due to security reasons the "default" endpoint (which is unencrypted) is not enabled by default!
+        var mqttServerOptions = mqttFactory.CreateServerOptionsBuilder().WithDefaultEndpoint().Build();
+
+        using (var server = mqttFactory.CreateMqttServer(mqttServerOptions))
+        {
+            // Make sure that the server will load the retained messages.
+            server.LoadingRetainedMessageAsync += async eventArgs =>
+            {
+                try
+                {
+                    var models = await JsonSerializer.DeserializeAsync<List<MqttRetainedMessageModel>>(File.OpenRead(storePath)) ?? new List<MqttRetainedMessageModel>();
+                    var retainedMessages = models.Select(m => m.ToApplicationMessage()).ToList();
+
+                    eventArgs.LoadedRetainedMessages = retainedMessages;
+                    Console.WriteLine("Retained messages loaded.");
+                }
+                catch (FileNotFoundException)
+                {
+                    // Ignore because nothing is stored yet.
+                    Console.WriteLine("No retained messages stored yet.");
+                }
+                catch (Exception exception)
+                {
+                    Console.WriteLine(exception);
+                }
+            };
+
+            // Make sure to persist the changed retained messages.
+            server.RetainedMessageChangedAsync += async eventArgs =>
+            {
+                try
+                {
+                    // This sample uses the property _StoredRetainedMessages_ which will contain all(!) retained messages.
+                    // The event args also contain the affected retained message (property ChangedRetainedMessage). This can be
+                    // used to write all retained messages to dedicated files etc. Then all files must be loaded and a full list
+                    // of retained messages must be provided in the loaded event.
+
+                    var models = eventArgs.StoredRetainedMessages.Select(MqttRetainedMessageModel.Create);
+
+                    var buffer = JsonSerializer.SerializeToUtf8Bytes(models);
+                    await File.WriteAllBytesAsync(storePath, buffer);
+                    Console.WriteLine("Retained messages saved.");
+                }
+                catch (Exception exception)
+                {
+                    Console.WriteLine(exception);
+                }
+            };
+
+            // Make sure to clear the retained messages when they are all deleted via API.
+            server.RetainedMessagesClearedAsync += _ =>
+            {
+                File.Delete(storePath);
+                return Task.CompletedTask;
+            };
+
+            await server.StartAsync();
+
+            Console.WriteLine("Press Enter to exit.");
+            Console.ReadLine();
+        }
+    }
+
+    sealed class MqttRetainedMessageModel
+    {
+        public string? ContentType { get; set; }
+        public byte[]? CorrelationData { get; set; }
+        public byte[]? Payload { get; set; }
+        public MqttPayloadFormatIndicator PayloadFormatIndicator { get; set; }
+        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
+        public string? ResponseTopic { get; set; }
+        public string? Topic { get; set; }
+        public List<MqttUserProperty>? UserProperties { get; set; }
+
+        public static MqttRetainedMessageModel Create(MqttApplicationMessage message)
+        {
+            if (message == null)
+            {
+                throw new ArgumentNullException(nameof(message));
+            }
+
+            return new MqttRetainedMessageModel
+            {
+                Topic = message.Topic,
+
+                // Create a copy of the buffer from the payload segment because 
+                // it cannot be serialized and deserialized with the JSON serializer.
+                Payload = message.PayloadSegment.ToArray(),
+                UserProperties = message.UserProperties,
+                ResponseTopic = message.ResponseTopic,
+                CorrelationData = message.CorrelationData,
+                ContentType = message.ContentType,
+                PayloadFormatIndicator = message.PayloadFormatIndicator,
+                QualityOfServiceLevel = message.QualityOfServiceLevel
+
+                // Other properties like "Retain" are not if interest in the storage.
+                // That's why a custom model makes sense.
+            };
+        }
+
+        public MqttApplicationMessage ToApplicationMessage()
+        {
+            return new MqttApplicationMessage
+            {
+                Topic = Topic,
+                PayloadSegment = new ArraySegment<byte>(Payload ?? Array.Empty<byte>()),
+                PayloadFormatIndicator = PayloadFormatIndicator,
+                ResponseTopic = ResponseTopic,
+                CorrelationData = CorrelationData,
+                ContentType = ContentType,
+                UserProperties = UserProperties,
+                QualityOfServiceLevel = QualityOfServiceLevel,
+                Dup = false,
+                Retain = true
+            };
+        }
+    }
+}
@@ -2,6 +2,11 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
+using MQTTnet.Diagnostics;
 using MQTTnet.Protocol;
 using MQTTnet.Server;

@@ -9,27 +14,95 @@ namespace MQTTnet.Samples.Server;

 public static class Server_Simple_Samples
 {
+    public static async Task Force_Disconnecting_Client()
+    {
+        /*
+         * This sample will disconnect a client.
+         *
+         * See _Run_Minimal_Server_ for more information.
+         */
+
+        using (var mqttServer = await StartMqttServer())
+        {
+            // Let the client connect.
+            await Task.Delay(TimeSpan.FromSeconds(5));
+
+            // Now disconnect the client (if connected).
+            var affectedClient = (await mqttServer.GetClientsAsync()).FirstOrDefault(c => c.Id == "MyClient");
+            if (affectedClient != null)
+            {
+                await affectedClient.DisconnectAsync();
+            }
+        }
+    }
+
+    public static async Task Publish_Message_From_Broker()
+    {
+        /*
+         * This sample will publish a message directly at the broker.
+         *
+         * See _Run_Minimal_Server_ for more information.
+         */
+
+        using (var mqttServer = await StartMqttServer())
+        {
+            // Create a new message using the builder as usual.
+            var message = new MqttApplicationMessageBuilder().WithTopic("HelloWorld").WithPayload("Test").Build();
+
+            // Now inject the new message at the broker.
+            await mqttServer.InjectApplicationMessage(
+                new InjectedMqttApplicationMessage(message)
+                {
+                    SenderClientId = "SenderClientId"
+                });
+        }
+    }
+
    public static async Task Run_Minimal_Server()
    {
        /*
         * This sample starts a simple MQTT server which will accept any TCP connection.
         */
-        
+
        var mqttFactory = new MqttFactory();

        // The port for the default endpoint is 1883.
        // The default endpoint is NOT encrypted!
        // Use the builder classes where possible.
-        var mqttServerOptions = new MqttServerOptionsBuilder()
-            .WithDefaultEndpoint()
-            .Build();
-        
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
+
        // The port can be changed using the following API (not used in this example).
-        new MqttServerOptionsBuilder()
-            .WithDefaultEndpoint()
-            .WithDefaultEndpointPort(1234)
-            .Build();
-        
+        // new MqttServerOptionsBuilder()
+        //     .WithDefaultEndpoint()
+        //     .WithDefaultEndpointPort(1234)
+        //     .Build();
+
+        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
+        {
+            await mqttServer.StartAsync();
+
+            Console.WriteLine("Press Enter to exit.");
+            Console.ReadLine();
+
+            // Stop and dispose the MQTT server if it is no longer needed!
+            await mqttServer.StopAsync();
+        }
+    }
+
+    public static async Task Run_Server_With_Logging()
+    {
+        /*
+         * This sample starts a simple MQTT server and prints the logs to the output.
+         *
+         * IMPORTANT! Do not enable logging in live environment. It will decrease performance.
+         *
+         * See sample "Run_Minimal_Server" for more details.
+         */
+
+        var mqttFactory = new MqttFactory(new ConsoleLogger());
+
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
+
        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
        {
            await mqttServer.StartAsync();
@@ -52,9 +125,7 @@ public static class Server_Simple_Samples

        var mqttFactory = new MqttFactory();

-        var mqttServerOptions = new MqttServerOptionsBuilder()
-            .WithDefaultEndpoint()
-            .Build();
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();

        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
        {
@@ -67,7 +138,7 @@ public static class Server_Simple_Samples
                    e.ReasonCode = MqttConnectReasonCode.ClientIdentifierNotValid;
                }

-                if (e.Username != "ValidUser")
+                if (e.UserName != "ValidUser")
                {
                    e.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
                }
@@ -88,4 +159,61 @@ public static class Server_Simple_Samples
            await mqttServer.StopAsync();
        }
    }
-}
+
+    static async Task<MqttServer> StartMqttServer()
+    {
+        var mqttFactory = new MqttFactory();
+
+        // Due to security reasons the "default" endpoint (which is unencrypted) is not enabled by default!
+        var mqttServerOptions = mqttFactory.CreateServerOptionsBuilder().WithDefaultEndpoint().Build();
+        var server = mqttFactory.CreateMqttServer(mqttServerOptions);
+        await server.StartAsync();
+        return server;
+    }
+
+    class ConsoleLogger : IMqttNetLogger
+    {
+        readonly object _consoleSyncRoot = new();
+
+        public bool IsEnabled => true;
+
+        public void Publish(MqttNetLogLevel logLevel, string source, string message, object[]? parameters, Exception? exception)
+        {
+            var foregroundColor = ConsoleColor.White;
+            switch (logLevel)
+            {
+                case MqttNetLogLevel.Verbose:
+                    foregroundColor = ConsoleColor.White;
+                    break;
+
+                case MqttNetLogLevel.Info:
+                    foregroundColor = ConsoleColor.Green;
+                    break;
+
+                case MqttNetLogLevel.Warning:
+                    foregroundColor = ConsoleColor.DarkYellow;
+                    break;
+
+                case MqttNetLogLevel.Error:
+                    foregroundColor = ConsoleColor.Red;
+                    break;
+            }
+
+            if (parameters?.Length > 0)
+            {
+                message = string.Format(message, parameters);
+            }
+
+            lock (_consoleSyncRoot)
+            {
+                Console.ForegroundColor = foregroundColor;
+                Console.WriteLine(message);
+
+                if (exception != null)
+                {
+                    Console.WriteLine(exception);
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,75 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
+using System.Net;
+using System.Security.Cryptography;
+using System.Security.Cryptography.X509Certificates;
+using MQTTnet.Server;
+
+namespace MQTTnet.Samples.Server;
+
+public static class Server_TLS_Samples
+{
+    public static async Task Run_Server_With_Self_Signed_Certificate()
+    {
+        /*
+         * This sample starts a simple MQTT server which will accept any TCP connection.
+         * It also has an encrypted connection using a self signed TLS certificate.
+         *
+         * See sample "Run_Minimal_Server" for more details.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        // This certificate is self signed so that
+        var certificate = CreateSelfSignedCertificate("1.3.6.1.5.5.7.3.1");
+        
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithEncryptionCertificate(certificate).WithEncryptedEndpoint().Build();
+
+        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
+        {
+            await mqttServer.StartAsync();
+
+            Console.WriteLine("Press Enter to exit.");
+            Console.ReadLine();
+
+            // Stop and dispose the MQTT server if it is no longer needed!
+            await mqttServer.StopAsync();
+        }
+    }
+
+    static X509Certificate2 CreateSelfSignedCertificate(string oid)
+    {
+        var sanBuilder = new SubjectAlternativeNameBuilder();
+        sanBuilder.AddIpAddress(IPAddress.Loopback);
+        sanBuilder.AddIpAddress(IPAddress.IPv6Loopback);
+        sanBuilder.AddDnsName("localhost");
+
+        using (var rsa = RSA.Create())
+        {
+            var certRequest = new CertificateRequest("CN=localhost", rsa, HashAlgorithmName.SHA512, RSASignaturePadding.Pkcs1);
+
+            certRequest.CertificateExtensions.Add(
+                new X509KeyUsageExtension(X509KeyUsageFlags.DataEncipherment | X509KeyUsageFlags.KeyEncipherment | X509KeyUsageFlags.DigitalSignature, false));
+
+            certRequest.CertificateExtensions.Add(new X509EnhancedKeyUsageExtension(new OidCollection { new(oid) }, false));
+
+            certRequest.CertificateExtensions.Add(sanBuilder.Build());
+
+            using (var certificate = certRequest.CreateSelfSigned(DateTimeOffset.Now.AddMinutes(-10), DateTimeOffset.Now.AddMinutes(10)))
+            {
+                var pfxCertificate = new X509Certificate2(
+                    certificate.Export(X509ContentType.Pfx),
+                    (string)null!,
+                    X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
+
+                return pfxCertificate;
+            }
+        }
+    }
+}
@@ -9,11 +9,9 @@
    </PropertyGroup>

    <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.0" />
-        <PackageReference Include="MSTest.TestAdapter" Version="2.1.2" />
-        <PackageReference Include="MSTest.TestFramework" Version="2.1.2" />
-        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
-        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
+        <PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
+        <PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
    </ItemGroup>

    <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' ">
@@ -1,26 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using System.Collections.Generic;
-using System.IO.Pipelines;
-using Microsoft.AspNetCore.Connections;
-using Microsoft.AspNetCore.Http.Features;
-
-namespace MQTTnet.AspNetCore.Tests.Mockups
-{
-    public class ConnectionContextMockup : ConnectionContext
-    {
-        public override string ConnectionId { get; set; }
-
-        public override IFeatureCollection Features { get; }
-
-        public override IDictionary<object, object> Items { get; set; }
-        public override IDuplexPipe Transport { get; set; }
-
-        public ConnectionContextMockup()
-        {
-            //Transport = new DefaultConnectionContext
-        }
-    }
-}
@@ -2,20 +2,24 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using Microsoft.AspNetCore.Connections;
-using MQTTnet.Adapter;
-using MQTTnet.Formatter;
-using MQTTnet.Server;
 using System;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Connections;
+using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
+using MQTTnet.Formatter;
+using MQTTnet.Server;

 namespace MQTTnet.AspNetCore.Tests.Mockups
 {
-    public class ConnectionHandlerMockup: IMqttServerAdapter
+    public sealed class ConnectionHandlerMockup : IMqttServerAdapter
    {
-        public TaskCompletionSource<MqttConnectionContext> Context { get; } = new TaskCompletionSource<MqttConnectionContext>();
        public Func<IMqttChannelAdapter, Task> ClientHandler { get; set; }
+        public TaskCompletionSource<MqttConnectionContext> Context { get; } = new TaskCompletionSource<MqttConnectionContext>();
+
+        public void Dispose()
+        {
+        }

        public async Task OnConnectedAsync(ConnectionContext connection)
        {
@@ -42,9 +46,5 @@ namespace MQTTnet.AspNetCore.Tests.Mockups
        {
            return Task.CompletedTask;
        }
-
-        public void Dispose()
-        {
-        }
    }
-}
+}
@@ -6,7 +6,7 @@ using System.IO.Pipelines;

 namespace MQTTnet.AspNetCore.Tests.Mockups
 {
-    public class DuplexPipeMockup : IDuplexPipe
+    public sealed class DuplexPipeMockup : IDuplexPipe
    {
        public DuplexPipeMockup()
        {
@@ -20,9 +20,8 @@ namespace MQTTnet.AspNetCore.Tests.Mockups

        PipeWriter IDuplexPipe.Output => Send.Writer;

+        public Pipe Receive { get; } 

-        public Pipe Receive { get; set; } 
-
-        public Pipe Send { get; set; }
+        public Pipe Send { get; }
    }
 }
@@ -6,7 +6,7 @@ using System.Buffers;

 namespace MQTTnet.AspNetCore.Tests.Mockups
 {
-    public class LimitedMemoryPool : MemoryPool<byte>
+    public sealed class LimitedMemoryPool : MemoryPool<byte>
    {
        protected override void Dispose(bool disposing)
        {
@@ -7,9 +7,9 @@ using System.Buffers;

 namespace MQTTnet.AspNetCore.Tests.Mockups
 {
-    public class MemoryOwner : IMemoryOwner<byte>
+    public sealed class MemoryOwner : IMemoryOwner<byte>
    {
-        private readonly byte[] _raw;
+        readonly byte[] _raw;

        public MemoryOwner(int size)
        {
@@ -27,11 +27,11 @@ namespace MQTTnet.AspNetCore.Tests.Mockups
            Memory = _raw;
        }

+        public Memory<byte> Memory { get; }
+
        public void Dispose()
        {
            ArrayPool<byte>.Shared.Return(_raw);
        }
-
-        public Memory<byte> Memory { get; }
    }
 }
@@ -2,44 +2,29 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using Microsoft.AspNetCore.Builder;
-using Microsoft.AspNetCore.Connections;
-using Microsoft.AspNetCore.Hosting;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
 using System;
 using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Connections;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Adapter;
 using MQTTnet.AspNetCore.Tests.Mockups;
+using MQTTnet.Client;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
-using MQTTnet.Client;
 using MQTTnet.Protocol;
-using MQTTnet.Tests.Extensions;
+using MQTTnet.Tests.Helpers;

 namespace MQTTnet.AspNetCore.Tests
 {
    [TestClass]
    public class MqttConnectionContextTest
    {
-        [TestMethod]
-        public async Task TestReceivePacketAsyncThrowsWhenReaderCompleted()
-        {
-            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
-            var pipe = new DuplexPipeMockup();
-            var connection = new DefaultConnectionContext();
-            connection.Transport = pipe;
-            var ctx = new MqttConnectionContext(serializer, connection);
-
-            pipe.Receive.Writer.Complete();
-
-            await Assert.ThrowsExceptionAsync<MqttCommunicationException>(() => ctx.ReceivePacketAsync(CancellationToken.None));
-        }
-
        [TestMethod]
        public async Task TestCorruptedConnectPacket()
        {
@@ -49,13 +34,43 @@ namespace MQTTnet.AspNetCore.Tests
            var connection = new DefaultConnectionContext();
            connection.Transport = pipe;
            var ctx = new MqttConnectionContext(serializer, connection);
-            
-            await pipe.Receive.Writer.WriteAsync(writer.AddMqttHeader(MqttControlPacketType.Connect, new byte[0]));
+
+            await pipe.Receive.Writer.WriteAsync(writer.AddMqttHeader(MqttControlPacketType.Connect, Array.Empty<byte>()));

            await Assert.ThrowsExceptionAsync<MqttProtocolViolationException>(() => ctx.ReceivePacketAsync(CancellationToken.None));

            // the first exception should complete the pipes so if someone tries to use the connection after that it should throw immidiatly
-            await Assert.ThrowsExceptionAsync<InvalidOperationException>(() =>  ctx.ReceivePacketAsync(CancellationToken.None));
+            await Assert.ThrowsExceptionAsync<InvalidOperationException>(() => ctx.ReceivePacketAsync(CancellationToken.None));
+        }
+
+        [TestMethod]
+        public async Task TestEndpoint()
+        {
+            var mockup = new ConnectionHandlerMockup();
+
+
+            using (var host = new WebHostBuilder().UseKestrel(kestrel => kestrel.ListenLocalhost(1883, listener => listener.Use((ctx, next) => mockup.OnConnectedAsync(ctx))))
+                       .UseStartup<Startup>()
+                       .ConfigureServices(
+                           (hostContext, services) =>
+                           {
+                               services.AddHostedMqttServer(o => o.WithoutDefaultEndpoint());
+                               services.AddSingleton<IMqttServerAdapter>(mockup);
+                           })
+                       .Build())
+
+            using (var client = new MqttFactory().CreateMqttClient())
+            {
+                host.Start();
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost").Build(), CancellationToken.None);
+
+                var ctx = await mockup.Context.Task;
+#if NETCOREAPP3_1
+                var ep = IPEndPoint.Parse(ctx.Endpoint);
+                Assert.IsNotNull(ep);
+#endif
+                Assert.IsNotNull(ctx);
+            }
        }

        // COMMENTED OUT DUE TO DEAD LOCK? OR VERY VERY SLOW PERFORMANCE ON LOCAL DEV MACHINE. TEST WAS STILL RUNNING AFTER SEVERAL MINUTES!
@@ -78,7 +93,7 @@ namespace MQTTnet.AspNetCore.Tests

        //    await Task.WhenAll(tasks).ConfigureAwait(false);
        //}
-        
+
        [TestMethod]
        public async Task TestLargePacket()
        {
@@ -88,49 +103,31 @@ namespace MQTTnet.AspNetCore.Tests
            connection.Transport = pipe;
            var ctx = new MqttConnectionContext(serializer, connection);

-            await ctx.SendPacketAsync(new MqttPublishPacket { Payload = new byte[20_000] }, CancellationToken.None).ConfigureAwait(false);
+            await ctx.SendPacketAsync(new MqttPublishPacket { PayloadSegment = new ArraySegment<byte>(new byte[20_000]) }, CancellationToken.None).ConfigureAwait(false);

            var readResult = await pipe.Send.Reader.ReadAsync();
            Assert.IsTrue(readResult.Buffer.Length > 20000);
        }

-        private class Startup 
+        [TestMethod]
+        public async Task TestReceivePacketAsyncThrowsWhenReaderCompleted()
+        {
+            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
+            var pipe = new DuplexPipeMockup();
+            var connection = new DefaultConnectionContext();
+            connection.Transport = pipe;
+            var ctx = new MqttConnectionContext(serializer, connection);
+
+            pipe.Receive.Writer.Complete();
+
+            await Assert.ThrowsExceptionAsync<MqttCommunicationException>(() => ctx.ReceivePacketAsync(CancellationToken.None));
+        }
+
+        class Startup
        {
            public void Configure(IApplicationBuilder app)
-            { 
+            {
            }
        }
-
-        [TestMethod]
-        public async Task TestEndpoint()
-        {
-            var mockup = new ConnectionHandlerMockup();
-
-
-            using (var host = new WebHostBuilder()
-                .UseKestrel(kestrel => kestrel.ListenLocalhost(1883, listener => listener.Use((ctx, next) => mockup.OnConnectedAsync(ctx))))
-                .UseStartup<Startup>()
-                .ConfigureServices((hostContext, services) =>
-                {
-                    services.AddHostedMqttServer(o => o.WithoutDefaultEndpoint());
-                    services.AddSingleton<IMqttServerAdapter>(mockup);
-                })
-                .Build())
-                
-            using (var client = new MqttFactory().CreateMqttClient())
-            {
-                host.Start();
-                await client.ConnectAsync(new MqttClientOptionsBuilder()
-                    .WithTcpServer("localhost")
-                    .Build(), CancellationToken.None);
-
-                var ctx = await mockup.Context.Task;
-#if NETCOREAPP3_1
-                var ep = IPEndPoint.Parse(ctx.Endpoint);
-                Assert.IsNotNull(ep);
-#endif
-                Assert.IsNotNull(ctx);
-            }               
-        }
    }
-}
+}
@@ -12,14 +12,14 @@ using MQTTnet.Packets;
 namespace MQTTnet.AspNetCore.Tests
 {
    [TestClass]
-    public class ReaderExtensionsTest
+    public sealed class ReaderExtensionsTest
    {
        [TestMethod]
        public void TestTryDeserialize()
        {
            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));

-            var buffer = serializer.Encode(new MqttPublishPacket {Topic = "a", Payload = new byte[5]}).Join();
+            var buffer = serializer.Encode(new MqttPublishPacket {Topic = "a", PayloadSegment = new byte[5]}).Join();

            var sequence = new ReadOnlySequence<byte>(buffer.Array, buffer.Offset, buffer.Count);

@@ -8,17 +8,15 @@
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
        <EnableNETAnalyzers>false</EnableNETAnalyzers>
        <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
+        <NoWarn>1591;NETSDK1138</NoWarn>
    </PropertyGroup>

    <ItemGroup>
-        <ProjectReference Include="..\..\Source\MQTTnet.AspnetCore\MQTTnet.AspNetCore.csproj"/>
-
-        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
-        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
+        <ProjectReference Include="..\..\Source\MQTTnet.AspnetCore\MQTTnet.AspNetCore.csproj" />
    </ItemGroup>

    <ItemGroup>
-        <Folder Include="wwwroot\"/>
+        <Folder Include="wwwroot\" />
    </ItemGroup>

 </Project>
@@ -44,7 +44,7 @@ namespace MQTTnet.AspNetCore.Client.Tcp
            _sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
            _receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
        }
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER
        public override ValueTask DisposeAsync()
 #else
        public Task DisposeAsync()
@@ -57,7 +57,7 @@ namespace MQTTnet.AspNetCore.Client.Tcp

            _socket?.Dispose();

-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER

            return base.DisposeAsync();
        }
@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.


-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER

 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Routing;
@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFrameworks>netstandard2.0;netcoreapp2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>netstandard2.0;netcoreapp2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>

        <AssemblyName>MQTTnet.AspNetCore</AssemblyName>
        <RootNamespace>MQTTnet.AspNetCore</RootNamespace>
@@ -16,7 +16,7 @@
        <PublishRepositoryUrl>true</PublishRepositoryUrl>
        <IncludeSymbols>true</IncludeSymbols>
        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-        <Copyright>Christian Kratky 2016-2022</Copyright>
+        <Copyright>Copyright (c) .NET Foundation and Contributors</Copyright>
        <PackageProjectUrl>https://github.com/dotnet/MQTTnet</PackageProjectUrl>
        <RepositoryUrl>https://github.com/dotnet/MQTTnet.git</RepositoryUrl>
        <RepositoryType>git</RepositoryType>
@@ -27,12 +27,13 @@
        <PackageIcon>nuget.png</PackageIcon>
        <EmbedUntrackedSources>true</EmbedUntrackedSources>
        <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
-        <PackageLicenseFile>LICENSE</PackageLicenseFile>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
        <PackageReleaseNotes>For release notes please go to MQTTnet release notes (https://www.nuget.org/packages/MQTTnet/).</PackageReleaseNotes>
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
        <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <NoWarn>1591</NoWarn>
+        <NoWarn>1591;NETSDK1138</NoWarn>
+        <LangVersion>7.3</LangVersion>
    </PropertyGroup>

    <ItemGroup>
@@ -41,27 +42,20 @@
            <PackagePath>\</PackagePath>
        </None>
    </ItemGroup>
-
+    
    <ItemGroup>
-        <None Include="..\..\LICENSE">
-            <Pack>True</Pack>
-            <PackagePath>\</PackagePath>
-        </None>
-    </ItemGroup>
-
-    <ItemGroup>
-        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
    </ItemGroup>

    <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
        <DefineConstants>RELEASE;NETSTANDARD2_0</DefineConstants>
    </PropertyGroup>

-    <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0' or '$(TargetFramework)' == 'net6.0' ">
+    <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0' or '$(TargetFramework)' == 'net6.0' or '$(TargetFramework)' == 'net7.0' ">
        <FrameworkReference Include="Microsoft.AspNetCore.App" />
    </ItemGroup>

-    <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp3.1' and '$(TargetFramework)' != 'net5.0' and '$(TargetFramework)' != 'net6.0' ">
+    <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp3.1' and '$(TargetFramework)' != 'net5.0' and '$(TargetFramework)' != 'net6.0' and '$(TargetFramework)' != 'net7.0' ">
        <PackageReference Include="Microsoft.AspNetCore.Http.Connections" Version="1.1.0" />
    </ItemGroup>

@@ -2,38 +2,62 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+using System;
+using System.IO.Pipelines;
+using System.Net;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Connections;
 using Microsoft.AspNetCore.Http.Connections.Features;
+using Microsoft.AspNetCore.Http.Features;
 using MQTTnet.Adapter;
 using MQTTnet.AspNetCore.Client.Tcp;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
-using MQTTnet.Packets;
-using System;
-using System.IO.Pipelines;
-using System.Security.Cryptography.X509Certificates;
-using System.Threading;
-using System.Threading.Tasks;
 using MQTTnet.Internal;
+using MQTTnet.Packets;

 namespace MQTTnet.AspNetCore
 {
    public sealed class MqttConnectionContext : IMqttChannelAdapter
    {
+        readonly ConnectionContext _connection;
        readonly AsyncLock _writerLock = new AsyncLock();
-        
+
        PipeReader _input;
        PipeWriter _output;
-        
+
        public MqttConnectionContext(MqttPacketFormatterAdapter packetFormatterAdapter, ConnectionContext connection)
        {
            PacketFormatterAdapter = packetFormatterAdapter ?? throw new ArgumentNullException(nameof(packetFormatterAdapter));
-            Connection = connection ?? throw new ArgumentNullException(nameof(connection));
+            _connection = connection ?? throw new ArgumentNullException(nameof(connection));

-            if (Connection.Transport != null)
+            if (!(_connection is TcpConnection tcp) || tcp.IsConnected)
            {
-                _input = Connection.Transport.Input;
-                _output = Connection.Transport.Output;
+                _input = connection.Transport.Input;
+                _output = connection.Transport.Output;
+            }
+        }
+
+        public long BytesReceived { get; private set; }
+
+        public long BytesSent { get; private set; }
+
+        public X509Certificate2 ClientCertificate
+        {
+            get
+            {
+                // mqtt over tcp
+                var tlsFeature = _connection.Features.Get<ITlsConnectionFeature>();
+                if (tlsFeature != null)
+                {
+                    return tlsFeature.ClientCertificate;
+                }
+
+                // mqtt over websocket
+                var httpFeature = _connection.Features.Get<IHttpContextFeature>();
+                return httpFeature?.HttpContext?.Connection.ClientCertificate;
            }
        }

@@ -41,47 +65,57 @@ namespace MQTTnet.AspNetCore
        {
            get
            {
-#if NETCOREAPP3_1
-                if (Connection?.RemoteEndPoint != null)
+                // mqtt over tcp 
+#if NETCOREAPP3_1_OR_GREATER
+                if (_connection.RemoteEndPoint != null)
                {
-                    return Connection.RemoteEndPoint.ToString();
+                    return _connection.RemoteEndPoint.ToString();
                }
 #endif
-                var connection = Http?.HttpContext?.Connection;
-                if (connection == null)
+                // mqtt over websocket
+                var httpFeature = _connection.Features.Get<IHttpConnectionFeature>();
+                if (httpFeature?.RemoteIpAddress != null)
                {
-                    return Connection.ConnectionId;
+                    return new IPEndPoint(httpFeature.RemoteIpAddress, httpFeature.RemotePort).ToString();
                }

-                return $"{connection.RemoteIpAddress}:{connection.RemotePort}";
+                return null;
            }
        }

-        public bool IsSecureConnection => Http?.HttpContext?.Request?.IsHttps ?? false;
+        public bool IsSecureConnection
+        {
+            get
+            {
+                // mqtt over tcp
+                var tlsFeature = _connection.Features.Get<ITlsConnectionFeature>();
+                if (tlsFeature != null)
+                {
+                    return true;
+                }

-        public X509Certificate2 ClientCertificate => Http?.HttpContext?.Connection?.ClientCertificate;
+                // mqtt over websocket
+                var httpFeature = _connection.Features.Get<IHttpContextFeature>();
+                if (httpFeature?.HttpContext != null)
+                {
+                    return httpFeature.HttpContext.Request.IsHttps;
+                }
+
+                return false;
+            }
+        }

-        public ConnectionContext Connection { get; }
-        
        public MqttPacketFormatterAdapter PacketFormatterAdapter { get; }

-        public long BytesSent { get; set; }
-
-        public long BytesReceived { get; set; }
-
-        public bool IsReadingPacket { get; private set; }
-
-        IHttpContextFeature Http => Connection.Features.Get<IHttpContextFeature>();
-
        public async Task ConnectAsync(CancellationToken cancellationToken)
        {
-            if (Connection is TcpConnection tcp && !tcp.IsConnected)
+            if (_connection is TcpConnection tcp && !tcp.IsConnected)
            {
                await tcp.StartAsync().ConfigureAwait(false);
            }

-            _input = Connection.Transport.Input;
-            _output = Connection.Transport.Output;
+            _input = _connection.Transport.Input;
+            _output = _connection.Transport.Output;
        }

        public Task DisconnectAsync(CancellationToken cancellationToken)
@@ -92,16 +126,19 @@ namespace MQTTnet.AspNetCore
            return Task.CompletedTask;
        }

+        public void Dispose()
+        {
+            _writerLock.Dispose();
+        }
+
        public async Task<MqttPacket> ReceivePacketAsync(CancellationToken cancellationToken)
        {
-            var input = Connection.Transport.Input;
-
            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    ReadResult readResult;
-                    var readTask = input.ReadAsync(cancellationToken);
+                    var readTask = _input.ReadAsync(cancellationToken);
                    if (readTask.IsCompleted)
                    {
                        readResult = readTask.Result;
@@ -125,11 +162,6 @@ namespace MQTTnet.AspNetCore
                                BytesReceived += received;
                                return packet;
                            }
-                            else
-                            {
-                                // we did receive something but the message is not yet complete
-                                IsReadingPacket = true;
-                            }
                        }
                        else if (readResult.IsCompleted)
                        {
@@ -141,21 +173,18 @@ namespace MQTTnet.AspNetCore
                        // The buffer was sliced up to where it was consumed, so we can just advance to the start.
                        // We mark examined as buffer.End so that if we didn't receive a full frame, we'll wait for more data
                        // before yielding the read again.
-                        input.AdvanceTo(consumed, observed);
+                        _input.AdvanceTo(consumed, observed);
                    }
                }
            }
-            catch (Exception e)
+            catch (Exception exception)
            {
                // completing the channel makes sure that there is no more data read after a protocol error
-                _input?.Complete(e);
-                _output?.Complete(e);
+                _input?.Complete(exception);
+                _output?.Complete(exception);
+
                throw;
            }
-            finally
-            {
-                IsReadingPacket = false;
-            }

            cancellationToken.ThrowIfCancellationRequested();
            return null;
@@ -169,25 +198,44 @@ namespace MQTTnet.AspNetCore

        public async Task SendPacketAsync(MqttPacket packet, CancellationToken cancellationToken)
        {
-            var formatter = PacketFormatterAdapter;
-            
-            using (await _writerLock.WaitAsync(cancellationToken).ConfigureAwait(false))
+            using (await _writerLock.EnterAsync(cancellationToken).ConfigureAwait(false))
            {
-                var buffer = formatter.Encode(packet);
-                var msg = buffer.Join().AsMemory();
-                var output = _output;
-                var result = await output.WriteAsync(msg, cancellationToken).ConfigureAwait(false);
-                if (result.IsCompleted)
+                try
                {
-                    BytesSent += msg.Length;
-                }
+                    var buffer = PacketFormatterAdapter.Encode(packet);

-                PacketFormatterAdapter.Cleanup();
+                    if (buffer.Payload.Count == 0)
+                    {
+                        // zero copy
+                        // https://github.com/dotnet/runtime/blob/e31ddfdc4f574b26231233dc10c9a9c402f40590/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeWriter.cs#L279
+                        await _output.WriteAsync(buffer.Packet, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        WritePacketBuffer(_output, buffer);
+                        await _output.FlushAsync(cancellationToken).ConfigureAwait(false);
+                    }
+
+                    BytesSent += buffer.Length;
+                }
+                finally
+                {
+                    PacketFormatterAdapter.Cleanup();
+                }
            }
        }

-        public void Dispose()
+        static void WritePacketBuffer(PipeWriter output, MqttPacketBuffer buffer)
        {
+            // copy MqttPacketBuffer's Packet and Payload to the same buffer block of PipeWriter
+            // MqttPacket will be transmitted within the bounds of a WebSocket frame after PipeWriter.FlushAsync
+
+            var span = output.GetSpan(buffer.Length);
+
+            buffer.Packet.AsSpan().CopyTo(span);
+            buffer.Payload.AsSpan().CopyTo(span.Slice(buffer.Packet.Count));
+
+            output.Advance(buffer.Length);
        }
    }
-}
+}
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
@@ -14,20 +15,27 @@ namespace MQTTnet.AspNetCore
 {
    public sealed class MqttHostedServer : MqttServer, IHostedService
    {
-        public MqttHostedServer(MqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger) 
-            : base(options, adapters, logger)
+        readonly MqttFactory _mqttFactory;
+
+        public MqttHostedServer(MqttFactory mqttFactory, MqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger) : base(
+            options,
+            adapters,
+            logger)
        {
+            _mqttFactory = mqttFactory ?? throw new ArgumentNullException(nameof(mqttFactory));
        }

-        public Task StartAsync(CancellationToken cancellationToken)
+        public async Task StartAsync(CancellationToken cancellationToken)
        {
-            _ =  StartAsync();
-            return Task.CompletedTask;
+            // The yield makes sure that the hosted service is considered up and running.
+            await Task.Yield();
+
+            _ = StartAsync();
        }

        public Task StopAsync(CancellationToken cancellationToken)
        {
-            return StopAsync();
+            return StopAsync(_mqttFactory.CreateMqttServerStopOptionsBuilder().Build());
        }
    }
 }
@@ -2,38 +2,34 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using Microsoft.AspNetCore.Http;
-using MQTTnet.Adapter;
-using MQTTnet.Formatter;
-using MQTTnet.Implementations;
-using MQTTnet.Server;
 using System;
 using System.Net.WebSockets;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
+using MQTTnet.Formatter;
+using MQTTnet.Implementations;
+using MQTTnet.Server;

 namespace MQTTnet.AspNetCore
 {
    public sealed class MqttWebSocketServerAdapter : IMqttServerAdapter
    {
-        IMqttNetLogger _logger = new MqttNetNullLogger();
-        
+        IMqttNetLogger _logger = MqttNetNullLogger.Instance;
+
        public Func<IMqttChannelAdapter, Task> ClientHandler { get; set; }

-        public Task StartAsync(MqttServerOptions options, IMqttNetLogger logger)
+        public void Dispose()
        {
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            return Task.CompletedTask;
-        }
-
-        public Task StopAsync()
-        {
-            return Task.CompletedTask;
        }

        public async Task RunWebSocketConnectionAsync(WebSocket webSocket, HttpContext httpContext)
        {
-            if (webSocket == null) throw new ArgumentNullException(nameof(webSocket));
+            if (webSocket == null)
+            {
+                throw new ArgumentNullException(nameof(webSocket));
+            }

            var endpoint = $"{httpContext.Connection.RemoteIpAddress}:{httpContext.Connection.RemotePort}";

@@ -48,7 +44,7 @@ namespace MQTTnet.AspNetCore
                    var formatter = new MqttPacketFormatterAdapter(new MqttBufferWriter(4096, 65535));
                    var channel = new MqttWebSocketChannel(webSocket, endpoint, isSecureConnection, clientCertificate);

-                    using (var channelAdapter = new MqttChannelAdapter(channel, formatter, null, _logger))
+                    using (var channelAdapter = new MqttChannelAdapter(channel, formatter, _logger))
                    {
                        await clientHandler(channelAdapter).ConfigureAwait(false);
                    }
@@ -60,8 +56,15 @@ namespace MQTTnet.AspNetCore
            }
        }

-        public void Dispose()
+        public Task StartAsync(MqttServerOptions options, IMqttNetLogger logger)
        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync()
+        {
+            return Task.CompletedTask;
        }
    }
 }
@@ -2,21 +2,23 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using System;
-using System.Buffers;
 using MQTTnet.Adapter;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
+using System;
+using System.Buffers;
+using System.Linq;
+using System.Runtime.InteropServices;

 namespace MQTTnet.AspNetCore
 {
    public static class ReaderExtensions
    {
-        public static bool TryDecode(this MqttPacketFormatterAdapter formatter, 
-            in ReadOnlySequence<byte> input, 
-            out MqttPacket packet, 
-            out SequencePosition consumed, 
+        public static bool TryDecode(this MqttPacketFormatterAdapter formatter,
+            in ReadOnlySequence<byte> input,
+            out MqttPacket packet,
+            out SequencePosition consumed,
            out SequencePosition observed,
            out int bytesRead)
        {
@@ -33,22 +35,22 @@ namespace MQTTnet.AspNetCore
                return false;
            }

-            var fixedHeader = copy.First.Span[0];
-            if (!TryReadBodyLength(ref copy, out int headerLength, out var bodyLength))
+            if (!TryReadBodyLength(ref copy, out var headerLength, out var bodyLength))
            {
                return false;
            }

+            var fixedHeader = copy.First.Span[0];
+            copy = copy.Slice(headerLength);
            if (copy.Length < bodyLength)
            {
                return false;
            }

            var bodySlice = copy.Slice(0, bodyLength);
-            var buffer = bodySlice.GetMemory().ToArray();
-            
-            var receivedMqttPacket = new ReceivedMqttPacket(fixedHeader, new ArraySegment<byte>(buffer, 0, buffer.Length), buffer.Length + 2);
-
+            var bodySegment = GetArraySegment(ref bodySlice); 
+    
+            var receivedMqttPacket = new ReceivedMqttPacket(fixedHeader, bodySegment, headerLength + bodyLength);
            if (formatter.ProtocolVersion == MqttProtocolVersion.Unknown)
            {
                formatter.DetectProtocolVersion(receivedMqttPacket);
@@ -61,18 +63,41 @@ namespace MQTTnet.AspNetCore
            return true;
        }

-        static ReadOnlyMemory<byte> GetMemory(this in ReadOnlySequence<byte> input)
+        static ArraySegment<byte> GetArraySegment(ref ReadOnlySequence<byte> input)
        {
-            if (input.IsSingleSegment)
+            if (input.IsSingleSegment && MemoryMarshal.TryGetArray(input.First, out var segment))
            {
-                return input.First;
+                return segment;
            }

            // Should be rare
-            return input.ToArray();
+            var array = input.ToArray();
+            return new ArraySegment<byte>(array);
        }

        static bool TryReadBodyLength(ref ReadOnlySequence<byte> input, out int headerLength, out int bodyLength)
+        {
+            var valueSequence = input.Slice(0, Math.Min(5, input.Length));
+            if (valueSequence.IsSingleSegment)
+            {
+                var valueSpan =
+#if NET5_0_OR_GREATER
+                    valueSequence.FirstSpan;
+#else
+                    valueSequence.First.Span;
+#endif
+                return TryReadBodyLength(valueSpan, out headerLength, out bodyLength);
+            }
+            else
+            {
+                Span<byte> valueSpan = stackalloc byte[8];
+                valueSequence.CopyTo(valueSpan);
+                valueSpan = valueSpan.Slice(0, (int)valueSequence.Length);
+                return TryReadBodyLength(valueSpan, out headerLength, out bodyLength);
+            }
+        }
+
+        static bool TryReadBodyLength(ReadOnlySpan<byte> span, out int headerLength, out int bodyLength)
        {
            // Alorithm taken from https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html.
            var multiplier = 1;
@@ -81,33 +106,35 @@ namespace MQTTnet.AspNetCore
            var index = 1;
            headerLength = 0;
            bodyLength = 0;
-            
-            var temp = input.Slice(0, Math.Min(5, input.Length)).GetMemory().Span;

            do
            {
-                if (index == temp.Length)
+                if (index == span.Length)
                {
                    return false;
                }

-                encodedByte = temp[index];
+                encodedByte = span[index];
                index++;

                value += (byte)(encodedByte & 127) * multiplier;
                if (multiplier > 128 * 128 * 128)
                {
-                    throw new MqttProtocolViolationException($"Remaining length is invalid (Data={string.Join(",", temp.Slice(1, index).ToArray())}).");
+                    ThrowProtocolViolationException(span, index);
                }

                multiplier *= 128;
            } while ((encodedByte & 128) != 0);

-            input = input.Slice(index);
-
            headerLength = index;
            bodyLength = value;
            return true;
        }
+
+
+        static void ThrowProtocolViolationException(ReadOnlySpan<byte> valueSpan, int index)
+        {
+            throw new MqttProtocolViolationException($"Remaining length is invalid (Data={string.Join(",", valueSpan.Slice(1, index).ToArray())}).");
+        }
    }
 }
@@ -4,6 +4,7 @@

 using System;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
@@ -14,86 +15,74 @@ namespace MQTTnet.AspNetCore
 {
    public static class ServiceCollectionExtensions
    {
-        public static IServiceCollection AddMqttServer(this IServiceCollection serviceCollection, Action<MqttServerOptionsBuilder> configure = null)
-        {
-            if (serviceCollection is null)
-            {
-                throw new ArgumentNullException(nameof(serviceCollection));
-            }
-
-            serviceCollection.AddMqttConnectionHandler();
-            serviceCollection.AddHostedMqttServer(configure);
-            
-            return serviceCollection;
-        }
-
        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, MqttServerOptions options)
        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
+            if (services == null)
+            {
+                throw new ArgumentNullException(nameof(services));
+            }
+
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }

            services.AddSingleton(options);
-
            services.AddHostedMqttServer();

            return services;
        }

-        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, Action<MqttServerOptionsBuilder> configure = null)
+        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, Action<MqttServerOptionsBuilder> configure)
        {
-            services.AddSingleton(s =>
+            if (services == null)
            {
-                var serverOptionsBuilder = new MqttServerOptionsBuilder();
-                configure?.Invoke(serverOptionsBuilder);
-                return serverOptionsBuilder.Build();
-            });
+                throw new ArgumentNullException(nameof(services));
+            }

-            services.AddHostedMqttServer();
+            if (configure == null)
+            {
+                throw new ArgumentNullException(nameof(configure));
+            }

-            return services;
+            var serverOptionsBuilder = new MqttServerOptionsBuilder();
+            configure.Invoke(serverOptionsBuilder);
+            var options = serverOptionsBuilder.Build();
+
+            return AddHostedMqttServer(services, options);
+        }
+
+        public static void AddHostedMqttServer(this IServiceCollection services)
+        {
+            // The user may have these services already registered.
+            services.TryAddSingleton<IMqttNetLogger>(MqttNetNullLogger.Instance);
+            services.TryAddSingleton(new MqttFactory());
+
+            services.AddSingleton<MqttHostedServer>();
+            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
+            services.AddSingleton<MqttServer>(s => s.GetService<MqttHostedServer>());
        }

        public static IServiceCollection AddHostedMqttServerWithServices(this IServiceCollection services, Action<AspNetMqttServerOptionsBuilder> configure)
        {
-            services.AddSingleton(s =>
+            if (services == null)
            {
-                var builder = new AspNetMqttServerOptionsBuilder(s);
-                configure(builder);
-                return builder.Build();
-            });
+                throw new ArgumentNullException(nameof(services));
+            }
+
+            services.AddSingleton(
+                s =>
+                {
+                    var builder = new AspNetMqttServerOptionsBuilder(s);
+                    configure(builder);
+                    return builder.Build();
+                });

            services.AddHostedMqttServer();

            return services;
        }

-        static IServiceCollection AddHostedMqttServer(this IServiceCollection services)
-        {
-            var logger = new MqttNetEventLogger();
-
-            services.AddSingleton<IMqttNetLogger>(logger);
-            services.AddSingleton<MqttHostedServer>();
-            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
-            services.AddSingleton<MqttServer>(s => s.GetService<MqttHostedServer>());
-
-            return services;
-        }
-
-        public static IServiceCollection AddMqttWebSocketServerAdapter(this IServiceCollection services)
-        {
-            services.AddSingleton<MqttWebSocketServerAdapter>();
-            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttWebSocketServerAdapter>());
-
-            return services;
-        }
-
-        public static IServiceCollection AddMqttTcpServerAdapter(this IServiceCollection services)
-        {
-            services.AddSingleton<MqttTcpServerAdapter>();
-            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttTcpServerAdapter>());
-
-            return services;
-        }
-
        public static IServiceCollection AddMqttConnectionHandler(this IServiceCollection services)
        {
            services.AddSingleton<MqttConnectionHandler>();
@@ -101,5 +90,44 @@ namespace MQTTnet.AspNetCore

            return services;
        }
+
+        public static void AddMqttLogger(this IServiceCollection services, IMqttNetLogger logger)
+        {
+            if (services == null)
+            {
+                throw new ArgumentNullException(nameof(services));
+            }
+
+            services.AddSingleton(logger);
+        }
+
+        public static IServiceCollection AddMqttServer(this IServiceCollection serviceCollection, Action<MqttServerOptionsBuilder> configure = null)
+        {
+            if (serviceCollection is null)
+            {
+                throw new ArgumentNullException(nameof(serviceCollection));
+            }
+
+            serviceCollection.AddMqttConnectionHandler();
+            serviceCollection.AddHostedMqttServer(configure);
+
+            return serviceCollection;
+        }
+
+        public static IServiceCollection AddMqttTcpServerAdapter(this IServiceCollection services)
+        {
+            services.AddSingleton<MqttTcpServerAdapter>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttTcpServerAdapter>());
+
+            return services;
+        }
+
+        public static IServiceCollection AddMqttWebSocketServerAdapter(this IServiceCollection services)
+        {
+            services.AddSingleton<MqttWebSocketServerAdapter>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttWebSocketServerAdapter>());
+
+            return services;
+        }
    }
-}
+}
@@ -0,0 +1,66 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using MQTTnet.Internal;
+
+namespace MQTTnet.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [MemoryDiagnoser]
+    public class AsyncLockBenchmark : BaseBenchmark
+    {
+        [Benchmark]
+        public async Task Synchronize_100_Tasks()
+        {
+            const int tasksCount = 100;
+
+            var tasks = new Task[tasksCount];
+            var asyncLock = new AsyncLock();
+            var globalI = 0;
+
+            for (var i = 0; i < tasksCount; i++)
+            {
+                tasks[i] = Task.Run(
+                    async () =>
+                    {
+                        using (await asyncLock.EnterAsync().ConfigureAwait(false))
+                        {
+                            var localI = globalI;
+                            await Task.Delay(5).ConfigureAwait(false); // Increase the chance for wrong data.
+                            localI++;
+                            globalI = localI;
+                        }
+                    });
+            }
+
+            await Task.WhenAll(tasks).ConfigureAwait(false);
+
+            if (globalI != tasksCount)
+            {
+                throw new Exception($"Code is broken ({globalI})!");
+            }
+        }
+        
+        [Benchmark]
+        public async Task Wait_100_000_Times()
+        {
+            var asyncLock = new AsyncLock();
+
+            using (var cancellationToken = new CancellationTokenSource())
+            {
+                for (var i = 0; i < 100000; i++)
+                {
+                    using (await asyncLock.EnterAsync(cancellationToken.Token).ConfigureAwait(false))
+                    {
+                    }
+                }
+            }
+        }
+    }
+}
@@ -1,3 +1,7 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
 namespace MQTTnet.Benchmarks
 {
    public abstract class BaseBenchmark
@@ -2,54 +2,25 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using BenchmarkDotNet.Attributes;
-using MQTTnet.Adapter;
-using MQTTnet.Internal;
-using MQTTnet.Packets;
 using System;
 using System.IO;
 using System.Threading;
+using BenchmarkDotNet.Attributes;
+using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 using MQTTnet.Formatter;
+using MQTTnet.Packets;
 using MQTTnet.Tests.Mockups;

 namespace MQTTnet.Benchmarks
 {
    [MemoryDiagnoser]
-    public sealed class ChannelAdapterBenchmark
+    public sealed class ChannelAdapterBenchmark : BaseBenchmark
    {
        MqttChannelAdapter _channelAdapter;
        int _iterations;
-        MemoryStream _stream;
        MqttPublishPacket _packet;
-
-        [GlobalSetup]
-        public void Setup()
-        {
-            _packet = new MqttPublishPacket
-            {
-                Topic = "A"
-            };
-
-            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
-            
-            var serializedPacket = Join(serializer.Encode(_packet).Join());
-
-            _iterations = 10000;
-
-            _stream = new MemoryStream(_iterations * serializedPacket.Length);
-
-            for (var i = 0; i < _iterations; i++)
-            {
-                _stream.Write(serializedPacket, 0, serializedPacket.Length);
-            }
-
-            _stream.Position = 0;
-
-            var channel = new TestMqttChannel(_stream);
-            
-            _channelAdapter = new MqttChannelAdapter(channel, serializer, null, new MqttNetEventLogger());
-        }
+        MemoryStream _stream;

        [Benchmark]
        public void Receive_10000_Messages()
@@ -77,6 +48,34 @@ namespace MQTTnet.Benchmarks
            _stream.Position = 0;
        }

+        [GlobalSetup]
+        public void Setup()
+        {
+            _packet = new MqttPublishPacket
+            {
+                Topic = "A"
+            };
+
+            var serializer = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
+
+            var serializedPacket = Join(serializer.Encode(_packet).Join());
+
+            _iterations = 10000;
+
+            _stream = new MemoryStream(_iterations * serializedPacket.Length);
+
+            for (var i = 0; i < _iterations; i++)
+            {
+                _stream.Write(serializedPacket, 0, serializedPacket.Length);
+            }
+
+            _stream.Position = 0;
+
+            var channel = new MemoryMqttChannel(_stream);
+
+            _channelAdapter = new MqttChannelAdapter(channel, serializer, new MqttNetEventLogger());
+        }
+
        static byte[] Join(params ArraySegment<byte>[] chunks)
        {
            var buffer = new MemoryStream();
@@ -88,4 +87,4 @@ namespace MQTTnet.Benchmarks
            return buffer.ToArray();
        }
    }
-}
+}
@@ -1,22 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Validators;
-
-namespace MQTTnet.Benchmarks.Configurations
-{
-    /// <summary>
-    /// this options may be used to run benchmarks in debugmode and attach a performance profiler
-    /// https://benchmarkdotnet.org/Configs/Configs.htm
-    /// </summary>
-    public class AllowNonOptimized : BaseConfig
-    {
-        public AllowNonOptimized()
-        {
-            AddValidator(JitOptimizationsValidator.DontFailOnError); // ALLOW NON-OPTIMIZED DLLS
-            AddJob(Job.InProcess);
-        }
-    }
-}
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using BenchmarkDotNet.Configs;
-using System.Linq;
-
-namespace MQTTnet.Benchmarks.Configurations
-{
-    public class BaseConfig : ManualConfig
-    {
-        public BaseConfig()
-        {
-            AddLogger(DefaultConfig.Instance.GetLoggers().ToArray()); // manual config has no loggers by default
-            AddExporter(DefaultConfig.Instance.GetExporters().ToArray()); // manual config has no exporters by default
-            AddColumnProvider(DefaultConfig.Instance.GetColumnProviders().ToArray()); // manual config has no columns by default
-        }
-    }
-}
@@ -1,19 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-// See the LICENSE file in the project root for more information.
-
-using BenchmarkDotNet.Environments;
-using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Toolchains.CsProj;
-
-namespace MQTTnet.Benchmarks.Configurations
-{
-    public class RuntimeCompareConfig : BaseConfig
-    {
-        public RuntimeCompareConfig()
-        {
-            AddJob(Job.Default.WithRuntime(ClrRuntime.Net48));
-            AddJob(Job.Default.WithRuntime(CoreRuntime.Core50).WithToolchain(CsProjCoreToolchain.NetCoreApp50));
-        }
-    }
-}
@@ -8,10 +8,10 @@ using MQTTnet.Diagnostics;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [RPlotExporter]
    [MemoryDiagnoser]
-    public class LoggerBenchmark
+    public class LoggerBenchmark : BaseBenchmark
    {
        MqttNetNullLogger _nullLogger;
        MqttNetSourceLogger _sourceNullLogger;
@@ -1,25 +1,23 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
        <OutputType>Exe</OutputType>
        <DebugType>Full</DebugType>
-        <TargetFrameworks>net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
        <LangVersion>7.2</LangVersion>
        <IsPackable>false</IsPackable>
        <EnableNETAnalyzers>false</EnableNETAnalyzers>
        <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
+        <NoWarn>1591;NETSDK1138</NoWarn>
    </PropertyGroup>

    <ItemGroup>
-        <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+        <PackageReference Include="BenchmarkDotNet" Version="0.13.2" />
        <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
    </ItemGroup>
-
-    <ItemGroup Condition="'$(TargetFramework)' != 'net5.0'">
-        <PackageReference Include="System.IO.Pipelines" Version="4.7.2" />
-    </ItemGroup>
-
+    
    <ItemGroup Condition="'$(TargetFramework)' == 'net5.0'">
        <PackageReference Include="System.IO.Pipelines" Version="5.0.0" />
    </ItemGroup>
@@ -28,11 +26,12 @@
        <PackageReference Include="System.IO.Pipelines" Version="5.0.0" />
    </ItemGroup>

+    <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+        <PackageReference Include="System.IO.Pipelines" Version="7.0.0" />
+    </ItemGroup>
+
    <ItemGroup>
        <ProjectReference Include="..\..\Source\MQTTnet.AspnetCore\MQTTnet.AspNetCore.csproj" />
-
-        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
-        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
        <ProjectReference Include="..\MQTTnet.Tests\MQTTnet.Tests.csproj" />
    </ItemGroup>

@@ -0,0 +1,40 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using System;
+
+
+namespace MQTTnet.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [RPlotExporter, RankColumn]
+    [MemoryDiagnoser]
+    public class MemoryCopyBenchmark
+    {
+        const int max_length = 1024 * 8;
+        private byte[] source;
+        private byte[] target;
+
+        [Params(64 - 1, 128 - 1, 256 - 1, 512 - 1, 1024 - 1, 2048 - 1, 5096 - 1)]
+        public int Length { get; set; }
+
+        [GlobalSetup]
+        public void Setup()
+        {
+            source = new byte[max_length];
+            target = new byte[max_length];
+        }
+
+        [Benchmark(Baseline = true)]
+        public void Array_Copy()
+        {
+            Array.Copy(source, 0, target, 0, Length);
+        }
+
+        [Benchmark]
+        public void Memory_Copy()
+        {
+            MQTTnet.Internal.MqttMemoryHelper.Copy(source, 0, target, 0, Length);
+        }
+
+    }
+}
@@ -1,5 +1,8 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Jobs;
 using MQTTnet.Client;
 using MQTTnet.Server;
 using System;
@@ -8,14 +11,10 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;

-
 namespace MQTTnet.Benchmarks
 {
-    /// <summary>
-    /// Create a number of topics, publish, subscribe, and wait for response
-    /// </summary>
    [MemoryDiagnoser]
-    public class MessageDeliveryBenchmark
+    public class MessageDeliveryBenchmark : BaseBenchmark
    {
        List<MqttApplicationMessage> _topicPublishMessages;

@@ -6,14 +6,13 @@ using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using MQTTnet.Client;
 using MQTTnet.Server;
-using MqttClient = MQTTnet.Client.MqttClient;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [RPlotExporter, RankColumn]
    [MemoryDiagnoser]
-    public class MessageProcessingBenchmark
+    public class MessageProcessingBenchmark : BaseBenchmark
    {
        MqttServer _mqttServer;
        IMqttClient _mqttClient;
@@ -13,9 +13,9 @@ using MQTTnet.Diagnostics;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [MemoryDiagnoser]
-    public class MessageProcessingMqttConnectionContextBenchmark
+    public class MessageProcessingMqttConnectionContextBenchmark : BaseBenchmark
    {
        IWebHost _host;
        IMqttClient _mqttClient;
@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Text;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [MemoryDiagnoser]
+    public class MqttBufferReaderBenchmark
+    {
+        byte[] _buffer;
+        int _bufferLength;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            var writer = new MqttBufferWriter(1024, 1024);
+            writer.WriteString("hgfjkdfkjlghfdjghdfljkdfhgdlkjfshgsldkfjghsdflkjghdsflkjhrstiuoghlkfjbhnfbutghjoiöjhklötnbhtroliöuhbjntluiobkjzbhtdrlskbhtruhjkfthgbkftgjhgfiklhotriuöhbjtrsioöbtrsötrhträhtrühjtriüoätrhjtsrölbktrbnhtrulöbionhströloubinströoliubhnsöotrunbtöroisntröointröioujhgötiohjgötorshjnbgtöorihbnjtröoihbjntröobntröoibntrjhötrohjbtröoihntröoibnrtoiöbtrjnboöitrhjtnriohötrhjtöroihjtroöihjtroösibntsroönbotöirsbntöoihjntröoihntroöbtrboöitrnhoöitrhjntröoishbnjtröosbhtröbntriohjtröoijtöoitbjöotibjnhöotirhbjntroöibhnjrtoöibnhtroöibnhtörsbnhtöoirbnhtöroibntoörhjnbträöbtrbträbtrbtirbätrsibohjntrsöiobthnjiohjsrtoib");
+
+            _buffer = writer.GetBuffer();
+            _bufferLength = writer.Length;
+        }
+
+        [Benchmark]
+        public void Use_Span()
+        {
+            var span = _buffer.AsSpan(0, _bufferLength);
+            Encoding.UTF8.GetString(span);
+        }
+        
+        [Benchmark]
+        public void Use_Encoding()
+        {
+            Encoding.UTF8.GetString(_buffer, 0, _bufferLength);
+        }
+    }
+}
@@ -1,15 +1,18 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
 using System;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
-using MQTTnet.AspNetCore;
 using MQTTnet.Formatter;
 using MQTTnet.Tests.Mockups;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [MemoryDiagnoser]
-    public class MqttPacketReaderWriterBenchmark
+    public class MqttPacketReaderWriterBenchmark : BaseBenchmark
    {
        readonly byte[] _demoPayload = new byte[1024];
        
@@ -27,17 +30,17 @@ namespace MQTTnet.Benchmarks
            
            var writer = new MqttBufferWriter(4096, 65535);
            writer.WriteString("A relative short string.");
-            writer.WriteBinaryData(_demoPayload);
+            writer.WriteBinary(_demoPayload);
            writer.WriteByte(0x01);
            writer.WriteByte(0x02);
            writer.WriteVariableByteInteger(5647382);
            writer.WriteString("A relative short string.");
            writer.WriteVariableByteInteger(8574489);
-            writer.WriteBinaryData(_demoPayload);
+            writer.WriteBinary(_demoPayload);
            writer.WriteByte(2);
            writer.WriteByte(0x02);
            writer.WriteString("fjgffiogfhgfhoihgoireghreghreguhreguireoghreouighreouighreughreguiorehreuiohruiorehreuioghreug");
-            writer.WriteBinaryData(_demoPayload);
+            writer.WriteBinary(_demoPayload);

            _readPayload = new ArraySegment<byte>(writer.GetBuffer(), 0, writer.Length).ToArray();
        }
@@ -80,11 +83,11 @@ namespace MQTTnet.Benchmarks
                writer.WriteVariableByteInteger(5647382);
                writer.WriteString("A relative short string.");
                writer.WriteVariableByteInteger(8574589);
-                writer.WriteBinaryData(_demoPayload);
+                writer.WriteBinary(_demoPayload);
                writer.WriteByte(2);
                writer.WriteByte(0x02);
                writer.WriteString("fjgffiogfhgfhoihgoireghreghreguhreguireoghreouighreouighreughreguiorehreuiohruiorehreuioghreug");
-                writer.WriteBinaryData(_demoPayload);
+                writer.WriteBinary(_demoPayload);

                writer.Reset(0);
            }
@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+using System;
 using BenchmarkDotNet.Attributes;
 using MQTTnet.Channel;
 using MQTTnet.Implementations;
@@ -14,9 +15,9 @@ using MQTTnet.Diagnostics;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [MemoryDiagnoser]
-    public sealed class MqttTcpChannelBenchmark
+    public class MqttTcpChannelBenchmark : BaseBenchmark
    {
        MqttServer _mqttServer;
        IMqttChannel _serverChannel;
@@ -70,8 +71,8 @@ namespace MQTTnet.Benchmarks

            while (read < expected)
            {
-                var readresult = await _clientChannel.ReadAsync(new byte[size], 0, size, CancellationToken.None).ConfigureAwait(false);
-                read += readresult;
+                var readResult = await _clientChannel.ReadAsync(new byte[size], 0, size, CancellationToken.None).ConfigureAwait(false);
+                read += readResult;
            }
        }

@@ -79,9 +80,11 @@ namespace MQTTnet.Benchmarks
        {
            await Task.Yield();

+            var buffer = new ArraySegment<byte>(new byte[size]);
+            
            for (var i = 0; i < iterations; i++)
            {
-                await _serverChannel.WriteAsync(new byte[size], 0, size, CancellationToken.None).ConfigureAwait(false);
+                await _serverChannel.WriteAsync(buffer, true, CancellationToken.None).ConfigureAwait(false);
            }
        }
    }
@@ -3,81 +3,140 @@
 // See the LICENSE file in the project root for more information.

 using System;
+using System.Collections.Generic;
+using System.Linq;
+using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Running;
-using MQTTnet.Benchmarks.Configurations;
 using MQTTnet.Diagnostics;

 namespace MQTTnet.Benchmarks
 {
    public static class Program
    {
-        public static void Main(string[] args)
-        {
-            Console.WriteLine($"MQTTnet - Benchmarks ({TargetFrameworkProvider.TargetFramework})");
-            Console.WriteLine("--------------------------------------------------------");
-            Console.WriteLine("1 = MessageProcessingBenchmark");
-            Console.WriteLine("2 = SerializerBenchmark");
-            Console.WriteLine("3 = LoggerBenchmark");
-            Console.WriteLine("4 = TopicFilterComparerBenchmark");
-            Console.WriteLine("5 = ChannelAdapterBenchmark");
-            Console.WriteLine("6 = MqttTcpChannelBenchmark");
-            Console.WriteLine("7 = TcpPipesBenchmark");
-            Console.WriteLine("8 = MessageProcessingMqttConnectionContextBenchmark");
-            Console.WriteLine("9 = ServerProcessingBenchmark");
-            Console.WriteLine("a = MqttPacketReaderWriterBenchmark");
-            Console.WriteLine("b = RoundtripBenchmark");
-            Console.WriteLine("c = SubscribeBenchmark");
-            Console.WriteLine("d = UnsubscribeBenchmark");
-            Console.WriteLine("e = MessageDeliveryBenchmark");
+        static int _selectedBenchmarkIndex;
+        static List<Type> _benchmarks;

-            var pressedKey = Console.ReadKey(true);
-            switch (pressedKey.KeyChar)
+        public static void Main(string[] arguments)
+        {
+            _benchmarks = CollectBenchmarks();
+            HandleArguments(arguments);
+
+            while (true)
            {
-                case '1':
-                    BenchmarkRunner.Run<MessageProcessingBenchmark>();
-                    break;
-                case '2':
-                    BenchmarkRunner.Run<SerializerBenchmark>();
-                    break;
-                case '3':
-                    BenchmarkRunner.Run<LoggerBenchmark>();
-                    break;
-                case '4':
-                    BenchmarkRunner.Run<TopicFilterComparerBenchmark>();
-                    break;
-                case '5':
-                    BenchmarkRunner.Run<ChannelAdapterBenchmark>();
-                    break;
-                case '6':
-                    BenchmarkRunner.Run<MqttTcpChannelBenchmark>();
-                    break;
-                case '7':
-                    BenchmarkRunner.Run<TcpPipesBenchmark>();
-                    break;
-                case '8':
-                    BenchmarkRunner.Run<MessageProcessingMqttConnectionContextBenchmark>(new RuntimeCompareConfig());
-                    break;
-                case '9':
-                    BenchmarkRunner.Run<ServerProcessingBenchmark>();
-                    break;
-                case 'a':
-                    BenchmarkRunner.Run(typeof(MqttPacketReaderWriterBenchmark));
-                    break;
-                case 'b':
-                    BenchmarkRunner.Run<RoundtripProcessingBenchmark>();
-                    break;
-                case 'c':
-                    BenchmarkRunner.Run<SubscribeBenchmark>();
-                    break;
-                case 'd':
-                    BenchmarkRunner.Run<UnsubscribeBenchmark>();
-                    break;
-                case 'e':
-                    BenchmarkRunner.Run<MessageDeliveryBenchmark>();
+                RenderMenu();
+
+                var key = Console.ReadKey(true);
+
+                if (key.Key == ConsoleKey.DownArrow)
+                {
+                    _selectedBenchmarkIndex++;
+                    if (_selectedBenchmarkIndex > _benchmarks.Count - 1)
+                    {
+                        _selectedBenchmarkIndex = 0;
+                    }
+                }
+                else if (key.Key == ConsoleKey.UpArrow)
+                {
+                    _selectedBenchmarkIndex--;
+                    if (_selectedBenchmarkIndex < 0)
+                    {
+                        _selectedBenchmarkIndex = _benchmarks.Count - 1;
+                    }
+                }
+                else if (key.Key == ConsoleKey.Escape)
+                {
+                    Environment.Exit(0);
+                }
+                else if (key.Key == ConsoleKey.Enter)
+                {
                    break;
+                }
            }

+            BenchmarkRunner.Run(_benchmarks[_selectedBenchmarkIndex]);
+
+            Console.ForegroundColor = ConsoleColor.Yellow;
+            Console.WriteLine("Press any key to exit");
            Console.ReadLine();
        }
+
+        static List<Type> CollectBenchmarks()
+        {
+            var benchmarks = new List<Type>();
+
+            var types = typeof(Program).Assembly.GetExportedTypes();
+            foreach (var type in types)
+            {
+                if (typeof(BaseBenchmark).IsAssignableFrom(type))
+                {
+                    if (type != typeof(BaseBenchmark))
+                    {
+                        benchmarks.Add(type);        
+                    }
+                }
+            }
+
+            return benchmarks.OrderBy(b => b.Name).ToList();
+        }
+
+        static void HandleArguments(string[] arguments)
+        {
+            if (arguments.Length == 0)
+            {
+                return;
+            }
+
+            // Allow for preselection to avoid developer frustration.
+            
+            if (int.TryParse(arguments[0], out var benchmarkIndex))
+            {
+                _selectedBenchmarkIndex = benchmarkIndex;
+                return;
+            }
+
+            _selectedBenchmarkIndex = _benchmarks.FindIndex(b => b.Name.Equals(arguments[0]));
+
+            if (_selectedBenchmarkIndex < 0)
+            {
+                _selectedBenchmarkIndex = 0;
+            }
+
+            if (_selectedBenchmarkIndex > _benchmarks.Count - 1)
+            {
+                _selectedBenchmarkIndex = _benchmarks.Count - 1;
+            }
+        }
+
+        static void RenderMenu()
+        {
+            Console.Clear();
+
+            Console.WriteLine($"MQTTnet - Benchmarks ({TargetFrameworkProvider.TargetFramework})");
+            Console.WriteLine("-----------------------------------------------");
+            Console.ForegroundColor = ConsoleColor.Yellow;
+            Console.WriteLine("Press arrow keys for benchmark selection");
+            Console.WriteLine("Press Enter for benchmark execution");
+            Console.WriteLine("Press Esc for exit");
+            Console.ForegroundColor = ConsoleColor.White;
+            Console.WriteLine();
+
+            for (var index = 0; index < _benchmarks.Count; index++)
+            {
+                var benchmark = _benchmarks[index];
+
+                if (_selectedBenchmarkIndex == index)
+                {
+                    Console.Write("-> ");
+                }
+                else
+                {
+                    Console.Write("   ");
+                }
+
+                Console.WriteLine(benchmark.Name);
+            }
+
+            Console.WriteLine();
+        }
    }
-}
+}
@@ -0,0 +1,240 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using MQTTnet.Adapter;
+using MQTTnet.AspNetCore;
+using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
+using MQTTnet.Packets;
+using System;
+using System.Buffers;
+using System.IO;
+using System.IO.Pipelines;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [RPlotExporter, RankColumn]
+    [MemoryDiagnoser]
+    public class ReaderExtensionsBenchmark
+    {
+        MqttPacketFormatterAdapter mqttPacketFormatter;
+        MemoryStream stream;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            mqttPacketFormatter = new MqttPacketFormatterAdapter(MqttProtocolVersion.V311, new MqttBufferWriter(4096, 65535));
+            var mqttMessage = new MqttApplicationMessageBuilder()
+            .WithTopic("topic")
+            .WithPayload(new byte[10 * 1024])
+            .Build();
+
+            var packet = MqttPacketFactories.Publish.Create(mqttMessage);
+
+            var buffer = mqttPacketFormatter.Encode(packet);
+            stream = new MemoryStream();
+            stream.Write(buffer.Packet);
+            stream.Write(buffer.Payload);
+            mqttPacketFormatter.Cleanup();
+        }
+
+        [Benchmark(Baseline = true)]
+        public async Task Before()
+        {
+            stream.Position = 0;
+            var input = PipeReader.Create(stream);
+
+            while (true)
+            {
+                ReadResult readResult;
+                var readTask = input.ReadAsync();
+                if (readTask.IsCompleted)
+                {
+                    readResult = readTask.Result;
+                }
+                else
+                {
+                    readResult = await readTask.ConfigureAwait(false);
+                }
+
+                var buffer = readResult.Buffer;
+
+                var consumed = buffer.Start;
+                var observed = buffer.Start;
+
+                try
+                {
+                    if (!buffer.IsEmpty)
+                    {
+                        if (ReaderExtensions_Before.TryDecode(mqttPacketFormatter, buffer, out var packet, out consumed, out observed, out var received))
+                        {
+                            break;
+                        }
+                    }
+                    else if (readResult.IsCompleted)
+                    {
+                        throw new MqttCommunicationException("Connection Aborted");
+                    }
+                }
+                finally
+                {
+                    // The buffer was sliced up to where it was consumed, so we can just advance to the start.
+                    // We mark examined as buffer.End so that if we didn't receive a full frame, we'll wait for more data
+                    // before yielding the read again.
+                    input.AdvanceTo(consumed, observed);
+                }
+            }
+        }
+
+        [Benchmark]
+        public async Task After()
+        {
+            stream.Position = 0;
+            var input = PipeReader.Create(stream);
+
+            while (true)
+            {
+                ReadResult readResult;
+                var readTask = input.ReadAsync();
+                if (readTask.IsCompleted)
+                {
+                    readResult = readTask.Result;
+                }
+                else
+                {
+                    readResult = await readTask.ConfigureAwait(false);
+                }
+
+                var buffer = readResult.Buffer;
+
+                var consumed = buffer.Start;
+                var observed = buffer.Start;
+
+                try
+                {
+                    if (!buffer.IsEmpty)
+                    {
+                        if (ReaderExtensions.TryDecode(mqttPacketFormatter, buffer, out var packet, out consumed, out observed, out var received))
+                        {
+                            break;
+                        }
+                    }
+                    else if (readResult.IsCompleted)
+                    {
+                        throw new MqttCommunicationException("Connection Aborted");
+                    }
+                }
+                finally
+                {
+                    // The buffer was sliced up to where it was consumed, so we can just advance to the start.
+                    // We mark examined as buffer.End so that if we didn't receive a full frame, we'll wait for more data
+                    // before yielding the read again.
+                    input.AdvanceTo(consumed, observed);
+                }
+            }
+        }
+
+        public static class ReaderExtensions_Before
+        {
+            public static bool TryDecode(MqttPacketFormatterAdapter formatter,
+                in ReadOnlySequence<byte> input,
+                out MqttPacket packet,
+                out SequencePosition consumed,
+                out SequencePosition observed,
+                out int bytesRead)
+            {
+                if (formatter == null) throw new ArgumentNullException(nameof(formatter));
+
+                packet = null;
+                consumed = input.Start;
+                observed = input.End;
+                bytesRead = 0;
+                var copy = input;
+
+                if (copy.Length < 2)
+                {
+                    return false;
+                }
+
+                var fixedHeader = copy.First.Span[0];
+                if (!TryReadBodyLength(ref copy, out int headerLength, out var bodyLength))
+                {
+                    return false;
+                }
+
+                if (copy.Length < bodyLength)
+                {
+                    return false;
+                }
+
+                var bodySlice = copy.Slice(0, bodyLength);
+                var buffer = GetMemory(bodySlice).ToArray();
+
+                var receivedMqttPacket = new ReceivedMqttPacket(fixedHeader, new ArraySegment<byte>(buffer, 0, buffer.Length), buffer.Length + 2);
+
+                if (formatter.ProtocolVersion == MqttProtocolVersion.Unknown)
+                {
+                    formatter.DetectProtocolVersion(receivedMqttPacket);
+                }
+
+                packet = formatter.Decode(receivedMqttPacket);
+                consumed = bodySlice.End;
+                observed = bodySlice.End;
+                bytesRead = headerLength + bodyLength;
+                return true;
+            }
+
+            static ReadOnlyMemory<byte> GetMemory(in ReadOnlySequence<byte> input)
+            {
+                if (input.IsSingleSegment)
+                {
+                    return input.First;
+                }
+
+                // Should be rare
+                return input.ToArray();
+            }
+
+            static bool TryReadBodyLength(ref ReadOnlySequence<byte> input, out int headerLength, out int bodyLength)
+            {
+                // Alorithm taken from https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html.
+                var multiplier = 1;
+                var value = 0;
+                byte encodedByte;
+                var index = 1;
+                headerLength = 0;
+                bodyLength = 0;
+
+                var temp = GetMemory(input.Slice(0, Math.Min(5, input.Length))).Span;
+
+                do
+                {
+                    if (index == temp.Length)
+                    {
+                        return false;
+                    }
+
+                    encodedByte = temp[index];
+                    index++;
+
+                    value += (byte)(encodedByte & 127) * multiplier;
+                    if (multiplier > 128 * 128 * 128)
+                    {
+                        throw new MqttProtocolViolationException($"Remaining length is invalid (Data={string.Join(",", temp.Slice(1, index).ToArray())}).");
+                    }
+
+                    multiplier *= 128;
+                } while ((encodedByte & 128) != 0);
+
+                input = input.Slice(index);
+
+                headerLength = index;
+                bodyLength = value;
+                return true;
+            }
+        }
+
+    }
+}
@@ -5,10 +5,10 @@ using MQTTnet.Tests.Server;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [RPlotExporter, RankColumn]
    [MemoryDiagnoser]
-    public class RoundtripProcessingBenchmark
+    public class RoundtripProcessingBenchmark : BaseBenchmark
    {
        [GlobalSetup]
        public void GlobalSetup()
@@ -0,0 +1,68 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using MQTTnet.Formatter;
+using System;
+using System.IO;
+using System.IO.Pipelines;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [RPlotExporter, RankColumn]
+    [MemoryDiagnoser]
+    public class SendPacketAsyncBenchmark : BaseBenchmark
+    {
+        MemoryStream stream;
+        MqttPacketBuffer buffer;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            stream = new MemoryStream(1024);
+            var packet = new ArraySegment<byte>(new byte[10]);
+            buffer = new MqttPacketBuffer(packet);
+        }
+
+        [Benchmark(Baseline = true)]
+        public async ValueTask Before()
+        {
+            stream.Position = 0;
+            var output = PipeWriter.Create(stream);
+
+            WritePacketBuffer(output, buffer);
+            await output.FlushAsync();
+        }
+
+        [Benchmark]
+        public async ValueTask After()
+        {
+            stream.Position = 0;
+            var output = PipeWriter.Create(stream);
+
+            if (buffer.Payload.Count == 0)
+            {
+                await output.WriteAsync(buffer.Packet).ConfigureAwait(false);
+            }
+            else
+            {
+                WritePacketBuffer(output, buffer);
+                await output.FlushAsync().ConfigureAwait(false);
+            }
+        }
+
+
+        static void WritePacketBuffer(PipeWriter output, MqttPacketBuffer buffer)
+        {
+            // copy MqttPacketBuffer's Packet and Payload to the same buffer block of PipeWriter
+            // MqttPacket will be transmitted within the bounds of a WebSocket frame after PipeWriter.FlushAsync
+
+            var span = output.GetSpan(buffer.Length);
+
+            buffer.Packet.AsSpan().CopyTo(span);
+            buffer.Payload.AsSpan().CopyTo(span.Slice(buffer.Packet.Count));
+
+            output.Advance(buffer.Length);
+        }
+    }
+}
@@ -17,7 +17,7 @@ using MQTTnet.Diagnostics;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [RPlotExporter]
    [MemoryDiagnoser]
    public class SerializerBenchmark : BaseBenchmark
@@ -54,7 +54,7 @@ namespace MQTTnet.Benchmarks
        public void Deserialize_10000_Messages()
        {
            var channel = new BenchmarkMqttChannel(_serializedPacket);
-            var reader = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(new MqttBufferWriter(4096, 65535)), null, new MqttNetEventLogger());
+            var reader = new MqttChannelAdapter(channel, new MqttPacketFormatterAdapter(new MqttBufferWriter(4096, 65535)), new MqttNetEventLogger());

            for (var i = 0; i < 10000; i++)
            {
@@ -104,7 +104,7 @@ namespace MQTTnet.Benchmarks
                return Task.FromResult(count);
            }

-            public Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+            public Task WriteAsync(ArraySegment<byte> buffer, bool isEndOfPacket, CancellationToken cancellationToken)
            {
                throw new NotSupportedException();
            }
@@ -1,3 +1,7 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using MQTTnet.Tests.Mockups;
@@ -5,10 +9,10 @@ using MQTTnet.Tests.Server;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [RPlotExporter, RankColumn]
    [MemoryDiagnoser]
-    public class ServerProcessingBenchmark
+    public class ServerProcessingBenchmark : BaseBenchmark
    {
        [GlobalSetup]
        public void GlobalSetup()
@@ -1,3 +1,7 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Jobs;
 using MQTTnet.Client;
@@ -8,7 +12,7 @@ using System.Linq;
 namespace MQTTnet.Benchmarks
 {
    [MemoryDiagnoser]
-    public class SubscribeBenchmark
+    public class SubscribeBenchmark : BaseBenchmark
    {
        MqttServer _mqttServer;
        IMqttClient _mqttClient;
@@ -13,9 +13,9 @@ using MQTTnet.AspNetCore.Client.Tcp;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [MemoryDiagnoser]
-    public class TcpPipesBenchmark
+    public class TcpPipesBenchmark : BaseBenchmark
    {
        IDuplexPipe _client;
        IDuplexPipe _server;
@@ -8,10 +8,10 @@ using BenchmarkDotNet.Jobs;

 namespace MQTTnet.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.NetCoreApp50)]
+    [SimpleJob(RuntimeMoniker.Net60)]
    [RPlotExporter]
    [MemoryDiagnoser]
-    public class TopicFilterComparerBenchmark
+    public class TopicFilterComparerBenchmark : BaseBenchmark
    {
        static readonly char[] TopicLevelSeparator = { '/' };

@@ -1,31 +1,30 @@
 using System;
 using System.Collections.Generic;
-using System.Text;

 namespace MQTTnet.Benchmarks
 {
    public class TopicGenerator
    {
        public static void Generate(
-           int numPublishers, int numTopicsPerPublisher,
-           out Dictionary<string, List<string>> topicsByPublisher,
-           out Dictionary<string, List<string>> singleWildcardTopicsByPublisher,
-           out Dictionary<string, List<string>> multiWildcardTopicsByPublisher
-           )
+            int numPublishers,
+            int numTopicsPerPublisher,
+            out Dictionary<string, List<string>> topicsByPublisher,
+            out Dictionary<string, List<string>> singleWildcardTopicsByPublisher,
+            out Dictionary<string, List<string>> multiWildcardTopicsByPublisher)
        {
            topicsByPublisher = new Dictionary<string, List<string>>();
            singleWildcardTopicsByPublisher = new Dictionary<string, List<string>>();
            multiWildcardTopicsByPublisher = new Dictionary<string, List<string>>();

            // Find some reasonable distribution across three topic levels
-            var topicsPerLevel = (int)Math.Pow(numTopicsPerPublisher, (1.0 / 3.0));
+            var topicsPerLevel = (int)Math.Pow(numTopicsPerPublisher, 1.0 / 3.0);
            if (topicsPerLevel <= 0)
            {
                topicsPerLevel = 1;
            }

-            int numLevel1Topics = topicsPerLevel;
-            int numLevel2Topics = topicsPerLevel;
+            var numLevel1Topics = topicsPerLevel;
+            var numLevel2Topics = topicsPerLevel;

            var maxNumLevel3Topics = 1 + (int)((double)numTopicsPerPublisher / numLevel1Topics / numLevel2Topics);
            if (maxNumLevel3Topics <= 0)
@@ -35,7 +34,7 @@ namespace MQTTnet.Benchmarks

            for (var p = 0; p < numPublishers; ++p)
            {
-                int publisherTopicCount = 0;
+                var publisherTopicCount = 0;
                var publisherName = "pub" + p;
                for (var l1 = 0; l1 < numLevel1Topics; ++l1)
                {
@@ -44,19 +43,22 @@ namespace MQTTnet.Benchmarks
                        for (var l3 = 0; l3 < maxNumLevel3Topics; ++l3)
                        {
                            if (publisherTopicCount >= numTopicsPerPublisher)
+                            {
                                break;
+                            }

-                            var topic = string.Format("{0}/building{1}/level{2}/sensor{3}", publisherName, l1 + 1, l2 + 1, l3 + 1);
+                            var topic = $"{publisherName}/building{l1 + 1}/level{l2 + 1}/sensor{l3 + 1}";
                            AddPublisherTopic(publisherName, topic, topicsByPublisher);

                            if (l2 == 0)
                            {
-                                var singleWildcardTopic = string.Format("{0}/building{1}/+/sensor{2}", publisherName, l1 + 1, l3 + 1);
+                                var singleWildcardTopic = $"{publisherName}/building{l1 + 1}/+/sensor{l3 + 1}";
                                AddPublisherTopic(publisherName, singleWildcardTopic, singleWildcardTopicsByPublisher);
                            }
-                            if ((l1 == 0) && (l3 == 0))
+
+                            if (l1 == 0 && l3 == 0)
                            {
-                                var multiWildcardTopic = string.Format("{0}/+/level{1}/+", publisherName, l2 + 1);
+                                var multiWildcardTopic = $"{publisherName}/+/level{l2 + 1}/+";
                                AddPublisherTopic(publisherName, multiWildcardTopic, multiWildcardTopicsByPublisher);
                            }

@@ -75,7 +77,8 @@ namespace MQTTnet.Benchmarks
                topicList = new List<string>();
                topicsByPublisher.Add(publisherName, topicList);
            }
+
            topicList.Add(topic);
        }
    }
-}
+}
@@ -1,3 +1,7 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
 using BenchmarkDotNet.Attributes;
 using MQTTnet.Client;
 using MQTTnet.Server;
@@ -7,7 +11,7 @@ using System.Linq;
 namespace MQTTnet.Benchmarks
 {
    [MemoryDiagnoser]
-    public class UnsubscribeBenchmark
+    public class UnsubscribeBenchmark : BaseBenchmark 
    {
        MqttServer _mqttServer;
        IMqttClient _mqttClient;
@@ -1,54 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<packages>
-  <package id="BenchmarkDotNet" version="0.10.14" targetFramework="net462" />
-  <package id="BenchmarkDotNet.Core" version="0.10.14" targetFramework="net462" />
-  <package id="BenchmarkDotNet.Toolchains.Roslyn" version="0.10.14" targetFramework="net462" />
-  <package id="Microsoft.CodeAnalysis.Analyzers" version="1.1.0" targetFramework="net462" />
-  <package id="Microsoft.CodeAnalysis.Common" version="2.6.1" targetFramework="net462" />
-  <package id="Microsoft.CodeAnalysis.CSharp" version="2.6.1" targetFramework="net462" />
-  <package id="Microsoft.DotNet.InternalAbstractions" version="1.0.0" targetFramework="net462" />
-  <package id="Microsoft.DotNet.PlatformAbstractions" version="1.1.1" targetFramework="net462" />
-  <package id="Microsoft.Win32.Registry" version="4.3.0" targetFramework="net462" />
-  <package id="System.AppContext" version="4.3.0" targetFramework="net462" />
-  <package id="System.Collections" version="4.3.0" targetFramework="net462" />
-  <package id="System.Collections.Concurrent" version="4.3.0" targetFramework="net462" />
-  <package id="System.Collections.Immutable" version="1.3.1" targetFramework="net462" />
-  <package id="System.Console" version="4.3.0" targetFramework="net462" />
-  <package id="System.Diagnostics.Debug" version="4.3.0" targetFramework="net462" />
-  <package id="System.Diagnostics.FileVersionInfo" version="4.3.0" targetFramework="net462" />
-  <package id="System.Diagnostics.StackTrace" version="4.3.0" targetFramework="net462" />
-  <package id="System.Diagnostics.Tools" version="4.3.0" targetFramework="net462" />
-  <package id="System.Dynamic.Runtime" version="4.3.0" targetFramework="net462" />
-  <package id="System.Globalization" version="4.3.0" targetFramework="net462" />
-  <package id="System.IO.Compression" version="4.3.0" targetFramework="net462" />
-  <package id="System.IO.FileSystem" version="4.3.0" targetFramework="net462" />
-  <package id="System.IO.FileSystem.Primitives" version="4.3.0" targetFramework="net462" />
-  <package id="System.Linq" version="4.3.0" targetFramework="net462" />
-  <package id="System.Linq.Expressions" version="4.3.0" targetFramework="net462" />
-  <package id="System.Reflection" version="4.3.0" targetFramework="net462" />
-  <package id="System.Reflection.Metadata" version="1.4.2" targetFramework="net462" />
-  <package id="System.Resources.ResourceManager" version="4.3.0" targetFramework="net462" />
-  <package id="System.Runtime" version="4.3.0" targetFramework="net462" />
-  <package id="System.Runtime.Extensions" version="4.3.0" targetFramework="net462" />
-  <package id="System.Runtime.InteropServices" version="4.3.0" targetFramework="net462" />
-  <package id="System.Runtime.Numerics" version="4.3.0" targetFramework="net462" />
-  <package id="System.Security.Cryptography.Algorithms" version="4.3.0" targetFramework="net462" />
-  <package id="System.Security.Cryptography.Encoding" version="4.3.0" targetFramework="net462" />
-  <package id="System.Security.Cryptography.Primitives" version="4.3.0" targetFramework="net462" />
-  <package id="System.Security.Cryptography.X509Certificates" version="4.3.0" targetFramework="net462" />
-  <package id="System.Text.Encoding" version="4.3.0" targetFramework="net462" />
-  <package id="System.Text.Encoding.CodePages" version="4.3.0" targetFramework="net462" />
-  <package id="System.Text.Encoding.Extensions" version="4.3.0" targetFramework="net462" />
-  <package id="System.Threading" version="4.3.0" targetFramework="net462" />
-  <package id="System.Threading.Tasks" version="4.3.0" targetFramework="net462" />
-  <package id="System.Threading.Tasks.Extensions" version="4.3.0" targetFramework="net462" />
-  <package id="System.Threading.Tasks.Parallel" version="4.3.0" targetFramework="net462" />
-  <package id="System.Threading.Thread" version="4.3.0" targetFramework="net462" />
-  <package id="System.ValueTuple" version="4.3.0" targetFramework="net462" />
-  <package id="System.Xml.ReaderWriter" version="4.3.0" targetFramework="net462" />
-  <package id="System.Xml.XDocument" version="4.3.0" targetFramework="net462" />
-  <package id="System.Xml.XmlDocument" version="4.3.0" targetFramework="net462" />
-  <package id="System.Xml.XmlSerializer" version="4.3.0" targetFramework="net462" />
-  <package id="System.Xml.XPath" version="4.3.0" targetFramework="net462" />
-  <package id="System.Xml.XPath.XDocument" version="4.3.0" targetFramework="net462" />
-</packages>
@@ -15,13 +15,13 @@ namespace MQTTnet.Extensions.ManagedClient
        
        event Func<ApplicationMessageSkippedEventArgs, Task> ApplicationMessageSkippedAsync;
        
-        event Func<EventArgs, Task> ConnectedAsync;
+        event Func<MqttClientConnectedEventArgs, Task> ConnectedAsync;
        
        event Func<ConnectingFailedEventArgs, Task> ConnectingFailedAsync;
        
        event Func<EventArgs, Task> ConnectionStateChangedAsync;
        
-        event Func<EventArgs, Task> DisconnectedAsync;
+        event Func<MqttClientDisconnectedEventArgs, Task> DisconnectedAsync;
        
        event Func<ManagedProcessFailedEventArgs, Task> SynchronizingSubscriptionsFailedAsync;
        
@@ -43,7 +43,7 @@ namespace MQTTnet.Extensions.ManagedClient
        
        Task StartAsync(ManagedMqttClientOptions options);
        
-        Task StopAsync();
+        Task StopAsync(bool cleanDisconnect = true);
        
        Task SubscribeAsync(ICollection<MqttTopicFilter> topicFilters);
        
@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
-        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
+        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
+        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461;net48</TargetFrameworks>
        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
        
        <AssemblyName>MQTTnet.Extensions.ManagedClient</AssemblyName>
@@ -18,7 +18,7 @@
        <PublishRepositoryUrl>true</PublishRepositoryUrl>
        <IncludeSymbols>true</IncludeSymbols>
        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-        <Copyright>Christian Kratky 2016-2022</Copyright>
+        <Copyright>Copyright (c) .NET Foundation and Contributors</Copyright>
        <PackageProjectUrl>https://github.com/dotnet/MQTTnet</PackageProjectUrl>
        <RepositoryUrl>https://github.com/dotnet/MQTTnet.git</RepositoryUrl>
        <RepositoryType>git</RepositoryType>
@@ -29,11 +29,11 @@
        <PackageIcon>nuget.png</PackageIcon>
        <EmbedUntrackedSources>true</EmbedUntrackedSources>
        <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
-        <PackageLicenseFile>LICENSE</PackageLicenseFile>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
        <PackageReleaseNotes>For release notes please go to MQTTnet release notes (https://www.nuget.org/packages/MQTTnet/).</PackageReleaseNotes>
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
        <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <NoWarn>1591</NoWarn>
+        <NoWarn>1591;NETSDK1138</NoWarn>
    </PropertyGroup>

    <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
@@ -55,16 +55,9 @@
            <PackagePath>\</PackagePath>
        </None>
    </ItemGroup>
-
+    
    <ItemGroup>
-        <None Include="..\..\LICENSE">
-            <Pack>True</Pack>
-            <PackagePath>\</PackagePath>
-        </None>
-    </ItemGroup>
-
-    <ItemGroup>
-        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
    </ItemGroup>

    <ItemGroup>
@@ -51,9 +51,9 @@ namespace MQTTnet.Extensions.ManagedClient
        ///         cref="MaintainConnectionAsync" />
        ///     .
        /// </summary>
-        readonly Dictionary<string, MqttQualityOfServiceLevel> _reconnectSubscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
+        readonly Dictionary<string, MqttTopicFilter> _reconnectSubscriptions = new Dictionary<string, MqttTopicFilter>();

-        readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
+        readonly Dictionary<string, MqttTopicFilter> _subscriptions = new Dictionary<string, MqttTopicFilter>();
        readonly SemaphoreSlim _subscriptionsQueuedSignal = new SemaphoreSlim(0);
        readonly HashSet<string> _unsubscriptions = new HashSet<string>();

@@ -62,6 +62,7 @@ namespace MQTTnet.Extensions.ManagedClient
        CancellationTokenSource _publishingCancellationToken;

        ManagedMqttClientStorageManager _storageManager;
+        bool _isCleanDisconnect;

        public ManagedMqttClient(IMqttClient mqttClient, IMqttNetLogger logger)
        {
@@ -93,7 +94,7 @@ namespace MQTTnet.Extensions.ManagedClient
            remove => InternalClient.ApplicationMessageReceivedAsync -= value;
        }

-        public event Func<EventArgs, Task> ConnectedAsync
+        public event Func<MqttClientConnectedEventArgs, Task> ConnectedAsync
        {
            add => InternalClient.ConnectedAsync += value;
            remove => InternalClient.ConnectedAsync -= value;
@@ -111,7 +112,7 @@ namespace MQTTnet.Extensions.ManagedClient
            remove => _connectionStateChangedEvent.RemoveHandler(value);
        }

-        public event Func<EventArgs, Task> DisconnectedAsync
+        public event Func<MqttClientDisconnectedEventArgs, Task> DisconnectedAsync
        {
            add => InternalClient.DisconnectedAsync += value;
            remove => InternalClient.DisconnectedAsync -= value;
@@ -160,14 +161,14 @@ namespace MQTTnet.Extensions.ManagedClient
                throw new InvalidOperationException("call StartAsync before publishing messages");
            }

-            MqttTopicValidator.ThrowIfInvalid(applicationMessage.ApplicationMessage.Topic);
+            MqttTopicValidator.ThrowIfInvalid(applicationMessage.ApplicationMessage);

            ManagedMqttApplicationMessage removedMessage = null;
            ApplicationMessageSkippedEventArgs applicationMessageSkippedEventArgs = null;

            try
            {
-                using (await _messageQueueLock.WaitAsync(CancellationToken.None).ConfigureAwait(false))
+                using (await _messageQueueLock.EnterAsync().ConfigureAwait(false))
                {
                    if (_messageQueue.Count >= Options.MaxPendingMessages)
                    {
@@ -201,7 +202,7 @@ namespace MQTTnet.Extensions.ManagedClient
            }
            finally
            {
-                if (_applicationMessageSkippedEvent.HasHandlers)
+                if (applicationMessageSkippedEventArgs != null && _applicationMessageSkippedEvent.HasHandlers)
                {
                    await _applicationMessageSkippedEvent.InvokeAsync(applicationMessageSkippedEventArgs).ConfigureAwait(false);
                }
@@ -255,10 +256,12 @@ namespace MQTTnet.Extensions.ManagedClient
            _logger.Info("Started");
        }

-        public async Task StopAsync()
+        public async Task StopAsync(bool cleanDisconnect = true)
        {
            ThrowIfDisposed();

+            _isCleanDisconnect = cleanDisconnect;
+            
            StopPublishing();
            StopMaintainingConnection();

@@ -289,14 +292,14 @@ namespace MQTTnet.Extensions.ManagedClient
            {
                foreach (var topicFilter in topicFilters)
                {
-                    _subscriptions[topicFilter.Topic] = topicFilter.QualityOfServiceLevel;
+                    _subscriptions[topicFilter.Topic] = topicFilter;
                    _unsubscriptions.Remove(topicFilter.Topic);
                }
            }

            _subscriptionsQueuedSignal.Release();

-            return Task.FromResult(0);
+            return CompletedTask.Instance;
        }

        public Task UnsubscribeAsync(ICollection<string> topics)
@@ -319,7 +322,7 @@ namespace MQTTnet.Extensions.ManagedClient

            _subscriptionsQueuedSignal.Release();

-            return Task.FromResult(0);
+            return CompletedTask.Instance;
        }

        protected override void Dispose(bool disposing)
@@ -350,13 +353,13 @@ namespace MQTTnet.Extensions.ManagedClient
            return remainingTime < TimeSpan.Zero ? TimeSpan.Zero : remainingTime;
        }

-        async Task HandleSubscriptionExceptionAsync(Exception exception)
+        async Task HandleSubscriptionExceptionAsync(Exception exception, List<MqttTopicFilter> addedSubscriptions, List<string> removedSubscriptions)
        {
            _logger.Warning(exception, "Synchronizing subscriptions failed.");

            if (_synchronizingSubscriptionsFailedEvent.HasHandlers)
            {
-                await _synchronizingSubscriptionsFailedEvent.InvokeAsync(new ManagedProcessFailedEventArgs(exception)).ConfigureAwait(false);
+                await _synchronizingSubscriptionsFailedEvent.InvokeAsync(new ManagedProcessFailedEventArgs(exception, addedSubscriptions, removedSubscriptions)).ConfigureAwait(false);
            }
        }

@@ -382,9 +385,12 @@ namespace MQTTnet.Extensions.ManagedClient
                {
                    try
                    {
-                        using (var disconnectTimeout = new CancellationTokenSource(Options.ClientOptions.Timeout))
+                        if (_isCleanDisconnect)
                        {
-                            await InternalClient.DisconnectAsync(new MqttClientDisconnectOptions(), disconnectTimeout.Token).ConfigureAwait(false);
+                            using (var disconnectTimeout = new CancellationTokenSource(Options.ClientOptions.Timeout))
+                            {
+                                await InternalClient.DisconnectAsync(new MqttClientDisconnectOptions(), disconnectTimeout.Token).ConfigureAwait(false);
+                            }
                        }
                    }
                    catch (OperationCanceledException)
@@ -451,22 +457,17 @@ namespace MQTTnet.Extensions.ManagedClient
        {
            _logger.Info("Publishing subscriptions at reconnect");

+            List<MqttTopicFilter> topicFilters = null;
+
            try
            {
                if (_reconnectSubscriptions.Any())
                {
-                    var subscriptions = _reconnectSubscriptions.Select(
-                        i => new MqttTopicFilter
-                        {
-                            Topic = i.Key,
-                            QualityOfServiceLevel = i.Value
-                        });
+                    topicFilters = new List<MqttTopicFilter>();

-                    var topicFilters = new List<MqttTopicFilter>();
-
-                    foreach (var sub in subscriptions)
+                    foreach (var sub in _reconnectSubscriptions)
                    {
-                        topicFilters.Add(sub);
+                        topicFilters.Add(sub.Value);

                        if (topicFilters.Count == Options.MaxTopicFiltersInSubscribeUnsubscribePackets)
                        {
@@ -480,7 +481,7 @@ namespace MQTTnet.Extensions.ManagedClient
            }
            catch (Exception exception)
            {
-                await HandleSubscriptionExceptionAsync(exception).ConfigureAwait(false);
+                await HandleSubscriptionExceptionAsync(exception, topicFilters, null).ConfigureAwait(false);
            }
        }

@@ -495,14 +496,7 @@ namespace MQTTnet.Extensions.ManagedClient

                lock (_subscriptions)
                {
-                    subscriptions = _subscriptions.Select(
-                            i => new MqttTopicFilter
-                            {
-                                Topic = i.Key,
-                                QualityOfServiceLevel = i.Value
-                            })
-                        .ToList();
-
+                    subscriptions = _subscriptions.Values.ToList();
                    _subscriptions.Clear();

                    unsubscriptions = new HashSet<string>(_unsubscriptions);
@@ -523,7 +517,7 @@ namespace MQTTnet.Extensions.ManagedClient

                foreach (var subscription in subscriptions)
                {
-                    _reconnectSubscriptions[subscription.Topic] = subscription.QualityOfServiceLevel;
+                    _reconnectSubscriptions[subscription.Topic] = subscription;
                }

                var addedTopicFilters = new List<MqttTopicFilter>();
@@ -599,6 +593,9 @@ namespace MQTTnet.Extensions.ManagedClient
                    }

                    await InternalClient.UnsubscribeAsync(unsubscribeOptionsBuilder.Build()).ConfigureAwait(false);
+
+                    //clear because these worked, maybe the subscribe below will fail, only report those
+                    removedSubscriptions.Clear();
                }

                if (addedSubscriptions != null && addedSubscriptions.Any())
@@ -615,7 +612,7 @@ namespace MQTTnet.Extensions.ManagedClient
            }
            catch (Exception exception)
            {
-                await HandleSubscriptionExceptionAsync(exception).ConfigureAwait(false);
+                await HandleSubscriptionExceptionAsync(exception, addedSubscriptions, removedSubscriptions).ConfigureAwait(false);
            }
        }

@@ -707,7 +704,7 @@ namespace MQTTnet.Extensions.ManagedClient
            {
                await InternalClient.PublishAsync(message.ApplicationMessage).ConfigureAwait(false);

-                using (await _messageQueueLock.WaitAsync(CancellationToken.None).ConfigureAwait(false)) //lock to avoid conflict with this.PublishAsync
+                using (await _messageQueueLock.EnterAsync().ConfigureAwait(false)) //lock to avoid conflict with this.PublishAsync
                {
                    // While publishing this message, this.PublishAsync could have booted this
                    // message off the queue to make room for another (when using a cap
@@ -738,7 +735,7 @@ namespace MQTTnet.Extensions.ManagedClient
                    //contradict the expected behavior of QoS 1 and 2, that's also true
                    //for the usage of a message queue cap, so it's still consistent
                    //with prior behavior in that way.
-                    using (await _messageQueueLock.WaitAsync(CancellationToken.None).ConfigureAwait(false)) //lock to avoid conflict with this.PublishAsync
+                    using (await _messageQueueLock.EnterAsync().ConfigureAwait(false)) //lock to avoid conflict with this.PublishAsync
                    {
                        _messageQueue.RemoveFirst(i => i.Id.Equals(message.Id));

@@ -24,7 +24,7 @@ namespace MQTTnet.Extensions.ManagedClient

        /// <summary>
        /// Defines the maximum amount of topic filters which will be sent in a SUBSCRIBE/UNSUBSCRIBE packet.
-        /// Amazon AWS limits this number to 8. The default is int.MaxValue.
+        /// Amazon Web Services (AWS) limits this number to 8. The default is int.MaxValue.
        /// </summary>
        public int MaxTopicFiltersInSubscribeUnsubscribePackets { get; set; } = int.MaxValue;
    }
@@ -34,7 +34,7 @@ namespace MQTTnet.Extensions.ManagedClient
        {
            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));

-            using (await _messagesLock.WaitAsync(CancellationToken.None).ConfigureAwait(false))
+            using (await _messagesLock.EnterAsync().ConfigureAwait(false))
            {
                _messages.Add(applicationMessage);
                await SaveAsync().ConfigureAwait(false);
@@ -45,7 +45,7 @@ namespace MQTTnet.Extensions.ManagedClient
        {
            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));

-            using (await _messagesLock.WaitAsync(CancellationToken.None).ConfigureAwait(false))
+            using (await _messagesLock.EnterAsync().ConfigureAwait(false))
            {
                var index = _messages.IndexOf(applicationMessage);
                if (index == -1)
@@ -2,17 +2,33 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+using MQTTnet.Packets;
 using System;
+using System.Collections.Generic;
+using System.Linq;

 namespace MQTTnet.Extensions.ManagedClient
 {
    public class ManagedProcessFailedEventArgs : EventArgs
    {
-        public ManagedProcessFailedEventArgs(Exception exception)
+        public ManagedProcessFailedEventArgs(Exception exception, List<MqttTopicFilter> addedSubscriptions, List<string> removedSubscriptions)
        {
            Exception = exception ?? throw new ArgumentNullException(nameof(exception));
+
+            if (addedSubscriptions != null)
+            {
+                AddedSubscriptions = new List<string>(addedSubscriptions.Select(item => item.Topic));
+            }
+
+            if (removedSubscriptions != null)
+            {
+                RemovedSubscriptions = new List<string>(removedSubscriptions);
+            }
        }

        public Exception Exception { get; }
+
+        public List<string> AddedSubscriptions { get; }
+        public List<string> RemovedSubscriptions { get; }
    }
 }
@@ -12,22 +12,37 @@ namespace MQTTnet.Extensions.ManagedClient
    {
        public static IManagedMqttClient CreateManagedMqttClient(this MqttFactory factory, IMqttClient mqttClient = null)
        {
-            if (factory == null) throw new ArgumentNullException(nameof(factory));
+            if (factory == null)
+            {
+                throw new ArgumentNullException(nameof(factory));
+            }

            if (mqttClient == null)
            {
-                return new ManagedMqttClient(factory.CreateMqttClient(), factory.DefaultLogger);    
+                return new ManagedMqttClient(factory.CreateMqttClient(), factory.DefaultLogger);
            }
-            
+
            return new ManagedMqttClient(mqttClient, factory.DefaultLogger);
        }
-        
+
        public static IManagedMqttClient CreateManagedMqttClient(this MqttFactory factory, IMqttNetLogger logger)
        {
-            if (factory == null) throw new ArgumentNullException(nameof(factory));
-            if (logger == null) throw new ArgumentNullException(nameof(logger));
+            if (factory == null)
+            {
+                throw new ArgumentNullException(nameof(factory));
+            }
+
+            if (logger == null)
+            {
+                throw new ArgumentNullException(nameof(logger));
+            }

            return new ManagedMqttClient(factory.CreateMqttClient(logger), logger);
        }
+
+        public static ManagedMqttClientOptionsBuilder CreateManagedMqttClientOptionsBuilder(this MqttFactory _)
+        {
+            return new ManagedMqttClientOptionsBuilder();
+        }
    }
 }
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Protocol;
@@ -7,8 +8,8 @@ namespace MQTTnet.Extensions.Rpc
 {
    public interface IMqttRpcClient : IDisposable
    {
-        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel);
+        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string,object> parameters = null);
        
-        Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken = default);
+        Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default);
    }
 }
@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
-        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
+        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
+        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461;net48</TargetFrameworks>
        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
        
        <AssemblyName>MQTTnet.Extensions.Rpc</AssemblyName>
@@ -18,7 +18,7 @@
        <PublishRepositoryUrl>true</PublishRepositoryUrl>
        <IncludeSymbols>true</IncludeSymbols>
        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-        <Copyright>Christian Kratky 2016-2022</Copyright>
+        <Copyright>Copyright (c) .NET Foundation and Contributors</Copyright>
        <PackageProjectUrl>https://github.com/dotnet/MQTTnet</PackageProjectUrl>
        <RepositoryUrl>https://github.com/dotnet/MQTTnet.git</RepositoryUrl>
        <RepositoryType>git</RepositoryType>
@@ -29,11 +29,12 @@
        <PackageIcon>nuget.png</PackageIcon>
        <EmbedUntrackedSources>true</EmbedUntrackedSources>
        <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
-        <PackageLicenseFile>LICENSE</PackageLicenseFile>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
        <PackageReleaseNotes>For release notes please go to MQTTnet release notes (https://www.nuget.org/packages/MQTTnet/).</PackageReleaseNotes>
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
        <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <NoWarn>1591</NoWarn>
+        <NoWarn>1591;NETSDK1138</NoWarn>
+        <LangVersion>7.3</LangVersion>
    </PropertyGroup>

    <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
@@ -55,16 +56,9 @@
            <PackagePath>\</PackagePath>
        </None>
    </ItemGroup>
-
+    
    <ItemGroup>
-        <None Include="..\..\LICENSE">
-            <Pack>True</Pack>
-            <PackagePath>\</PackagePath>
-        </None>
-    </ItemGroup>
-
-    <ItemGroup>
-        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
    </ItemGroup>

    <ItemGroup>
@@ -11,10 +11,12 @@ namespace MQTTnet.Extensions.Rpc
    {
        public static IMqttRpcClient CreateMqttRpcClient(this MqttFactory factory, IMqttClient mqttClient)
        {
-            return factory.CreateMqttRpcClient(mqttClient, new MqttRpcClientOptions
-            {
-                TopicGenerationStrategy = new DefaultMqttRpcClientTopicGenerationStrategy()
-            });
+            return factory.CreateMqttRpcClient(
+                mqttClient,
+                new MqttRpcClientOptions
+                {
+                    TopicGenerationStrategy = new DefaultMqttRpcClientTopicGenerationStrategy()
+                });
        }

        public static IMqttRpcClient CreateMqttRpcClient(this MqttFactory _, IMqttClient mqttClient, MqttRpcClientOptions rpcClientOptions)
@@ -2,23 +2,27 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using MQTTnet.Client;
-using MQTTnet.Exceptions;
-using MQTTnet.Protocol;
 using System;
 using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Implementations;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
+using MQTTnet.Internal;
+using MQTTnet.Protocol;

 namespace MQTTnet.Extensions.Rpc
 {
    public sealed class MqttRpcClient : IMqttRpcClient
    {
-        readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
        readonly IMqttClient _mqttClient;
        readonly MqttRpcClientOptions _options;
-        
+
+        readonly ConcurrentDictionary<string, AsyncTaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, AsyncTaskCompletionSource<byte[]>>();
+
        public MqttRpcClient(IMqttClient mqttClient, MqttRpcClientOptions options)
        {
            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
@@ -27,13 +31,25 @@ namespace MQTTnet.Extensions.Rpc
            _mqttClient.ApplicationMessageReceivedAsync += HandleApplicationMessageReceivedAsync;
        }

-        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        public void Dispose()
+        {
+            _mqttClient.ApplicationMessageReceivedAsync -= HandleApplicationMessageReceivedAsync;
+
+            foreach (var tcs in _waitingCalls)
+            {
+                tcs.Value.TrySetCanceled();
+            }
+
+            _waitingCalls.Clear();
+        }
+
+        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string, object> parameters = null)
        {
            using (var timeoutToken = new CancellationTokenSource(timeout))
            {
                try
                {
-                    return await ExecuteAsync(methodName, payload, qualityOfServiceLevel, timeoutToken.Token).ConfigureAwait(false);
+                    return await ExecuteAsync(methodName, payload, qualityOfServiceLevel, parameters, timeoutToken.Token).ConfigureAwait(false);
                }
                catch (OperationCanceledException exception)
                {
@@ -47,17 +63,15 @@ namespace MQTTnet.Extensions.Rpc
            }
        }

-        public async Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken = default)
+        public async Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
        {
-            if (methodName == null) throw new ArgumentNullException(nameof(methodName));
-            
-            var topicNames = _options.TopicGenerationStrategy.CreateRpcTopics(new TopicGenerationContext
+            if (methodName == null)
            {
-                MethodName = methodName,
-                QualityOfServiceLevel = qualityOfServiceLevel,
-                MqttClient = _mqttClient,
-                Options = _options
-            });
+                throw new ArgumentNullException(nameof(methodName));
+            }
+
+            var context = new TopicGenerationContext(_mqttClient, _options, methodName, parameters, qualityOfServiceLevel);
+            var topicNames = _options.TopicGenerationStrategy.CreateRpcTopics(context);

            var requestTopic = topicNames.RequestTopic;
            var responseTopic = topicNames.ResponseTopic;
@@ -72,34 +86,34 @@ namespace MQTTnet.Extensions.Rpc
                throw new MqttProtocolViolationException("RPC response topic is empty.");
            }

-            var requestMessage = new MqttApplicationMessageBuilder()
-                .WithTopic(requestTopic)
-                .WithPayload(payload)
-                .WithQualityOfServiceLevel(qualityOfServiceLevel)
-                .WithResponseTopic(responseTopic)
-                .Build();
+            var requestMessageBuilder = new MqttApplicationMessageBuilder().WithTopic(requestTopic).WithPayload(payload).WithQualityOfServiceLevel(qualityOfServiceLevel);
+
+            if (_mqttClient.Options.ProtocolVersion == MqttProtocolVersion.V500)
+            {
+                requestMessageBuilder.WithResponseTopic(responseTopic);
+            }
+
+            var requestMessage = requestMessageBuilder.Build();

            try
            {
-#if NET452
-                var awaitable = new TaskCompletionSource<byte[]>();
-#else
-                var awaitable = new TaskCompletionSource<byte[]>(TaskCreationOptions.RunContinuationsAsynchronously);
-#endif
+                var awaitable = new AsyncTaskCompletionSource<byte[]>();

                if (!_waitingCalls.TryAdd(responseTopic, awaitable))
                {
                    throw new InvalidOperationException();
                }

-                var subscribeOptions = new MqttClientSubscribeOptionsBuilder()
-                    .WithTopicFilter(responseTopic, qualityOfServiceLevel)
-                    .Build();
+                var subscribeOptions = new MqttClientSubscribeOptionsBuilder().WithTopicFilter(responseTopic, qualityOfServiceLevel).Build();

                await _mqttClient.SubscribeAsync(subscribeOptions, cancellationToken).ConfigureAwait(false);
                await _mqttClient.PublishAsync(requestMessage, cancellationToken).ConfigureAwait(false);

-                using (cancellationToken.Register(() => { awaitable.TrySetCanceled(); }))
+                using (cancellationToken.Register(
+                           () =>
+                           {
+                               awaitable.TrySetCanceled();
+                           }))
                {
                    return await awaitable.Task.ConfigureAwait(false);
                }
@@ -107,8 +121,7 @@ namespace MQTTnet.Extensions.Rpc
            finally
            {
                _waitingCalls.TryRemove(responseTopic, out _);
-                
-                await _mqttClient.UnsubscribeAsync(responseTopic).ConfigureAwait(false);
+                await _mqttClient.UnsubscribeAsync(responseTopic, CancellationToken.None).ConfigureAwait(false);
            }
        }

@@ -116,31 +129,16 @@ namespace MQTTnet.Extensions.Rpc
        {
            if (!_waitingCalls.TryRemove(eventArgs.ApplicationMessage.Topic, out var awaitable))
            {
-                return PlatformAbstractionLayer.CompletedTask;
+                return CompletedTask.Instance;
            }

-#if NET452
-            Task.Run(() => awaitable.TrySetResult(eventArgs.ApplicationMessage.Payload));
-#else
-            awaitable.TrySetResult(eventArgs.ApplicationMessage.Payload);
-#endif
+            var payloadBuffer = eventArgs.ApplicationMessage.PayloadSegment.ToArray();
+            awaitable.TrySetResult(payloadBuffer);

            // Set this message to handled to that other code can avoid execution etc.
            eventArgs.IsHandled = true;

-            return PlatformAbstractionLayer.CompletedTask;
-        }
-
-        public void Dispose()
-        {
-            _mqttClient.ApplicationMessageReceivedAsync -= HandleApplicationMessageReceivedAsync;
-
-            foreach (var tcs in _waitingCalls)
-            {
-                tcs.Value.TrySetCanceled();
-            }
-
-            _waitingCalls.Clear();
+            return CompletedTask.Instance;
        }
    }
 }
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.

 using System;
+using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 using MQTTnet.Protocol;
@@ -11,13 +12,13 @@ namespace MQTTnet.Extensions.Rpc
 {
    public static class MqttRpcClientExtensions
    {
-        public static Task<byte[]> ExecuteAsync(this IMqttRpcClient client, TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        public static Task<byte[]> ExecuteAsync(this IMqttRpcClient client, TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string,object> parameters = null)
        {
            if (client == null) throw new ArgumentNullException(nameof(client));

            var buffer = Encoding.UTF8.GetBytes(payload ?? string.Empty);

-            return client.ExecuteAsync(timeout, methodName, buffer, qualityOfServiceLevel);
+            return client.ExecuteAsync(timeout, methodName, buffer, qualityOfServiceLevel, parameters);
        }
    }
 }
@@ -10,13 +10,6 @@ namespace MQTTnet.Extensions.Rpc
    {
        IMqttRpcClientTopicGenerationStrategy _topicGenerationStrategy = new DefaultMqttRpcClientTopicGenerationStrategy();

-        public MqttRpcClientOptionsBuilder WithTopicGenerationStrategy(IMqttRpcClientTopicGenerationStrategy value)
-        {
-            _topicGenerationStrategy = value ?? throw new ArgumentNullException(nameof(value));
-
-            return this;
-        }
-
        public MqttRpcClientOptions Build()
        {
            return new MqttRpcClientOptions
@@ -24,5 +17,12 @@ namespace MQTTnet.Extensions.Rpc
                TopicGenerationStrategy = _topicGenerationStrategy
            };
        }
+
+        public MqttRpcClientOptionsBuilder WithTopicGenerationStrategy(IMqttRpcClientTopicGenerationStrategy value)
+        {
+            _topicGenerationStrategy = value ?? throw new ArgumentNullException(nameof(value));
+
+            return this;
+        }
    }
-}
+}
@@ -10,6 +10,11 @@ namespace MQTTnet.Extensions.Rpc
    {
        public MqttRpcTopicPair CreateRpcTopics(TopicGenerationContext context)
        {
+            if (context == null)
+            {
+                throw new ArgumentNullException(nameof(context));
+            }
+
            if (context.MethodName.Contains("/") || context.MethodName.Contains("+") || context.MethodName.Contains("#"))
            {
                throw new ArgumentException("The method name cannot contain /, + or #.");
@@ -2,6 +2,8 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

+using System;
+using System.Collections.Generic;
 using MQTTnet.Client;
 using MQTTnet.Protocol;

@@ -9,20 +11,33 @@ namespace MQTTnet.Extensions.Rpc
 {
    public sealed class TopicGenerationContext
    {
-        public string MethodName { get; set; }
+        public TopicGenerationContext(IMqttClient mqttClient, MqttRpcClientOptions options, string methodName,
+            IDictionary<string, object> parameters, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            MethodName = methodName ?? throw new ArgumentNullException(nameof(methodName));
+            Parameters = parameters;
+            QualityOfServiceLevel = qualityOfServiceLevel;
+            MqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+            Options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public string MethodName { get; }
+
+        public IDictionary<string, object> Parameters { get; }
+
+        public IMqttClient MqttClient { get; }
+
+        public MqttRpcClientOptions Options { get; }

        /// <summary>
-        /// Gets or sets the quality of service level.
-        /// The Quality of Service (QoS) level is an agreement between the sender of a message and the receiver of a message that defines the guarantee of delivery for a specific message.
-        /// There are 3 QoS levels in MQTT:
-        /// - At most once  (0): Message gets delivered no time, once or multiple times.
-        /// - At least once (1): Message gets delivered at least once (one time or more often).
-        /// - Exactly once  (2): Message gets delivered exactly once (It's ensured that the message only comes once).
+        ///     Gets or sets the quality of service level.
+        ///     The Quality of Service (QoS) level is an agreement between the sender of a message and the receiver of a message
+        ///     that defines the guarantee of delivery for a specific message.
+        ///     There are 3 QoS levels in MQTT:
+        ///     - At most once  (0): Message gets delivered no time, once or multiple times.
+        ///     - At least once (1): Message gets delivered at least once (one time or more often).
+        ///     - Exactly once  (2): Message gets delivered exactly once (It's ensured that the message only comes once).
        /// </summary>
-        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
-
-        public IMqttClient MqttClient { get; set; }
-
-        public MqttRpcClientOptions Options { get; set; }
+        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; }
    }
-}
+}
@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
-        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
-        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
+        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
+        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461;net48</TargetFrameworks>
        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
        
        <AssemblyName>MQTTnet.Extensions.WebSocket4Net</AssemblyName>
@@ -18,7 +18,7 @@
        <PublishRepositoryUrl>true</PublishRepositoryUrl>
        <IncludeSymbols>true</IncludeSymbols>
        <SymbolPackageFormat>snupkg</SymbolPackageFormat>
-        <Copyright>Christian Kratky 2016-2022</Copyright>
+        <Copyright>Copyright (c) .NET Foundation and Contributors</Copyright>
        <PackageProjectUrl>https://github.com/dotnet/MQTTnet</PackageProjectUrl>
        <RepositoryUrl>https://github.com/dotnet/MQTTnet.git</RepositoryUrl>
        <RepositoryType>git</RepositoryType>
@@ -29,11 +29,12 @@
        <PackageIcon>nuget.png</PackageIcon>
        <EmbedUntrackedSources>true</EmbedUntrackedSources>
        <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
-        <PackageLicenseFile>LICENSE</PackageLicenseFile>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
        <PackageReleaseNotes>For release notes please go to MQTTnet release notes (https://www.nuget.org/packages/MQTTnet/).</PackageReleaseNotes>
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
        <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <NoWarn>1591</NoWarn>
+        <NoWarn>1591;NETSDK1138</NoWarn>
+        <LangVersion>7.3</LangVersion>
    </PropertyGroup>

    <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
@@ -55,24 +56,17 @@
            <PackagePath>\</PackagePath>
        </None>
    </ItemGroup>
-
+    
    <ItemGroup>
-        <None Include="..\..\LICENSE">
-            <Pack>True</Pack>
-            <PackagePath>\</PackagePath>
-        </None>
+        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.1.1" PrivateAssets="All" />
    </ItemGroup>

    <ItemGroup>
-        <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All"/>
+        <PackageReference Include="WebSocket4Net" Version="0.15.2" />
    </ItemGroup>

    <ItemGroup>
-        <PackageReference Include="WebSocket4Net" Version="0.15.2"/>
-    </ItemGroup>
-
-    <ItemGroup>
-        <ProjectReference Include="..\MQTTnet\MQTTnet.csproj"/>
+        <ProjectReference Include="..\MQTTnet\MQTTnet.csproj" />
    </ItemGroup>

 </Project>
@@ -10,9 +10,12 @@ namespace MQTTnet.Extensions.WebSocket4Net
    {
        public static MqttFactory UseWebSocket4Net(this MqttFactory mqttFactory)
        {
-            if (mqttFactory == null) throw new ArgumentNullException(nameof(mqttFactory));
+            if (mqttFactory == null)
+            {
+                throw new ArgumentNullException(nameof(mqttFactory));
+            }

            return mqttFactory.UseClientAdapterFactory(new WebSocket4NetMqttClientAdapterFactory());
        }
    }
-}
+}
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Net;
 using System.Security.Authentication;
@@ -14,16 +15,17 @@ using System.Threading.Tasks;
 using MQTTnet.Channel;
 using MQTTnet.Client;
 using MQTTnet.Exceptions;
+using MQTTnet.Internal;
 using SuperSocket.ClientEngine;
 using WebSocket4Net;
+using DataReceivedEventArgs = WebSocket4Net.DataReceivedEventArgs;

 namespace MQTTnet.Extensions.WebSocket4Net
 {
    public sealed class WebSocket4NetMqttChannel : IMqttChannel
    {
-        readonly BlockingCollection<byte> _receiveBuffer = new BlockingCollection<byte>();
-
        readonly MqttClientOptions _clientOptions;
+        readonly BlockingCollection<byte> _receiveBuffer = new BlockingCollection<byte>();
        readonly MqttClientWebSocketOptions _webSocketOptions;

        WebSocket _webSocket;
@@ -34,31 +36,33 @@ namespace MQTTnet.Extensions.WebSocket4Net
            _webSocketOptions = webSocketOptions ?? throw new ArgumentNullException(nameof(webSocketOptions));
        }

+        public X509Certificate2 ClientCertificate { get; }
+
        public string Endpoint => _webSocketOptions.Uri;

        public bool IsSecureConnection { get; private set; }

-        public X509Certificate2 ClientCertificate { get; }
-
-        public async Task ConnectAsync(CancellationToken cancellationToken)
+        public Task ConnectAsync(CancellationToken cancellationToken)
        {
            var uri = _webSocketOptions.Uri;
            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
            {
-                if (_webSocketOptions.TlsOptions?.UseTls == false)
-                {
-                    uri = "ws://" + uri;
-                }
-                else
+                if (_webSocketOptions.TlsOptions?.UseTls == true)
                {
                    uri = "wss://" + uri;
                }
+                else
+                {
+                    uri = "ws://" + uri;
+                }
            }
+            
+            IsSecureConnection = uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase);

-#if NET48 || NETCOREAPP3_1 || NET5 || NET6
-            var sslProtocols = _webSocketOptions?.TlsOptions?.SslProtocol ?? SslProtocols.Tls12 | SslProtocols.Tls13;
+#if NET48 || NETCOREAPP3_0_OR_GREATER
+            var sslProtocols = _webSocketOptions.TlsOptions?.SslProtocol ?? SslProtocols.Tls12 | SslProtocols.Tls13;
 #else
-            var sslProtocols = _webSocketOptions?.TlsOptions?.SslProtocol ?? SslProtocols.Tls12 | (SslProtocols)0x00003000 /*Tls13*/;
+            var sslProtocols = _webSocketOptions.TlsOptions?.SslProtocol ?? SslProtocols.Tls12 | (SslProtocols)0x00003000 /*Tls13*/;
 #endif

            var subProtocol = _webSocketOptions.SubProtocols.FirstOrDefault() ?? string.Empty;
@@ -88,34 +92,20 @@ namespace MQTTnet.Extensions.WebSocket4Net
            var webSocketVersion = WebSocketVersion.None;
            var receiveBufferSize = 0;

-            var certificates = new X509CertificateCollection();
-            if (_webSocketOptions?.TlsOptions?.Certificates != null)
-            {
-                foreach (var certificate in _webSocketOptions.TlsOptions.Certificates)
-                {
-#if WINDOWS_UWP
-                    certificates.Add(new X509Certificate(certificate));
-#else
-                    certificates.Add(certificate);
-#endif
-                    
-                }
-            }
+            var certificates = _webSocketOptions.TlsOptions?.ClientCertificatesProvider?.GetCertificates();

            _webSocket = new WebSocket(uri, subProtocol, cookies, customHeaders, userAgent, origin, webSocketVersion, proxy, sslProtocols, receiveBufferSize)
            {
                NoDelay = true,
                Security =
                {
-                    AllowUnstrustedCertificate = _webSocketOptions?.TlsOptions?.AllowUntrustedCertificates == true,
-                    AllowCertificateChainErrors = _webSocketOptions?.TlsOptions?.IgnoreCertificateChainErrors == true,
+                    AllowUnstrustedCertificate = _webSocketOptions.TlsOptions?.AllowUntrustedCertificates == true,
+                    AllowCertificateChainErrors = _webSocketOptions.TlsOptions?.IgnoreCertificateChainErrors == true,
                    Certificates = certificates
                }
            };

-            await ConnectInternalAsync(cancellationToken).ConfigureAwait(false);
-            
-            IsSecureConnection = uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase);
+            return ConnectInternalAsync(cancellationToken);
        }

        public Task DisconnectAsync(CancellationToken cancellationToken)
@@ -124,8 +114,21 @@ namespace MQTTnet.Extensions.WebSocket4Net
            {
                _webSocket.Close();
            }
-            
-            return Task.FromResult(0);
+
+            return CompletedTask.Instance;
+        }
+
+        public void Dispose()
+        {
+            if (_webSocket == null)
+            {
+                return;
+            }
+
+            _webSocket.DataReceived -= OnDataReceived;
+            _webSocket.Error -= OnError;
+            _webSocket.Dispose();
+            _webSocket = null;
        }

        public Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
@@ -155,36 +158,10 @@ namespace MQTTnet.Extensions.WebSocket4Net
            return Task.FromResult(readBytes);
        }

-        public Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public Task WriteAsync(ArraySegment<byte> buffer, bool isEndOfPacket, CancellationToken cancellationToken)
        {
-            _webSocket.Send(buffer, offset, count);
-            return Task.FromResult(0);
-        }
-
-        public void Dispose()
-        {
-            if (_webSocket == null)
-            {
-                return;
-            }
-
-            _webSocket.DataReceived -= OnDataReceived;
-            _webSocket.Error -= OnError;
-            _webSocket.Dispose();
-            _webSocket = null;
-        }
-
-        static void OnError(object sender, ErrorEventArgs e)
-        {
-            System.Diagnostics.Debug.Write(e.Exception.ToString());
-        }
-
-        void OnDataReceived(object sender, DataReceivedEventArgs e)
-        {
-            foreach (var @byte in e.Data)
-            {
-                _receiveBuffer.Add(@byte);
-            }
+            _webSocket.Send(buffer.Array, buffer.Offset, buffer.Count);
+            return CompletedTask.Instance;
        }

        async Task ConnectInternalAsync(CancellationToken cancellationToken)
@@ -192,44 +169,50 @@ namespace MQTTnet.Extensions.WebSocket4Net
            _webSocket.Error += OnError;
            _webSocket.DataReceived += OnDataReceived;

-            var taskCompletionSource = new TaskCompletionSource<Exception>();
+            var promise = new AsyncTaskCompletionSource<bool>();

            void ErrorHandler(object sender, ErrorEventArgs e)
            {
-                taskCompletionSource.TrySetResult(e.Exception);
+                promise.TrySetException(e.Exception);
            }

-            void SuccessHandler(object sender, EventArgs e)
+            void OpenedHandler(object sender, EventArgs e)
            {
-                taskCompletionSource.TrySetResult(null);
+                promise.TrySetResult(true);
+            }
+
+            void ClosedHandler(object sender, EventArgs e)
+            {
+                promise.TrySetException(new MqttCommunicationException("Connection closed."));
            }

            try
            {
-                _webSocket.Opened += SuccessHandler;
+                _webSocket.Opened += OpenedHandler;
+                _webSocket.Closed += ClosedHandler;
                _webSocket.Error += ErrorHandler;

-#pragma warning disable AsyncFixer02 // Long-running or blocking operations inside an async method
-                _webSocket.Open();
-#pragma warning restore AsyncFixer02 // Long-running or blocking operations inside an async method
-
-                using (var timeoutCts = new CancellationTokenSource(_clientOptions.Timeout))
-                using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken))
+                using (var timeout = new CancellationTokenSource(_clientOptions.Timeout))
+                using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(timeout.Token, cancellationToken))
                {
-                    using (linkedCts.Token.Register(() => taskCompletionSource.TrySetCanceled()))
+                    using (linkedCts.Token.Register(() => promise.TrySetCanceled()))
                    {
                        try
                        {
-                            await taskCompletionSource.Task.ConfigureAwait(false);
+                            // OpenAsync does basically the same but without support for a cancellation token.
+                            // So we do it on our own!
+                            _webSocket.Open();
+
+                            await promise.Task.ConfigureAwait(false);
                        }
                        catch (Exception exception)
                        {
-                            var timeoutReached = timeoutCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested;
+                            var timeoutReached = timeout.IsCancellationRequested && !cancellationToken.IsCancellationRequested;
                            if (timeoutReached)
                            {
                                throw new MqttCommunicationTimedOutException(exception);
                            }
-                            
+
                            if (exception is AuthenticationException authenticationException)
                            {
                                throw new MqttCommunicationException(authenticationException.InnerException);
@@ -251,9 +234,23 @@ namespace MQTTnet.Extensions.WebSocket4Net
            }
            finally
            {
-                _webSocket.Opened -= SuccessHandler;
+                _webSocket.Opened -= OpenedHandler;
+                _webSocket.Closed -= ClosedHandler;
                _webSocket.Error -= ErrorHandler;
            }
        }
+
+        void OnDataReceived(object sender, DataReceivedEventArgs e)
+        {
+            foreach (var @byte in e.Data)
+            {
+                _receiveBuffer.Add(@byte);
+            }
+        }
+
+        static void OnError(object sender, ErrorEventArgs e)
+        {
+            Debug.Write(e.Exception.ToString());
+        }
    }
-}
+}
@@ -2,12 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using MQTTnet.Adapter;
-using MQTTnet.Formatter;
-using MQTTnet.Implementations;
 using System;
+using MQTTnet.Adapter;
 using MQTTnet.Client;
 using MQTTnet.Diagnostics;
+using MQTTnet.Formatter;
+using MQTTnet.Implementations;

 namespace MQTTnet.Extensions.WebSocket4Net
 {
@@ -15,7 +15,10 @@ namespace MQTTnet.Extensions.WebSocket4Net
    {
        public IMqttChannelAdapter CreateClientAdapter(MqttClientOptions options, MqttPacketInspector packetInspector, IMqttNetLogger logger)
        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }

            switch (options.ChannelOptions)
            {
@@ -23,25 +26,29 @@ namespace MQTTnet.Extensions.WebSocket4Net
                {
                    return new MqttChannelAdapter(
                        new MqttTcpChannel(options),
-                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(4096, 65535)),
-                        packetInspector,
-                        logger);
+                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(options.WriterBufferSize, options.WriterBufferSizeMax)),
+                        logger)
+                    {
+                        PacketInspector = packetInspector
+                    };
                }

                case MqttClientWebSocketOptions webSocketOptions:
                {
                    return new MqttChannelAdapter(
                        new WebSocket4NetMqttChannel(options, webSocketOptions),
-                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(4068, 65535)), 
-                        packetInspector,
-                        logger);
+                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(options.WriterBufferSize, options.WriterBufferSizeMax)),
+                        logger)
+                    {
+                        PacketInspector = packetInspector
+                    };
                }

                default:
-                    {
-                        throw new NotSupportedException();
-                    }
+                {
+                    throw new NotSupportedException();
+                }
            }
        }
    }
-}
+}
@@ -0,0 +1,28 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Internal;
+
+namespace MQTTnet.TestApp
+{
+    public sealed class AsyncLockTest
+    {
+        public async Task Run()
+        {
+            var asyncLock = new AsyncLock();
+
+            using (var cancellationToken = new CancellationTokenSource())
+            {
+                for (var i = 0; i < 100000; i++)
+                {
+                    using (await asyncLock.EnterAsync(cancellationToken.Token).ConfigureAwait(false))
+                    {
+                    }
+                } 
+            }
+        }
+    }
+}
@@ -7,7 +7,7 @@ using System;
 using System.Text;
 using System.Threading.Tasks;
 using MQTTnet.Diagnostics;
-using MQTTnet.Implementations;
+using MQTTnet.Internal;
 using MQTTnet.Protocol;

 namespace MQTTnet.TestApp
@@ -33,14 +33,23 @@ namespace MQTTnet.TestApp

                client.ApplicationMessageReceivedAsync += e =>
                {
+                    var payloadText = string.Empty;
+                    if (e.ApplicationMessage.PayloadSegment.Count > 0)
+                    {
+                        payloadText = Encoding.UTF8.GetString(
+                            e.ApplicationMessage.PayloadSegment.Array,
+                            e.ApplicationMessage.PayloadSegment.Offset,
+                            e.ApplicationMessage.PayloadSegment.Count);
+                    }
+                    
                    Console.WriteLine("### RECEIVED APPLICATION MESSAGE ###");
                    Console.WriteLine($"+ Topic = {e.ApplicationMessage.Topic}");
-                    Console.WriteLine($"+ Payload = {Encoding.UTF8.GetString(e.ApplicationMessage.Payload)}");
+                    Console.WriteLine($"+ Payload = {payloadText}");
                    Console.WriteLine($"+ QoS = {e.ApplicationMessage.QualityOfServiceLevel}");
                    Console.WriteLine($"+ Retain = {e.ApplicationMessage.Retain}");
                    Console.WriteLine();
                    
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                client.ConnectedAsync += async e =>
@@ -1,20 +1,19 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">

    <PropertyGroup>
        <OutputType>Exe</OutputType>
        <DebugType>Full</DebugType>
-        <TargetFrameworks>net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>net5.0;net6.0;net7.0</TargetFrameworks>
        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
        <IsPackable>false</IsPackable>
        <EnableNETAnalyzers>false</EnableNETAnalyzers>
        <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
        <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
+        <NoWarn>1591;NETSDK1138</NoWarn>
    </PropertyGroup>

    <ItemGroup>
-        <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
-        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
-        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
+        <PackageReference Include="Newtonsoft.Json" Version="13.0.2" />
    </ItemGroup>

    <ItemGroup>
@@ -23,10 +22,4 @@
        <ProjectReference Include="..\..\Source\MQTTnet\MQTTnet.csproj" />
    </ItemGroup>

-    <ItemGroup>
-        <None Update="Start.bat">
-            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
-        </None>
-    </ItemGroup>
-
 </Project>
@@ -9,7 +9,7 @@ using Newtonsoft.Json;
 using System.Collections.Generic;
 using MQTTnet.Client;
 using MQTTnet.Extensions.ManagedClient;
-using MQTTnet.Implementations;
+using MQTTnet.Internal;
 using MQTTnet.Protocol;

 namespace MQTTnet.TestApp
@@ -42,7 +42,7 @@ namespace MQTTnet.TestApp
                managedClient.ApplicationMessageReceivedAsync += e =>
                {
                    Console.WriteLine(">> RECEIVED: " + e.ApplicationMessage.Topic);
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await managedClient.StartAsync(options);
@@ -85,7 +85,7 @@ namespace MQTTnet.TestApp
            public Task SaveQueuedMessagesAsync(IList<ManagedMqttApplicationMessage> messages)
            {
                File.WriteAllText(Filename, JsonConvert.SerializeObject(messages));
-                return Task.FromResult(0);
+                return CompletedTask.Instance;
            }

            public Task<IList<ManagedMqttApplicationMessage>> LoadQueuedMessagesAsync()
@@ -5,6 +5,7 @@ using System;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Linq;
+using MQTTnet.Internal;

 namespace MQTTnet.TestApp
 {
@@ -124,7 +125,7 @@ namespace MQTTnet.TestApp
            {
                _cancellationTokenSource.Cancel();
            }
-            return Implementations.PlatformAbstractionLayer.CompletedTask;
+            return CompletedTask.Instance;
        }

        public async Task Cleanup()
@@ -196,7 +196,7 @@ namespace MQTTnet.TestApp
            return new MqttApplicationMessage
            {
                Topic = "A/B/C",
-                Payload = Encoding.UTF8.GetBytes(Payload),
+                PayloadSegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes(Payload)),
                QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce
            };
        }
@@ -229,7 +229,7 @@ namespace MQTTnet.TestApp
                var message = new MqttApplicationMessage
                {
                    Topic = "A/B/C",
-                    Payload = Encoding.UTF8.GetBytes("Hello World"),
+                    PayloadSegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello World")),
                    QualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce
                };

@@ -280,7 +280,7 @@ namespace MQTTnet.TestApp
                var message = new MqttApplicationMessage
                {
                    Topic = "A/B/C",
-                    Payload = Encoding.UTF8.GetBytes("Hello World"),
+                    PayloadSegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello World")),
                    QualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce
                };

@@ -331,7 +331,7 @@ namespace MQTTnet.TestApp
                var message = new MqttApplicationMessage
                {
                    Topic = "A/B/C",
-                    Payload = Encoding.UTF8.GetBytes("Hello World"),
+                    PayloadSegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes("Hello World")),
                    QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce
                };

@@ -28,6 +28,7 @@ namespace MQTTnet.TestApp
            Console.WriteLine("c = Start QoS 0 benchmark");
            Console.WriteLine("d = Start server with logging");
            Console.WriteLine("e = Start Message Throughput Test");
+            Console.WriteLine("f = Start AsyncLock Test");

            var pressedKey = Console.ReadKey(true);
            if (pressedKey.KeyChar == '1')
@@ -88,6 +89,10 @@ namespace MQTTnet.TestApp
            {
                Task.Run(new MessageThroughputTest().Run);
            }
+            else if (pressedKey.KeyChar == 'f')
+            {
+                Task.Run(new AsyncLockTest().Run);
+            }

            Thread.Sleep(Timeout.Infinite);
        }
@@ -2,13 +2,14 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.

-using MQTTnet.Client;
 using System;
 using System.Security.Authentication;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Client;
+using MQTTnet.Extensions.WebSocket4Net;
 using MQTTnet.Formatter;
-using MQTTnet.Implementations;
+using MQTTnet.Internal;
 using MQTTnet.Protocol;

 namespace MQTTnet.TestApp
@@ -17,155 +18,192 @@ namespace MQTTnet.TestApp
    {
        public static async Task RunAsync()
        {
-            // MqttNetConsoleLogger.ForwardToConsole();
-
-            // For most of these connections to work, set output target to Net5.0.            
-
 #if NET5_0_OR_GREATER
            // TLS13 is only available in Net5.0
-            var unsafeTls13 = new MqttClientOptionsBuilderTlsParameters
+            var unsafeTls13 = new MqttClientTlsOptions
            {
                UseTls = true,
                SslProtocol = SslProtocols.Tls13,
                // Don't use this in production code. This handler simply allows any invalid certificate to work.
-                CertificateValidationHandler = w => true
+                AllowUntrustedCertificates = true,
+                IgnoreCertificateChainErrors = true,
+                CertificateValidationHandler = _ => true
            };
 #endif
-
            // Also defining TLS12 for servers that don't seem no to support TLS13.
-            var unsafeTls12 = new MqttClientOptionsBuilderTlsParameters
+            var unsafeTls12 = new MqttClientTlsOptions
            {
                UseTls = true,
                SslProtocol = SslProtocols.Tls12,
                // Don't use this in production code. This handler simply allows any invalid certificate to work.
-                CertificateValidationHandler = w => true
+                AllowUntrustedCertificates = true,
+                IgnoreCertificateChainErrors = true,
+                CertificateValidationHandler = _ => true
            };

            // mqtt.eclipseprojects.io
-            await ExecuteTestAsync("mqtt.eclipseprojects.io TCP",
-                    new MqttClientOptionsBuilder().WithTcpServer("mqtt.eclipseprojects.io", 1883)
-                        .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "mqtt.eclipseprojects.io TCP",
+                new MqttClientOptionsBuilder().WithTcpServer("mqtt.eclipseprojects.io", 1883).WithProtocolVersion(MqttProtocolVersion.V311).Build());

-            await ExecuteTestAsync("mqtt.eclipseprojects.io WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer("mqtt.eclipseprojects.io:80/mqtt")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "mqtt.eclipseprojects.io WS",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("mqtt.eclipseprojects.io:80/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());

 #if NET5_0_OR_GREATER
            await ExecuteTestAsync("mqtt.eclipseprojects.io WS TLS13",
-                new MqttClientOptionsBuilder().WithWebSocketServer("mqtt.eclipseprojects.io:443/mqtt")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls13).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("mqtt.eclipseprojects.io:443/mqtt"))
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build());
+            
+            await ExecuteTestAsync("mqtt.eclipseprojects.io WS TLS13 (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("mqtt.eclipseprojects.io:443/mqtt"))
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build(),
+                    true);
 #endif

            // test.mosquitto.org
-            await ExecuteTestAsync("test.mosquitto.org TCP",
-                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 1883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "test.mosquitto.org TCP",
+                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 1883).WithProtocolVersion(MqttProtocolVersion.V311).Build());

-            await ExecuteTestAsync("test.mosquitto.org TCP - Authenticated",
-                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 1884)
-                    .WithCredentials("rw", "readwrite")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "test.mosquitto.org TCP - Authenticated",
+                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 1884).WithCredentials("rw", "readwrite").WithProtocolVersion(MqttProtocolVersion.V311).Build());

-            await ExecuteTestAsync("test.mosquitto.org TCP TLS12",
-                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
+            await ExecuteTestAsync(
+                "test.mosquitto.org TCP TLS12",
+                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());

 #if NET5_0_OR_GREATER
            await ExecuteTestAsync("test.mosquitto.org TCP TLS13",
                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls13).Build());
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build());
 #endif

-            await ExecuteTestAsync("test.mosquitto.org TCP TLS12 - Authenticated",
+            await ExecuteTestAsync(
+                "test.mosquitto.org TCP TLS12 - Authenticated",
                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8885)
                    .WithCredentials("rw", "readwrite")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
+                    .WithProtocolVersion(MqttProtocolVersion.V311)
+                    .WithTlsOptions(unsafeTls12)
+                    .Build());

-            await ExecuteTestAsync("test.mosquitto.org WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer("test.mosquitto.org:8080/mqtt")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "test.mosquitto.org WS",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8080/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());

-            await ExecuteTestAsync("test.mosquitto.org WS TLS12",
-                new MqttClientOptionsBuilder().WithWebSocketServer("test.mosquitto.org:8081/mqtt")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
+            await ExecuteTestAsync(
+                "test.mosquitto.org WS (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8080/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                true);
+
+            await ExecuteTestAsync(
+                "test.mosquitto.org WS TLS12",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8081/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());
+
+            await ExecuteTestAsync(
+                "test.mosquitto.org WS TLS12 (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8081/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build(),
+                true);

            // broker.emqx.io
-            await ExecuteTestAsync("broker.emqx.io TCP",
-                new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 1883)
-                     .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "broker.emqx.io TCP",
+                new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 1883).WithProtocolVersion(MqttProtocolVersion.V311).Build());

-            await ExecuteTestAsync("broker.emqx.io TCP TLS12",
-                new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 8883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
+            await ExecuteTestAsync(
+                "broker.emqx.io TCP TLS12",
+                new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 8883).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());

 #if NET5_0_OR_GREATER
            await ExecuteTestAsync("broker.emqx.io TCP TLS13",
                new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 8883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls13).Build());
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build());
 #endif

-            await ExecuteTestAsync("broker.emqx.io WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer("broker.emqx.io:8083/mqtt")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "broker.emqx.io WS",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8083/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());

-            await ExecuteTestAsync("broker.emqx.io WS TLS12",
-                new MqttClientOptionsBuilder().WithWebSocketServer("broker.emqx.io:8084/mqtt")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
+            await ExecuteTestAsync(
+                "broker.emqx.io WS (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8084/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                true);

+            await ExecuteTestAsync(
+                "broker.emqx.io WS TLS12",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8084/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());
+
+            await ExecuteTestAsync(
+                "broker.emqx.io WS TLS12 (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8084/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build(),
+                true);

            // broker.hivemq.com
-            await ExecuteTestAsync("broker.hivemq.com TCP",
-                new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com", 1883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "broker.hivemq.com TCP",
+                new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com", 1883).WithProtocolVersion(MqttProtocolVersion.V311).Build());

-            await ExecuteTestAsync("broker.hivemq.com WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer("broker.hivemq.com:8000/mqtt")
-                    .WithProtocolVersion(MqttProtocolVersion.V311).Build());
+            await ExecuteTestAsync(
+                "broker.hivemq.com WS",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());
+
+            await ExecuteTestAsync(
+                "broker.hivemq.com WS (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                true);

            // mqtt.swifitch.cz: Does not seem to operate any more
-
            // cloudmqtt.com: Cannot test because it does not offer a free plan any more.

            Write("Finished.", ConsoleColor.White);
            Console.ReadLine();
        }

-        static async Task ExecuteTestAsync(string name, MqttClientOptions options)
+        static async Task ExecuteTestAsync(string name, MqttClientOptions options, bool useWebSocket4Net = false)
        {
            try
            {
                Write("Testing '" + name + "'... ", ConsoleColor.Gray);
+
                var factory = new MqttFactory();
-                //factory.UseWebSocket4Net();
-                var client = factory.CreateMqttClient();
-                var topic = Guid.NewGuid().ToString();
-
-                MqttApplicationMessage receivedMessage = null;
-                client.ApplicationMessageReceivedAsync += e =>
+                if (useWebSocket4Net)
                {
-                    receivedMessage = e.ApplicationMessage;
-                    return PlatformAbstractionLayer.CompletedTask;
-                };
-
-                await client.ConnectAsync(options);
-                await client.SubscribeAsync(topic, MqttQualityOfServiceLevel.AtLeastOnce);
-                await client.PublishStringAsync(topic, "Hello_World", MqttQualityOfServiceLevel.AtLeastOnce);
-
-                SpinWait.SpinUntil(() => receivedMessage != null, 5000);
-
-                if (receivedMessage?.Topic != topic || receivedMessage?.ConvertPayloadToString() != "Hello_World")
-                {
-                    throw new Exception("Message invalid.");
+                    factory.UseWebSocket4Net();
                }

-                await client.UnsubscribeAsync(topic);
-                await client.DisconnectAsync();
+                using (var client = factory.CreateMqttClient())
+                {
+                    MqttApplicationMessage receivedMessage = null;
+                    client.ApplicationMessageReceivedAsync += e =>
+                    {
+                        receivedMessage = e.ApplicationMessage;
+                        return CompletedTask.Instance;
+                    };
+
+                    await client.ConnectAsync(options).ConfigureAwait(false);
+
+                    var topic = Guid.NewGuid().ToString();
+                    await client.SubscribeAsync(topic, MqttQualityOfServiceLevel.AtLeastOnce).ConfigureAwait(false);
+                    await client.PublishStringAsync(topic, "Hello_World", MqttQualityOfServiceLevel.AtLeastOnce).ConfigureAwait(false);
+
+                    SpinWait.SpinUntil(() => receivedMessage != null, 5000);
+
+                    if (receivedMessage?.Topic != topic || receivedMessage?.ConvertPayloadToString() != "Hello_World")
+                    {
+                        throw new Exception("Message invalid.");
+                    }
+
+                    await client.UnsubscribeAsync(topic).ConfigureAwait(false);
+                    await client.DisconnectAsync().ConfigureAwait(false);
+                }

                Write("[OK]\n", ConsoleColor.Green);
            }
-            catch (Exception e)
+            catch (Exception exception)
            {
-                Write("[FAILED] " + e.Message + "\n", ConsoleColor.Red);
+                Write("[FAILED]" + Environment.NewLine, ConsoleColor.Red);
+                Write(exception + Environment.NewLine, ConsoleColor.Red);
            }
        }

@@ -174,6 +212,5 @@ namespace MQTTnet.TestApp
            Console.ForegroundColor = color;
            Console.Write(message);
        }
-
    }
-}
+}
@@ -4,13 +4,12 @@

 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
+using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using MQTTnet.Diagnostics;
-using MQTTnet.Extensions.ManagedClient;
-using MQTTnet.Implementations;
+using MQTTnet.Internal;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using Newtonsoft.Json;
@@ -69,13 +68,13 @@ namespace MQTTnet.TestApp
                    }

                    File.WriteAllText(Filename, JsonConvert.SerializeObject(e.StoredRetainedMessages));
-                    return Task.FromResult(0);
+                    return CompletedTask.Instance;
                };
                
                mqttServer.RetainedMessagesClearedAsync += e =>
                {
                    File.Delete(Filename);
-                    return Task.FromResult(0);
+                    return CompletedTask.Instance;
                };
                
                mqttServer.LoadingRetainedMessageAsync += e =>
@@ -93,7 +92,7 @@ namespace MQTTnet.TestApp

                    e.LoadedRetainedMessages = retainedMessages;

-                    return Task.FromResult(0);
+                    return CompletedTask.Instance;
                };

                mqttServer.InterceptingPublishAsync += e =>
@@ -102,7 +101,7 @@ namespace MQTTnet.TestApp
                    {
                        // Replace the payload with the timestamp. But also extending a JSON 
                        // based payload with the timestamp is a suitable use case.
-                        e.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(DateTime.Now.ToString("O"));
+                        e.ApplicationMessage.PayloadSegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes(DateTime.Now.ToString("O")));
                    }

                    if (e.ApplicationMessage.Topic == "not_allowed_topic")
@@ -111,20 +110,20 @@ namespace MQTTnet.TestApp
                        e.CloseConnection = true;
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };
                
                mqttServer.ValidatingConnectionAsync += e =>
                {
                    if (e.ClientId == "SpecialClient")
                    {
-                        if (e.Username != "USER" || e.Password != "PASS")
+                        if (e.UserName != "USER" || e.Password != "PASS")
                        {
                            e.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
                        }
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                mqttServer.InterceptingSubscriptionAsync += e =>
@@ -140,16 +139,22 @@ namespace MQTTnet.TestApp
                        e.CloseConnection = true;
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };
                
                mqttServer.InterceptingPublishAsync += e =>
                {
-                    MqttNetConsoleLogger.PrintToConsole(
-                        $"'{e.ClientId}' reported '{e.ApplicationMessage.Topic}' > '{Encoding.UTF8.GetString(e.ApplicationMessage.Payload ?? new byte[0])}'",
-                        ConsoleColor.Magenta);
+                    var payloadText = string.Empty;
+                    if (e.ApplicationMessage.PayloadSegment.Count > 0)
+                    {
+                        payloadText = Encoding.UTF8.GetString(
+                            e.ApplicationMessage.PayloadSegment.Array,
+                            e.ApplicationMessage.PayloadSegment.Offset,
+                            e.ApplicationMessage.PayloadSegment.Count);
+                    }
                    
-                    return PlatformAbstractionLayer.CompletedTask;
+                    MqttNetConsoleLogger.PrintToConsole($"'{e.ClientId}' reported '{e.ApplicationMessage.Topic}' > '{payloadText}'", ConsoleColor.Magenta);
+                    return CompletedTask.Instance;
                };

                //options.ApplicationMessageInterceptor = c =>
@@ -177,7 +182,7 @@ namespace MQTTnet.TestApp
                mqttServer.ClientConnectedAsync += e =>
                {
                    Console.Write("Client disconnected event fired.");
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await mqttServer.StartAsync();
@@ -1 +0,0 @@
-dotnet MQTTnet.TestApp.NetCore.dll
@@ -13,8 +13,9 @@ using MQTTnet.Exceptions;
 using MQTTnet.LowLevelClient;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
+using MQTTnet.Server;

-namespace MQTTnet.Tests.Client
+namespace MQTTnet.Tests.Clients.LowLevelMqttClient
 {
    [TestClass]
    public sealed class LowLevelMqttClient_Tests : BaseTestClass
@@ -64,7 +65,7 @@ namespace MQTTnet.Tests.Client

            await client.ConnectAsync(options, CancellationToken.None).ConfigureAwait(false);
        }
-        
+
        [TestMethod]
        [ExpectedException(typeof(MqttCommunicationException))]
        public async Task Connect_To_Wrong_Host()
@@ -80,6 +81,8 @@ namespace MQTTnet.Tests.Client
        {
            using (var testEnvironment = CreateTestEnvironment())
            {
+                testEnvironment.IgnoreServerLogErrors = true;
+
                testEnvironment.ServerPort = 8364;
                var server = await testEnvironment.StartServer();

@@ -116,6 +119,8 @@ namespace MQTTnet.Tests.Client
        {
            using (var testEnvironment = CreateTestEnvironment())
            {
+                testEnvironment.IgnoreServerLogErrors = true;
+
                var server = await testEnvironment.StartServer();

                using (var lowLevelClient = testEnvironment.CreateLowLevelClient())
@@ -123,7 +128,7 @@ namespace MQTTnet.Tests.Client
                    Assert.IsFalse(lowLevelClient.IsConnected);

                    var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort).WithTimeout(TimeSpan.FromSeconds(1)).Build();
-                    
+
                    await lowLevelClient.ConnectAsync(clientOptions, CancellationToken.None);

                    Assert.IsTrue(lowLevelClient.IsConnected);
@@ -148,7 +153,7 @@ namespace MQTTnet.Tests.Client
                    catch
                    {
                    }
-           
+
                    Assert.IsFalse(lowLevelClient.IsConnected);
                }
            }
@@ -11,14 +11,13 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Diagnostics;
 using MQTTnet.Extensions.ManagedClient;
-using MQTTnet.Implementations;
+using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
-using MqttClient = MQTTnet.Client.MqttClient;

-namespace MQTTnet.Tests.Client
+namespace MQTTnet.Tests.Clients.ManagedMqttClient
 {
    [TestClass]
    public sealed class ManagedMqttClient_Tests : BaseTestClass
@@ -35,11 +34,10 @@ namespace MQTTnet.Tests.Client
                var managedClient = testEnvironment.Factory.CreateManagedMqttClient(mqttClient);

                ConnectingFailedEventArgs connectingFailedEventArgs = null;
-
                managedClient.ConnectingFailedAsync += args =>
                {
                    connectingFailedEventArgs = args;
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await managedClient.StartAsync(
@@ -90,6 +88,38 @@ namespace MQTTnet.Tests.Client
            }
        }

+        [TestMethod]
+        public async Task Expose_Custom_Connection_Error()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                var server = await testEnvironment.StartServer();
+
+                server.ValidatingConnectionAsync += args =>
+                {
+                    args.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
+                    return CompletedTask.Instance;
+                };
+
+                var managedClient = testEnvironment.Factory.CreateManagedMqttClient();
+
+                MqttClientDisconnectedEventArgs disconnectedArgs = null;
+                managedClient.DisconnectedAsync += args =>
+                {
+                    disconnectedArgs = args;
+                    return CompletedTask.Instance;
+                };
+
+                var clientOptions = testEnvironment.Factory.CreateManagedMqttClientOptionsBuilder().WithClientOptions(testEnvironment.CreateDefaultClientOptions()).Build();
+                await managedClient.StartAsync(clientOptions);
+
+                await LongTestDelay();
+
+                Assert.IsNotNull(disconnectedArgs);
+                Assert.AreEqual(MqttClientConnectResultCode.BadUserNameOrPassword, disconnectedArgs.ConnectResult.ResultCode);
+            }
+        }
+
        [TestMethod]
        public async Task ManagedClients_Will_Message_Send()
        {
@@ -105,7 +135,7 @@ namespace MQTTnet.Tests.Client
                    .Build();

                var dyingClient = testEnvironment.CreateClient();
-                var dyingManagedClient = new ManagedMqttClient(dyingClient, testEnvironment.ClientLogger);
+                var dyingManagedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(dyingClient, testEnvironment.ClientLogger);

                await dyingManagedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).Build());

@@ -117,7 +147,7 @@ namespace MQTTnet.Tests.Client
                receivingClient.ApplicationMessageReceivedAsync += e =>
                {
                    Interlocked.Increment(ref receivedMessagesCount);
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await receivingClient.SubscribeAsync("My/last/will");
@@ -133,6 +163,67 @@ namespace MQTTnet.Tests.Client
            }
        }

+        [TestMethod]
+        public async Task Receive_While_Not_Cleanly_Disconnected()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer(o => o.WithPersistentSessions());
+
+                var senderClient = await testEnvironment.ConnectClient();
+
+                // Prepare managed client.
+                var managedClient = testEnvironment.Factory.CreateManagedMqttClient();
+                await managedClient.SubscribeAsync("#");
+                var receivedMessages = testEnvironment.CreateApplicationMessageHandler(managedClient);
+
+                var managedClientOptions = new ManagedMqttClientOptions
+                {
+                    ClientOptions = testEnvironment.Factory.CreateClientOptionsBuilder()
+                        .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
+                        .WithClientId(nameof(Receive_While_Not_Cleanly_Disconnected) + "_managed")
+                        .WithCleanSession(false)
+                        .Build()
+                };
+
+                await managedClient.StartAsync(managedClientOptions);
+                await LongTestDelay();
+                await LongTestDelay();
+
+                // Send test data.
+                await senderClient.PublishStringAsync("topic1");
+                await LongTestDelay();
+                await LongTestDelay();
+
+                receivedMessages.AssertReceivedCountEquals(1);
+
+                // Stop the managed client but keep session at server (not clean disconnect required).
+                await managedClient.StopAsync(false);
+                await LongTestDelay();
+
+                // Send new messages in the meantime.
+                await senderClient.PublishStringAsync("topic2", qualityOfServiceLevel: MqttQualityOfServiceLevel.ExactlyOnce);
+                await LongTestDelay();
+
+                // Start the managed client, it should receive the new message.
+                await managedClient.StartAsync(managedClientOptions);
+                await LongTestDelay();
+
+                receivedMessages.AssertReceivedCountEquals(2);
+
+                // Stop and start again, no new message should be received.
+                for (var i = 0; i < 3; i++)
+                {
+                    await managedClient.StopAsync(false);
+                    await LongTestDelay();
+                    await managedClient.StartAsync(managedClientOptions);
+                    await LongTestDelay();
+                }
+
+                receivedMessages.AssertReceivedCountEquals(2);
+            }
+        }
+
        [TestMethod]
        public async Task Start_Stop()
        {
@@ -140,7 +231,7 @@ namespace MQTTnet.Tests.Client
            {
                var server = await testEnvironment.StartServer();

-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
+                var managedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
                var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort);

                var connected = GetConnectedTask(managedClient);
@@ -167,7 +258,7 @@ namespace MQTTnet.Tests.Client

                await testEnvironment.StartServer();

-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
+                var managedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
                var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort);
                var storage = new ManagedMqttClientTestStorage();

@@ -272,16 +363,10 @@ namespace MQTTnet.Tests.Client
                await testEnvironment.StartServer().ConfigureAwait(false);

                var sendingClient = await testEnvironment.ConnectClient().ConfigureAwait(false);
-                await sendingClient.PublishAsync(
-                    new MqttApplicationMessage
-                    {
-                        Topic = "topic",
-                        Payload = new byte[] { 1 },
-                        Retain = true
-                    });
+                await sendingClient.PublishStringAsync("topic", "A", retain: true);

                // Wait a bit for the retained message to be available
-                await Task.Delay(1000);
+                await LongTestDelay();

                await sendingClient.DisconnectAsync();

@@ -290,28 +375,26 @@ namespace MQTTnet.Tests.Client
                var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort);

                var receivedManagedMessages = new List<MqttApplicationMessage>();
-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
+
+                var managedClient = testEnvironment.Factory.CreateManagedMqttClient(testEnvironment.CreateClient());
                managedClient.ApplicationMessageReceivedAsync += e =>
                {
                    receivedManagedMessages.Add(e.ApplicationMessage);
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await managedClient.SubscribeAsync("topic");

-                await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).WithAutoReconnectDelay(TimeSpan.FromSeconds(1)).Build());
-
-                await Task.Delay(1000);
+                await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).WithAutoReconnectDelay(TimeSpan.FromSeconds(0.5)).Build());
+                await LongTestDelay();

                Assert.AreEqual(1, receivedManagedMessages.Count);

                await managedClient.StopAsync();
+                await LongTestDelay();

-                await Task.Delay(500);
-
-                await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).WithAutoReconnectDelay(TimeSpan.FromSeconds(1)).Build());
-
-                await Task.Delay(1000);
+                await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).WithAutoReconnectDelay(TimeSpan.FromSeconds(0.5)).Build());
+                await LongTestDelay();

                // After reconnect and then some delay, the retained message must not be received,
                // showing that the subscriptions were cleared
@@ -319,7 +402,8 @@ namespace MQTTnet.Tests.Client

                // Make sure that it gets received after subscribing again.
                await managedClient.SubscribeAsync("topic");
-                await Task.Delay(500);
+                await LongTestDelay();
+
                Assert.AreEqual(2, receivedManagedMessages.Count);
            }
        }
@@ -337,7 +421,7 @@ namespace MQTTnet.Tests.Client
                var receivingClient = await CreateManagedClientAsync(testEnvironment, null, connectionCheckInterval);
                var sendingClient = await testEnvironment.ConnectClient();

-                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", Payload = new byte[] { 1 }, Retain = true });
+                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", PayloadSegment = new ArraySegment<byte>(new byte[] { 1 }), Retain = true });

                var subscribeTime = DateTime.UtcNow;

@@ -370,7 +454,7 @@ namespace MQTTnet.Tests.Client
                //wait a bit for the subscription to become established
                await Task.Delay(500);

-                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", Payload = new byte[] { 1 }, Retain = true });
+                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", PayloadSegment = new ArraySegment<byte>(new byte[] { 1 }), Retain = true });

                var messages = await SetupReceivingOfMessages(managedClient, 1);

@@ -387,7 +471,7 @@ namespace MQTTnet.Tests.Client
            }
        }

-        async Task<ManagedMqttClient> CreateManagedClientAsync(
+        async Task<MQTTnet.Extensions.ManagedClient.ManagedMqttClient> CreateManagedClientAsync(
            TestEnvironment testEnvironment,
            IMqttClient underlyingClient = null,
            TimeSpan? connectionCheckInterval = null,
@@ -404,7 +488,7 @@ namespace MQTTnet.Tests.Client
            // at connection check intervals
            managedOptions.ConnectionCheckInterval = connectionCheckInterval ?? TimeSpan.FromSeconds(0.1);

-            var managedClient = new ManagedMqttClient(underlyingClient ?? testEnvironment.CreateClient(), new MqttNetEventLogger());
+            var managedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(underlyingClient ?? testEnvironment.CreateClient(), new MqttNetEventLogger());

            var connected = GetConnectedTask(managedClient);

@@ -421,14 +505,14 @@ namespace MQTTnet.Tests.Client
        ///         name="managedClient" />
        ///     has connected
        /// </summary>
-        Task GetConnectedTask(ManagedMqttClient managedClient)
+        Task GetConnectedTask(MQTTnet.Extensions.ManagedClient.ManagedMqttClient managedClient)
        {
            var connected = new TaskCompletionSource<bool>();

            managedClient.ConnectedAsync += e =>
            {
                connected.TrySetResult(true);
-                return PlatformAbstractionLayer.CompletedTask;
+                return CompletedTask.Instance;
            };

            return connected.Task;
@@ -443,7 +527,7 @@ namespace MQTTnet.Tests.Client
        ///         name="expectedNumberOfMessages" />
        ///     have been received
        /// </summary>
-        Task<List<MqttApplicationMessage>> SetupReceivingOfMessages(ManagedMqttClient managedClient, int expectedNumberOfMessages)
+        Task<List<MqttApplicationMessage>> SetupReceivingOfMessages(MQTTnet.Extensions.ManagedClient.ManagedMqttClient managedClient, int expectedNumberOfMessages)
        {
            var receivedMessages = new List<MqttApplicationMessage>();
            var result = new AsyncTaskCompletionSource<List<MqttApplicationMessage>>();
@@ -457,7 +541,7 @@ namespace MQTTnet.Tests.Client
                    result.TrySetResult(receivedMessages);
                }

-                return PlatformAbstractionLayer.CompletedTask;
+                return CompletedTask.Instance;
            };

            return result.Task;
@@ -486,7 +570,7 @@ namespace MQTTnet.Tests.Client
        public Task SaveQueuedMessagesAsync(IList<ManagedMqttApplicationMessage> messages)
        {
            _messages = messages;
-            return Task.FromResult(0);
+            return CompletedTask.Instance;
        }
    }
 }
@@ -0,0 +1,254 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+using MQTTnet.Protocol;
+using MQTTnet.Server;
+
+namespace MQTTnet.Tests.Clients.MqttClient
+{
+    [TestClass]
+    public sealed class MqttClient_Connection_Tests : BaseTestClass
+    {
+        [TestMethod]
+        [ExpectedException(typeof(MqttCommunicationException))]
+        public async Task Connect_To_Invalid_Server_Port_Not_Opened()
+        {
+            var client = new MqttFactory().CreateMqttClient();
+            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5)))
+            {
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", 12345).Build(), timeout.Token);
+            }
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(OperationCanceledException))]
+        public async Task Connect_To_Invalid_Server_Wrong_IP()
+        {
+            var client = new MqttFactory().CreateMqttClient();
+            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(2)))
+            {
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build(), timeout.Token);
+            }
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(MqttCommunicationException))]
+        public async Task Connect_To_Invalid_Server_Wrong_Protocol()
+        {
+            var client = new MqttFactory().CreateMqttClient();
+            await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("http://127.0.0.1", 12345).WithTimeout(TimeSpan.FromSeconds(2)).Build());
+        }
+
+        [TestMethod]
+        public async Task ConnectTimeout_Throws_Exception()
+        {
+            var factory = new MqttFactory();
+            using (var client = factory.CreateMqttClient())
+            {
+                var disconnectHandlerCalled = false;
+                try
+                {
+                    client.DisconnectedAsync += args =>
+                    {
+                        disconnectHandlerCalled = true;
+                        return CompletedTask.Instance;
+                    };
+
+                    await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build());
+
+                    Assert.Fail("Must fail!");
+                }
+                catch (Exception exception)
+                {
+                    Assert.IsNotNull(exception);
+                    Assert.IsInstanceOfType(exception, typeof(MqttCommunicationException));
+                }
+
+                await LongTestDelay(); // disconnected handler is called async
+                Assert.IsTrue(disconnectHandlerCalled);
+            }
+        }
+
+        [TestMethod]
+        public async Task Disconnect_Clean()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                var server = await testEnvironment.StartServer();
+
+                ClientDisconnectedEventArgs eventArgs = null;
+                server.ClientDisconnectedAsync += args =>
+                {
+                    eventArgs = args;
+                    return CompletedTask.Instance;
+                };
+
+                var client = await testEnvironment.ConnectClient();
+
+                var disconnectOptions = testEnvironment.Factory.CreateClientDisconnectOptionsBuilder().WithReason(MqttClientDisconnectOptionsReason.MessageRateTooHigh).Build();
+
+                // Perform a clean disconnect.
+                await client.DisconnectAsync(disconnectOptions);
+
+                await LongTestDelay();
+
+                Assert.IsNotNull(eventArgs);
+                Assert.AreEqual(MqttClientDisconnectType.Clean, eventArgs.DisconnectType);
+            }
+        }
+
+        [TestMethod]
+        public async Task Disconnect_Clean_With_Custom_Reason()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                var server = await testEnvironment.StartServer();
+
+                ClientDisconnectedEventArgs eventArgs = null;
+                server.ClientDisconnectedAsync += args =>
+                {
+                    eventArgs = args;
+                    return CompletedTask.Instance;
+                };
+
+                var client = await testEnvironment.ConnectClient();
+
+                var disconnectOptions = testEnvironment.Factory.CreateClientDisconnectOptionsBuilder().WithReason(MqttClientDisconnectOptionsReason.MessageRateTooHigh).Build();
+
+                // Perform a clean disconnect.
+                await client.DisconnectAsync(disconnectOptions);
+
+                await LongTestDelay();
+
+                Assert.IsNotNull(eventArgs);
+                Assert.AreEqual(MqttDisconnectReasonCode.MessageRateTooHigh, eventArgs.ReasonCode);
+            }
+        }
+
+        [TestMethod]
+        public async Task Disconnect_Clean_With_User_Properties()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                var server = await testEnvironment.StartServer();
+
+                ClientDisconnectedEventArgs eventArgs = null;
+                server.ClientDisconnectedAsync += args =>
+                {
+                    eventArgs = args;
+                    return CompletedTask.Instance;
+                };
+
+                var client = await testEnvironment.ConnectClient();
+
+                var disconnectOptions = testEnvironment.Factory.CreateClientDisconnectOptionsBuilder().WithUserProperty("test_name", "test_value").Build();
+
+                // Perform a clean disconnect.
+                await client.DisconnectAsync(disconnectOptions);
+
+                await LongTestDelay();
+
+                Assert.IsNotNull(eventArgs);
+                Assert.IsNotNull(eventArgs.UserProperties);
+                Assert.AreEqual(1, eventArgs.UserProperties.Count);
+                Assert.AreEqual("test_name", eventArgs.UserProperties[0].Name);
+                Assert.AreEqual("test_value", eventArgs.UserProperties[0].Value);
+            }
+        }
+
+        [TestMethod]
+        public async Task No_Unobserved_Exception()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                testEnvironment.IgnoreClientLogErrors = true;
+
+                var client = testEnvironment.CreateClient();
+                var options = new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithTimeout(TimeSpan.FromSeconds(2)).Build();
+
+                try
+                {
+                    using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(0.5)))
+                    {
+                        await client.ConnectAsync(options, timeout.Token);
+                    }
+                }
+                catch (OperationCanceledException)
+                {
+                }
+
+                client.Dispose();
+
+                // These delays and GC calls are required in order to make calling the finalizer reproducible.
+                GC.Collect();
+                GC.WaitForPendingFinalizers();
+                await LongTestDelay();
+                await LongTestDelay();
+                await LongTestDelay();
+            }
+        }
+
+        [TestMethod]
+        public async Task Return_Non_Success()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                var server = await testEnvironment.StartServer();
+
+                server.ValidatingConnectionAsync += args =>
+                {
+                    args.ResponseUserProperties = new List<MqttUserProperty>
+                    {
+                        new MqttUserProperty("Property", "Value")
+                    };
+
+                    args.ReasonCode = MqttConnectReasonCode.QuotaExceeded;
+
+                    return CompletedTask.Instance;
+                };
+
+                var client = testEnvironment.CreateClient();
+
+                var response = await client.ConnectAsync(testEnvironment.CreateDefaultClientOptionsBuilder().WithoutThrowOnNonSuccessfulConnectResponse().Build());
+
+                Assert.IsNotNull(response);
+                Assert.AreEqual(MqttClientConnectResultCode.QuotaExceeded, response.ResultCode);
+                Assert.AreEqual(response.UserProperties[0].Name, "Property");
+                Assert.AreEqual(response.UserProperties[0].Value, "Value");
+            }
+        }
+
+        [TestMethod]
+        public async Task Throw_Proper_Exception_When_Not_Connected()
+        {
+            try
+            {
+                var mqttFactory = new MqttFactory();
+                using (var mqttClient = mqttFactory.CreateMqttClient())
+                {
+                    await mqttClient.SubscribeAsync("test", MqttQualityOfServiceLevel.AtLeastOnce);
+                }
+            }
+            catch (MqttCommunicationException exception)
+            {
+                if (exception.Message == "The client is not connected.")
+                {
+                    return;
+                }
+            }
+
+            Assert.Fail();
+        }
+    }
+}
@@ -14,15 +14,18 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
-using MQTTnet.Implementations;
+using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
+using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;

-namespace MQTTnet.Tests.Client
+// ReSharper disable InconsistentNaming
+
+namespace MQTTnet.Tests.Clients.MqttClient
 {
    [TestClass]
-    public sealed class Client_Tests : BaseTestClass
+    public sealed class MqttClient_Tests : BaseTestClass
    {
        [DataTestMethod]
        [DataRow(MqttQualityOfServiceLevel.ExactlyOnce)]
@@ -56,7 +59,7 @@ namespace MQTTnet.Tests.Client
                    }

                    _ = InvokeInternal();
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                var publishes = Task.WhenAll(publisher.PublishStringAsync("a", null, qos), publisher.PublishStringAsync("b", null, qos));
@@ -69,60 +72,34 @@ namespace MQTTnet.Tests.Client
        }

        [TestMethod]
-        [ExpectedException(typeof(MqttCommunicationException))]
-        public async Task Connect_To_Invalid_Server_Port_Not_Opened()
+        public async Task Connect_Disconnect_Connect()
        {
-            var client = new MqttFactory().CreateMqttClient();
-            await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", 12345).WithTimeout(TimeSpan.FromSeconds(5)).Build());
-        }
-
-        [TestMethod]
-        [ExpectedException(typeof(OperationCanceledException))]
-        public async Task Connect_To_Invalid_Server_Wrong_IP()
-        {
-            var client = new MqttFactory().CreateMqttClient();
-            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(2)))
+            using (var testEnvironment = CreateTestEnvironment())
            {
-                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build(), timeout.Token);
+                await testEnvironment.StartServer();
+
+                var clientOptions = testEnvironment.CreateDefaultClientOptions();
+                var client = testEnvironment.CreateClient();
+
+                await client.ConnectAsync(clientOptions);
+                await client.DisconnectAsync();
+                await client.ConnectAsync(clientOptions);
            }
        }
-
+        
        [TestMethod]
-        [ExpectedException(typeof(MqttCommunicationException))]
-        public async Task Connect_To_Invalid_Server_Wrong_Protocol()
+        [ExpectedException(typeof(InvalidOperationException))]
+        public async Task Connect_Multiple_Times_Should_Fail()
        {
-            var client = new MqttFactory().CreateMqttClient();
-            await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("http://127.0.0.1", 12345).WithTimeout(TimeSpan.FromSeconds(2)).Build());
-        }
-
-        [TestMethod]
-        public async Task ConnectTimeout_Throws_Exception()
-        {
-            var factory = new MqttFactory();
-            using (var client = factory.CreateMqttClient())
+            using (var testEnvironment = CreateTestEnvironment())
            {
-                var disconnectHandlerCalled = false;
-                try
-                {
-                    client.DisconnectedAsync += args =>
-                    {
-                        disconnectHandlerCalled = true;
-                        return PlatformAbstractionLayer.CompletedTask;
-                    };
+                await testEnvironment.StartServer();

-                    await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build());
+                var clientOptions = testEnvironment.CreateDefaultClientOptions();
+                var client = testEnvironment.CreateClient();

-                    Assert.Fail("Must fail!");
-                }
-                catch (Exception exception)
-                {
-                    Assert.IsNotNull(exception);
-                    Assert.IsInstanceOfType(exception, typeof(MqttCommunicationException));
-                    //Assert.IsInstanceOfType(exception.InnerException, typeof(SocketException));
-                }
-
-                await Task.Delay(100); // disconnected handler is called async
-                Assert.IsTrue(disconnectHandlerCalled);
+                await client.ConnectAsync(clientOptions);
+                await client.ConnectAsync(clientOptions);
            }
        }

@@ -136,7 +113,7 @@ namespace MQTTnet.Tests.Client
                client.DisconnectedAsync += e =>
                {
                    ex = e.Exception;
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                try
@@ -145,6 +122,7 @@ namespace MQTTnet.Tests.Client
                }
                catch
                {
+                    // Ignore errors.
                }

                await Task.Delay(500);
@@ -167,7 +145,7 @@ namespace MQTTnet.Tests.Client
                server.InterceptingPublishAsync += c =>
                {
                    i++;
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await client.SendAsync(
@@ -208,7 +186,7 @@ namespace MQTTnet.Tests.Client
                client.DisconnectedAsync += e =>
                {
                    handlerFired = true;
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await server.StopAsync();
@@ -239,10 +217,10 @@ namespace MQTTnet.Tests.Client

                for (var i = 0; i < 98; i++)
                {
-                    Assert.IsFalse(clients[i].IsConnected, $"clients[{i}] is not connected");
+                    Assert.IsFalse(clients[i].TryPingAsync().GetAwaiter().GetResult(), $"clients[{i}] is not connected");
                }

-                Assert.IsTrue(clients[99].IsConnected);
+                Assert.IsTrue(clients[99].TryPingAsync().GetAwaiter().GetResult());

                Assert.AreEqual(1, clientStatus.Count);
                Assert.AreEqual(1, sessionStatus.Count);
@@ -252,7 +230,7 @@ namespace MQTTnet.Tests.Client
                receiveClient.ApplicationMessageReceivedAsync += e =>
                {
                    receivedPayload = e.ApplicationMessage.ConvertPayloadToString();
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await receiveClient.SubscribeAsync("x");
@@ -310,7 +288,7 @@ namespace MQTTnet.Tests.Client
                receiver.ApplicationMessageReceivedAsync += e =>
                {
                    receivedMessage = e.ApplicationMessage;
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await sender.PublishAsync(message.Build(), CancellationToken.None);
@@ -319,7 +297,7 @@ namespace MQTTnet.Tests.Client

                Assert.IsNotNull(receivedMessage);
                Assert.AreEqual("A", receivedMessage.Topic);
-                Assert.AreEqual(null, receivedMessage.Payload);
+                Assert.AreEqual(null, receivedMessage.PayloadSegment.Array);
            }
        }

@@ -332,7 +310,7 @@ namespace MQTTnet.Tests.Client

                var client = await testEnvironment.ConnectClient();

-                Assert.IsTrue(client.IsConnected);
+                Assert.IsTrue(client.TryPingAsync().GetAwaiter().GetResult());
            }
        }

@@ -343,11 +321,11 @@ namespace MQTTnet.Tests.Client
            {
                await testEnvironment.StartServer();
                var client = await testEnvironment.ConnectClient();
-                Assert.IsTrue(client.IsConnected);
+                Assert.IsTrue(client.TryPingAsync().GetAwaiter().GetResult());

                await client.DisconnectAsync();

-                Assert.IsFalse(client.IsConnected);
+                Assert.IsFalse(client.TryPingAsync().GetAwaiter().GetResult());
            }
        }

@@ -453,7 +431,7 @@ namespace MQTTnet.Tests.Client
                        receivedValues.Add(value);
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                }

                client1.ApplicationMessageReceivedAsync += Handler1;
@@ -530,8 +508,8 @@ namespace MQTTnet.Tests.Client

                client2.ApplicationMessageReceivedAsync += e =>
                {
-                    client2TopicResults.Add(Encoding.UTF8.GetString(e.ApplicationMessage.Payload));
-                    return PlatformAbstractionLayer.CompletedTask;
+                    client2TopicResults.Add(Encoding.UTF8.GetString(e.ApplicationMessage.PayloadSegment.ToArray()));
+                    return CompletedTask.Instance;
                };

                await client2.SubscribeAsync(client2Topic);
@@ -566,7 +544,7 @@ namespace MQTTnet.Tests.Client
                        receivedMessages.Add(e.ApplicationMessage);
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await client1.SubscribeAsync("a");
@@ -591,17 +569,17 @@ namespace MQTTnet.Tests.Client
                var client = await testEnvironment.ConnectClient();

                await Task.Delay(500);
-                Assert.IsTrue(client.IsConnected);
+                Assert.IsTrue(await client.TryPingAsync());

                await server.StopAsync();
                await Task.Delay(500);
-                Assert.IsFalse(client.IsConnected);
+                Assert.IsFalse(await client.TryPingAsync());

                await server.StartAsync();
                await Task.Delay(500);

                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
-                Assert.IsTrue(client.IsConnected);
+                Assert.IsTrue(await client.TryPingAsync());
            }
        }

@@ -637,6 +615,7 @@ namespace MQTTnet.Tests.Client
                }
                catch
                {
+                    // Ignore errors.
                }

                SpinWait.SpinUntil(() => tries >= maxTries, 10000);
@@ -656,11 +635,11 @@ namespace MQTTnet.Tests.Client
                var client = await testEnvironment.ConnectClient();

                await Task.Delay(500);
-                Assert.IsTrue(client.IsConnected);
+                Assert.IsTrue(client.TryPingAsync().GetAwaiter().GetResult());

                await server.StopAsync();
                await Task.Delay(500);
-                Assert.IsFalse(client.IsConnected);
+                Assert.IsFalse(client.TryPingAsync().GetAwaiter().GetResult());

                for (var i = 0; i < 5; i++)
                {
@@ -671,6 +650,7 @@ namespace MQTTnet.Tests.Client
                    }
                    catch
                    {
+                        // Ignore errors.
                    }
                }

@@ -678,7 +658,7 @@ namespace MQTTnet.Tests.Client
                await Task.Delay(500);

                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort).Build());
-                Assert.IsTrue(client.IsConnected);
+                await client.PingAsync();
            }
        }

@@ -723,7 +703,7 @@ namespace MQTTnet.Tests.Client
                        replies.Add(eventArgs.ApplicationMessage.Topic);
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                }

                client2.ApplicationMessageReceivedAsync += Handler2;
@@ -761,7 +741,7 @@ namespace MQTTnet.Tests.Client
                        replyReceived = true;
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                client2.ApplicationMessageReceivedAsync += async e =>
@@ -812,7 +792,7 @@ namespace MQTTnet.Tests.Client
                        replyReceived = true;
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await client.PublishStringAsync("request", null, MqttQualityOfServiceLevel.AtLeastOnce);
@@ -828,14 +808,14 @@ namespace MQTTnet.Tests.Client
        {
            using (var testEnvironment = new TestEnvironment(TestContext))
            {
-                var server = await testEnvironment.StartServer();
+                await testEnvironment.StartServer();
                var client = await testEnvironment.ConnectClient();

-                Assert.IsTrue(client.IsConnected);
+                Assert.IsTrue(client.TryPingAsync().GetAwaiter().GetResult());
                client.DisconnectedAsync += e =>
                {
                    Assert.IsTrue(e.ClientWasConnected);
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await client.DisconnectAsync();
@@ -851,11 +831,11 @@ namespace MQTTnet.Tests.Client
                var server = await testEnvironment.StartServer();
                var client = await testEnvironment.ConnectClient();

-                Assert.IsTrue(client.IsConnected);
+                Assert.IsTrue(client.TryPingAsync().GetAwaiter().GetResult());
                client.DisconnectedAsync += e =>
                {
                    Assert.IsTrue(e.ClientWasConnected);
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await server.StopAsync();
@@ -892,7 +872,7 @@ namespace MQTTnet.Tests.Client
                        receivedMessages.Add(e.ApplicationMessage);
                    }

-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort).Build());
@@ -917,14 +897,14 @@ namespace MQTTnet.Tests.Client
                client1.DisconnectedAsync += c =>
                {
                    disconnectedFired = true;
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                var messageReceived = false;
                client1.ApplicationMessageReceivedAsync += e =>
                {
                    messageReceived = true;
-                    return PlatformAbstractionLayer.CompletedTask;
+                    return CompletedTask.Instance;
                };

                await client1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("topic1").WithExactlyOnceQoS().Build());
@@ -941,7 +921,7 @@ namespace MQTTnet.Tests.Client
                await Task.Delay(500);

                Assert.IsTrue(messageReceived);
-                Assert.IsTrue(client1.IsConnected);
+                Assert.IsTrue(client1.TryPingAsync().GetAwaiter().GetResult());
                Assert.IsFalse(disconnectedFired);
            }
        }
@@ -6,9 +6,8 @@ using System.Linq;
 using System.Text;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Extensions;

-namespace MQTTnet.Tests.Client
+namespace MQTTnet.Tests.Clients
 {
    [TestClass]
    public class MqttClientOptionsBuilder_Tests
--- a/Show More
+++ b/Show More