1612 mqttserver subscription to similar base and subtopic with wildcards fails (#1622)

Bumps [Newtonsoft.Json](https://github.com/JamesNK/Newtonsoft.Json) from 13.0.1 to 13.0.2.
- [Release notes](https://github.com/JamesNK/Newtonsoft.Json/releases)
- [Commits](https://github.com/JamesNK/Newtonsoft.Json/compare/13.0.1...13.0.2)

---
updated-dependencies:
- dependency-name: Newtonsoft.Json
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

.github/workflows/ReleaseNotes.md

@@ -1,5 +1,9 @@
-* [Core] Fixed several dead locks by implementing a new async signal (#1552)
-* [Client] All waiting tasks will now fail when the client connection gets closed. This fixes several freezes (#1561)
-* [Server] Fixed duplicated invocation of the event _ClientAcknowledgedPublishPacketAsync_ for QoS level 2 (#1550)
-* [Server] Fixed issue in upgrading and downgrading of QoS levels for subscriptions and retained messages (#1560)
-* [Server] Fixed memory leak when old sessions are discarded (#1553)
+* [Core] Fixed a memory leak in _AsyncSignal_ implementation (#1586, thanks to @mario-zelger).
+* [Core] Fixed an issue with bounds handling in _MqttBufferReader_ (#1593).
+* [Core] Performance improvements and reduced memory usage due to improved buffer copies (#1599, thanks to @xljiulang).
+* [Server] Fix not properly reset statistics (#1587, thanks to @damikun).
+* [Server] Now using an empty string as the sender client ID for injected application messages (#1583, thanks to @xljiulang).
+* [Server] Improved memory usage for ASP.NET connections (#1582, thanks to @xljiulang).
+* [Server] Improved memory usage and performance for ASP.NET integration (#1596, thanks to @xljiulang).
+* [Server] Add support for interception of will messages (#1613).
+* [Server] Fixed wrong topic filter detections (#1615, thanks to @logicaloud).

.github/workflows/ci.yml

@@ -3,7 +3,7 @@ name: CI
 on: [push, pull_request]
 
 env:
-  VERSION: "4.1.3.${{github.run_number}}"
+  VERSION: "4.1.4.${{github.run_number}}"
 
 jobs:
   build:
@@ -60,8 +60,4 @@ jobs:
 
       - 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

MQTTnet.sln.DotSettings

@@ -240,8 +240,14 @@ 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_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/=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>

README.md

@@ -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)

Samples/Client/Client_Connection_Samples.cs

@@ -138,7 +138,7 @@ public static class Client_Connection_Samples
     {
         /*
          * 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 implementaion from WebSocket4Net is used. It provides more
+         * 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.
@@ -386,4 +386,4 @@ public static class Client_Connection_Samples
                 });
         }
     }
-}
+}

Samples/MQTTnet.Samples.csproj

@@ -9,12 +9,10 @@
         <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" />
 
         <ProjectReference Include="..\Source\MQTTnet.AspnetCore\MQTTnet.AspNetCore.csproj" />
         <ProjectReference Include="..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.csproj" />

Source/MQTTnet.AspNetCore.Tests/MQTTnet.AspNetCore.Tests.csproj

@@ -12,8 +12,6 @@
         <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" />
-        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
-        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
     </ItemGroup>
 
     <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' ">

Source/MQTTnet.AspNetCore.Tests/MqttConnectionContextTest.cs

@@ -18,7 +18,7 @@ using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Tests.Extensions;
+using MQTTnet.Tests.Helpers;
 
 namespace MQTTnet.AspNetCore.Tests
 {
@@ -35,7 +35,7 @@ namespace MQTTnet.AspNetCore.Tests
             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));
 

Source/MQTTnet.AspTestApp/MQTTnet.AspTestApp.csproj

@@ -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>

Source/MQTTnet.AspnetCore/MQTTnet.AspNetCore.csproj

@@ -32,7 +32,8 @@
         <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <GenerateDocumentationFile>true</GenerateDocumentationFile>
-        <NoWarn>1591</NoWarn>
+        <NoWarn>1591;NETSDK1138</NoWarn>
+        <LangVersion>7.3</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>

Source/MQTTnet.AspnetCore/MqttConnectionContext.cs

@@ -2,38 +2,59 @@
 // 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)
+            _input = connection.Transport.Input;
+            _output = connection.Transport.Output;
+        }
+
+        public long BytesReceived { get; private set; }
+
+        public long BytesSent { get; private set; }
+
+        public X509Certificate2 ClientCertificate
+        {
+            get
             {
-                _input = Connection.Transport.Input;
-                _output = Connection.Transport.Output;
+                // 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 +62,59 @@ 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 X509Certificate2 ClientCertificate => Http?.HttpContext?.Connection?.ClientCertificate;
-
-        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 bool IsSecureConnection
+        {
+            get
+            {
+                // mqtt over tcp
+                var tlsFeature = _connection.Features.Get<ITlsConnectionFeature>();
+                if (tlsFeature != null)
+                {
+                    return true;
+                }
+
+                // mqtt over websocket
+                var httpFeature = _connection.Features.Get<IHttpContextFeature>();
+                if (httpFeature?.HttpContext != null)
+                {
+                    return httpFeature.HttpContext.Request.IsHttps;
+                }
+
+                return false;
+            }
+        }
+
+        public MqttPacketFormatterAdapter PacketFormatterAdapter { get; }
 
         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 +125,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;
@@ -141,15 +177,15 @@ 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
@@ -169,25 +205,35 @@ namespace MQTTnet.AspNetCore
 
         public async Task SendPacketAsync(MqttPacket packet, CancellationToken cancellationToken)
         {
-            var formatter = PacketFormatterAdapter;
-            
             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();
+                    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);
         }
     }
-}
+}

Source/MQTTnet.AspnetCore/ReaderExtensions.cs

@@ -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())}).");
+        }
     }
 }

Source/MQTTnet.Benchmarks/BaseBenchmark.cs

@@ -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

Source/MQTTnet.Benchmarks/ChannelAdapterBenchmark.cs

@@ -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 MemoryMqttChannel(_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, null, new MqttNetEventLogger());
+        }
+
         static byte[] Join(params ArraySegment<byte>[] chunks)
         {
             var buffer = new MemoryStream();
@@ -88,4 +87,4 @@ namespace MQTTnet.Benchmarks
             return buffer.ToArray();
         }
     }
-}
+}

Source/MQTTnet.Benchmarks/Configurations/AllowNonOptimized.cs

@@ -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);
-        }
-    }
-}

Source/MQTTnet.Benchmarks/Configurations/BaseConfig.cs

@@ -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
-        }
-    }
-}

Source/MQTTnet.Benchmarks/Configurations/RuntimeCompareConfig.cs

@@ -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));
-        }
-    }
-}

Source/MQTTnet.Benchmarks/LoggerBenchmark.cs

@@ -11,7 +11,7 @@ namespace MQTTnet.Benchmarks
     [SimpleJob(RuntimeMoniker.Net60)]
     [RPlotExporter]
     [MemoryDiagnoser]
-    public class LoggerBenchmark
+    public class LoggerBenchmark : BaseBenchmark
     {
         MqttNetNullLogger _nullLogger;
         MqttNetSourceLogger _sourceNullLogger;

Source/MQTTnet.Benchmarks/MQTTnet.Benchmarks.csproj

@@ -1,14 +1,16 @@
-<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</TargetFrameworks>
         <LangVersion>7.2</LangVersion>
         <IsPackable>false</IsPackable>
         <EnableNETAnalyzers>false</EnableNETAnalyzers>
         <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
         <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
+        <NoWarn>1591;NETSDK1138</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
@@ -26,9 +28,6 @@
 
     <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>
 

Source/MQTTnet.Benchmarks/MemoryCopyBenchmark.cs

@@ -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);
+        }
+
+    }
+}

Source/MQTTnet.Benchmarks/MessageDeliveryBenchmark.cs

@@ -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;
 

Source/MQTTnet.Benchmarks/MessageProcessingBenchmark.cs

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

Source/MQTTnet.Benchmarks/MessageProcessingMqttConnectionContextBenchmark.cs

@@ -15,7 +15,7 @@ namespace MQTTnet.Benchmarks
 {
     [SimpleJob(RuntimeMoniker.Net60)]
     [MemoryDiagnoser]
-    public class MessageProcessingMqttConnectionContextBenchmark
+    public class MessageProcessingMqttConnectionContextBenchmark : BaseBenchmark
     {
         IWebHost _host;
         IMqttClient _mqttClient;

Source/MQTTnet.Benchmarks/MqttBufferReaderBenchmark.cs

@@ -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);
+        }
+    }
+}

Source/MQTTnet.Benchmarks/MqttPacketReaderWriterBenchmark.cs

@@ -1,7 +1,10 @@
+// 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;
 
@@ -9,7 +12,7 @@ namespace MQTTnet.Benchmarks
 {
     [SimpleJob(RuntimeMoniker.Net60)]
     [MemoryDiagnoser]
-    public class MqttPacketReaderWriterBenchmark
+    public class MqttPacketReaderWriterBenchmark : BaseBenchmark
     {
         readonly byte[] _demoPayload = new byte[1024];
         

Source/MQTTnet.Benchmarks/MqttTcpChannelBenchmark.cs

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

Source/MQTTnet.Benchmarks/Program.cs

@@ -3,85 +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");
-            Console.WriteLine("f = AsyncLockBenchmark");
+        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>();
-                    break;
-                case 'f':
-                    BenchmarkRunner.Run<AsyncLockBenchmark>();
+                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();
+        }
     }
-}
+}

Source/MQTTnet.Benchmarks/ReaderExtensionsBenchmark.cs

@@ -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;
+            }
+        }
+
+    }
+}

Source/MQTTnet.Benchmarks/RoundtripProcessingBenchmark.cs

@@ -8,7 +8,7 @@ namespace MQTTnet.Benchmarks
     [SimpleJob(RuntimeMoniker.Net60)]
     [RPlotExporter, RankColumn]
     [MemoryDiagnoser]
-    public class RoundtripProcessingBenchmark
+    public class RoundtripProcessingBenchmark : BaseBenchmark
     {
         [GlobalSetup]
         public void GlobalSetup()

Source/MQTTnet.Benchmarks/ServerProcessingBenchmark.cs

@@ -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;
@@ -8,7 +12,7 @@ namespace MQTTnet.Benchmarks
     [SimpleJob(RuntimeMoniker.Net60)]
     [RPlotExporter, RankColumn]
     [MemoryDiagnoser]
-    public class ServerProcessingBenchmark
+    public class ServerProcessingBenchmark : BaseBenchmark
     {
         [GlobalSetup]
         public void GlobalSetup()

Source/MQTTnet.Benchmarks/SubscribeBenchmark.cs

@@ -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;

Source/MQTTnet.Benchmarks/TcpPipesBenchmark.cs

@@ -15,7 +15,7 @@ namespace MQTTnet.Benchmarks
 {
     [SimpleJob(RuntimeMoniker.Net60)]
     [MemoryDiagnoser]
-    public class TcpPipesBenchmark
+    public class TcpPipesBenchmark : BaseBenchmark
     {
         IDuplexPipe _client;
         IDuplexPipe _server;

Source/MQTTnet.Benchmarks/TopicFilterComparerBenchmark.cs

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

Source/MQTTnet.Benchmarks/TopicGenerator.cs

@@ -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);
         }
     }
-}
+}

Source/MQTTnet.Benchmarks/UnsubscribeBenchmark.cs

@@ -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;

Source/MQTTnet.Benchmarks/packages.config

@@ -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>

Source/MQTTnet.Extensions.ManagedClient/IManagedMqttClient.cs

@@ -43,7 +43,7 @@ namespace MQTTnet.Extensions.ManagedClient
         
         Task StartAsync(ManagedMqttClientOptions options);
         
-        Task StopAsync();
+        Task StopAsync(bool cleanDisconnect = true);
         
         Task SubscribeAsync(ICollection<MqttTopicFilter> topicFilters);
         

Source/MQTTnet.Extensions.ManagedClient/MQTTnet.Extensions.ManagedClient.csproj

@@ -33,7 +33,7 @@
         <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'">

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClient.cs

@@ -62,6 +62,7 @@ namespace MQTTnet.Extensions.ManagedClient
         CancellationTokenSource _publishingCancellationToken;
 
         ManagedMqttClientStorageManager _storageManager;
+        bool _isCleanDisconnect;
 
         public ManagedMqttClient(IMqttClient mqttClient, IMqttNetLogger logger)
         {
@@ -160,7 +161,7 @@ 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;
@@ -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();
 
@@ -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)

Source/MQTTnet.Extensions.Rpc/MQTTnet.Extensions.Rpc.csproj

@@ -33,7 +33,8 @@
         <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'">

Source/MQTTnet.Extensions.Rpc/MqttFactoryExtensions.cs

@@ -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)

Source/MQTTnet.Extensions.Rpc/MqttRpcClient.cs

@@ -2,23 +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 MQTTnet.Client;
-using MQTTnet.Exceptions;
-using MQTTnet.Protocol;
 using System;
 using System.Collections.Concurrent;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
 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,6 +28,18 @@ namespace MQTTnet.Extensions.Rpc
             _mqttClient.ApplicationMessageReceivedAsync += HandleApplicationMessageReceivedAsync;
         }
 
+        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)
         {
             using (var timeoutToken = new CancellationTokenSource(timeout))
@@ -49,15 +62,13 @@ namespace MQTTnet.Extensions.Rpc
 
         public async Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, 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, qualityOfServiceLevel);
+            var topicNames = _options.TopicGenerationStrategy.CreateRpcTopics(context);
 
             var requestTopic = topicNames.RequestTopic;
             var responseTopic = topicNames.ResponseTopic;
@@ -72,8 +83,7 @@ namespace MQTTnet.Extensions.Rpc
                 throw new MqttProtocolViolationException("RPC response topic is empty.");
             }
 
-            var requestMessage = new MqttApplicationMessageBuilder()
-                .WithTopic(requestTopic)
+            var requestMessage = new MqttApplicationMessageBuilder().WithTopic(requestTopic)
                 .WithPayload(payload)
                 .WithQualityOfServiceLevel(qualityOfServiceLevel)
                 .WithResponseTopic(responseTopic)
@@ -81,25 +91,23 @@ namespace MQTTnet.Extensions.Rpc
 
             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 +115,8 @@ namespace MQTTnet.Extensions.Rpc
             finally
             {
                 _waitingCalls.TryRemove(responseTopic, out _);
-                
-                await _mqttClient.UnsubscribeAsync(responseTopic).ConfigureAwait(false);
+
+                await _mqttClient.UnsubscribeAsync(responseTopic, CancellationToken.None).ConfigureAwait(false);
             }
         }
 
@@ -119,28 +127,12 @@ namespace MQTTnet.Extensions.Rpc
                 return CompletedTask.Instance;
             }
 
-#if NET452
-            Task.Run(() => awaitable.TrySetResult(eventArgs.ApplicationMessage.Payload));
-#else
             awaitable.TrySetResult(eventArgs.ApplicationMessage.Payload);
-#endif
 
             // Set this message to handled to that other code can avoid execution etc.
             eventArgs.IsHandled = true;
 
             return CompletedTask.Instance;
         }
-
-        public void Dispose()
-        {
-            _mqttClient.ApplicationMessageReceivedAsync -= HandleApplicationMessageReceivedAsync;
-
-            foreach (var tcs in _waitingCalls)
-            {
-                tcs.Value.TrySetCanceled();
-            }
-
-            _waitingCalls.Clear();
-        }
     }
 }

Source/MQTTnet.Extensions.Rpc/Options/MqttRpcClientOptionsBuilder.cs

@@ -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;
+        }
     }
-}
+}

Source/MQTTnet.Extensions.Rpc/Options/TopicGeneration/DefaultMqttRpcClientTopicGenerationStrategy.cs

@@ -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 #.");

Source/MQTTnet.Extensions.Rpc/Options/TopicGeneration/TopicGenerationContext.cs

@@ -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 MQTTnet.Client;
 using MQTTnet.Protocol;
 
@@ -9,20 +10,29 @@ namespace MQTTnet.Extensions.Rpc
 {
     public sealed class TopicGenerationContext
     {
-        public string MethodName { get; set; }
+        public TopicGenerationContext(IMqttClient mqttClient, MqttRpcClientOptions options, string methodName, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            MethodName = methodName ?? throw new ArgumentNullException(nameof(methodName));
+            QualityOfServiceLevel = qualityOfServiceLevel;
+            MqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+            Options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public string MethodName { 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; }
     }
-}
+}

Source/MQTTnet.Extensions.WebSocket4Net/MQTTnet.Extensions.WebSocket4Net.csproj

@@ -33,7 +33,8 @@
         <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'">

Source/MQTTnet.Extensions.WebSocket4Net/MqttFactoryExtensions.cs

@@ -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());
         }
     }
-}
+}

Source/MQTTnet.Extensions.WebSocket4Net/WebSocket4NetMqttChannel.cs

@@ -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;
@@ -17,14 +18,14 @@ 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;
@@ -35,13 +36,13 @@ 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))
@@ -55,11 +56,13 @@ namespace MQTTnet.Extensions.WebSocket4Net
                     uri = "wss://" + 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;
@@ -90,7 +93,7 @@ namespace MQTTnet.Extensions.WebSocket4Net
             var receiveBufferSize = 0;
 
             var certificates = new X509CertificateCollection();
-            if (_webSocketOptions?.TlsOptions?.Certificates != null)
+            if (_webSocketOptions.TlsOptions?.Certificates != null)
             {
                 foreach (var certificate in _webSocketOptions.TlsOptions.Certificates)
                 {
@@ -107,15 +110,13 @@ namespace MQTTnet.Extensions.WebSocket4Net
                 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,10 +125,23 @@ namespace MQTTnet.Extensions.WebSocket4Net
             {
                 _webSocket.Close();
             }
-            
+
             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)
         {
             var readBytes = 0;
@@ -161,75 +175,55 @@ namespace MQTTnet.Extensions.WebSocket4Net
             return CompletedTask.Instance;
         }
 
-        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);
-            }
-        }
-
         async Task ConnectInternalAsync(CancellationToken cancellationToken)
         {
             _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 +245,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());
+        }
     }
-}
+}

Source/MQTTnet.Extensions.WebSocket4Net/WebSocket4NetMqttClientAdapterFactory.cs

@@ -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,7 +26,7 @@ namespace MQTTnet.Extensions.WebSocket4Net
                 {
                     return new MqttChannelAdapter(
                         new MqttTcpChannel(options),
-                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(4096, 65535)),
+                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(options.WriterBufferSize, options.WriterBufferSizeMax)),
                         packetInspector,
                         logger);
                 }
@@ -32,16 +35,16 @@ namespace MQTTnet.Extensions.WebSocket4Net
                 {
                     return new MqttChannelAdapter(
                         new WebSocket4NetMqttChannel(options, webSocketOptions),
-                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(4068, 65535)), 
+                        new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttBufferWriter(options.WriterBufferSize, options.WriterBufferSizeMax)),
                         packetInspector,
                         logger);
                 }
 
                 default:
-                    {
-                        throw new NotSupportedException();
-                    }
+                {
+                    throw new NotSupportedException();
+                }
             }
         }
     }
-}
+}

Source/MQTTnet.TestApp/MQTTnet.TestApp.csproj

@@ -9,12 +9,11 @@
         <EnableNETAnalyzers>false</EnableNETAnalyzers>
         <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
         <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
+        <NoWarn>1591;NETSDK1138</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
-        <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>

Source/MQTTnet.TestApp/PublicBrokerTest.cs

@@ -2,11 +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.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.Internal;
 using MQTTnet.Protocol;
@@ -17,10 +18,6 @@ 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
@@ -31,7 +28,6 @@ namespace MQTTnet.TestApp
                 CertificateValidationHandler = w => true
             };
 #endif
-
             // Also defining TLS12 for servers that don't seem no to support TLS13.
             var unsafeTls12 = new MqttClientOptionsBuilderTlsParameters
             {
@@ -42,33 +38,37 @@ namespace MQTTnet.TestApp
             };
 
             // 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("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());
+            
+            await ExecuteTestAsync("mqtt.eclipseprojects.io WS TLS13 (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer("mqtt.eclipseprojects.io:443/mqtt")
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(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).WithTls(unsafeTls12).Build());
 
 #if NET5_0_OR_GREATER
             await ExecuteTestAsync("test.mosquitto.org TCP TLS13",
@@ -76,27 +76,40 @@ namespace MQTTnet.TestApp
                     .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(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)
+                    .WithTls(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("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("test.mosquitto.org:8080/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                true);
+
+            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 TLS12 (WebSocket4Net)",
+            //     new MqttClientOptionsBuilder().WithWebSocketServer("test.mosquitto.org:8081/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).WithTls(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).WithTls(unsafeTls12).Build());
 
 #if NET5_0_OR_GREATER
             await ExecuteTestAsync("broker.emqx.io TCP TLS13",
@@ -104,23 +117,37 @@ namespace MQTTnet.TestApp
                     .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(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("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("broker.emqx.io:8084/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                true);
 
+            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 TLS12 (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.emqx.io:8084/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).WithTls(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("broker.hivemq.com:8000/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build());
+
+            await ExecuteTestAsync(
+                "broker.hivemq.com WS (WebSocket4Net)",
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.hivemq.com:8000/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                true);
 
             // mqtt.swifitch.cz: Does not seem to operate any more
 
@@ -130,36 +157,43 @@ namespace MQTTnet.TestApp
             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 CompletedTask.Instance;
-                };
-
-                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);
             }
@@ -174,6 +208,5 @@ namespace MQTTnet.TestApp
             Console.ForegroundColor = color;
             Console.Write(message);
         }
-
     }
-}
+}

Source/MQTTnet.Tests/Client/LowLevelMqttClient_Tests.cs

@@ -64,7 +64,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 +80,8 @@ namespace MQTTnet.Tests.Client
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
+                testEnvironment.IgnoreServerLogErrors = true;
+
                 testEnvironment.ServerPort = 8364;
                 var server = await testEnvironment.StartServer();
 
@@ -116,6 +118,8 @@ namespace MQTTnet.Tests.Client
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
+                testEnvironment.IgnoreServerLogErrors = true;
+
                 var server = await testEnvironment.StartServer();
 
                 using (var lowLevelClient = testEnvironment.CreateLowLevelClient())
@@ -123,7 +127,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 +152,7 @@ namespace MQTTnet.Tests.Client
                     catch
                     {
                     }
-           
+
                     Assert.IsFalse(lowLevelClient.IsConnected);
                 }
             }

Source/MQTTnet.Tests/Client/ManagedMqttClient_Tests.cs

@@ -11,6 +11,7 @@ using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Diagnostics;
 using MQTTnet.Extensions.ManagedClient;
+using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
@@ -21,6 +22,67 @@ namespace MQTTnet.Tests.Client
     [TestClass]
     public sealed class ManagedMqttClient_Tests : BaseTestClass
     {
+        [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 Connect_To_Invalid_Server()
         {
@@ -33,7 +95,6 @@ namespace MQTTnet.Tests.Client
                 var managedClient = testEnvironment.Factory.CreateManagedMqttClient(mqttClient);
 
                 ConnectingFailedEventArgs connectingFailedEventArgs = null;
-
                 managedClient.ConnectingFailedAsync += args =>
                 {
                     connectingFailedEventArgs = args;
@@ -270,13 +331,7 @@ 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 LongTestDelay();
@@ -298,18 +353,15 @@ namespace MQTTnet.Tests.Client
 
                 await managedClient.SubscribeAsync("topic");
 
-                await managedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).WithAutoReconnectDelay(TimeSpan.FromSeconds(1)).Build());
-
+                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 managedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).WithAutoReconnectDelay(TimeSpan.FromSeconds(1)).Build());
-
+                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,
@@ -318,7 +370,6 @@ namespace MQTTnet.Tests.Client
 
                 // Make sure that it gets received after subscribing again.
                 await managedClient.SubscribeAsync("topic");
-                
                 await LongTestDelay();
                 
                 Assert.AreEqual(2, receivedManagedMessages.Count);

Source/MQTTnet.Tests/Extensions/Rpc_Tests.cs

@@ -6,68 +6,93 @@ using System;
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Tests.Mockups;
 using MQTTnet.Client;
 using MQTTnet.Exceptions;
 using MQTTnet.Extensions.Rpc;
-using MQTTnet.Protocol;
 using MQTTnet.Formatter;
-using MQTTnet.Implementations;
 using MQTTnet.Internal;
+using MQTTnet.Protocol;
+using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests
+namespace MQTTnet.Tests.Extensions
 {
     [TestClass]
-    public sealed class RPC_Tests : BaseTestClass
+    public sealed class Rpc_Tests : BaseTestClass
     {
+        [TestMethod]
+        public async Task Execute_Success_MQTT_V5_Mixed_Clients()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+                var responseSender = await testEnvironment.ConnectClient();
+                await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping");
+
+                responseSender.ApplicationMessageReceivedAsync += async e =>
+                {
+                    Assert.IsNull(e.ApplicationMessage.ResponseTopic);
+                    await responseSender.PublishStringAsync(e.ApplicationMessage.Topic + "/response", "pong");
+                };
+
+                var requestSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
+
+                using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
+                {
+                    var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
+
+                    Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
+                }
+            }
+        }
+
         [TestMethod]
         public Task Execute_Success_With_QoS_0()
         {
             return Execute_Success(MqttQualityOfServiceLevel.AtMostOnce, MqttProtocolVersion.V311);
         }
 
-        [TestMethod]
-        public Task Execute_Success_With_QoS_1()
-        {
-            return Execute_Success(MqttQualityOfServiceLevel.AtLeastOnce, MqttProtocolVersion.V311);
-        }
-
-        [TestMethod]
-        public Task Execute_Success_With_QoS_2()
-        {
-            return Execute_Success(MqttQualityOfServiceLevel.ExactlyOnce, MqttProtocolVersion.V311);
-        }
-
         [TestMethod]
         public Task Execute_Success_With_QoS_0_MQTT_V5()
         {
             return Execute_Success(MqttQualityOfServiceLevel.AtMostOnce, MqttProtocolVersion.V500);
         }
 
-        [TestMethod]
-        public Task Execute_Success_With_QoS_1_MQTT_V5()
-        {
-            return Execute_Success(MqttQualityOfServiceLevel.AtLeastOnce, MqttProtocolVersion.V500);
-        }
-
-        [TestMethod]
-        public Task Execute_Success_With_QoS_2_MQTT_V5()
-        {
-            return Execute_Success(MqttQualityOfServiceLevel.ExactlyOnce, MqttProtocolVersion.V500);
-        }
-
         [TestMethod]
         public Task Execute_Success_With_QoS_0_MQTT_V5_Use_ResponseTopic()
         {
             return Execute_Success_MQTT_V5(MqttQualityOfServiceLevel.AtMostOnce);
         }
 
+        [TestMethod]
+        public Task Execute_Success_With_QoS_1()
+        {
+            return Execute_Success(MqttQualityOfServiceLevel.AtLeastOnce, MqttProtocolVersion.V311);
+        }
+
+        [TestMethod]
+        public Task Execute_Success_With_QoS_1_MQTT_V5()
+        {
+            return Execute_Success(MqttQualityOfServiceLevel.AtLeastOnce, MqttProtocolVersion.V500);
+        }
+
         [TestMethod]
         public Task Execute_Success_With_QoS_1_MQTT_V5_Use_ResponseTopic()
         {
             return Execute_Success_MQTT_V5(MqttQualityOfServiceLevel.AtLeastOnce);
         }
 
+        [TestMethod]
+        public Task Execute_Success_With_QoS_2()
+        {
+            return Execute_Success(MqttQualityOfServiceLevel.ExactlyOnce, MqttProtocolVersion.V311);
+        }
+
+        [TestMethod]
+        public Task Execute_Success_With_QoS_2_MQTT_V5()
+        {
+            return Execute_Success(MqttQualityOfServiceLevel.ExactlyOnce, MqttProtocolVersion.V500);
+        }
+
         [TestMethod]
         public Task Execute_Success_With_QoS_2_MQTT_V5_Use_ResponseTopic()
         {
@@ -90,6 +115,31 @@ namespace MQTTnet.Tests
             }
         }
 
+        [TestMethod]
+        [ExpectedException(typeof(MqttCommunicationTimedOutException))]
+        public async Task Execute_Timeout_MQTT_V5_Mixed_Clients()
+        {
+            using (var testEnvironment = new TestEnvironment(TestContext))
+            {
+                await testEnvironment.StartServer();
+                var responseSender = await testEnvironment.ConnectClient();
+                await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping");
+
+                responseSender.ApplicationMessageReceivedAsync += async e =>
+                {
+                    Assert.IsNull(e.ApplicationMessage.ResponseTopic);
+                    await CompletedTask.Instance;
+                };
+
+                var requestSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
+
+                using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
+                {
+                    var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
+                }
+            }
+        }
+
         [TestMethod]
         [ExpectedException(typeof(MqttCommunicationTimedOutException))]
         public async Task Execute_With_Custom_Topic_Names()
@@ -98,14 +148,24 @@ namespace MQTTnet.Tests
             {
                 await testEnvironment.StartServer();
 
-                var requestSender = await testEnvironment.ConnectClient();
-
                 var rpcClient = await testEnvironment.ConnectRpcClient(new MqttRpcClientOptionsBuilder().WithTopicGenerationStrategy(new TestTopicStrategy()).Build());
 
                 await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
             }
         }
 
+        [TestMethod]
+        public void Use_Factory()
+        {
+            var factory = new MqttFactory();
+            using (var client = factory.CreateMqttClient())
+            {
+                var rpcClient = factory.CreateMqttRpcClient(client);
+
+                Assert.IsNotNull(rpcClient);
+            }
+        }
+
         async Task Execute_Success(MqttQualityOfServiceLevel qosLevel, MqttProtocolVersion protocolVersion)
         {
             using (var testEnvironment = CreateTestEnvironment())
@@ -151,57 +211,6 @@ namespace MQTTnet.Tests
             }
         }
 
-        [TestMethod]
-        public async Task Execute_Success_MQTT_V5_Mixed_Clients()
-        {
-            using (var testEnvironment = CreateTestEnvironment())
-            {
-                await testEnvironment.StartServer();
-                var responseSender = await testEnvironment.ConnectClient();
-                await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping", MqttQualityOfServiceLevel.AtMostOnce);
-
-                responseSender.ApplicationMessageReceivedAsync += async e =>
-                {
-                    Assert.IsNull(e.ApplicationMessage.ResponseTopic);
-                    await responseSender.PublishStringAsync(e.ApplicationMessage.Topic + "/response", "pong");
-                };
-
-                var requestSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
-
-                using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
-                {
-                    var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
-
-                    Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
-                }
-            }
-        }
-
-        [TestMethod]
-        [ExpectedException(typeof(MqttCommunicationTimedOutException))]
-        public async Task Execute_Timeout_MQTT_V5_Mixed_Clients()
-        {
-            using (var testEnvironment = new TestEnvironment(TestContext))
-            {
-                await testEnvironment.StartServer();
-                var responseSender = await testEnvironment.ConnectClient();
-                await responseSender.SubscribeAsync("MQTTnet.RPC/+/ping", MqttQualityOfServiceLevel.AtMostOnce);
-
-                responseSender.ApplicationMessageReceivedAsync += async e =>
-                {
-                    Assert.IsNull(e.ApplicationMessage.ResponseTopic);
-                    await CompletedTask.Instance;
-                };
-
-                var requestSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500));
-
-                using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
-                {
-                    var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
-                }
-            }
-        }
-
         class TestTopicStrategy : IMqttRpcClientTopicGenerationStrategy
         {
             public MqttRpcTopicPair CreateRpcTopics(TopicGenerationContext context)
@@ -214,4 +223,4 @@ namespace MQTTnet.Tests
             }
         }
     }
-}
+}

Source/MQTTnet.Tests/Extensions/WebSocket4Net_Tests.cs

@@ -0,0 +1,51 @@
+// 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.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
+using MQTTnet.Extensions.WebSocket4Net;
+using MQTTnet.Tests.Helpers;
+
+namespace MQTTnet.Tests.Extensions
+{
+    [TestClass]
+    public sealed class WebSocket4Net_Tests
+    {
+        [TestMethod]
+        [ExpectedException(typeof(MqttCommunicationException))]
+        public async Task Connect_Failed_With_Invalid_Server()
+        {
+            var factory = new MqttFactory().UseWebSocket4Net();
+
+            using (var client = factory.CreateMqttClient())
+            {
+                var options = new MqttClientOptionsBuilder().WithWebSocketServer("ws://a.b/mqtt").WithTimeout(TimeSpan.FromSeconds(2)).Build();
+                await client.ConnectAsync(options).ConfigureAwait(false);
+            }
+        }
+
+        [TestMethod]
+        public void Use_Correct_Adapter()
+        {
+            // Should not throw exception
+            var factory = new MqttFactory().UseWebSocket4Net();
+            using (var client = factory.CreateMqttClient())
+            {
+                var adapterFactory = client.GetFieldValue("_adapterFactory");
+
+                Assert.IsInstanceOfType(adapterFactory, typeof(WebSocket4NetMqttClientAdapterFactory));
+            }
+        }
+
+        [TestMethod]
+        public void Use_WebSocket4Net()
+        {
+            // Should not throw exception
+            new MqttFactory().UseWebSocket4Net();
+        }
+    }
+}

Source/MQTTnet.Tests/Formatter/MqttBufferReader_Tests.cs

@@ -0,0 +1,310 @@
+// 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.IO;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Tests.Formatter
+{
+    [TestClass]
+    public sealed class MqttBufferReader_Tests
+    {
+        [TestMethod]
+        [ExpectedException(typeof(MqttProtocolViolationException), "Expected at least 4 bytes but there are only 3 bytes")]
+        public void Fire_Exception_If_Not_Enough_Data()
+        {
+            var buffer = new byte[] { 0, 1, 2 };
+
+            var reader = new MqttBufferReader();
+
+            reader.SetBuffer(buffer, 0, 3);
+
+            // 1 byte is missing.
+            reader.ReadFourByteInteger();
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(MqttProtocolViolationException), "Expected at least 4 bytes but there are only 3 bytes")]
+        public void Fire_Exception_If_Not_Enough_Data_With_Longer_Buffer()
+        {
+            var buffer = new byte[] { 0, 1, 2, 3, 4, 5, 6 };
+
+            var reader = new MqttBufferReader();
+
+            reader.SetBuffer(buffer, 0, 3);
+
+            // 1 byte is missing.
+            reader.ReadFourByteInteger();
+        }
+
+        [TestMethod]
+        public void Is_EndOfStream_Without_Buffer()
+        {
+            var reader = new MqttBufferReader();
+
+            Assert.IsTrue(reader.EndOfStream);
+            Assert.AreEqual(0, reader.BytesLeft);
+        }
+
+        [TestMethod]
+        public void Read_Remaining_Data_From_Larger_Buffer()
+        {
+            var buffer = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+            var reader = new MqttBufferReader();
+
+            // The used buffer contains more data than used!
+            reader.SetBuffer(buffer, 0, 5);
+
+            // This should only read 5 bytes even if more data is in the buffer
+            // due to custom bounds.
+            var remainingData = reader.ReadRemainingData();
+
+            Assert.IsTrue(reader.EndOfStream);
+            Assert.AreEqual(0, reader.BytesLeft);
+            Assert.AreEqual(5, remainingData.Length);
+        }
+
+        [TestMethod]
+        public void Read_Various_Positions_and_Offsets()
+        {
+            const int NumBufferElements = 1000;
+            const int NumTestSequences = 10000;
+
+            const string TestString = "The quick brown fox jumps over the lazy dog.";
+
+            var rndSeed = Environment.TickCount;
+            // rndSeed = ...; // assign random seed here if there is an error so that it can be repeated
+            var rnd = new Random(rndSeed);
+            // rndSeed is printed when an assert fails
+
+            var bufferElements = new List<ElementReference>();
+
+            byte[] elementBuffer;
+
+            // Fill a buffer with strings or numbers in big endian format
+            using (var ms = new MemoryStream())
+            {
+                using (var bw = new BinaryWriter(ms))
+                {
+                    var bufferOffset = 0;
+
+                    for (var i = 0; i < NumBufferElements; i++)
+                    {
+                        var nextElementType = (ElementReference.BufferElementType)rnd.Next(ElementReference.NumBufferElementTypes);
+
+                        byte[] elementBytes = null;
+                        uint elementNumberValue = 0; // all element number values fit into uint
+                        string elementStringValue = null;
+                        var elementSize = 0;
+
+                        var alreadyBigEndian = false;
+                        switch (nextElementType)
+                        {
+                            case ElementReference.BufferElementType.Byte:
+                                var byteValue = (byte)i;
+                                elementNumberValue = byteValue;
+                                elementSize = sizeof(byte);
+                                elementBytes = new byte[1] { byteValue };
+                                alreadyBigEndian = true; // nothing to swap
+                                break;
+                            case ElementReference.BufferElementType.TwoByteInt:
+                                var ushortValue = (ushort)i;
+                                elementNumberValue = ushortValue;
+                                elementSize = sizeof(ushort);
+                                elementBytes = BitConverter.GetBytes(ushortValue);
+                                break;
+                            case ElementReference.BufferElementType.FourByteInt:
+                                var uintValue = (uint)i;
+                                elementNumberValue = uintValue;
+                                elementSize = sizeof(uint);
+                                elementBytes = BitConverter.GetBytes(uintValue);
+                                break;
+                            case ElementReference.BufferElementType.VariableSizeInt:
+                            {
+                                elementNumberValue = (uint)i;
+                                var writer = new MqttBufferWriter(4, 4);
+                                writer.WriteVariableByteInteger(elementNumberValue);
+                                elementSize = writer.Length;
+                                elementBytes = new byte[elementSize];
+                                var buffer = writer.GetBuffer();
+                                Array.Copy(buffer, elementBytes, elementSize);
+                                alreadyBigEndian = true; // nothing to swap
+                            }
+                                break;
+                            case ElementReference.BufferElementType.String:
+                            {
+                                var stringLen = rnd.Next(TestString.Length);
+                                elementStringValue = TestString.Substring(0, stringLen); // could be empty
+                                var writer = new MqttBufferWriter(stringLen + 1, stringLen + 1);
+                                writer.WriteString(elementStringValue);
+                                elementSize = writer.Length;
+                                elementBytes = new byte[elementSize];
+                                var buffer = writer.GetBuffer();
+                                Array.Copy(buffer, elementBytes, elementSize);
+                                alreadyBigEndian = true; // nothing to swap
+                            }
+                                break;
+                        }
+
+                        if (BitConverter.IsLittleEndian && !alreadyBigEndian)
+                        {
+                            Array.Reverse(elementBytes);
+                        }
+
+                        bw.Write(elementBytes);
+                        bufferElements.Add(new ElementReference(nextElementType, elementSize, elementNumberValue, elementStringValue, bufferOffset));
+                        bufferOffset += elementSize;
+                    }
+
+                    elementBuffer = ms.ToArray();
+                }
+            }
+
+            for (var i = 0; i < NumTestSequences; i++)
+            {
+                var firstElementIndex = rnd.Next(NumBufferElements - 1);
+                // segmentElementIndex will be < NumBufferElements - 1, which means there is at least one byte left for segment element count
+                var elementCount = rnd.Next(NumBufferElements - firstElementIndex) + 1;
+                var lastElementIndex = firstElementIndex + elementCount - 1;
+                // Use element index to get buffer offsets
+                var lastElement = bufferElements[lastElementIndex];
+                var segmentStartPosition = bufferElements[firstElementIndex].BufferOffset;
+                var segmentEndPosition = lastElement.BufferOffset + lastElement.Size;
+                var segmentLength = segmentEndPosition - segmentStartPosition;
+
+                var reader = new MqttBufferReader();
+                reader.SetBuffer(elementBuffer, segmentStartPosition, segmentLength);
+
+                // read all elements in the buffer segment; values should be as expected              
+                for (var n = 0; n < elementCount; n++)
+                {
+                    var element = bufferElements[firstElementIndex + n];
+                    uint elementNumberValue = 0;
+                    string elementStringValue = null;
+
+                    var expectedPosition = element.BufferOffset - segmentStartPosition;
+                    Assert.AreEqual(expectedPosition, reader.Position);
+
+                    switch (element.Type)
+                    {
+                        case ElementReference.BufferElementType.Byte:
+                        {
+                            elementNumberValue = reader.ReadByte();
+                        }
+                            break;
+                        case ElementReference.BufferElementType.TwoByteInt:
+                        {
+                            elementNumberValue = reader.ReadTwoByteInteger();
+                        }
+                            break;
+                        case ElementReference.BufferElementType.FourByteInt:
+                        {
+                            elementNumberValue = reader.ReadFourByteInteger();
+                        }
+                            break;
+                        case ElementReference.BufferElementType.VariableSizeInt:
+                        {
+                            elementNumberValue = reader.ReadVariableByteInteger();
+                        }
+                            break;
+                        case ElementReference.BufferElementType.String:
+                        {
+                            elementStringValue = reader.ReadString();
+                        }
+                            break;
+                    }
+
+                    if (elementStringValue != null)
+                    {
+                        Assert.AreEqual(elementStringValue, element.StringValue, $"'{elementStringValue}' not equal '{element.StringValue}' with random seed {rndSeed}.");
+                    }
+                    else
+                    {
+                        Assert.AreEqual(elementNumberValue, element.NumberValue, $"{elementNumberValue} not equal {element.NumberValue} with random seed {rndSeed}.");
+                    }
+                }
+
+                // confirm end of stream
+                Assert.AreEqual(0, reader.BytesLeft, "BytesLeft not zero as expected with random seed " + rndSeed);
+                Assert.IsTrue(reader.EndOfStream, "Not end of stream as expected with random seed " + rndSeed);
+            }
+        }
+
+        [TestMethod]
+        public void Report_Correct_Length_For_Full_Buffer()
+        {
+            var buffer = new byte[] { 5, 6, 7, 8, 9 };
+
+            var reader = new MqttBufferReader();
+            reader.SetBuffer(buffer, 0, 5);
+
+            Assert.IsFalse(reader.EndOfStream);
+            Assert.AreEqual(5, reader.BytesLeft);
+        }
+
+        [TestMethod]
+        public void Report_Correct_Length_For_Partial_End_Buffer()
+        {
+            var buffer = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+            var reader = new MqttBufferReader();
+
+            // The used buffer contains more data than used!
+            reader.SetBuffer(buffer, 5, 5);
+
+            Assert.IsFalse(reader.EndOfStream);
+            Assert.AreEqual(5, reader.BytesLeft);
+        }
+
+        [TestMethod]
+        public void Report_Correct_Length_For_Partial_Start_Buffer()
+        {
+            var buffer = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
+
+            var reader = new MqttBufferReader();
+
+            // The used buffer contains more data than used!
+            reader.SetBuffer(buffer, 0, 5);
+
+            Assert.IsFalse(reader.EndOfStream);
+            Assert.AreEqual(5, reader.BytesLeft);
+        }
+
+
+        // Helper class to build up a reference to elements of various types in a buffer
+        class ElementReference
+        {
+            public enum BufferElementType
+            {
+                Byte,
+                TwoByteInt,
+                FourByteInt,
+                VariableSizeInt,
+                String
+            }
+
+            public const int NumBufferElementTypes = 5;
+
+            public ElementReference(BufferElementType type, int size, uint numberValue, string stringValue, int bufferOffset)
+            {
+                Type = type;
+                Size = size;
+                NumberValue = numberValue;
+                StringValue = stringValue;
+                BufferOffset = bufferOffset;
+            }
+
+            public int BufferOffset { get; }
+            public uint NumberValue { get; }
+            public int Size { get; }
+            public string StringValue { get; }
+            public BufferElementType Type { get; }
+        }
+    }
+}

Source/MQTTnet.Tests/Formatter/MqttPacketSerialization_V3_Binary_Tests.cs

@@ -15,7 +15,7 @@ using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Tests.Extensions;
+using MQTTnet.Tests.Helpers;
 using MQTTnet.Tests.Mockups;
 
 namespace MQTTnet.Tests.Formatter

Source/MQTTnet.Tests/Helpers/MqttClientExtensions.cs

@@ -0,0 +1,23 @@
+// 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 MQTTnet.Client;
+using MQTTnet.Tests.Mockups;
+
+namespace MQTTnet.Tests.Helpers
+{
+    public static class MqttClientExtensions
+    {
+        public static TestApplicationMessageReceivedHandler TrackReceivedMessages(this IMqttClient client)
+        {
+            if (client == null)
+            {
+                throw new ArgumentNullException(nameof(client));
+            }
+
+            return new TestApplicationMessageReceivedHandler(client);
+        }
+    }
+}

Source/MQTTnet.Tests/Helpers/MqttPacketWriterExtensions.cs

@@ -5,7 +5,7 @@
 using MQTTnet.Formatter;
 using MQTTnet.Protocol;
 
-namespace MQTTnet.Tests.Extensions
+namespace MQTTnet.Tests.Helpers
 {
     public static class MqttPacketWriterExtensions
     {

Source/MQTTnet.Tests/Helpers/ReflectionExtensions.cs

@@ -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;
+using System.Reflection;
+
+namespace MQTTnet.Tests.Helpers
+{
+    public static class ReflectionExtensions
+    {
+        public static object GetFieldValue(this object source, string fieldName)
+        {
+            if (source == null)
+            {
+                throw new ArgumentNullException(nameof(source));
+            }
+
+            var field = source.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.NonPublic);
+            if (field == null)
+            {
+                throw new ArgumentException($"Field {fieldName} not found.");
+            }
+            
+            return field.GetValue(source);
+        }
+    }
+}

Source/MQTTnet.Tests/Internal/AsyncSignal_Tests.cs

@@ -52,12 +52,26 @@ namespace MQTTnet.Tests.Internal
         }
 
         [TestMethod]
-        public async Task Loop_Signal()
+        public async Task Reset_Signal()
         {
             var asyncSignal = new AsyncSignal();
 
+            // WaitAsync should fail because no signal is available.
             for (var i = 0; i < 10; i++)
             {
+                try
+                {
+                    using (var timeout = new CancellationTokenSource(TimeSpan.FromMilliseconds(100)))
+                    {
+                        await asyncSignal.WaitAsync(timeout.Token);
+                    }
+                    
+                    Assert.Fail("This must fail because the signal is not yet set.");
+                }
+                catch (OperationCanceledException)
+                {
+                }
+                
                 asyncSignal.Set();
                 
                 // WaitAsync should return directly because the signal is available.

Source/MQTTnet.Tests/Internal/MqttPacketBusItem_Tests.cs

@@ -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.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+
+namespace MQTTnet.Tests.Internal
+{
+    [TestClass]
+    public sealed class MqttPacketBusItem_Tests
+    {
+        [TestMethod]
+        public void Fire_Completed_Event()
+        {
+            var eventFired = false;
+
+            var item = new MqttPacketBusItem(new MqttPublishPacket());
+            item.Completed += (_, __) =>
+            {
+                eventFired = true;
+            };
+
+            item.Complete();
+
+            Assert.IsTrue(eventFired);
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(TaskCanceledException))]
+        public async Task Wait_Packet_Bus_Item_After_Already_Canceled()
+        {
+            var item = new MqttPacketBusItem(new MqttPublishPacket());
+
+            // Finish the item before the actual 
+            item.Cancel();
+
+            await item.WaitAsync();
+        }
+    }
+}

Source/MQTTnet.Tests/Internal/MqttPacketBus_Tests.cs

@@ -13,7 +13,129 @@ namespace MQTTnet.Tests.Internal
 {
     [TestClass]
     public sealed class MqttPacketBus_Tests
-    {
+    {       
+        [TestMethod]
+        public void Alternate_Priorities()
+        {
+            var bus = new MqttPacketBus();
+
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
+
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttSubAckPacket()), MqttPacketBusPartition.Control);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttSubAckPacket()), MqttPacketBusPartition.Control);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttSubAckPacket()), MqttPacketBusPartition.Control);
+
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPingRespPacket()), MqttPacketBusPartition.Health);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPingRespPacket()), MqttPacketBusPartition.Health);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPingRespPacket()), MqttPacketBusPartition.Health);
+
+            Assert.AreEqual(9, bus.TotalItemsCount);
+
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPublishPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttSubAckPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPingRespPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPublishPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttSubAckPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPingRespPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPublishPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttSubAckPacket));
+            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPingRespPacket));
+
+            Assert.AreEqual(0, bus.TotalItemsCount);
+        }
+
+        [TestMethod]
+        public void Await_Single_Packet()
+        {
+            var bus = new MqttPacketBus();
+
+            var delivered = false;
+
+            var item1 = new MqttPacketBusItem(new MqttPublishPacket());
+            var item2 = new MqttPacketBusItem(new MqttPublishPacket());
+
+            var item3 = new MqttPacketBusItem(new MqttPublishPacket());
+            item3.Completed += (_, __) =>
+            {
+                delivered = true;
+            };
+
+            bus.EnqueueItem(item1, MqttPacketBusPartition.Data);
+            bus.EnqueueItem(item2, MqttPacketBusPartition.Data);
+            bus.EnqueueItem(item3, MqttPacketBusPartition.Data);
+
+            Assert.IsFalse(delivered);
+
+            bus.DequeueItemAsync(CancellationToken.None).Result.Complete();
+
+            Assert.IsFalse(delivered);
+
+            bus.DequeueItemAsync(CancellationToken.None).Result.Complete();
+
+            Assert.IsFalse(delivered);
+
+            bus.DequeueItemAsync(CancellationToken.None).Result.Complete();
+
+            // The third packet has the event attached.
+            Assert.IsTrue(delivered);
+        }
+
+        [TestMethod]
+        public void Export_Packets_Without_Dequeue()
+        {
+            var bus = new MqttPacketBus();
+
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
+            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
+
+            Assert.AreEqual(3, bus.TotalItemsCount);
+
+            var exportedPackets = bus.ExportPackets(MqttPacketBusPartition.Control);
+            Assert.AreEqual(0, exportedPackets.Count);
+
+            exportedPackets = bus.ExportPackets(MqttPacketBusPartition.Health);
+            Assert.AreEqual(0, exportedPackets.Count);
+
+            exportedPackets = bus.ExportPackets(MqttPacketBusPartition.Data);
+            Assert.AreEqual(3, exportedPackets.Count);
+
+            Assert.AreEqual(3, bus.TotalItemsCount);
+        }
+
+        [TestMethod]
+        public async Task Fill_From_Different_Task()
+        {
+            const int MessageCount = 500;
+
+            var delayRandom = new Random();
+
+            var bus = new MqttPacketBus();
+
+            _ = Task.Run(
+                () =>
+                {
+                    for (var i = 0; i < MessageCount; i++)
+                    {
+                        bus.EnqueueItem(new MqttPacketBusItem(MqttPingReqPacket.Instance), MqttPacketBusPartition.Health);
+
+                        Thread.Sleep(delayRandom.Next(0, 10));
+                    }
+                });
+
+            for (var i = 0; i < MessageCount; i++)
+            {
+                using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
+                {
+                    await bus.DequeueItemAsync(timeout.Token);
+                }
+            }
+
+            Assert.AreEqual(0, bus.TotalItemsCount);
+        }
+
         [TestMethod]
         [ExpectedException(typeof(TaskCanceledException))]
         public async Task Wait_With_Empty_Bus()
@@ -25,127 +147,5 @@ namespace MQTTnet.Tests.Internal
                 await bus.DequeueItemAsync(timeout.Token);
             }
         }
-        
-        [TestMethod]
-        public async Task Fill_From_Different_Task()
-        {
-            const int MessageCount = 500;
-
-            var delayRandom = new Random();
-            
-            var bus = new MqttPacketBus();
-
-            _ = Task.Run(
-                () =>
-                {
-                    for (int i = 0; i < MessageCount; i++)
-                    {
-                        bus.EnqueueItem(new MqttPacketBusItem(MqttPingReqPacket.Instance), MqttPacketBusPartition.Health);
-                        
-                        Thread.Sleep(delayRandom.Next(0, 10));
-                    }
-                });
-            
-            for (var i = 0; i < MessageCount; i++)
-            {
-                using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
-                {
-                    await bus.DequeueItemAsync(timeout.Token);
-                }    
-            }
-            
-            Assert.AreEqual(0, bus.TotalItemsCount);
-        }
-        
-        [TestMethod]
-        public void Alternate_Priorities()
-        {
-            var bus = new MqttPacketBus();
-            
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
-            
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttSubAckPacket()), MqttPacketBusPartition.Control);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttSubAckPacket()), MqttPacketBusPartition.Control);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttSubAckPacket()), MqttPacketBusPartition.Control);
-            
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPingRespPacket()), MqttPacketBusPartition.Health);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPingRespPacket()), MqttPacketBusPartition.Health);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPingRespPacket()), MqttPacketBusPartition.Health);
-
-            Assert.AreEqual(9, bus.TotalItemsCount);
-            
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPublishPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttSubAckPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPingRespPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPublishPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttSubAckPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPingRespPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPublishPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttSubAckPacket));
-            Assert.IsInstanceOfType(bus.DequeueItemAsync(CancellationToken.None).Result.Packet, typeof(MqttPingRespPacket));
-            
-            Assert.AreEqual(0, bus.TotalItemsCount);
-        }
-        
-        [TestMethod]
-        public void Export_Packets_Without_Dequeue()
-        {
-            var bus = new MqttPacketBus();
-
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
-            bus.EnqueueItem(new MqttPacketBusItem(new MqttPublishPacket()), MqttPacketBusPartition.Data);
-            
-            Assert.AreEqual(3, bus.TotalItemsCount);
-
-            var exportedPackets = bus.ExportPackets(MqttPacketBusPartition.Control);
-            Assert.AreEqual(0, exportedPackets.Count);
-            
-            exportedPackets = bus.ExportPackets(MqttPacketBusPartition.Health);
-            Assert.AreEqual(0, exportedPackets.Count);
-            
-            exportedPackets = bus.ExportPackets(MqttPacketBusPartition.Data);
-            Assert.AreEqual(3, exportedPackets.Count);
-            
-            Assert.AreEqual(3, bus.TotalItemsCount);
-        }
-        
-        [TestMethod]
-        public void Await_Single_Packet()
-        {
-            var bus = new MqttPacketBus();
-
-            var delivered = false;
-
-            var item1 = new MqttPacketBusItem(new MqttPublishPacket());
-            var item2 = new MqttPacketBusItem(new MqttPublishPacket());
-            
-            var item3 = new MqttPacketBusItem(new MqttPublishPacket());
-            item3.Delivered += (_, __) =>
-            {
-                delivered = true;
-            };
-            
-            bus.EnqueueItem(item1, MqttPacketBusPartition.Data);
-            bus.EnqueueItem(item2, MqttPacketBusPartition.Data);
-            bus.EnqueueItem(item3, MqttPacketBusPartition.Data);
-            
-            Assert.IsFalse(delivered);
-
-            bus.DequeueItemAsync(CancellationToken.None).Result.MarkAsDelivered();
-            
-            Assert.IsFalse(delivered);
-            
-            bus.DequeueItemAsync(CancellationToken.None).Result.MarkAsDelivered();
-            
-            Assert.IsFalse(delivered);
-            
-            bus.DequeueItemAsync(CancellationToken.None).Result.MarkAsDelivered();
-            
-            // The third packet has the event attached.
-            Assert.IsTrue(delivered);
-        }
     }
 }

Source/MQTTnet.Tests/MQTTnet.Tests.csproj

@@ -7,21 +7,20 @@
         <EnableNETAnalyzers>false</EnableNETAnalyzers>
         <EnforceCodeStyleInBuild>false</EnforceCodeStyleInBuild>
         <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
+        <NoWarn>1591;NETSDK1138</NoWarn>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="MSTest.TestAdapter" Version="2.2.10" />
         <PackageReference Include="MSTest.TestFramework" Version="2.2.10" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.2.0" />
-
-        <PackageReference Include="Microsoft.CodeAnalysis.Compilers" Version="4.0.1" />
-        <PackageReference Include="Microsoft.Net.Compilers" Version="4.0.1" />
     </ItemGroup>
 
     <ItemGroup>
         <ProjectReference Include="..\..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.csproj" />
         <ProjectReference Include="..\..\Source\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj" />
         <ProjectReference Include="..\..\Source\MQTTnet\MQTTnet.csproj" />
+        <ProjectReference Include="..\MQTTnet.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.csproj" />
     </ItemGroup>
 
 </Project>

Source/MQTTnet.Tests/MQTTv5/Client_Tests.cs

@@ -154,7 +154,7 @@ namespace MQTTnet.Tests.MQTTv5
                 var result = await client.PublishStringAsync("a", "b", MqttQualityOfServiceLevel.AtLeastOnce);
                 await client.DisconnectAsync();
 
-                Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
+                Assert.AreEqual(MqttClientPublishReasonCode.NoMatchingSubscribers, result.ReasonCode);
             }
         }
 
@@ -169,7 +169,7 @@ namespace MQTTnet.Tests.MQTTv5
                 var result = await client.PublishStringAsync("a", "b", MqttQualityOfServiceLevel.ExactlyOnce);
                 await client.DisconnectAsync();
 
-                Assert.AreEqual(MqttClientPublishReasonCode.Success, result.ReasonCode);
+                Assert.AreEqual(MqttClientPublishReasonCode.NoMatchingSubscribers, result.ReasonCode);
             }
         }
 

Source/MQTTnet.Tests/MQTTv5/Server_Tests.cs

@@ -37,9 +37,9 @@ namespace MQTTnet.Tests.MQTTv5
                 await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
                 var c2 = await testEnvironment.ConnectClient(clientOptions);
-                c2.Dispose(); // Dispose will not send a DISCONNECT pattern first so the will message must be sent.
+                c2.Dispose(); // Dispose will not send a DISCONNECT packet first so the will message must be sent.
 
-                await Task.Delay(1000);
+                await LongTestDelay();
 
                 Assert.AreEqual(1, receivedMessagesCount);
             }

Source/MQTTnet.Tests/Mockups/TestApplicationMessageReceivedHandler.cs

@@ -2,8 +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.
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
@@ -17,7 +19,23 @@ namespace MQTTnet.Tests.Mockups
 
         public TestApplicationMessageReceivedHandler(IMqttClient mqttClient)
         {
-            mqttClient.ApplicationMessageReceivedAsync += MqttClientOnApplicationMessageReceivedAsync;
+            if (mqttClient == null)
+            {
+                throw new ArgumentNullException(nameof(mqttClient));
+            }
+
+            mqttClient.ApplicationMessageReceivedAsync += OnApplicationMessageReceivedAsync;
+        }
+
+        public int Count
+        {
+            get
+            {
+                lock (_receivedEventArgs)
+                {
+                    return _receivedEventArgs.Count;
+                }
+            }
         }
 
         public List<MqttApplicationMessageReceivedEventArgs> ReceivedEventArgs
@@ -39,7 +57,25 @@ namespace MQTTnet.Tests.Mockups
             }
         }
 
-        Task MqttClientOnApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
+        public string GeneratePayloadSequence()
+        {
+            var sequence = new StringBuilder();
+
+            lock (_receivedEventArgs)
+            {
+                foreach (var receivedEventArg in _receivedEventArgs)
+                {
+                    var payload = receivedEventArg.ApplicationMessage.ConvertPayloadToString();
+
+                    // An empty payload is not part of the sequence!
+                    sequence.Append(payload);
+                }
+            }
+
+            return sequence.ToString();
+        }
+
+        Task OnApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
         {
             lock (_receivedEventArgs)
             {

Source/MQTTnet.Tests/Mockups/TestEnvironment.cs

@@ -11,6 +11,7 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Diagnostics;
+using MQTTnet.Extensions.ManagedClient;
 using MQTTnet.Extensions.Rpc;
 using MQTTnet.Formatter;
 using MQTTnet.Internal;
@@ -109,7 +110,7 @@ namespace MQTTnet.Tests.Mockups
             configureOptions.Invoke(optionsBuilder);
 
             var options = optionsBuilder.Build();
-            
+
             var client = CreateClient();
 
             if (timeout == TimeSpan.Zero)
@@ -137,7 +138,7 @@ namespace MQTTnet.Tests.Mockups
             options = options.WithTcpServer("127.0.0.1", ServerPort);
 
             var client = CreateClient();
-            
+
             if (timeout == TimeSpan.Zero)
             {
                 await client.ConnectAsync(options.Build()).ConfigureAwait(false);
@@ -161,7 +162,7 @@ namespace MQTTnet.Tests.Mockups
             }
 
             var client = CreateClient();
-            
+
             if (timeout == TimeSpan.Zero)
             {
                 await client.ConnectAsync(options).ConfigureAwait(false);
@@ -199,6 +200,16 @@ namespace MQTTnet.Tests.Mockups
             return new TestApplicationMessageReceivedHandler(mqttClient);
         }
 
+        public TestApplicationMessageReceivedHandler CreateApplicationMessageHandler(IManagedMqttClient managedClient)
+        {
+            if (managedClient == null)
+            {
+                throw new ArgumentNullException(nameof(managedClient));
+            }
+
+            return new TestApplicationMessageReceivedHandler(managedClient.InternalClient);
+        }
+
         public IMqttClient CreateClient()
         {
             lock (_clients)
@@ -325,7 +336,7 @@ namespace MQTTnet.Tests.Mockups
             var options = optionsBuilder.Build();
             var server = CreateServer(options);
             await server.StartAsync();
-            
+
             // The OS has chosen the port to we have to properly expose it to the tests.
             ServerPort = options.DefaultEndpointOptions.Port;
             return server;
@@ -344,7 +355,7 @@ namespace MQTTnet.Tests.Mockups
             var options = optionsBuilder.Build();
             var server = CreateServer(options);
             await server.StartAsync();
-            
+
             // The OS has chosen the port to we have to properly expose it to the tests.
             ServerPort = options.DefaultEndpointOptions.Port;
             return server;

Source/MQTTnet.Tests/Protocol_Tests.cs

@@ -8,27 +8,48 @@ using MQTTnet.Formatter;
 namespace MQTTnet.Tests
 {
     [TestClass]
-    public class Protocol_Tests
+    public sealed class Protocol_Tests
     {
         [TestMethod]
         public void Encode_Four_Byte_Integer()
         {
             var writer = new MqttBufferWriter(4, 4);
-            
+
             for (uint value = 0; value < 268435455; value++)
             {
                 writer.WriteVariableByteInteger(value);
-                
+
                 var buffer = writer.GetBuffer();
-                
+
                 var reader = new MqttBufferReader();
                 reader.SetBuffer(buffer, 0, writer.Length);
                 var checkValue = reader.ReadVariableByteInteger();
 
                 Assert.AreEqual(value, checkValue);
-                
+
+                writer.Reset(0);
+            }
+        }
+
+        [TestMethod]
+        public void Encode_Two_Byte_Integer()
+        {
+            var writer = new MqttBufferWriter(2, 2);
+
+            for (ushort value = 0; value < ushort.MaxValue; value++)
+            {
+                writer.WriteTwoByteInteger(value);
+
+                var buffer = writer.GetBuffer();
+
+                var reader = new MqttBufferReader();
+                reader.SetBuffer(buffer, 0, writer.Length);
+                var checkValue = reader.ReadTwoByteInteger();
+
+                Assert.AreEqual(value, checkValue);
+
                 writer.Reset(0);
             }
         }
     }
-}
+}

Source/MQTTnet.Tests/Server/Injection_Tests.cs

@@ -1,6 +1,7 @@
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
+using MQTTnet.Internal;
 using MQTTnet.Server;
 
 namespace MQTTnet.Tests.Server
@@ -60,5 +61,28 @@ namespace MQTTnet.Tests.Server
                 Assert.AreEqual("InjectedOne", messageReceivedHandler.ReceivedEventArgs[0].ApplicationMessage.Topic);
             }
         }
+
+        [TestMethod]
+        public async Task Intercept_Injected_Application_Message()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                var server = await testEnvironment.StartServer();
+
+                MqttApplicationMessage interceptedMessage = null;
+                server.InterceptingPublishAsync += eventArgs =>
+                {
+                    interceptedMessage = eventArgs.ApplicationMessage;
+                    return CompletedTask.Instance;
+                };
+
+                var injectedApplicationMessage = new MqttApplicationMessageBuilder().WithTopic("InjectedOne").Build();
+                await server.InjectApplicationMessage(new InjectedMqttApplicationMessage(injectedApplicationMessage));
+
+                await LongTestDelay();
+
+                Assert.IsNotNull(interceptedMessage);
+            }
+        }
     }
 }

Source/MQTTnet.Tests/Server/Load_Tests.cs

@@ -55,7 +55,7 @@ namespace MQTTnet.Tests.Server
                             });
                     }
 
-                    SpinWait.SpinUntil(() => receivedMessages == 100000, TimeSpan.FromSeconds(90));
+                    SpinWait.SpinUntil(() => receivedMessages == 100000, TimeSpan.FromSeconds(120));
 
                     Assert.AreEqual(100000, receivedMessages);
                 }

Source/MQTTnet.Tests/Server/MqttSubscriptionsManager_Tests.cs

@@ -114,6 +114,104 @@ namespace MQTTnet.Tests.Server
             Assert.AreEqual(result.QualityOfServiceLevel, MqttQualityOfServiceLevel.AtLeastOnce);
         }
 
+        [TestMethod]
+        public async Task MqttSubscriptionsManager_SubscribeWildcard1()
+        {
+            await SubscribeToTopic("house/+/room");
+            await SubscribeToTopic("house/+/room/+");
+
+            CheckIsSubscribed("house/1/room");
+            CheckIsSubscribed("house/1/room/bed");
+            CheckIsSubscribed("house/1/room/chair");
+            CheckIsSubscribed("house/2/room/bed");
+            CheckIsSubscribed("house/2/room/chair");
+
+            CheckIsNotSubscribed("house/1/room/bed/cover");
+            CheckIsNotSubscribed("house/1/study/bed");
+        }
+
+        [TestMethod]
+        public async Task MqttSubscriptionsManager_SubscribeWildcard2()
+        {
+            await SubscribeToTopic("house/+/room");
+            await SubscribeToTopic("house/+/room/#");
+
+            CheckIsSubscribed("house/1/room");
+            CheckIsSubscribed("house/1/room/bed");
+            CheckIsSubscribed("house/2/room");
+            CheckIsSubscribed("house/2/room/bed");
+            CheckIsSubscribed("house/2/room/bed/cover");
+
+            CheckIsNotSubscribed("house/1/level");
+            CheckIsNotSubscribed("house/1/level/door");
+        }
+
+        [TestMethod]
+        public async Task MqttSubscriptionsManager_SubscribeWildcard3()
+        {
+            await SubscribeToTopic("house/1/room");
+            await SubscribeToTopic("house/1/room/+");
+
+            CheckIsSubscribed("house/1/room");
+            CheckIsSubscribed("house/1/room/bed");
+            CheckIsSubscribed("house/1/room/chair");
+
+            CheckIsNotSubscribed("house/2/room");
+            CheckIsNotSubscribed("house/2/room/bed/cover");
+        }
+
+        [TestMethod]
+        public async Task MqttSubscriptionsManager_SubscribeWildcard4()
+        {
+            await SubscribeToTopic("house/1/+/+");
+
+            CheckIsSubscribed("house/1/room/bed");
+            CheckIsSubscribed("house/1/room/chair");
+
+            CheckIsNotSubscribed("house/1/room");
+            CheckIsNotSubscribed("house/1/room/bed/cover");
+        }
+
+        [TestMethod]
+        public async Task MqttSubscriptionsManager_SubscribeWildcard5()
+        {
+            await SubscribeToTopic("house/1/+/#");
+
+            CheckIsSubscribed("house/1/room/bed");
+            CheckIsSubscribed("house/1/room/chair");
+            CheckIsSubscribed("house/1/room/chair/leg");
+            CheckIsSubscribed("house/1/level/window");
+            CheckIsSubscribed("house/1/level/door");
+
+            CheckIsNotSubscribed("house/2/room/bed");
+        }
+
+        async Task SubscribeToTopic(string topic)
+        {
+            var sp = new MqttSubscribePacket
+            {
+                TopicFilters = new List<MqttTopicFilter>
+                {
+                    new MqttTopicFilter { Topic = topic, QualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce },
+                }
+            };
+
+            await _subscriptionsManager.Subscribe(sp, CancellationToken.None);
+        }
+
+        void CheckIsSubscribed(string topic)
+        {
+            var result = CheckSubscriptions(topic, MqttQualityOfServiceLevel.AtMostOnce, "");
+            Assert.IsTrue(result.IsSubscribed);
+            Assert.AreEqual(result.QualityOfServiceLevel, MqttQualityOfServiceLevel.AtMostOnce);
+        }
+
+        void CheckIsNotSubscribed(string topic)
+        {
+            var result = CheckSubscriptions(topic, MqttQualityOfServiceLevel.AtMostOnce, "");
+            Assert.IsFalse(result.IsSubscribed);
+        }
+
         [TestInitialize]
         public void TestInitialize()
         {

Source/MQTTnet.Tests/Server/Publish_Tests.cs

@@ -0,0 +1,58 @@
+// 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.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Publish_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Return_Success_When_Subscribed()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+
+                var sender = await testEnvironment.ConnectClient();
+                var receiver = await testEnvironment.ConnectClient();
+
+                await receiver.SubscribeAsync("A");
+
+                // AtLeastOnce is required to get an ACK packet from the server.
+                var publishResult = await sender.PublishStringAsync("A", "Payload", MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                Assert.AreEqual(MqttClientPublishReasonCode.Success, publishResult.ReasonCode);
+                
+                Assert.AreEqual(true, publishResult.IsSuccess);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Return_NoMatchingSubscribers_When_Not_Subscribed()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer();
+
+                var sender = await testEnvironment.ConnectClient();
+                var receiver = await testEnvironment.ConnectClient();
+             
+                await receiver.SubscribeAsync("A");
+
+                // AtLeastOnce is required to get an ACK packet from the server.
+                var publishResult = await sender.PublishStringAsync("B", "Payload", MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                Assert.AreEqual(MqttClientPublishReasonCode.NoMatchingSubscribers, publishResult.ReasonCode);
+                
+                Assert.AreEqual(true, publishResult.IsSuccess);
+            }
+        }
+    }
+}

Source/MQTTnet.Tests/Server/QoS_Tests.cs

@@ -15,6 +15,60 @@ namespace MQTTnet.Tests.Server
     [TestClass]
     public sealed class QoS_Tests : BaseTestClass
     {
+        [TestMethod]
+        public async Task Preserve_Message_Order_For_Queued_Messages()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                var server = await testEnvironment.StartServer(o => o.WithPersistentSessions());
+
+                // Create a session which will contain the messages.
+                var dummyClient = await testEnvironment.ConnectClient(o => o.WithClientId("A").WithCleanSession(false));
+                await dummyClient.SubscribeAsync("#", MqttQualityOfServiceLevel.AtLeastOnce);
+                dummyClient.Dispose();
+
+                await LongTestDelay();
+                await LongTestDelay();
+                
+                // Now inject messages which are appended to the queue of the client.
+                await server.InjectApplicationMessage("T", "0", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                await server.InjectApplicationMessage("T", "2", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                await server.InjectApplicationMessage("T", "1", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                await server.InjectApplicationMessage("T", "4", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                await server.InjectApplicationMessage("T", "3", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                await server.InjectApplicationMessage("T", "6", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                await server.InjectApplicationMessage("T", "5", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                await server.InjectApplicationMessage("T", "8", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                await server.InjectApplicationMessage("T", "7", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                await server.InjectApplicationMessage("T", "9", qualityOfServiceLevel: MqttQualityOfServiceLevel.AtLeastOnce);
+                
+                await LongTestDelay();
+                
+                // Create a new client for the existing message.
+                var client = await testEnvironment.ConnectClient(o => o.WithClientId("A").WithCleanSession(false));
+                var messages = testEnvironment.CreateApplicationMessageHandler(client);
+                
+                await LongTestDelay();
+                
+                var payloadSequence = messages.GeneratePayloadSequence();
+                Assert.AreEqual("0214365879", payloadSequence);
+
+                // Disconnect and reconnect to make sure that the server will not send the messages twice.
+                await client.DisconnectAsync();
+                await LongTestDelay();
+                await client.ReconnectAsync();
+                await LongTestDelay();
+                
+                payloadSequence = messages.GeneratePayloadSequence();
+                Assert.AreEqual("0214365879", payloadSequence);
+            }
+        }
+        
         [TestMethod]
         public async Task Fire_Event_On_Client_Acknowledges_QoS_0()
         {

Source/MQTTnet.Tests/Server/Session_Tests.cs

@@ -121,10 +121,9 @@ namespace MQTTnet.Tests.Server
                 Assert.AreEqual(true, session.Items["can_subscribe_x"]);
             }
         }
-
-        #if !NET452
         
         [TestMethod]
+        [DataRow(MqttProtocolVersion.V310)]
         [DataRow(MqttProtocolVersion.V311)]
         [DataRow(MqttProtocolVersion.V500)]
         public async Task Handle_Parallel_Connection_Attempts(MqttProtocolVersion protocolVersion)
@@ -150,8 +149,6 @@ namespace MQTTnet.Tests.Server
                 // Try to connect 50 clients at the same time.
                 var clients = await Task.WhenAll(Enumerable.Range(0, 50).Select(i => ConnectAndSubscribe(testEnvironment, options, OnReceive)));
 
-                await Task.Delay(5000);
-                
                 var connectedClients = clients.Where(c => c?.TryPingAsync().GetAwaiter().GetResult() == true).ToList();
 
                 await LongTestDelay();
@@ -162,13 +159,12 @@ namespace MQTTnet.Tests.Server
                 var sendClient = await testEnvironment.ConnectClient(option2);
                 await sendClient.PublishStringAsync("aaa", "1");
 
-                await Task.Delay(3000);
+                await LongTestDelay();
 
                 Assert.AreEqual(true, hasReceive);
             }
         }
-#endif
-        
+ 
         [DataTestMethod]
         [DataRow(MqttQualityOfServiceLevel.ExactlyOnce)]
         [DataRow(MqttQualityOfServiceLevel.AtLeastOnce)]

Source/MQTTnet.Tests/Server/Subscribe_Tests.cs

@@ -13,12 +13,56 @@ using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
+using MQTTnet.Tests.Helpers;
 
 namespace MQTTnet.Tests.Server
 {
     [TestClass]
     public sealed class Subscribe_Tests : BaseTestClass
     {
+        [DataTestMethod]
+        [DataRow("A", "A", true)]
+        [DataRow("A", "B", false)]
+        [DataRow("A", "#", true)]
+        [DataRow("A", "+", true)]
+        [DataRow("A/B", "A/B", true)]
+        [DataRow("A/B", "A/+", true)]
+        [DataRow("A/B", "A/#", true)]
+        [DataRow("A/B/C", "A/B/C", true)]
+        [DataRow("A/B/C", "A/+/C", true)]
+        [DataRow("A/B/C", "A/+/+", true)]
+        [DataRow("A/B/C", "A/+/#", true)]
+        [DataRow("A/B/C/D", "A/B/C/D", true)]
+        [DataRow("A/B/C/D", "A/+/C/+", true)]
+        [DataRow("A/B/C/D", "A/+/C/#", true)]
+        [DataRow("A/B/C", "A/B/+", true)]
+        [DataRow("A/B1/B2/C", "A/+/C", false)]
+        public async Task Subscription_Roundtrip(string topic, string filter, bool shouldWork)
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer().ConfigureAwait(false);
+
+                var receiver = await testEnvironment.ConnectClient();
+                await receiver.SubscribeAsync(filter).ConfigureAwait(false);
+                var receivedMessages = receiver.TrackReceivedMessages();
+
+                var sender = await testEnvironment.ConnectClient();
+                await sender.PublishStringAsync(topic, "PAYLOAD").ConfigureAwait(false);
+
+                await LongTestDelay().ConfigureAwait(false);
+
+                if (shouldWork)
+                {
+                    Assert.AreEqual(1, receivedMessages.Count, message: "The filter should work!");
+                }
+                else
+                {
+                    Assert.AreEqual(0, receivedMessages.Count, message: "The filter should not work!");
+                }
+            }
+        }
+        
         [TestMethod]
         public async Task Deny_Invalid_Topic()
         {

Source/MQTTnet.Tests/Server/Will_Tests.cs

@@ -1,4 +1,3 @@
-using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
@@ -10,33 +9,51 @@ namespace MQTTnet.Tests.Server
     [TestClass]
     public sealed class Will_Tests : BaseTestClass
     {
+        [TestMethod]
+        public async Task Intercept_Will_Message()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                var server = await testEnvironment.StartServer().ConfigureAwait(false);
+
+                MqttApplicationMessage willMessage = null;
+                server.InterceptingPublishAsync += eventArgs =>
+                {
+                    willMessage = eventArgs.ApplicationMessage;
+                    return CompletedTask.Instance;
+                };
+
+                await testEnvironment.ConnectClient(new MqttClientOptionsBuilder()).ConfigureAwait(false);
+                var clientOptions = new MqttClientOptionsBuilder().WithWillTopic("My/last/will").WithWillQualityOfServiceLevel(MqttQualityOfServiceLevel.AtMostOnce);
+                var takeOverClient = await testEnvironment.ConnectClient(clientOptions).ConfigureAwait(false);
+                takeOverClient.Dispose(); // Dispose will not send a DISCONNECT pattern first so the will message must be sent.
+
+                await LongTestDelay().ConfigureAwait(false);
+
+                Assert.IsNotNull(willMessage);
+            }
+        }
+
         [TestMethod]
         public async Task Will_Message_Do_Not_Send_On_Clean_Disconnect()
         {
             using (var testEnvironment = CreateTestEnvironment())
             {
-                var receivedMessagesCount = 0;
-
                 await testEnvironment.StartServer();
 
+                var receiver = await testEnvironment.ConnectClient().ConfigureAwait(false);
+
+                var receivedMessages = testEnvironment.CreateApplicationMessageHandler(receiver);
+
+                await receiver.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
+
                 var clientOptions = new MqttClientOptionsBuilder().WithWillTopic("My/last/will");
+                var sender = await testEnvironment.ConnectClient(clientOptions).ConfigureAwait(false);
+                await sender.DisconnectAsync().ConfigureAwait(false);
 
-                var c1 = await testEnvironment.ConnectClient();
+                await LongTestDelay().ConfigureAwait(false);
 
-                c1.ApplicationMessageReceivedAsync += e =>
-                {
-                    Interlocked.Increment(ref receivedMessagesCount);
-                    return CompletedTask.Instance;
-                };
-
-                await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
-
-                var c2 = await testEnvironment.ConnectClient(clientOptions);
-                await c2.DisconnectAsync().ConfigureAwait(false);
-
-                await Task.Delay(1000);
-
-                Assert.AreEqual(0, receivedMessagesCount);
+                Assert.AreEqual(0, receivedMessages.ReceivedEventArgs.Count);
             }
         }
 
@@ -47,24 +64,17 @@ namespace MQTTnet.Tests.Server
             {
                 await testEnvironment.StartServer();
 
-                var c1 = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder());
-
-                var receivedMessagesCount = 0;
-                c1.ApplicationMessageReceivedAsync += e =>
-                {
-                    Interlocked.Increment(ref receivedMessagesCount);
-                    return CompletedTask.Instance;
-                };
-
-                await c1.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
+                var receiver = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder()).ConfigureAwait(false);
+                var receivedMessages = testEnvironment.CreateApplicationMessageHandler(receiver);
+                await receiver.SubscribeAsync(new MqttTopicFilterBuilder().WithTopic("#").Build());
 
                 var clientOptions = new MqttClientOptionsBuilder().WithWillTopic("My/last/will").WithWillQualityOfServiceLevel(MqttQualityOfServiceLevel.AtMostOnce);
-                var c2 = await testEnvironment.ConnectClient(clientOptions);
-                c2.Dispose(); // Dispose will not send a DISCONNECT pattern first so the will message must be sent.
+                var takeOverClient = await testEnvironment.ConnectClient(clientOptions).ConfigureAwait(false);
+                takeOverClient.Dispose(); // Dispose will not send a DISCONNECT pattern first so the will message must be sent.
 
-                await Task.Delay(1000);
+                await LongTestDelay().ConfigureAwait(false);
 
-                Assert.AreEqual(1, receivedMessagesCount);
+                Assert.AreEqual(1, receivedMessages.ReceivedEventArgs.Count);
             }
         }
     }

Source/MQTTnet/Adapter/MqttChannelAdapter.cs

@@ -86,7 +86,7 @@ namespace MQTTnet.Adapter
                     await Task.WhenAny(connectTask, timeout.Task).ConfigureAwait(false);
                     if (timeout.Task.IsCompleted && !connectTask.IsCompleted)
                     {
-                        throw new OperationCanceledException("MQTT connect cancelled.", cancellationToken);
+                        throw new OperationCanceledException("MQTT connect canceled.", cancellationToken);
                     }
 
                     // Make sure that the exception from the connect task gets thrown.
@@ -298,7 +298,7 @@ namespace MQTTnet.Adapter
                 // Check two times for cancellation because the call to _ReadAsync_ might block for some time.
                 if (cancellationToken.IsCancellationRequested)
                 {
-                    return ReadFixedHeaderResult.Cancelled;
+                    return ReadFixedHeaderResult.Canceled;
                 }
 
                 int bytesRead;
@@ -308,7 +308,7 @@ namespace MQTTnet.Adapter
                 }
                 catch (OperationCanceledException)
                 {
-                    return ReadFixedHeaderResult.Cancelled;
+                    return ReadFixedHeaderResult.Canceled;
                 }
                 catch (SocketException)
                 {
@@ -317,7 +317,7 @@ namespace MQTTnet.Adapter
                
                 if (cancellationToken.IsCancellationRequested)
                 {
-                    return ReadFixedHeaderResult.Cancelled;
+                    return ReadFixedHeaderResult.Canceled;
                 }
 
                 if (bytesRead == 0)

Source/MQTTnet/Client/MqttClient.cs

@@ -19,7 +19,6 @@ namespace MQTTnet.Client
     public sealed class MqttClient : Disposable, IMqttClient
     {
         readonly IMqttClientAdapterFactory _adapterFactory;
-        readonly MqttApplicationMessageFactory _applicationMessageFactory = new MqttApplicationMessageFactory();
         readonly AsyncEvent<MqttApplicationMessageReceivedEventArgs> _applicationMessageReceivedEvent = new AsyncEvent<MqttApplicationMessageReceivedEventArgs>();
 
         readonly MqttClientPublishResultFactory _clientPublishResultFactory = new MqttClientPublishResultFactory();
@@ -32,7 +31,6 @@ namespace MQTTnet.Client
         readonly object _disconnectLock = new object();
         readonly AsyncEvent<InspectMqttPacketEventArgs> _inspectPacketEvent = new AsyncEvent<InspectMqttPacketEventArgs>();
         readonly MqttNetSourceLogger _logger;
-        readonly MqttPacketFactories _packetFactories = new MqttPacketFactories();
 
         readonly MqttPacketIdentifierProvider _packetIdentifierProvider = new MqttPacketIdentifierProvider();
         readonly IMqttNetLogger _rootLogger;
@@ -207,7 +205,7 @@ namespace MQTTnet.Client
 
                 if (clientWasConnected)
                 {
-                    var disconnectPacket = _packetFactories.Disconnect.Create(options);
+                    var disconnectPacket = MqttPacketFactories.Disconnect.Create(options);
                     await SendAsync(disconnectPacket, cancellationToken).ConfigureAwait(false);
                 }
             }
@@ -241,7 +239,7 @@ namespace MQTTnet.Client
             ThrowIfDisposed();
             ThrowIfNotConnected();
 
-            var publishPacket = _packetFactories.Publish.Create(applicationMessage);
+            var publishPacket = MqttPacketFactories.Publish.Create(applicationMessage);
 
             switch (applicationMessage.QualityOfServiceLevel)
             {
@@ -301,7 +299,7 @@ namespace MQTTnet.Client
             ThrowIfDisposed();
             ThrowIfNotConnected();
 
-            var subscribePacket = _packetFactories.Subscribe.Create(options);
+            var subscribePacket = MqttPacketFactories.Subscribe.Create(options);
             subscribePacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
 
             var subAckPacket = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket, cancellationToken).ConfigureAwait(false);
@@ -319,7 +317,7 @@ namespace MQTTnet.Client
             ThrowIfDisposed();
             ThrowIfNotConnected();
 
-            var unsubscribePacket = _packetFactories.Unsubscribe.Create(options);
+            var unsubscribePacket = MqttPacketFactories.Unsubscribe.Create(options);
             unsubscribePacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
 
             var unsubAckPacket = await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket, cancellationToken).ConfigureAwait(false);
@@ -347,7 +345,7 @@ namespace MQTTnet.Client
             {
                 if (!eventArgs.ProcessingFailed)
                 {
-                    var pubAckPacket = _packetFactories.PubAck.Create(eventArgs);
+                    var pubAckPacket = MqttPacketFactories.PubAck.Create(eventArgs);
                     return SendAsync(pubAckPacket, cancellationToken);
                 }
             }
@@ -355,7 +353,7 @@ namespace MQTTnet.Client
             {
                 if (!eventArgs.ProcessingFailed)
                 {
-                    var pubRecPacket = _packetFactories.PubRec.Create(eventArgs);
+                    var pubRecPacket = MqttPacketFactories.PubRec.Create(eventArgs);
                     return SendAsync(pubRecPacket, cancellationToken);
                 }
             }
@@ -373,7 +371,7 @@ namespace MQTTnet.Client
 
             try
             {
-                var connectPacket = _packetFactories.Connect.Create(options);
+                var connectPacket = MqttPacketFactories.Connect.Create(options);
 
                 var connAckPacket = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket, cancellationToken).ConfigureAwait(false);
 
@@ -535,7 +533,7 @@ namespace MQTTnet.Client
 
         async Task<MqttApplicationMessageReceivedEventArgs> HandleReceivedApplicationMessageAsync(MqttPublishPacket publishPacket)
         {
-            var applicationMessage = _applicationMessageFactory.Create(publishPacket);
+            var applicationMessage = MqttApplicationMessageFactory.Create(publishPacket);
             var eventArgs = new MqttApplicationMessageReceivedEventArgs(Options.ClientId, applicationMessage, publishPacket, AcknowledgeReceivedPublishPacket);
 
             await _applicationMessageReceivedEvent.InvokeAsync(eventArgs).ConfigureAwait(false);
@@ -601,7 +599,7 @@ namespace MQTTnet.Client
             {
                 // The packet is unknown. Probably due to a restart of the client.
                 // So wen send this to the server to trigger a full resend of the message.
-                var pubRelPacket = _packetFactories.PubRel.Create(pubRecPacket, MqttApplicationMessageReceivedReasonCode.PacketIdentifierNotFound);
+                var pubRelPacket = MqttPacketFactories.PubRel.Create(pubRecPacket, MqttApplicationMessageReceivedReasonCode.PacketIdentifierNotFound);
                 return SendAsync(pubRelPacket, cancellationToken);
             }
 
@@ -610,7 +608,7 @@ namespace MQTTnet.Client
 
         Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
         {
-            var pubCompPacket = _packetFactories.PubComp.Create(pubRelPacket, MqttApplicationMessageReceivedReasonCode.Success);
+            var pubCompPacket = MqttPacketFactories.PubComp.Create(pubRelPacket, MqttApplicationMessageReceivedReasonCode.Success);
             return SendAsync(pubCompPacket, cancellationToken);
         }
 
@@ -637,7 +635,7 @@ namespace MQTTnet.Client
 
             var pubRecPacket = await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket, cancellationToken).ConfigureAwait(false);
 
-            var pubRelPacket = _packetFactories.PubRel.Create(pubRecPacket, MqttApplicationMessageReceivedReasonCode.Success);
+            var pubRelPacket = MqttPacketFactories.PubRel.Create(pubRecPacket, MqttApplicationMessageReceivedReasonCode.Success);
 
             var pubCompPacket = await SendAndReceiveAsync<MqttPubCompPacket>(pubRelPacket, cancellationToken).ConfigureAwait(false);
 

Source/MQTTnet/Client/MqttClientExtensions.cs

@@ -14,26 +14,6 @@ namespace MQTTnet.Client
 {
     public static class MqttClientExtensions
     {
-        public static async Task<bool> TryPingAsync(this IMqttClient client, CancellationToken cancellationToken = default)
-        {
-            if (client == null)
-            {
-                throw new ArgumentNullException(nameof(client));
-            }
-
-            try
-            {
-                await client.PingAsync(cancellationToken).ConfigureAwait(false);
-                return true;
-            }
-            catch
-            {
-                // Ignore errors.
-            }
-
-            return false;
-        }
-        
         public static Task DisconnectAsync(this IMqttClient client, MqttClientDisconnectReason reason = MqttClientDisconnectReason.NormalDisconnection, string reasonString = null)
         {
             if (client == null)
@@ -89,6 +69,17 @@ namespace MQTTnet.Client
             return mqttClient.PublishBinaryAsync(topic, payloadBuffer, qualityOfServiceLevel, retain, cancellationToken);
         }
 
+        public static Task ReconnectAsync(this IMqttClient client, CancellationToken cancellationToken = default)
+        {
+            if (client.Options == null)
+            {
+                throw new InvalidOperationException(
+                    "The MQTT client was not connected before. A reconnect is only permitted when the client was already connected or at least tried to.");
+            }
+
+            return client.ConnectAsync(client.Options, cancellationToken);
+        }
+
         public static Task SendExtendedAuthenticationExchangeDataAsync(this IMqttClient client, MqttExtendedAuthenticationExchangeData data)
         {
             if (client == null)
@@ -137,6 +128,26 @@ namespace MQTTnet.Client
             return mqttClient.SubscribeAsync(subscribeOptions, cancellationToken);
         }
 
+        public static async Task<bool> TryPingAsync(this IMqttClient client, CancellationToken cancellationToken = default)
+        {
+            if (client == null)
+            {
+                throw new ArgumentNullException(nameof(client));
+            }
+
+            try
+            {
+                await client.PingAsync(cancellationToken).ConfigureAwait(false);
+                return true;
+            }
+            catch
+            {
+                // Ignore errors.
+            }
+
+            return false;
+        }
+
         public static Task<MqttClientUnsubscribeResult> UnsubscribeAsync(this IMqttClient mqttClient, string topic, CancellationToken cancellationToken = default)
         {
             if (mqttClient == null)

Source/MQTTnet/Client/Publishing/MqttClientPublishResult.cs

@@ -10,29 +10,38 @@ namespace MQTTnet.Client
     public sealed class MqttClientPublishResult
     {
         /// <summary>
-        /// Gets the packet identifier which was used for this publish.
+        ///     Returns if the overall status of the publish is a success. This can be the reason code _Success_ or
+        ///     _NoMatchingSubscribers_. _NoMatchingSubscribers_ usually indicates only that no other client is interested in the topic but overall transmit
+        ///     to the server etc. was a success.
+        /// </summary>
+        public bool IsSuccess => ReasonCode == MqttClientPublishReasonCode.Success || ReasonCode == MqttClientPublishReasonCode.NoMatchingSubscribers;
+
+        /// <summary>
+        ///     Gets the packet identifier which was used for this publish.
         /// </summary>
         public ushort? PacketIdentifier { get; set; }
 
         /// <summary>
-        /// Gets or sets the reason code.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the reason code.
+        ///     Hint: MQTT 5 feature only.
         /// </summary>
         public MqttClientPublishReasonCode ReasonCode { get; set; } = MqttClientPublishReasonCode.Success;
 
         /// <summary>
-        /// Gets or sets the reason string.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the reason string.
+        ///     Hint: MQTT 5 feature only.
         /// </summary>
         public string ReasonString { get; set; }
 
         /// <summary>
-        /// Gets or sets the user properties.
-        /// In MQTT 5, user properties are basic UTF-8 string key-value pairs that you can append to almost every type of MQTT packet.
-        /// As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add metadata to MQTT messages and pass information between publisher, broker, and subscriber.
-        /// The feature is very similar to the HTTP header concept.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the user properties.
+        ///     In MQTT 5, user properties are basic UTF-8 string key-value pairs that you can append to almost every type of MQTT
+        ///     packet.
+        ///     As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add
+        ///     metadata to MQTT messages and pass information between publisher, broker, and subscriber.
+        ///     The feature is very similar to the HTTP header concept.
+        ///     Hint: MQTT 5 feature only.
         /// </summary>
         public IReadOnlyCollection<MqttUserProperty> UserProperties { get; internal set; }
     }
-}
+}

Source/MQTTnet/Diagnostics/Logger/MqttNetSourceLoggerExtensions.cs

@@ -6,17 +6,100 @@ using System;
 
 namespace MQTTnet.Diagnostics
 {
+    /*
+     * The logger uses generic parameters in order to avoid boxing of parameter values like integers etc.
+     */
+    
     public static class MqttNetSourceLoggerExtensions
     {
-        /*
-         * The logger uses generic parameters in order to avoid boxing of parameter values like integers etc.
-         */
-
-        public static MqttNetSourceLogger WithSource(this IMqttNetLogger logger, string source)
+        public static void Error<TParameter1>(this MqttNetSourceLogger logger, Exception exception, string message, TParameter1 parameter1)
         {
-            if (logger == null) throw new ArgumentNullException(nameof(logger));
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
 
-            return new MqttNetSourceLogger(logger, source);
+            logger.Publish(MqttNetLogLevel.Error, message, new object[] { parameter1 }, exception);
+        }
+
+        public static void Error<TParameter1, TParameter2>(this MqttNetSourceLogger logger, Exception exception, string message, TParameter1 parameter1, TParameter2 parameter2)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(MqttNetLogLevel.Error, message, new object[] { parameter1, parameter2 }, exception);
+        }
+
+        public static void Error(this MqttNetSourceLogger logger, Exception exception, string message)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(MqttNetLogLevel.Error, message, null, exception);
+        }
+
+        public static void Error(this MqttNetSourceLogger logger, string message)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(MqttNetLogLevel.Error, message, null, null);
+        }
+
+        public static void Info<TParameter1>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(MqttNetLogLevel.Info, message, new object[] { parameter1 }, null);
+        }
+
+        public static void Info<TParameter1, TParameter2>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1, TParameter2 parameter2)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(MqttNetLogLevel.Info, message, new object[] { parameter1, parameter2 }, null);
+        }
+
+        public static void Info(this MqttNetSourceLogger logger, string message)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(MqttNetLogLevel.Info, message, null, null);
+        }
+
+        public static void Publish<TParameter1>(this MqttNetSourceLogger logger, MqttNetLogLevel logLevel, Exception exception, string message, TParameter1 parameter1)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(logLevel, message, new object[] { parameter1 }, exception);
+        }
+        
+        public static void Publish<TParameter1, TParameter2>(this MqttNetSourceLogger logger, MqttNetLogLevel logLevel, Exception exception, string message, TParameter1 parameter1, TParameter2 parameter2)
+        {
+            if (!logger.IsEnabled)
+            {
+                return;
+            }
+
+            logger.Publish(logLevel, message, new object[] { parameter1, parameter2 }, exception);
         }
 
         public static void Verbose<TParameter1>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1)
@@ -26,7 +109,7 @@ namespace MQTTnet.Diagnostics
                 return;
             }
 
-            logger.Publish(MqttNetLogLevel.Verbose, message, new object[] {parameter1}, null);
+            logger.Publish(MqttNetLogLevel.Verbose, message, new object[] { parameter1 }, null);
         }
 
         public static void Verbose<TParameter1, TParameter2>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1, TParameter2 parameter2)
@@ -36,10 +119,14 @@ namespace MQTTnet.Diagnostics
                 return;
             }
 
-            logger.Publish(MqttNetLogLevel.Verbose, message, new object[] {parameter1, parameter2}, null);
+            logger.Publish(MqttNetLogLevel.Verbose, message, new object[] { parameter1, parameter2 }, null);
         }
 
-        public static void Verbose<TParameter1, TParameter2, TParameter3>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1, TParameter2 parameter2,
+        public static void Verbose<TParameter1, TParameter2, TParameter3>(
+            this MqttNetSourceLogger logger,
+            string message,
+            TParameter1 parameter1,
+            TParameter2 parameter2,
             TParameter3 parameter3)
         {
             if (!logger.IsEnabled)
@@ -47,7 +134,7 @@ namespace MQTTnet.Diagnostics
                 return;
             }
 
-            logger.Publish(MqttNetLogLevel.Verbose, message, new object[] {parameter1, parameter2, parameter3}, null);
+            logger.Publish(MqttNetLogLevel.Verbose, message, new object[] { parameter1, parameter2, parameter3 }, null);
         }
 
         public static void Verbose(this MqttNetSourceLogger logger, string message)
@@ -60,134 +147,74 @@ namespace MQTTnet.Diagnostics
             logger.Publish(MqttNetLogLevel.Verbose, message, null, null);
         }
 
-        public static void Info<TParameter1>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1)
-        {
-            if (!logger.IsEnabled)
-            {
-                return;
-            }
-
-            logger.Publish(MqttNetLogLevel.Info, message, new object[] {parameter1}, null);
-        }
-        
-        public static void Info<TParameter1, TParameter2>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1, TParameter2 parameter2)
-        {
-            if (!logger.IsEnabled)
-            {
-                return;
-            }
-
-            logger.Publish(MqttNetLogLevel.Info, message, new object[] {parameter1, parameter2}, null);
-        }
-
-        public static void Info(this MqttNetSourceLogger logger, string message)
-        {
-            if (!logger.IsEnabled)
-            {
-                return;
-            }
-            
-            logger.Publish(MqttNetLogLevel.Info, message, null, null);
-        }
-
         public static void Warning<TParameter1>(this MqttNetSourceLogger logger, Exception exception, string message, TParameter1 parameter1)
         {
             if (!logger.IsEnabled)
             {
                 return;
             }
-            
-            logger.Publish(MqttNetLogLevel.Warning, message, new object[] {parameter1}, exception);
+
+            logger.Publish(MqttNetLogLevel.Warning, message, new object[] { parameter1 }, exception);
         }
-        
+
         public static void Warning<TParameter1, TParameter2>(this MqttNetSourceLogger logger, Exception exception, string message, TParameter1 parameter1, TParameter2 parameter2)
         {
             if (!logger.IsEnabled)
             {
                 return;
             }
-            
-            logger.Publish(MqttNetLogLevel.Warning, message, new object[] {parameter1, parameter2}, exception);
+
+            logger.Publish(MqttNetLogLevel.Warning, message, new object[] { parameter1, parameter2 }, exception);
         }
-        
+
         public static void Warning(this MqttNetSourceLogger logger, Exception exception, string message)
         {
             if (!logger.IsEnabled)
             {
                 return;
             }
-            
+
             logger.Publish(MqttNetLogLevel.Warning, message, null, exception);
         }
-        
+
         public static void Warning<TParameter1>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1)
         {
             if (!logger.IsEnabled)
             {
                 return;
             }
-            
-            logger.Publish(MqttNetLogLevel.Warning, message, new object[] {parameter1}, null);
+
+            logger.Publish(MqttNetLogLevel.Warning, message, new object[] { parameter1 }, null);
         }
-        
+
         public static void Warning<TParameter1, TParameter2>(this MqttNetSourceLogger logger, string message, TParameter1 parameter1, TParameter2 parameter2)
         {
             if (!logger.IsEnabled)
             {
                 return;
             }
-            
-            logger.Publish(MqttNetLogLevel.Warning, message, new object[] {parameter1, parameter2}, null);
+
+            logger.Publish(MqttNetLogLevel.Warning, message, new object[] { parameter1, parameter2 }, null);
         }
-        
+
         public static void Warning(this MqttNetSourceLogger logger, string message)
         {
             if (!logger.IsEnabled)
             {
                 return;
             }
-            
+
             logger.Publish(MqttNetLogLevel.Warning, message, null, null);
         }
 
-        public static void Error<TParameter1>(this MqttNetSourceLogger logger, Exception exception, string message, TParameter1 parameter1)
+        public static MqttNetSourceLogger WithSource(this IMqttNetLogger logger, string source)
         {
-            if (!logger.IsEnabled)
+            if (logger == null)
             {
-                return;
+                throw new ArgumentNullException(nameof(logger));
             }
-            
-            logger.Publish(MqttNetLogLevel.Error, message, new object[] {parameter1}, exception);
-        }
-        
-        public static void Error<TParameter1, TParameter2>(this MqttNetSourceLogger logger, Exception exception, string message, TParameter1 parameter1, TParameter2 parameter2)
-        {
-            if (!logger.IsEnabled)
-            {
-                return;
-            }
-            
-            logger.Publish(MqttNetLogLevel.Error, message, new object[] {parameter1, parameter2}, exception);
-        }
 
-        public static void Error(this MqttNetSourceLogger logger, Exception exception, string message)
-        {
-            if (!logger.IsEnabled)
-            {
-                return;
-            }
-            
-            logger.Publish(MqttNetLogLevel.Error, message, null, exception);
-        }
-
-        public static void Error(this MqttNetSourceLogger logger, string message)
-        {
-            if (!logger.IsEnabled)
-            {
-                return;
-            }
-            
-            logger.Publish(MqttNetLogLevel.Error, message, null, null);
+            return new MqttNetSourceLogger(logger, source);
         }
     }
 }

Source/MQTTnet/Formatter/MqttApplicationMessageFactory.cs

@@ -7,9 +7,9 @@ using MQTTnet.Packets;
 
 namespace MQTTnet.Formatter
 {
-    public sealed class MqttApplicationMessageFactory
+    public static class MqttApplicationMessageFactory
     {
-        public MqttApplicationMessage Create(MqttPublishPacket publishPacket)
+        public static MqttApplicationMessage Create(MqttPublishPacket publishPacket)
         {
             if (publishPacket == null)
             {

Source/MQTTnet/Formatter/MqttBufferReader.cs

@@ -7,21 +7,24 @@ using System.Runtime.CompilerServices;
 using System.Text;
 using MQTTnet.Exceptions;
 using MQTTnet.Internal;
+#if NETCOREAPP3_0_OR_GREATER
+using System.Buffers.Binary;
+#endif
 
 namespace MQTTnet.Formatter
 {
     public sealed class MqttBufferReader
     {
         byte[] _buffer = EmptyBuffer.Array;
-        int _initialPosition;
-        int _length;
+        int _maxPosition;
+        int _offset;
         int _position;
 
-        public bool EndOfStream => _position == _length;
-        
-        public int Position => _position;
-        
-        public int BytesLeft => _length - _position;
+        public int BytesLeft => _maxPosition - _position;
+
+        public bool EndOfStream => BytesLeft == 0;
+
+        public int Position => _position - _offset;
 
         public byte[] ReadBinaryData()
         {
@@ -35,7 +38,7 @@ namespace MQTTnet.Formatter
             ValidateReceiveBuffer(length);
 
             var result = new byte[length];
-            Array.Copy(_buffer, _position, result, 0, length);
+            MqttMemoryHelper.Copy(_buffer, _position, result, 0, length);
             _position += length;
 
             return result;
@@ -44,7 +47,6 @@ namespace MQTTnet.Formatter
         public byte ReadByte()
         {
             ValidateReceiveBuffer(1);
-
             return _buffer[_position++];
         }
 
@@ -52,25 +54,32 @@ namespace MQTTnet.Formatter
         {
             ValidateReceiveBuffer(4);
 
-            var byte0 = _buffer[_position++];
-            var byte1 = _buffer[_position++];
-            var byte2 = _buffer[_position++];
-            var byte3 = _buffer[_position++];
+#if NETCOREAPP3_0_OR_GREATER
+            var value = BinaryPrimitives.ReadUInt32BigEndian(_buffer.AsSpan(_position));
+#else
+            var byte0 = _buffer[_position];
+            var byte1 = _buffer[_position + 1];
+            var byte2 = _buffer[_position + 2];
+            var byte3 = _buffer[_position + 3];
 
-            return (uint)((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
+            var value = (uint)((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3);
+#endif
+
+            _position += 4;
+            return value;
         }
 
         public byte[] ReadRemainingData()
         {
-            var bufferLength = _length - _position;
-
+            var bufferLength = BytesLeft;
             if (bufferLength == 0)
             {
                 return EmptyBuffer.Array;
             }
-            
+
             var buffer = new byte[bufferLength];
-            Array.Copy(_buffer, _position, buffer, 0, bufferLength);
+            MqttMemoryHelper.Copy(_buffer, _position, buffer, 0, bufferLength);
+            _position += bufferLength;
 
             return buffer;
         }
@@ -83,10 +92,16 @@ namespace MQTTnet.Formatter
             {
                 return string.Empty;
             }
-            
+
             ValidateReceiveBuffer(length);
 
+#if NETCOREAPP3_0_OR_GREATER
+            // AsSpan() version is slightly faster. Not much but at least a little bit.
+            var result = Encoding.UTF8.GetString(_buffer.AsSpan(_position, length));
+#else
             var result = Encoding.UTF8.GetString(_buffer, _position, length);
+#endif
+
             _position += length;
             return result;
         }
@@ -95,10 +110,17 @@ namespace MQTTnet.Formatter
         {
             ValidateReceiveBuffer(2);
 
-            var msb = _buffer[_position++];
-            var lsb = _buffer[_position++];
+#if NETCOREAPP3_0_OR_GREATER
+            var value = BinaryPrimitives.ReadUInt16BigEndian(_buffer.AsSpan(_position));
+#else
+            var msb = _buffer[_position];
+            var lsb = _buffer[_position + 1];
 
-            return (ushort)((msb << 8) | lsb);
+            var value = (ushort)((msb << 8) | lsb);
+#endif
+
+            _position += 2;
+            return value;
         }
 
         public uint ReadVariableByteInteger()
@@ -125,23 +147,29 @@ namespace MQTTnet.Formatter
 
         public void Seek(int position)
         {
-            _position = _initialPosition + position;
+            _position = _offset + position;
         }
 
-        public void SetBuffer(byte[] buffer, int position, int length)
+        public void SetBuffer(ArraySegment<byte> buffer)
         {
-            _buffer = buffer;
-            _initialPosition = position;
-            _position = position;
-            _length = length;
+            SetBuffer(buffer.Array, buffer.Offset, buffer.Count);
+        }
+
+        public void SetBuffer(byte[] buffer, int offset, int length)
+        {
+            _buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
+            _offset = offset;
+            _position = offset;
+            _maxPosition = offset + length;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void ValidateReceiveBuffer(int length)
         {
-            if (_length < _position + length)
+            var newPosition = _position + length;
+            if (_maxPosition < newPosition)
             {
-                throw new MqttProtocolViolationException($"Expected at least {Position + length} bytes but there are only {_length} bytes");
+                throw new MqttProtocolViolationException($"Expected at least {newPosition} bytes but there are only {_maxPosition} bytes");
             }
         }
     }

Source/MQTTnet/Formatter/MqttBufferWriter.cs

@@ -6,6 +6,7 @@ using System;
 using System.Runtime.CompilerServices;
 using System.Text;
 using MQTTnet.Exceptions;
+using MQTTnet.Internal;
 using MQTTnet.Protocol;
 
 namespace MQTTnet.Formatter
@@ -63,17 +64,30 @@ namespace MQTTnet.Formatter
             return _buffer;
         }
 
-        public static int GetLengthOfVariableInteger(uint value)
+        public static int GetVariableByteIntegerSize(uint value)
         {
-            var result = 0;
-            var x = value;
-            do
-            {
-                x /= 128;
-                result++;
-            } while (x > 0);
+            // From RFC: Table 2.4 Size of Remaining Length field
 
-            return result;
+            // 0 (0x00) to 127 (0x7F)
+            if (value <= 127)
+            {
+                return 1;
+            }
+
+            // 128 (0x80, 0x01) to 16 383 (0xFF, 0x7F)
+            if (value <= 16383)
+            {
+                return 2;
+            }
+
+            // 16 384 (0x80, 0x80, 0x01) to 2 097 151 (0xFF, 0xFF, 0x7F)
+            if (value <= 2097151)
+            {
+                return 3;
+            }
+
+            // 2 097 152 (0x80, 0x80, 0x80, 0x01) to 268 435 455 (0xFF, 0xFF, 0xFF, 0x7F)
+            return 4;
         }
 
         public void Reset(int length)
@@ -90,18 +104,12 @@ namespace MQTTnet.Formatter
 
         public void Write(MqttBufferWriter propertyWriter)
         {
-            if (propertyWriter is MqttBufferWriter writer)
-            {
-                WriteBinary(writer._buffer, 0, writer.Length);
-                return;
-            }
-
             if (propertyWriter == null)
             {
                 throw new ArgumentNullException(nameof(propertyWriter));
             }
 
-            throw new InvalidOperationException($"{nameof(propertyWriter)} must be of type {nameof(MqttBufferWriter)}");
+            WriteBinary(propertyWriter._buffer, 0, propertyWriter.Length);
         }
 
         public void WriteBinary(byte[] buffer, int offset, int count)
@@ -118,7 +126,7 @@ namespace MQTTnet.Formatter
 
             EnsureAdditionalCapacity(count);
 
-            Array.Copy(buffer, offset, _buffer, _position, count);
+            MqttMemoryHelper.Copy(buffer, offset, _buffer, _position, count);
             IncreasePosition(count);
         }
 
@@ -142,7 +150,7 @@ namespace MQTTnet.Formatter
                 _buffer[_position] = (byte)(valueLength >> 8);
                 _buffer[_position + 1] = (byte)valueLength;
 
-                Array.Copy(value, 0, _buffer, _position + 2, valueLength);
+                MqttMemoryHelper.Copy(value, 0, _buffer, _position + 2, valueLength);
                 IncreasePosition(valueLength + 2);
             }
         }
@@ -180,7 +188,7 @@ namespace MQTTnet.Formatter
 
                 _buffer[_position] = (byte)(writtenBytes >> 8);
                 _buffer[_position + 1] = (byte)writtenBytes;
-                
+
                 IncreasePosition(writtenBytes + 2);
             }
         }

Source/MQTTnet/Formatter/MqttPacketBuffer.cs

@@ -37,28 +37,28 @@ namespace MQTTnet.Formatter
 
         public byte[] ToArray()
         {
-            if (Packet.Count == 0)
+            if (Payload.Count == 0)
             {
                 return Packet.ToArray();
             }
 
             var buffer = new byte[Length];
-            Array.Copy(Packet.Array, Packet.Offset, buffer, 0, Packet.Count);
-            Array.Copy(Payload.Array, Payload.Offset, buffer, Packet.Count, Payload.Count);
+            MqttMemoryHelper.Copy(Packet.Array, Packet.Offset, buffer, 0, Packet.Count);
+            MqttMemoryHelper.Copy(Payload.Array, Payload.Offset, buffer, Packet.Count, Payload.Count);
 
             return buffer;
         }
         
         public ArraySegment<byte> Join()
         {
-            if (Packet.Count == 0)
+            if (Payload.Count == 0)
             {
                 return Packet;
             }
 
             var buffer = new byte[Length];
-            Array.Copy(Packet.Array, Packet.Offset, buffer, 0, Packet.Count);
-            Array.Copy(Payload.Array, Payload.Offset, buffer, Packet.Count, Payload.Count);
+            MqttMemoryHelper.Copy(Packet.Array, Packet.Offset, buffer, 0, Packet.Count);
+            MqttMemoryHelper.Copy(Payload.Array, Payload.Offset, buffer, Packet.Count, Payload.Count);
 
             return new ArraySegment<byte>(buffer);
         }

Source/MQTTnet/Formatter/MqttPacketFactories.cs

@@ -4,30 +4,30 @@
 
 namespace MQTTnet.Formatter
 {
-    public sealed class MqttPacketFactories
+    public static class MqttPacketFactories
     {
-        public MqttConnAckPacketFactory ConnAck { get; } = new MqttConnAckPacketFactory();
+        public static MqttConnAckPacketFactory ConnAck { get; } = new MqttConnAckPacketFactory();
         
-        public MqttConnectPacketFactory Connect { get; } = new MqttConnectPacketFactory();
+        public static MqttConnectPacketFactory Connect { get; } = new MqttConnectPacketFactory();
 
-        public MqttDisconnectPacketFactory Disconnect { get; } = new MqttDisconnectPacketFactory();
+        public static MqttDisconnectPacketFactory Disconnect { get; } = new MqttDisconnectPacketFactory();
 
-        public MqttPubAckPacketFactory PubAck { get; } = new MqttPubAckPacketFactory();
+        public static MqttPubAckPacketFactory PubAck { get; } = new MqttPubAckPacketFactory();
 
-        public MqttPubCompPacketFactory PubComp { get; } = new MqttPubCompPacketFactory();
+        public static MqttPubCompPacketFactory PubComp { get; } = new MqttPubCompPacketFactory();
 
-        public MqttPublishPacketFactory Publish { get; } = new MqttPublishPacketFactory();
+        public static MqttPublishPacketFactory Publish { get; } = new MqttPublishPacketFactory();
 
-        public MqttPubRecPacketFactory PubRec { get; } = new MqttPubRecPacketFactory();
+        public static MqttPubRecPacketFactory PubRec { get; } = new MqttPubRecPacketFactory();
 
-        public MqttPubRelPacketFactory PubRel { get; } = new MqttPubRelPacketFactory();
+        public static MqttPubRelPacketFactory PubRel { get; } = new MqttPubRelPacketFactory();
 
-        public MqttSubAckPacketFactory SubAck { get; } = new MqttSubAckPacketFactory();
+        public static MqttSubAckPacketFactory SubAck { get; } = new MqttSubAckPacketFactory();
 
-        public MqttSubscribePacketFactory Subscribe { get; } = new MqttSubscribePacketFactory();
+        public static MqttSubscribePacketFactory Subscribe { get; } = new MqttSubscribePacketFactory();
 
-        public MqttUnsubAckPacketFactory UnsubAck { get; } = new MqttUnsubAckPacketFactory();
+        public static MqttUnsubAckPacketFactory UnsubAck { get; } = new MqttUnsubAckPacketFactory();
 
-        public MqttUnsubscribePacketFactory Unsubscribe { get; } = new MqttUnsubscribePacketFactory();
+        public static MqttUnsubscribePacketFactory Unsubscribe { get; } = new MqttUnsubscribePacketFactory();
     }
 }

Source/MQTTnet/Formatter/MqttPubAckPacketFactory.cs

@@ -12,26 +12,28 @@ namespace MQTTnet.Formatter
 {
     public sealed class MqttPubAckPacketFactory
     {
-        public MqttPubAckPacket Create(MqttPublishPacket publishPacket, InterceptingPublishEventArgs interceptingPublishEventArgs)
+        public MqttPubAckPacket Create(
+            MqttPublishPacket publishPacket,
+            DispatchApplicationMessageResult dispatchApplicationMessageResult)
         {
             if (publishPacket == null)
             {
                 throw new ArgumentNullException(nameof(publishPacket));
             }
 
+            if (dispatchApplicationMessageResult == null)
+            {
+                throw new ArgumentNullException(nameof(dispatchApplicationMessageResult));
+            }
+
             var pubAckPacket = new MqttPubAckPacket
             {
                 PacketIdentifier = publishPacket.PacketIdentifier,
-                ReasonCode = MqttPubAckReasonCode.Success
+                ReasonCode = (MqttPubAckReasonCode)dispatchApplicationMessageResult.ReasonCode,
+                ReasonString = dispatchApplicationMessageResult.ReasonString,
+                UserProperties = dispatchApplicationMessageResult.UserProperties
             };
-
-            if (interceptingPublishEventArgs != null)
-            {
-                pubAckPacket.ReasonCode = (MqttPubAckReasonCode)(int)interceptingPublishEventArgs.Response.ReasonCode;
-                pubAckPacket.ReasonString = interceptingPublishEventArgs.Response.ReasonString;
-                pubAckPacket.UserProperties = interceptingPublishEventArgs.Response.UserProperties;
-            }
-
+            
             return pubAckPacket;
         }
 
@@ -42,24 +44,12 @@ namespace MQTTnet.Formatter
                 throw new ArgumentNullException(nameof(applicationMessageReceivedEventArgs));
             }
 
-            var pubAckPacket = Create(applicationMessageReceivedEventArgs.PublishPacket, applicationMessageReceivedEventArgs.ReasonCode);
-            pubAckPacket.UserProperties = applicationMessageReceivedEventArgs.ResponseUserProperties;
-            pubAckPacket.ReasonString = applicationMessageReceivedEventArgs.ResponseReasonString;
-
-            return pubAckPacket;
-        }
-
-        static MqttPubAckPacket Create(MqttPublishPacket publishPacket, MqttApplicationMessageReceivedReasonCode applicationMessageReceivedReasonCode)
-        {
-            if (publishPacket == null)
-            {
-                throw new ArgumentNullException(nameof(publishPacket));
-            }
-
             var pubAckPacket = new MqttPubAckPacket
             {
-                PacketIdentifier = publishPacket.PacketIdentifier,
-                ReasonCode = (MqttPubAckReasonCode)(int)applicationMessageReceivedReasonCode
+                PacketIdentifier = applicationMessageReceivedEventArgs.PublishPacket.PacketIdentifier,
+                ReasonCode = (MqttPubAckReasonCode)(int)applicationMessageReceivedEventArgs.ReasonCode,
+                UserProperties = applicationMessageReceivedEventArgs.ResponseUserProperties,
+                ReasonString = applicationMessageReceivedEventArgs.ResponseReasonString
             };
 
             return pubAckPacket;

Source/MQTTnet/Formatter/MqttPubRecPacketFactory.cs

@@ -25,7 +25,7 @@ namespace MQTTnet.Formatter
             return pubRecPacket;
         }
 
-        public MqttPacket Create(MqttPublishPacket publishPacket, InterceptingPublishEventArgs interceptingPublishEventArgs)
+        public MqttPacket Create(MqttPublishPacket publishPacket, DispatchApplicationMessageResult dispatchApplicationMessageResult)
         {
             if (publishPacket == null)
             {
@@ -35,16 +35,11 @@ namespace MQTTnet.Formatter
             var pubRecPacket = new MqttPubRecPacket
             {
                 PacketIdentifier = publishPacket.PacketIdentifier,
-                ReasonCode = MqttPubRecReasonCode.Success
+                ReasonCode = (MqttPubRecReasonCode)dispatchApplicationMessageResult.ReasonCode,
+                ReasonString = dispatchApplicationMessageResult.ReasonString,
+                UserProperties = dispatchApplicationMessageResult.UserProperties
             };
 
-            if (interceptingPublishEventArgs != null)
-            {
-                pubRecPacket.ReasonCode = (MqttPubRecReasonCode)(int)interceptingPublishEventArgs.Response.ReasonCode;
-                pubRecPacket.ReasonString = interceptingPublishEventArgs.Response.ReasonString;
-                pubRecPacket.UserProperties = interceptingPublishEventArgs.Response.UserProperties;
-            }
-
             return pubRecPacket;
         }
 

Source/MQTTnet/Formatter/ReadFixedHeaderResult.cs

@@ -6,9 +6,9 @@ namespace MQTTnet.Formatter
 {
     public struct ReadFixedHeaderResult
     {
-        public static ReadFixedHeaderResult Cancelled { get; } = new ReadFixedHeaderResult
+        public static ReadFixedHeaderResult Canceled { get; } = new ReadFixedHeaderResult
         {
-            IsCancelled = true
+            IsCanceled = true
         };
         
         public static ReadFixedHeaderResult ConnectionClosed { get; } = new ReadFixedHeaderResult
@@ -16,7 +16,7 @@ namespace MQTTnet.Formatter
             IsConnectionClosed = true
         };
         
-        public bool IsCancelled { get; set; }
+        public bool IsCanceled { get; set; }
         
         public bool IsConnectionClosed { get; set; }
 

Source/MQTTnet/Formatter/V3/MqttV3PacketFormatter.cs

@@ -78,7 +78,7 @@ namespace MQTTnet.Formatter.V3
                     return DecodeSubscribePacket(receivedMqttPacket.Body);
                 case MqttControlPacketType.SubAck:
                     return DecodeSubAckPacket(receivedMqttPacket.Body);
-                case MqttControlPacketType.Unsubscibe:
+                case MqttControlPacketType.Unsubscribe:
                     return DecodeUnsubscribePacket(receivedMqttPacket.Body);
                 case MqttControlPacketType.UnsubAck:
                     return DecodeUnsubAckPacket(receivedMqttPacket.Body);
@@ -108,7 +108,7 @@ namespace MQTTnet.Formatter.V3
                 remainingLength += (uint)publishPacket.Payload.Length;
             }
 
-            var remainingLengthSize = MqttBufferWriter.GetLengthOfVariableInteger(remainingLength);
+            var remainingLengthSize = MqttBufferWriter.GetVariableByteIntegerSize(remainingLength);
 
             var headerSize = FixedHeaderSize + remainingLengthSize;
             var headerOffset = 5 - headerSize;
@@ -783,7 +783,7 @@ namespace MQTTnet.Formatter.V3
                 }
             }
 
-            return MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.Unsubscibe, 0x02);
+            return MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.Unsubscribe, 0x02);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

Source/MQTTnet/Formatter/V5/MqttV5PacketDecoder.cs

@@ -54,7 +54,7 @@ namespace MQTTnet.Formatter.V5
                     return DecodeSubscribePacket(receivedMqttPacket.Body);
                 case MqttControlPacketType.SubAck:
                     return DecodeSubAckPacket(receivedMqttPacket.Body);
-                case MqttControlPacketType.Unsubscibe:
+                case MqttControlPacketType.Unsubscribe:
                     return DecodeUnsubscribePacket(receivedMqttPacket.Body);
                 case MqttControlPacketType.UnsubAck:
                     return DecodeUnsubAckPacket(receivedMqttPacket.Body);

Source/MQTTnet/Formatter/V5/MqttV5PacketEncoder.cs

@@ -12,6 +12,8 @@ namespace MQTTnet.Formatter.V5
 {
     public sealed class MqttV5PacketEncoder
     {
+        const int FixedHeaderSize = 1;
+        
         readonly MqttBufferWriter _bufferWriter;
         readonly MqttV5PropertiesWriter _propertiesWriter = new MqttV5PropertiesWriter(new MqttBufferWriter(1024, 4096));
 
@@ -40,9 +42,9 @@ namespace MQTTnet.Formatter.V5
                 remainingLength += (uint)publishPacket.Payload.Length;
             }
 
-            var remainingLengthSize = MqttBufferWriter.GetLengthOfVariableInteger(remainingLength);
+            var remainingLengthSize = MqttBufferWriter.GetVariableByteIntegerSize(remainingLength);
 
-            var headerSize = 1 + remainingLengthSize;
+            var headerSize = FixedHeaderSize + remainingLengthSize;
             var headerOffset = 5 - headerSize;
 
             // Position cursor on correct offset on beginning of array (has leading 0x0)
@@ -522,7 +524,7 @@ namespace MQTTnet.Formatter.V5
                 _bufferWriter.WriteString(topicFilter);
             }
 
-            return MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.Unsubscibe, 0x02);
+            return MqttBufferWriter.BuildFixedHeader(MqttControlPacketType.Unsubscribe, 0x02);
         }
 
         static void ThrowIfPacketIdentifierIsInvalid(ushort packetIdentifier, MqttPacket packet)

Source/MQTTnet/Internal/AsyncQueue.cs

@@ -29,7 +29,7 @@ namespace MQTTnet.Internal
         {
             lock (_syncRoot)
             {
-                _signal?.Dispose();
+                _signal.Dispose();
 
                 _isDisposed = true;
             }
@@ -48,10 +48,10 @@ namespace MQTTnet.Internal
         {
             if (_queue.TryDequeue(out var item))
             {
-                return new AsyncQueueDequeueResult<TItem>(true, item);
+                return AsyncQueueDequeueResult<TItem>.Success(item);
             }
 
-            return new AsyncQueueDequeueResult<TItem>(false, default);
+            return AsyncQueueDequeueResult<TItem>.NonSuccess;
         }
 
         public async Task<AsyncQueueDequeueResult<TItem>> TryDequeueAsync(CancellationToken cancellationToken)
@@ -60,36 +60,42 @@ namespace MQTTnet.Internal
             {
                 try
                 {
-                    Task task;
+                    Task task = null;
                     lock (_syncRoot)
                     {
                         if (_isDisposed)
                         {
-                            return new AsyncQueueDequeueResult<TItem>(false, default);
+                            return AsyncQueueDequeueResult<TItem>.NonSuccess;
                         }
 
-                        task = _signal.WaitAsync(cancellationToken);
+                        if (_queue.IsEmpty)
+                        {
+                            task = _signal.WaitAsync(cancellationToken);
+                        }
                     }
 
-                    await task.ConfigureAwait(false);
-
+                    if (task != null)
+                    {
+                        await task.ConfigureAwait(false);    
+                    }
+                    
                     if (cancellationToken.IsCancellationRequested)
                     {
-                        return new AsyncQueueDequeueResult<TItem>(false, default);
+                        return AsyncQueueDequeueResult<TItem>.NonSuccess;
                     }
 
                     if (_queue.TryDequeue(out var item))
                     {
-                        return new AsyncQueueDequeueResult<TItem>(true, item);
+                        return AsyncQueueDequeueResult<TItem>.Success(item);
                     }
                 }
                 catch (OperationCanceledException)
                 {
-                    return new AsyncQueueDequeueResult<TItem>(false, default);
+                    return AsyncQueueDequeueResult<TItem>.NonSuccess;
                 }
             }
 
-            return new AsyncQueueDequeueResult<TItem>(false, default);
+            return AsyncQueueDequeueResult<TItem>.NonSuccess;
         }
     }
 }

Source/MQTTnet/Internal/AsyncQueueDequeueResult.cs

@@ -4,8 +4,10 @@
 
 namespace MQTTnet.Internal
 {
-    public class AsyncQueueDequeueResult<TItem>
+    public sealed class AsyncQueueDequeueResult<TItem>
     {
+        public static readonly AsyncQueueDequeueResult<TItem> NonSuccess = new AsyncQueueDequeueResult<TItem>(false, default);
+
         public AsyncQueueDequeueResult(bool isSuccess, TItem item)
         {
             IsSuccess = isSuccess;
@@ -15,5 +17,10 @@ namespace MQTTnet.Internal
         public bool IsSuccess { get; }
 
         public TItem Item { get; }
+
+        public static AsyncQueueDequeueResult<TItem> Success(TItem item)
+        {
+            return new AsyncQueueDequeueResult<TItem>(true, item);
+        }
     }
 }

Source/MQTTnet/Internal/AsyncSignal.cs

@@ -33,9 +33,18 @@ namespace MQTTnet.Internal
             {
                 _isSignaled = true;
 
+                Cleanup();
+
                 // If there is already a waiting task let it run.
-                _waiter?.Approve();
-                _waiter = null;
+                if (_waiter != null)
+                {
+                    _waiter.Approve();
+                    _waiter.Dispose();
+                    _waiter = null;
+
+                    // Since we already got a waiter the signal must be reset right now!
+                    _isSignaled = false;
+                }
             }
         }
 
@@ -47,8 +56,11 @@ namespace MQTTnet.Internal
             {
                 ThrowIfDisposed();
 
+                Cleanup();
+
                 if (_isSignaled)
                 {
+                    _isSignaled = false;
                     return CompletedTask.Instance;
                 }
 
@@ -58,7 +70,7 @@ namespace MQTTnet.Internal
                     {
                         throw new InvalidOperationException("Only one waiting task is permitted per async signal.");
                     }
-                    
+
                     _waiter.Dispose();
                 }
 
@@ -67,6 +79,15 @@ namespace MQTTnet.Internal
             }
         }
 
+        void Cleanup()
+        {
+            // Cleanup if the previous waiter was cancelled.
+            if (_waiter != null && _waiter.Task.IsCanceled)
+            {
+                _waiter = null;
+            }
+        }
+
         void ThrowIfDisposed()
         {
             if (_isDisposed)
@@ -82,6 +103,8 @@ namespace MQTTnet.Internal
             // ReSharper disable once FieldCanBeMadeReadOnly.Local
             CancellationTokenRegistration _cancellationTokenRegistration;
 
+            volatile bool _isCompleted;
+
             public AsyncSignalWaiter(CancellationToken cancellationToken)
             {
                 if (cancellationToken.CanBeCanceled)
@@ -94,18 +117,37 @@ namespace MQTTnet.Internal
 
             public void Approve()
             {
+                if (_isCompleted)
+                {
+                    return;
+                }
+
+                _isCompleted = true;
                 _promise.TrySetResult(true);
             }
 
             public void Dispose()
             {
                 _cancellationTokenRegistration.Dispose();
+                
+                if (_isCompleted)
+                {
+                    // Avoid allocation of _ObjectDisposedException_ which may not be used.
+                    return;
+                }
 
+                _isCompleted = true;
                 _promise.TrySetException(new ObjectDisposedException(nameof(AsyncSignalWaiter)));
             }
 
             void Cancel()
             {
+                if (_isCompleted)
+                {
+                    return;
+                }
+
+                _isCompleted = true;
                 _promise.TrySetCanceled();
             }
         }

Source/MQTTnet/Internal/CancellationTokenSourceExtensions.cs

@@ -0,0 +1,37 @@
+// 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;
+
+namespace MQTTnet.Internal
+{
+    public static class CancellationTokenSourceExtensions
+    {
+        public static bool TryCancel(this CancellationTokenSource cancellationTokenSource, bool throwOnFirstException = false)
+        {
+            if (cancellationTokenSource == null)
+            {
+                return false;
+            }
+
+            try
+            {
+                // Checking the _IsCancellationRequested_ here will not throw an
+                // "ObjectDisposedException" as the getter of the property "Token" will do!
+                if (cancellationTokenSource.IsCancellationRequested)
+                {
+                    return false;
+                }
+
+                cancellationTokenSource.Cancel(throwOnFirstException);
+                return true;
+            }
+            catch (ObjectDisposedException)
+            {
+                return false;
+            }
+        }
+    }
+}

Source/MQTTnet/Internal/MqttMemoryHelper.cs

@@ -0,0 +1,29 @@
+using System;
+using System.Runtime.CompilerServices;
+
+namespace MQTTnet.Internal
+{
+    public static class MqttMemoryHelper
+    {
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Copy(byte[] source, int sourceIndex, byte[] destination, int destinationIndex, int length)
+        {
+#if NETCOREAPP3_1_OR_GREATER || NETSTANDARD2_1
+            source.AsSpan(sourceIndex, length).CopyTo(destination.AsSpan(destinationIndex, length));
+#elif NET461_OR_GREATER || NETSTANDARD1_3_OR_GREATER
+            unsafe
+            {
+                fixed (byte* sourceHandle = &source[sourceIndex])
+                {
+                    fixed (byte* destinationHandle = &destination[destinationIndex])
+                    {
+                        System.Buffer.MemoryCopy(sourceHandle, destinationHandle, length, length);
+                    }
+                }
+            }
+#else
+            Array.Copy(source, sourceIndex, destination, destinationIndex, length);
+#endif
+        }
+    }
+}

Source/MQTTnet/Internal/MqttPacketBusItem.cs

@@ -10,40 +10,36 @@ namespace MQTTnet.Internal
 {
     public sealed class MqttPacketBusItem
     {
-        readonly AsyncTaskCompletionSource<int> _promise = new AsyncTaskCompletionSource<int>();
-
+        readonly AsyncTaskCompletionSource<bool> _promise = new AsyncTaskCompletionSource<bool>();
+        
         public MqttPacketBusItem(MqttPacket packet)
         {
             Packet = packet ?? throw new ArgumentNullException(nameof(packet));
         }
-        
+
+        public event EventHandler Completed;
+
         public MqttPacket Packet { get; }
 
-        public event EventHandler Delivered;
-
-        public Task WaitForDeliveryAsync()
-        {
-            return _promise.Task;
-        }
-        
-        public void MarkAsDelivered()
-        {
-            if (_promise.TrySetResult(0))
-            {
-                Delivered?.Invoke(this, EventArgs.Empty);
-            }
-        }
-
-        public void MarkAsFailed(Exception exception)
-        {
-            if (exception == null) throw new ArgumentNullException(nameof(exception));
-            
-            _promise.TrySetException(exception);
-        }
-
-        public void MarkAsCancelled()
+        public void Cancel()
         {
             _promise.TrySetCanceled();
         }
+
+        public void Complete()
+        {
+            _promise.TrySetResult(true);
+            Completed?.Invoke(this, EventArgs.Empty);
+        }
+
+        public void Fail(Exception exception)
+        {
+            _promise.TrySetException(exception);
+        }
+
+        public Task WaitAsync()
+        {
+            return _promise.Task;
+        }
     }
 }

Source/MQTTnet/MQTTnet.csproj

@@ -41,7 +41,8 @@
         <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
         <PackageLicenseExpression>MIT</PackageLicenseExpression>
         <DisableImplicitAspNetCoreAnalyzers>true</DisableImplicitAspNetCoreAnalyzers>
-        <NoWarn>1591</NoWarn>
+        <NoWarn>1591;NETSDK1138</NoWarn>
+        <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     </PropertyGroup>
 
     <PropertyGroup Condition="'$(TargetFramework)'=='uap10.0'">