Added reference to SparkplugNet.

Added code documentation hint.

.editorconfig

@@ -1,5 +1,84 @@
-[*.cs]
+[*.cs]
 
 
 # CA1031: Do not catch general exception types
-dotnet_diagnostic.CA1031.severity = none
+
+# Microsoft .NET properties
+csharp_new_line_before_members_in_object_initializers = false
+csharp_preferred_modifier_order = public, private, protected, internal, new, abstract, virtual, sealed, override, static, readonly, extern, unsafe, volatile, async:suggestion
+csharp_style_var_elsewhere = true:suggestion
+csharp_style_var_for_built_in_types = true:suggestion
+csharp_style_var_when_type_is_apparent = true:suggestion
+dotnet_naming_rule.constants_rule.severity = warning
+dotnet_naming_rule.constants_rule.style = upper_camel_case_style
+dotnet_naming_rule.constants_rule.symbols = constants_symbols
+dotnet_naming_rule.public_fields_rule.severity = warning
+dotnet_naming_rule.public_fields_rule.style = lower_camel_case_style
+dotnet_naming_rule.public_fields_rule.symbols = public_fields_symbols
+dotnet_naming_rule.static_readonly_rule.severity = warning
+dotnet_naming_rule.static_readonly_rule.style = upper_camel_case_style
+dotnet_naming_rule.static_readonly_rule.symbols = static_readonly_symbols
+dotnet_naming_style.lower_camel_case_style.capitalization = camel_case
+dotnet_naming_style.lower_camel_case_style.required_prefix = _
+dotnet_naming_style.upper_camel_case_style.capitalization = pascal_case
+dotnet_naming_symbols.constants_symbols.applicable_accessibilities = public,internal,protected,protected_internal,private_protected
+dotnet_naming_symbols.constants_symbols.applicable_kinds = field
+dotnet_naming_symbols.constants_symbols.required_modifiers = const
+dotnet_naming_symbols.public_fields_symbols.applicable_accessibilities = public,internal,protected,protected_internal,private_protected
+dotnet_naming_symbols.public_fields_symbols.applicable_kinds = field
+dotnet_naming_symbols.static_readonly_symbols.applicable_accessibilities = public,internal,protected,protected_internal,private_protected
+dotnet_naming_symbols.static_readonly_symbols.applicable_kinds = field
+dotnet_naming_symbols.static_readonly_symbols.required_modifiers = static,readonly
+dotnet_style_parentheses_in_arithmetic_binary_operators = never_if_unnecessary:none
+dotnet_style_parentheses_in_other_binary_operators = never_if_unnecessary:none
+dotnet_style_parentheses_in_relational_binary_operators = never_if_unnecessary:none
+dotnet_style_predefined_type_for_locals_parameters_members = true:suggestion
+dotnet_style_predefined_type_for_member_access = true:suggestion
+dotnet_style_qualification_for_event = false:suggestion
+dotnet_style_qualification_for_field = false:suggestion
+dotnet_style_qualification_for_method = false:suggestion
+dotnet_style_qualification_for_property = false:suggestion
+
+# ReSharper properties
+resharper_autodetect_indent_settings = true
+resharper_default_private_modifier = implicit
+resharper_place_accessorholder_attribute_on_same_line = false
+resharper_use_indent_from_vs = false
+
+# ReSharper inspection severities
+resharper_arrange_redundant_parentheses_highlighting = hint
+resharper_arrange_this_qualifier_highlighting = hint
+resharper_built_in_type_reference_style_for_member_access_highlighting = hint
+resharper_built_in_type_reference_style_highlighting = hint
+resharper_redundant_base_qualifier_highlighting = warning
+resharper_suggest_var_or_type_built_in_types_highlighting = hint
+resharper_suggest_var_or_type_elsewhere_highlighting = hint
+resharper_suggest_var_or_type_simple_types_highlighting = hint
+resharper_web_config_module_not_resolved_highlighting = warning
+resharper_web_config_type_not_resolved_highlighting = warning
+resharper_web_config_wrong_module_highlighting = warning
+
+[*]
+charset = utf-8
+end_of_line = crlf
+trim_trailing_whitespace = false
+insert_final_newline = false
+indent_style = space
+indent_size = 4
+
+[{*.har,*.inputactions,*.jsb2,*.jsb3,*.json,.babelrc,.eslintrc,.stylelintrc,bowerrc,jest.config}]
+indent_style = space
+indent_size = 2
+
+[{*.yaml,*.yml}]
+indent_style = space
+indent_size = 2
+
+[{tsconfig.app.json,tsconfig.e2e.json,tsconfig.json,tsconfig.lib.json,tsconfig.spec.json}]
+indent_style = space
+indent_size = 2
+
+[*.{appxmanifest,asax,ascx,aspx,axaml,build,cg,cginc,compute,cs,cshtml,dtd,hlsl,hlsli,hlslinc,master,nuspec,paml,razor,resw,resx,shader,skin,usf,ush,vb,xaml,xamlx,xoml,xsd}]
+indent_style = space
+indent_size = 4
+tab_width = 4

Build/MQTTnet.AspNetCore.nuspec

@@ -19,10 +19,14 @@
         <dependency id="MQTTnet" version="$nugetVersion" />
         <dependency id="Microsoft.AspNetCore.Http.Connections" version="1.0.0"  />
       </group>
-      
+
       <group targetFramework="netcoreapp3.1">
         <dependency id="MQTTnet" version="$nugetVersion" />
       </group>
+
+      <group targetFramework="net5.0">
+        <dependency id="MQTTnet" version="$nugetVersion" />
+      </group>
     </dependencies>
   </metadata>
 
@@ -33,10 +37,13 @@
     <!-- Images -->
     <file src="..\Images\Logo_128x128.png" target="images\" />
 
+    <!-- .NET 5.0 -->
+    <file src="..\Source\MQTTnet.AspNetCore\bin\Release\net5.0\MQTTnet.*" target="lib\net5.0\" />
+
     <!-- .NET Standard 2.0 -->
-    <file src="..\Source\MQTTnet.AspNetCore\bin\Release\netstandard2.0\MQTTnet.AspNetCore.*" target="lib\netstandard2.0\"/>
+    <file src="..\Source\MQTTnet.AspNetCore\bin\Release\netstandard2.0\MQTTnet.AspNetCore.*" target="lib\netstandard2.0\" />
-    
+
     <!-- .NET Core App 3.1 -->
-    <file src="..\Source\MQTTnet.AspNetCore\bin\Release\netcoreapp3.1\MQTTnet.AspNetCore.*" target="lib\netcoreapp3.1\"/>
+    <file src="..\Source\MQTTnet.AspNetCore\bin\Release\netcoreapp3.1\MQTTnet.AspNetCore.*" target="lib\netcoreapp3.1\" />
   </files>
 </package>

Build/MQTTnet.Extensions.ManagedClient.nuspec

@@ -13,7 +13,7 @@
     <description>This is an extension library which provides a managed MQTT client with additional features using MQTTnet.</description>
     <releaseNotes>For release notes please go to MQTTnet release notes (https://www.nuget.org/packages/MQTTnet/).</releaseNotes>
     <copyright>Copyright Christian Kratky 2016-2020</copyright>
-    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags> 
+    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags>
     <dependencies>
       <dependency id="MQTTnet" version="$nugetVersion" />
     </dependencies>
@@ -26,20 +26,23 @@
     <!-- Images -->
     <file src="..\Images\Logo_128x128.png" target="images\" />
 
+    <!-- .NET 5.0 -->
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\net5.0\MQTTnet.*" target="lib\net5.0\" />
+
     <!-- .NET Standard 1.3 -->
-    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\netstandard1.3\MQTTnet.Extensions.ManagedClient.*" target="lib\netstandard1.3\"/>
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\netstandard1.3\MQTTnet.Extensions.ManagedClient.*" target="lib\netstandard1.3\" />
 
     <!-- .NET Standard 2.0 -->
-    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\netstandard2.0\MQTTnet.Extensions.ManagedClient.*" target="lib\netstandard2.0\"/>
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\netstandard2.0\MQTTnet.Extensions.ManagedClient.*" target="lib\netstandard2.0\" />
 
     <!-- Universal Windows -->
-    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\uap10.0\MQTTnet.Extensions.ManagedClient.*" target="lib\uap10.0\"/>
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\uap10.0\MQTTnet.Extensions.ManagedClient.*" target="lib\uap10.0\" />
 
     <!-- .NET Framework -->
-    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\net452\MQTTnet.Extensions.ManagedClient.*" target="lib\net452\"/>
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\net452\MQTTnet.Extensions.ManagedClient.*" target="lib\net452\" />
 
     <!-- .NET Framework 4.6.0 will use binaries from 4.5.2. -->
-    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\net461\MQTTnet.Extensions.Rpc.*" target="lib\net461\"/>
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\net461\MQTTnet.Extensions.Rpc.*" target="lib\net461\" />
 
     <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
   </files>

Build/MQTTnet.Extensions.Rpc.nuspec

@@ -13,7 +13,7 @@
     <description>This is an extension library which allows executing synchronous device calls including a response using MQTTnet.</description>
     <releaseNotes>For release notes please go to MQTTnet release notes (https://www.nuget.org/packages/MQTTnet/).</releaseNotes>
     <copyright>Copyright Christian Kratky 2016-2020</copyright>
-    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags> 
+    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags>
     <dependencies>
       <dependency id="MQTTnet" version="$nugetVersion" />
     </dependencies>
@@ -26,20 +26,23 @@
     <!-- Images -->
     <file src="..\Images\Logo_128x128.png" target="images\" />
 
+    <!-- .NET 5.0 -->
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\net5.0\MQTTnet.*" target="lib\net5.0\" />
+
     <!-- .NET Standard 1.3 -->
-    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\netstandard1.3\MQTTnet.Extensions.Rpc.*" target="lib\netstandard1.3\"/>
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\netstandard1.3\MQTTnet.Extensions.Rpc.*" target="lib\netstandard1.3\" />
 
     <!-- .NET Standard 2.0 -->
-    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\netstandard2.0\MQTTnet.Extensions.Rpc.*" target="lib\netstandard2.0\"/>
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\netstandard2.0\MQTTnet.Extensions.Rpc.*" target="lib\netstandard2.0\" />
 
     <!-- Universal Windows -->
-    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\uap10.0\MQTTnet.Extensions.Rpc.*" target="lib\uap10.0\"/>
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\uap10.0\MQTTnet.Extensions.Rpc.*" target="lib\uap10.0\" />
 
     <!-- .NET Framework -->
-    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\net452\MQTTnet.Extensions.Rpc.*" target="lib\net452\"/>
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\net452\MQTTnet.Extensions.Rpc.*" target="lib\net452\" />
 
     <!-- .NET Framework 4.6.0 will use binaries from 4.5.2. -->
-    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\net461\MQTTnet.Extensions.Rpc.*" target="lib\net461\"/>
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\net461\MQTTnet.Extensions.Rpc.*" target="lib\net461\" />
 
     <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
   </files>

Build/MQTTnet.Extensions.WebSocket4Net.nuspec

@@ -13,7 +13,7 @@
     <description>This is an extension library which allows using _WebSocket4Net_ as transport for MQTTnet clients.</description>
     <releaseNotes>For release notes please go to MQTTnet release notes (https://www.nuget.org/packages/MQTTnet/).</releaseNotes>
     <copyright>Copyright Christian Kratky 2016-2020</copyright>
-    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags> 
+    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags>
     <dependencies>
     <group targetFramework="netstandard1.3">
         <dependency id="MQTTnet" version="$nugetVersion" />
@@ -41,20 +41,23 @@
     <!-- Images -->
     <file src="..\Images\Logo_128x128.png" target="images\" />
 
+    <!-- .NET 5.0 -->
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\net5.0\MQTTnet.*" target="lib\net5.0\" />
+
     <!-- .NET Standard 1.3 -->
-    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\netstandard1.3\MQTTnet.Extensions.WebSocket4Net.*" target="lib\netstandard1.3\"/>
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\netstandard1.3\MQTTnet.Extensions.WebSocket4Net.*" target="lib\netstandard1.3\" />
 
     <!-- .NET Standard 2.0 -->
-    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\netstandard2.0\MQTTnet.Extensions.WebSocket4Net.*" target="lib\netstandard2.0\"/>
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\netstandard2.0\MQTTnet.Extensions.WebSocket4Net.*" target="lib\netstandard2.0\" />
 
     <!-- Universal Windows -->
-    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\uap10.0\MQTTnet.Extensions.WebSocket4Net.*" target="lib\uap10.0\"/>
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\uap10.0\MQTTnet.Extensions.WebSocket4Net.*" target="lib\uap10.0\" />
 
     <!-- .NET Framework -->
-    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\net452\MQTTnet.Extensions.WebSocket4Net.*" target="lib\net452\"/>
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\net452\MQTTnet.Extensions.WebSocket4Net.*" target="lib\net452\" />
 
     <!-- .NET Framework 4.6.0 will use binaries from 4.5.2. -->
-    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\net461\MQTTnet.Extensions.WebSocket4Net.*" target="lib\net461\"/>
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\net461\MQTTnet.Extensions.WebSocket4Net.*" target="lib\net461\" />
 
     <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
   </files>

Build/MQTTnet.nuspec

@@ -12,25 +12,35 @@
     <requireLicenseAcceptance>true</requireLicenseAcceptance>
     <description>MQTTnet is a high performance .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker) and supports v3.1.0, v3.1.1 and v5.0.0 of the MQTT protocol.</description>
     <releaseNotes>
-* [LowLevelClient] Fixed a null reference exception when connecting to a not existing server (thanks to @SGStino).      
+* [Core] Added .NET 5.0 TFMs (thanks to @StefanOssendorf, @JanEggers).
-* [RcpClient] Adjusted some namespaces (BREAKING CHANGE!).
+* [Core] Added support for TLS 1.3 (requires .NET Core 3.1+) (thanks to @Dvergatal).
-* [AspNetCore] Adjusted some namespaces (BREAKING CHANGE!).
+* [Core] Added support for _MaximumQoS_ transmit when using MQTTv5 (thanks to @nayato).
-* [Server] Adjusted some namespaces (BREAKING CHANGE!).
+* [Core] Aligned the format of some log messages.
-* [Server] Added state checks (throw if not started etc.) for most server APIs.
+* [Client] Fixed an issue with connection state detection (thanks to @tobiasfrick).
-* [Server] Exposed real X509Certificate2 (instead byte array) to TLS options (thanks to @borigas).
+* [Client] Fixed an issue when receiving partial QoS 2 packets after a reconnect.
-* [Server] Fixed memory leak with TCP sockets (MqttServer is now Disposable!) (BREAKING CHANGE!).
+* [Client] Added new API for raw packet inspection.
-* [Core] Fixed a null reference exception in the MqttTcpChannel with WriteAsync and ReadAsync.
+* [ManagedClient] Removed _AutoReconnect_ since this does no longer work (BREAKING CHANGE!).
-* [Core] Added server interceptor for undelivered messages (thanks to @cshark-inator).
+* [RpcClient] Moved the RPC topic validation to the topic generation strategy.
-* [nuget] Added support for SourceLink (thanks to @JTOne123).
+* [RcpClient] Added interface for _MqttRpcClient_.
+* [Server] Reduced async tasks count by moving dedicated keep alive tasks per connection to shared one.
+* [Server] Session takeover and keep alive timeout are now properly set in DISCONNECT packet.
+* [Server] Fixed bug in PubRel packet generation (MQTTv5 only).
+* [Server] Improved message processing performance (+ ~5%).
+* [Server] Fix wrong usage of client session items for undelivered messages.
+* [Server] Allow to respond with a reason code in PUBACK/PUBREC (thanks to @muneebmajeed).
+* [Server] Fixed topic filter comparer on edge cases, e.g. "foo/" matching "foo/#" (thanks to @dagophil).
+* [Core] Added code documentation.
+
+Git commit: $gitCommit
     </releaseNotes>
     <copyright>Copyright Christian Kratky 2016-2020</copyright>
-    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags> 
+    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin Blazor</tags>
     <dependencies>
       <group targetFramework="netstandard1.3">
         <dependency id="NETStandard.Library" version="1.3.0" />
         <dependency id="System.Net.Security" version="4.3.2" />
         <dependency id="System.Net.WebSockets" version="4.3.0" />
-        <dependency id="System.Net.WebSockets.Client" version="4.3.2" />      
+        <dependency id="System.Net.WebSockets.Client" version="4.3.2" />
       </group>
       <group targetFramework="netstandard2.0">
         <dependency id="NETStandard.Library" version="2.0.0" />
@@ -44,6 +54,12 @@
         <dependency id="System.Net.WebSockets" version="4.3.0" />
         <dependency id="System.Net.WebSockets.Client" version="4.3.2" />
       </group>
+      <group targetFramework="netcoreapp3.1">
+        <dependency id="NETStandard.Library" version="2.0.0" />
+        <dependency id="System.Net.Security" version="4.3.2" />
+        <dependency id="System.Net.WebSockets" version="4.3.0" />
+        <dependency id="System.Net.WebSockets.Client" version="4.3.2" />
+      </group>
       <group targetFramework="uap10.0">
         <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="6.2.10" />
       </group>
@@ -57,23 +73,29 @@
     <!-- Images -->
     <file src="..\Images\Logo_128x128.png" target="images\" />
 
+    <!-- .NET 5.0 -->
+    <file src="..\Source\MQTTnet\bin\Release\net5.0\MQTTnet.*" target="lib\net5.0\" />
+
     <!-- .NET Standard 1.3 -->
-    <file src="..\Source\MQTTnet\bin\Release\netstandard1.3\MQTTnet.*" target="lib\netstandard1.3\"/>
+    <file src="..\Source\MQTTnet\bin\Release\netstandard1.3\MQTTnet.*" target="lib\netstandard1.3\" />
-    
+
     <!-- .NET Standard 2.0 -->
-    <file src="..\Source\MQTTnet\bin\Release\netstandard2.0\MQTTnet.*" target="lib\netstandard2.0\"/>
+    <file src="..\Source\MQTTnet\bin\Release\netstandard2.0\MQTTnet.*" target="lib\netstandard2.0\" />
 
     <!-- .NET Standard 2.1 -->
-    <file src="..\Source\MQTTnet\bin\Release\netstandard2.1\MQTTnet.*" target="lib\netstandard2.1\"/>
+    <file src="..\Source\MQTTnet\bin\Release\netstandard2.1\MQTTnet.*" target="lib\netstandard2.1\" />
+
+    <!-- .NET Standard 3.1 -->
+    <file src="..\Source\MQTTnet\bin\Release\netcoreapp3.1\MQTTnet.*" target="lib\netcoreapp3.1\" />
 
     <!-- Universal Windows -->
-    <file src="..\Source\MQTTnet\bin\Release\uap10.0\MQTTnet.*" target="lib\uap10.0\"/>
+    <file src="..\Source\MQTTnet\bin\Release\uap10.0\MQTTnet.*" target="lib\uap10.0\" />
 
     <!-- .NET Framework -->
-    <file src="..\Source\MQTTnet\bin\Release\net452\MQTTnet.*" target="lib\net452\"/>
+    <file src="..\Source\MQTTnet\bin\Release\net452\MQTTnet.*" target="lib\net452\" />
 
     <!-- .NET Framework 4.6.0 will use binaries from 4.5.2. -->
-    <file src="..\Source\MQTTnet\bin\Release\net461\MQTTnet.*" target="lib\net461\"/>
+    <file src="..\Source\MQTTnet\bin\Release\net461\MQTTnet.*" target="lib\net461\" />
 
     <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
   </files>

Build/build.ps1

@@ -29,6 +29,7 @@ vstest.console.exe ..\Tests\MQTTnet.AspNetCore.Tests\bin\Release\netcoreapp3.1\M
 &$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard1.3" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
 &$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard2.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
 &$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard2.1" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netcoreapp3.1" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
 &$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="uap10.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
 
 # Build the ASP.NET Core 2.0 extension
@@ -63,6 +64,10 @@ vstest.console.exe ..\Tests\MQTTnet.AspNetCore.Tests\bin\Release\netcoreapp3.1\M
 
 Remove-Item .\NuGet -Force -Recurse -ErrorAction SilentlyContinue
 
+$gitCommit = git log -1 --format=%h
+
+Copy-Item MQTTnet.nuspec -Destination MQTTnet.nuspec.old -Force
+(Get-Content MQTTnet.nuspec) -replace '\$gitCommit', $gitCommit | Set-Content MQTTnet.nuspec
 Copy-Item MQTTnet.AspNetCore.nuspec -Destination MQTTnet.AspNetCore.nuspec.old -Force
 (Get-Content MQTTnet.AspNetCore.nuspec) -replace '\$nugetVersion', $nugetVersion | Set-Content MQTTnet.AspNetCore.nuspec
 Copy-Item MQTTnet.Extensions.Rpc.nuspec -Destination MQTTnet.Extensions.Rpc.nuspec.old -Force
@@ -79,6 +84,7 @@ New-Item -ItemType Directory -Force -Path .\NuGet
 .\nuget.exe pack MQTTnet.Extensions.ManagedClient.nuspec -Verbosity detailed -Symbols -SymbolPackageFormat snupkg -OutputDir "NuGet" -Version $nugetVersion
 .\nuget.exe pack MQTTnet.Extensions.WebSocket4Net.nuspec -Verbosity detailed -Symbols -SymbolPackageFormat snupkg -OutputDir "NuGet" -Version $nugetVersion
 
+Move-Item MQTTnet.nuspec.old -Destination MQTTnet.nuspec -Force
 Move-Item MQTTnet.AspNetCore.nuspec.old -Destination MQTTnet.AspNetCore.nuspec -Force
 Move-Item MQTTnet.Extensions.Rpc.nuspec.old -Destination MQTTnet.Extensions.Rpc.nuspec -Force
 Move-Item MQTTnet.Extensions.ManagedClient.nuspec.old -Destination MQTTnet.Extensions.ManagedClient.nuspec -Force
@@ -89,7 +95,7 @@ Remove-Item "nuget.exe" -Force -Recurse -ErrorAction SilentlyContinue
 ####################################################################
 
 # Build MQTTnet.Server Portable
-&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion
+&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion --framework net5.0
 
 $source = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\Release\netcoreapp3.1\publish"
 $destination = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\MQTTnet.Server-Portable-v$nugetVersion.zip"
@@ -100,7 +106,7 @@ If(Test-path $destination) {Remove-item $destination}
 ####################################################################
 
 # Build MQTTnet.Server Linux-x64
-&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion --self-contained --runtime linux-x64 
+&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion --self-contained --runtime linux-x64 --framework net5.0
 
 $source = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\Release\netcoreapp3.1\linux-x64\publish"
 $destination = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\MQTTnet.Server-Linux-x64-v$nugetVersion.zip"
@@ -111,7 +117,7 @@ If(Test-path $destination) {Remove-item $destination}
 ####################################################################
 
 # Build MQTTnet.Server Linux-ARM
-&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion --self-contained --runtime linux-arm 
+&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion --self-contained --runtime linux-arm --framework net5.0
 
 $source = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\Release\netcoreapp3.1\linux-ARM\publish"
 $destination = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\MQTTnet.Server-Linux-ARM-v$nugetVersion.zip"
@@ -122,7 +128,7 @@ If(Test-path $destination) {Remove-item $destination}
 ####################################################################
 
 # Build MQTTnet.Server Windows-x64
-&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion --self-contained --runtime win-x64
+&dotnet publish ..\Source\MQTTnet.Server\MQTTnet.Server.csproj --configuration Release /p:FileVersion=$assemblyVersion /p:Version=$nugetVersion --self-contained --runtime win-x64 --framework net5.0
 
 $source = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\Release\netcoreapp3.1\win-x64\publish"
 $destination = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\MQTTnet.Server-Windows-x64-v$nugetVersion.zip"

MQTTnet.sln

@@ -9,8 +9,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Tests", "Tests", "{9248C2E1
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Source", "Source", "{32A630A7-2598-41D7-B625-204CD906F5FB}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MQTTnet.TestApp.UniversalWindows", "Tests\MQTTnet.TestApp.UniversalWindows\MQTTnet.TestApp.UniversalWindows.csproj", "{FF1F72D6-9524-4422-9497-3CC0002216ED}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MQTTnet", "Source\MQTTnet\MQTTnet.csproj", "{3587E506-55A2-4EB3-99C7-DC01E42D25D2}"
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Build", "Build", "{67C28AC1-BC3A-420A-BE9C-FA2401431CF9}"
@@ -57,11 +55,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Apps", "Apps", "{A56E3128-1
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Blazor", "Blazor", "{61B165A0-5AA8-4E04-A53D-A22A84AA6EB7}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MQTTnet.Test.BlazorApp.Server", "Tests\MQTTnet.Test.BlazorApp\Server\MQTTnet.Test.BlazorApp.Server.csproj", "{A9662AF3-3520-4BF8-9DFF-C55C0C33D08F}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MQTTnet.Test.BlazorApp.Server", "Tests\MQTTnet.Test.BlazorApp\Server\MQTTnet.Test.BlazorApp.Server.csproj", "{A9662AF3-3520-4BF8-9DFF-C55C0C33D08F}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MQTTnet.Test.BlazorApp.Client", "Tests\MQTTnet.Test.BlazorApp\Client\MQTTnet.Test.BlazorApp.Client.csproj", "{D260D63D-7902-4C55-9665-84C5CACBBB24}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MQTTnet.Test.BlazorApp.Client", "Tests\MQTTnet.Test.BlazorApp\Client\MQTTnet.Test.BlazorApp.Client.csproj", "{D260D63D-7902-4C55-9665-84C5CACBBB24}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MQTTnet.Test.BlazorApp.Shared", "Tests\MQTTnet.Test.BlazorApp\Shared\MQTTnet.Test.BlazorApp.Shared.csproj", "{DDB069BA-6E1A-48C7-B374-5D903B553CAD}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MQTTnet.Test.BlazorApp.Shared", "Tests\MQTTnet.Test.BlazorApp\Shared\MQTTnet.Test.BlazorApp.Shared.csproj", "{DDB069BA-6E1A-48C7-B374-5D903B553CAD}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -91,29 +89,6 @@ Global
 		{A7FF0C91-25DE-4BA6-B39E-F54E8DADF1CC}.Release|x64.Build.0 = Release|Any CPU
 		{A7FF0C91-25DE-4BA6-B39E-F54E8DADF1CC}.Release|x86.ActiveCfg = Release|Any CPU
 		{A7FF0C91-25DE-4BA6-B39E-F54E8DADF1CC}.Release|x86.Build.0 = Release|Any CPU
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|ARM.ActiveCfg = Debug|ARM
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|ARM.Build.0 = Debug|ARM
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|ARM.Deploy.0 = Debug|ARM
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|x64.ActiveCfg = Debug|x64
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|x64.Build.0 = Debug|x64
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|x64.Deploy.0 = Debug|x64
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|x86.ActiveCfg = Debug|x86
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|x86.Build.0 = Debug|x86
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Debug|x86.Deploy.0 = Debug|x86
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|Any CPU.Build.0 = Release|Any CPU
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|ARM.ActiveCfg = Release|ARM
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|ARM.Build.0 = Release|ARM
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|ARM.Deploy.0 = Release|ARM
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|x64.ActiveCfg = Release|x64
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|x64.Build.0 = Release|x64
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|x64.Deploy.0 = Release|x64
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|x86.ActiveCfg = Release|x86
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|x86.Build.0 = Release|x86
-		{FF1F72D6-9524-4422-9497-3CC0002216ED}.Release|x86.Deploy.0 = Release|x86
 		{3587E506-55A2-4EB3-99C7-DC01E42D25D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3587E506-55A2-4EB3-99C7-DC01E42D25D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3587E506-55A2-4EB3-99C7-DC01E42D25D2}.Debug|ARM.ActiveCfg = Debug|Any CPU
@@ -328,7 +303,6 @@ Global
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
 		{A7FF0C91-25DE-4BA6-B39E-F54E8DADF1CC} = {9248C2E1-B9D6-40BF-81EC-86004D7765B4}
-		{FF1F72D6-9524-4422-9497-3CC0002216ED} = {A56E3128-1639-4F31-873A-325E14BB6295}
 		{3587E506-55A2-4EB3-99C7-DC01E42D25D2} = {32A630A7-2598-41D7-B625-204CD906F5FB}
 		{3D283AAD-AAA8-4339-8394-52F80B6304DB} = {9248C2E1-B9D6-40BF-81EC-86004D7765B4}
 		{C6FF8AEA-0855-41EC-A1F3-AC262225BAB9} = {9248C2E1-B9D6-40BF-81EC-86004D7765B4}

MQTTnet.sln.DotSettings

@@ -11,4 +11,5 @@
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EAddAccessorOwnerDeclarationBracesMigration/@EntryIndexedValue">True</s:Boolean>
 	<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></wpf:ResourceDictionary>
+	<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/=unsub/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

README.md

@@ -19,7 +19,7 @@ MQTTnet is a high performance .NET library for MQTT based communication. It prov
 ### General
 
 * Async support
-* TLS 1.2 support for client and server (but not UWP servers)
+* TLS support for client and server (but not UWP servers)
 * Extensible communication channels (e.g. In-Memory, TCP, TCP+TLS, WS)
 * Lightweight (only the low level implementation of MQTT, no overhead)
 * Performance optimized (processing ~70.000 messages / second)*
@@ -64,15 +64,32 @@ _MQTTnet Server_ is a standalone cross platform MQTT server (like mosquitto) bas
 
 ## Supported frameworks
 
+* .NET 5.0+
 * .NET Standard 1.3+
 * .NET Core 1.1+
 * .NET Core App 1.1+
-* .NET Framework 4.5.2+ (x86, x64, AnyCPU)
+* .NET Framework 4.5.2+
 * Mono 5.2+
-* Universal Windows Platform (UWP) 10.0.10240+ (x86, x64, ARM, AnyCPU, Windows 10 IoT Core)
+* Universal Windows Platform (UWP) 10.0.10240+ (Windows 10 IoT Core)
 * Xamarin.Android 7.5+
 * Xamarin.iOS 10.14+
-* Blazor WebAssembly 3.2.0
+* Blazor WebAssembly 3.2.0+
+
+## Supported platforms
+
+* x86
+* x64
+* AnyCPU
+* ARM
+
+## Supported OS
+
+* Windows
+* Windows 10 IoT Core
+* Linux (Ubuntu, Raspbian etc.)
+* macOS
+* Android
+* iOS
 
 ## Supported MQTT versions
 
@@ -97,11 +114,14 @@ Also additions and updates in the Wiki are welcome.
 
 This library is used in the following projects:
 
-* Azure Functions MQTT Bindings, [CaseOnline.Azure.WebJobs.Extensions.Mqtt](https://github.com/keesschollaart81/CaseOnline.Azure.WebJobs.Extensions.Mqtt/)
+* Azure Functions MQTT Bindings, <https://github.com/keesschollaart81/CaseOnline.Azure.WebJobs.Extensions.Mqtt>)
 * HA4IoT (Open Source Home Automation system for .NET, <https://github.com/chkr1011/HA4IoT>)
 * MQTT Client Rx (Wrapper for Reactive Extensions, <https://github.com/1iveowl/MQTTClient.rx>)
+* MQTT Client Rx (Managed Client Wrapper for Reactive Extensions, <https://github.com/mmuecke/RxMQTTnet>)
 * MQTT Tester (MQTT client test app for [Android](https://play.google.com/store/apps/details?id=com.liveowl.mqtttester) and [iOS](https://itunes.apple.com/us/app/mqtt-tester/id1278621826?mt=8))
+* MQTTnet App (Cross platform client application for MQTT debugging, inspection etc., <https://github.com/chkr1011/MQTTnet.App>)
 * Wirehome.Core (Open Source Home Automation system for .NET Core, <https://github.com/chkr1011/Wirehome.Core>)
+* SparkplugNet (Sparkplug library for .Net, <https://github.com/SeppPenner/SparkplugNet>)
 
 Further projects using this project can be found under https://github.com/chkr1011/MQTTnet/network/dependents.
 
@@ -111,7 +131,7 @@ If you use this library and want to see your project here please create a pull r
 
 MIT License
 
-MQTTnet Copyright (c) 2016-2020 Christian Kratky
+MQTTnet Copyright (c) 2016-2021 Christian Kratky
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

Source/MQTTnet.AspnetCore/Client/Tcp/TcpConnection.cs

@@ -40,7 +40,7 @@ namespace MQTTnet.AspNetCore.Client.Tcp
             _sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
             _receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
         }
-#if NETCOREAPP3_1
+#if NETCOREAPP3_1 || NET5_0
         public override ValueTask DisposeAsync()
 #else
         public Task DisposeAsync()
@@ -53,7 +53,7 @@ namespace MQTTnet.AspNetCore.Client.Tcp
 
             _socket?.Dispose();
 
-#if NETCOREAPP3_1
+#if NETCOREAPP3_1 || NET5_0
 
             return base.DisposeAsync();
         }

Source/MQTTnet.AspnetCore/Extensions/ConnectionRouteBuilderExtensions.cs

@@ -12,6 +12,7 @@ namespace MQTTnet.AspNetCore.Extensions
 #if NETCOREAPP3_1
         [Obsolete("This class is obsolete and will be removed in a future version. The recommended alternative is to use MapMqtt inside Microsoft.AspNetCore.Builder.UseEndpoints(...).")]
 #endif
+#if NETCOREAPP3_1 || NETCOREAPP2_1 || NETSTANDARD
         public static void MapMqtt(this ConnectionsRouteBuilder connection, PathString path)
         {
             connection.MapConnectionHandler<MqttConnectionHandler>(path, options =>
@@ -19,5 +20,6 @@ namespace MQTTnet.AspNetCore.Extensions
                 options.WebSockets.SubProtocolSelector = MqttSubProtocolSelector.SelectSubProtocol;
             });
         }
+#endif
     }
 }

Source/MQTTnet.AspnetCore/Extensions/EndpointRouterExtensions.cs

@@ -1,5 +1,5 @@
 
-#if NETCOREAPP3_1
+#if NETCOREAPP3_1 || NET5_0
 
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Routing;

Source/MQTTnet.AspnetCore/MQTTnet.AspNetCore.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard2.0;netcoreapp2.1;netcoreapp3.1</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;netcoreapp2.1;netcoreapp3.1;net5.0</TargetFrameworks>
     <Product />
     <Company />
     <Authors />
@@ -21,11 +21,11 @@
     <DefineConstants>RELEASE;NETSTANDARD2_0</DefineConstants>
   </PropertyGroup>
 
-  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
+  <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0' ">
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
   </ItemGroup>
     
-  <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp3.1'">
+  <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp3.1' and '$(TargetFramework)' != 'net5.0' ">
     <PackageReference Include="Microsoft.AspNetCore.Http.Connections" Version="1.1.0" />
   </ItemGroup>
 

Source/MQTTnet.AspnetCore/MqttConnectionContext.cs

@@ -66,10 +66,10 @@ namespace MQTTnet.AspNetCore
         public MqttPacketFormatterAdapter PacketFormatterAdapter { get; }
 
         public long BytesSent { get; set; }
+
         public long BytesReceived { get; set; }
 
-        public Action ReadingPacketStartedCallback { get; set; }
+        public bool IsReadingPacket { get; private set; }
-        public Action ReadingPacketCompletedCallback { get; set; }
 
         IHttpContextFeature Http => Connection.Features.Get<IHttpContextFeature>();
 
@@ -92,7 +92,7 @@ namespace MQTTnet.AspNetCore
             return Task.CompletedTask;
         }
 
-        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        public async Task<MqttBasePacket> ReceivePacketAsync(CancellationToken cancellationToken)
         {
             var input = Connection.Transport.Input;
 
@@ -128,7 +128,7 @@ namespace MQTTnet.AspNetCore
                             else
                             {
                                 // we did receive something but the message is not yet complete
-                                ReadingPacketStartedCallback?.Invoke();
+                                IsReadingPacket = true;
                             }
                         }
                         else if (readResult.IsCompleted)
@@ -147,14 +147,14 @@ namespace MQTTnet.AspNetCore
             }
             catch (Exception e)
             {
-                // completing the cannels makes sure that there is no more data read after a protocol error
+                // completing the channel makes sure that there is no more data read after a protocol error
                 _input?.Complete(e);
                 _output?.Complete(e);
                 throw;
             }
             finally
             {
-                ReadingPacketCompletedCallback?.Invoke();
+                IsReadingPacket = false;
             }
 
             cancellationToken.ThrowIfCancellationRequested();
@@ -167,7 +167,7 @@ namespace MQTTnet.AspNetCore
             BytesSent = 0;
         }
 
-        public async Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout, CancellationToken cancellationToken)
+        public async Task SendPacketAsync(MqttBasePacket packet, CancellationToken cancellationToken)
         {
             var formatter = PacketFormatterAdapter;
             using (await _writerLock.WaitAsync(cancellationToken).ConfigureAwait(false))
@@ -180,6 +180,7 @@ namespace MQTTnet.AspNetCore
                 {
                     BytesSent += msg.Length;
                 }
+
                 PacketFormatterAdapter.FreeBuffer();
             }
         }

Source/MQTTnet.AspnetCore/MqttWebSocketServerAdapter.cs

@@ -49,7 +49,7 @@ namespace MQTTnet.AspNetCore
                     var formatter = new MqttPacketFormatterAdapter(writer);
                     var channel = new MqttWebSocketChannel(webSocket, endpoint, isSecureConnection, clientCertificate);
 
-                    using (var channelAdapter = new MqttChannelAdapter(channel, formatter, _rootLogger))
+                    using (var channelAdapter = new MqttChannelAdapter(channel, formatter, null, _rootLogger))
                     {
                         await clientHandler(channelAdapter).ConfigureAwait(false);
                     }

Source/MQTTnet.Extensions.ManagedClient/IManagedMqttClient.cs

@@ -4,30 +4,46 @@ using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Client;
 
 namespace MQTTnet.Extensions.ManagedClient
 {
     public interface IManagedMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
     {
-        bool IsStarted { get; }
+        /// <summary>
-        bool IsConnected { get; }
+        /// Gets the internally used MQTT client.
-        int PendingApplicationMessagesCount { get; }
+        /// This property should be used with caution because manipulating the internal client might break the managed client.
-        IManagedMqttClientOptions Options { get; }
+        /// </summary>
+        IMqttClient InternalClient { get; }
 
+        bool IsStarted { get; }
+        
+        bool IsConnected { get; }
+        
+        int PendingApplicationMessagesCount { get; }
+        
+        IManagedMqttClientOptions Options { get; }
+        
         IMqttClientConnectedHandler ConnectedHandler { get; set; }
+        
         IMqttClientDisconnectedHandler DisconnectedHandler { get; set; }
 
         IApplicationMessageProcessedHandler ApplicationMessageProcessedHandler { get; set; }
+        
         IApplicationMessageSkippedHandler ApplicationMessageSkippedHandler { get; set; }
 
         IConnectingFailedHandler ConnectingFailedHandler { get; set; }
+        
         ISynchronizingSubscriptionsFailedHandler SynchronizingSubscriptionsFailedHandler { get; set; }
 
         Task StartAsync(IManagedMqttClientOptions options);
+        
         Task StopAsync();
+        
         Task PingAsync(CancellationToken cancellationToken);
 
         Task SubscribeAsync(IEnumerable<MqttTopicFilter> topicFilters);
+        
         Task UnsubscribeAsync(IEnumerable<string> topics);
 
         Task PublishAsync(ManagedMqttApplicationMessage applicationMessages);

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;net5.0</TargetFrameworks>
     <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
     <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' AND '$(SolutionName)' != 'MQTTnet.noUWP' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
     <Product />

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClient.cs

@@ -18,7 +18,7 @@ namespace MQTTnet.Extensions.ManagedClient
 {
     public class ManagedMqttClient : Disposable, IManagedMqttClient
     {
-        private readonly BlockingQueue<ManagedMqttApplicationMessage> _messageQueue = new BlockingQueue<ManagedMqttApplicationMessage>();
+        readonly BlockingQueue<ManagedMqttApplicationMessage> _messageQueue = new BlockingQueue<ManagedMqttApplicationMessage>();
 
         /// <summary>
         /// The subscriptions are managed in 2 separate buckets:
@@ -27,51 +27,55 @@ namespace MQTTnet.Extensions.ManagedClient
         /// any thread and are therefore mutex'ed. <see cref="_reconnectSubscriptions"/> get sent to the broker
         ///  at reconnect and are solely owned by <see cref="MaintainConnectionAsync"/>.
         /// </summary>
-        private readonly Dictionary<string, MqttQualityOfServiceLevel> _reconnectSubscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
+        readonly Dictionary<string, MqttQualityOfServiceLevel> _reconnectSubscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
-        private readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
+        readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
-        private readonly HashSet<string> _unsubscriptions = new HashSet<string>();
+        readonly HashSet<string> _unsubscriptions = new HashSet<string>();
-        private readonly SemaphoreSlim _subscriptionsQueuedSignal = new SemaphoreSlim(0);
+        readonly SemaphoreSlim _subscriptionsQueuedSignal = new SemaphoreSlim(0);
 
-        private readonly IMqttClient _mqttClient;
+        readonly IMqttNetScopedLogger _logger;
-        private readonly IMqttNetScopedLogger _logger;
 
-        private readonly AsyncLock _messageQueueLock = new AsyncLock();
+        readonly AsyncLock _messageQueueLock = new AsyncLock();
 
-        private CancellationTokenSource _connectionCancellationToken;
+        CancellationTokenSource _connectionCancellationToken;
-        private CancellationTokenSource _publishingCancellationToken;
+        CancellationTokenSource _publishingCancellationToken;
-        private Task _maintainConnectionTask;
+        Task _maintainConnectionTask;
 
-        private ManagedMqttClientStorageManager _storageManager;
+        ManagedMqttClientStorageManager _storageManager;
 
         public ManagedMqttClient(IMqttClient mqttClient, IMqttNetLogger logger)
         {
-            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+            InternalClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
 
             if (logger == null) throw new ArgumentNullException(nameof(logger));
             _logger = logger.CreateScopedLogger(nameof(ManagedMqttClient));
         }
 
-        public bool IsConnected => _mqttClient.IsConnected;
+        public bool IsConnected => InternalClient.IsConnected;
+
         public bool IsStarted => _connectionCancellationToken != null;
+
+        public IMqttClient InternalClient { get; }
+
         public int PendingApplicationMessagesCount => _messageQueue.Count;
+
         public IManagedMqttClientOptions Options { get; private set; }
 
         public IMqttClientConnectedHandler ConnectedHandler
         {
-            get => _mqttClient.ConnectedHandler;
+            get => InternalClient.ConnectedHandler;
-            set => _mqttClient.ConnectedHandler = value;
+            set => InternalClient.ConnectedHandler = value;
         }
 
         public IMqttClientDisconnectedHandler DisconnectedHandler
         {
-            get => _mqttClient.DisconnectedHandler;
+            get => InternalClient.DisconnectedHandler;
-            set => _mqttClient.DisconnectedHandler = value;
+            set => InternalClient.DisconnectedHandler = value;
         }
 
         public IMqttApplicationMessageReceivedHandler ApplicationMessageReceivedHandler
         {
-            get => _mqttClient.ApplicationMessageReceivedHandler;
+            get => InternalClient.ApplicationMessageReceivedHandler;
-            set => _mqttClient.ApplicationMessageReceivedHandler = value;
+            set => InternalClient.ApplicationMessageReceivedHandler = value;
         }
 
         public IApplicationMessageProcessedHandler ApplicationMessageProcessedHandler { get; set; }
@@ -89,14 +93,13 @@ namespace MQTTnet.Extensions.ManagedClient
             if (options == null) throw new ArgumentNullException(nameof(options));
             if (options.ClientOptions == null) throw new ArgumentException("The client options are not set.", nameof(options));
 
-
             if (!_maintainConnectionTask?.IsCompleted ?? false) throw new InvalidOperationException("The managed client is already started.");
 
             Options = options;
 
-            if (Options.Storage != null)
+            if (options.Storage != null)
             {
-                _storageManager = new ManagedMqttClientStorageManager(Options.Storage);
+                _storageManager = new ManagedMqttClientStorageManager(options.Storage);
                 var messages = await _storageManager.LoadQueuedMessagesAsync().ConfigureAwait(false);
 
                 foreach (var message in messages)
@@ -105,10 +108,12 @@ namespace MQTTnet.Extensions.ManagedClient
                 }
             }
 
-            _connectionCancellationToken = new CancellationTokenSource();
+            var cancellationTokenSource = new CancellationTokenSource();
+            var cancellationToken = cancellationTokenSource.Token;
+            _connectionCancellationToken = cancellationTokenSource;
 
-            _maintainConnectionTask = Task.Run(() => MaintainConnectionAsync(_connectionCancellationToken.Token), _connectionCancellationToken.Token);
+            _maintainConnectionTask = Task.Run(() => MaintainConnectionAsync(cancellationToken), cancellationToken);
-            _maintainConnectionTask.Forget(_logger);
+            _maintainConnectionTask.RunInBackground(_logger);
 
             _logger.Info("Started");
         }
@@ -131,7 +136,7 @@ namespace MQTTnet.Extensions.ManagedClient
 
         public Task PingAsync(CancellationToken cancellationToken)
         {
-            return _mqttClient.PingAsync(cancellationToken);
+            return InternalClient.PingAsync(cancellationToken);
         }
 
         public async Task<MqttClientPublishResult> PublishAsync(MqttApplicationMessage applicationMessage, CancellationToken cancellationToken)
@@ -218,6 +223,7 @@ namespace MQTTnet.Extensions.ManagedClient
                     _unsubscriptions.Remove(topicFilter.Topic);
                 }
             }
+
             _subscriptionsQueuedSignal.Release();
 
             return Task.FromResult(0);
@@ -257,13 +263,14 @@ namespace MQTTnet.Extensions.ManagedClient
 
                 _messageQueue.Dispose();
                 _messageQueueLock.Dispose();
-                _mqttClient.Dispose();
+                InternalClient.Dispose();
                 _subscriptionsQueuedSignal.Dispose();
             }
+
             base.Dispose(disposing);
         }
 
-        private async Task MaintainConnectionAsync(CancellationToken cancellationToken)
+        async Task MaintainConnectionAsync(CancellationToken cancellationToken)
         {
             try
             {
@@ -285,7 +292,14 @@ namespace MQTTnet.Extensions.ManagedClient
                 {
                     try
                     {
-                        await _mqttClient.DisconnectAsync().ConfigureAwait(false);
+                        using (var disconnectTimeout = new CancellationTokenSource(Options.ClientOptions.CommunicationTimeout))
+                        {
+                            await InternalClient.DisconnectAsync(disconnectTimeout.Token).ConfigureAwait(false);
+                        }
+                    }
+                    catch (OperationCanceledException)
+                    {
+                        _logger.Warning("Timeout while sending DISCONNECT packet.");
                     }
                     catch (Exception exception)
                     {
@@ -294,7 +308,9 @@ namespace MQTTnet.Extensions.ManagedClient
 
                     _logger.Info("Stopped");
                 }
+
                 _reconnectSubscriptions.Clear();
+
                 lock (_subscriptions)
                 {
                     _subscriptions.Clear();
@@ -303,11 +319,11 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private async Task TryMaintainConnectionAsync(CancellationToken cancellationToken)
+        async Task TryMaintainConnectionAsync(CancellationToken cancellationToken)
         {
             try
             {
-                var connectionState = await ReconnectIfRequiredAsync().ConfigureAwait(false);
+                var connectionState = await ReconnectIfRequiredAsync(cancellationToken).ConfigureAwait(false);
                 if (connectionState == ReconnectionResult.NotConnected)
                 {
                     StopPublishing();
@@ -346,11 +362,11 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private async Task PublishQueuedMessagesAsync(CancellationToken cancellationToken)
+        async Task PublishQueuedMessagesAsync(CancellationToken cancellationToken)
         {
             try
             {
-                while (!cancellationToken.IsCancellationRequested && _mqttClient.IsConnected)
+                while (!cancellationToken.IsCancellationRequested && InternalClient.IsConnected)
                 {
                     // Peek at the message without dequeueing in order to prevent the
                     // possibility of the queue growing beyond the configured cap.
@@ -384,12 +400,12 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private async Task TryPublishQueuedMessageAsync(ManagedMqttApplicationMessage message)
+        async Task TryPublishQueuedMessageAsync(ManagedMqttApplicationMessage message)
         {
             Exception transmitException = null;
             try
             {
-                await _mqttClient.PublishAsync(message.ApplicationMessage).ConfigureAwait(false);
+                await InternalClient.PublishAsync(message.ApplicationMessage).ConfigureAwait(false);
 
                 using (await _messageQueueLock.WaitAsync(CancellationToken.None).ConfigureAwait(false)) //lock to avoid conflict with this.PublishAsync
                 {
@@ -411,7 +427,7 @@ namespace MQTTnet.Extensions.ManagedClient
             {
                 transmitException = exception;
 
-                _logger.Warning(exception, $"Publishing application ({message.Id}) message failed.");
+                _logger.Warning(exception, "Publishing application message ({0}) failed.", message.Id);
 
                 if (message.ApplicationMessage.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
                 {
@@ -436,7 +452,7 @@ namespace MQTTnet.Extensions.ManagedClient
             catch (Exception exception)
             {
                 transmitException = exception;
-                _logger.Error(exception, $"Error while publishing application message ({message.Id}).");
+                _logger.Error(exception, "Error while publishing application message ({0}).", message.Id);
             }
             finally
             {
@@ -449,9 +465,10 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private async Task PublishSubscriptionsAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        async Task PublishSubscriptionsAsync(TimeSpan timeout, CancellationToken cancellationToken)
         {
             var endTime = DateTime.UtcNow + timeout;
+
             while (await _subscriptionsQueuedSignal.WaitAsync(GetRemainingTime(endTime), cancellationToken).ConfigureAwait(false))
             {
                 List<MqttTopicFilter> subscriptions;
@@ -470,7 +487,7 @@ namespace MQTTnet.Extensions.ManagedClient
                     continue;
                 }
 
-                _logger.Verbose($"Publishing subscriptions ({subscriptions.Count} subscriptions and {unsubscriptions.Count} unsubscriptions)");
+                _logger.Verbose("Publishing {0} subscriptions and {1} unsubscriptions)", subscriptions.Count, unsubscriptions.Count);
 
                 foreach (var unsubscription in unsubscriptions)
                 {
@@ -486,12 +503,12 @@ namespace MQTTnet.Extensions.ManagedClient
                 {
                     if (unsubscriptions.Any())
                     {
-                        await _mqttClient.UnsubscribeAsync(unsubscriptions.ToArray()).ConfigureAwait(false);
+                        await InternalClient.UnsubscribeAsync(unsubscriptions.ToArray()).ConfigureAwait(false);
                     }
 
                     if (subscriptions.Any())
                     {
-                        await _mqttClient.SubscribeAsync(subscriptions.ToArray()).ConfigureAwait(false);
+                        await InternalClient.SubscribeAsync(subscriptions.ToArray()).ConfigureAwait(false);
                     }
                 }
                 catch (Exception exception)
@@ -501,7 +518,7 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private async Task PublishReconnectSubscriptionsAsync()
+        async Task PublishReconnectSubscriptionsAsync()
         {
             _logger.Info("Publishing subscriptions at reconnect");
 
@@ -510,7 +527,7 @@ namespace MQTTnet.Extensions.ManagedClient
                 if (_reconnectSubscriptions.Any())
                 {
                     var subscriptions = _reconnectSubscriptions.Select(i => new MqttTopicFilter { Topic = i.Key, QualityOfServiceLevel = i.Value });
-                    await _mqttClient.SubscribeAsync(subscriptions.ToArray()).ConfigureAwait(false);
+                    await InternalClient.SubscribeAsync(subscriptions.ToArray()).ConfigureAwait(false);
                 }
             }
             catch (Exception exception)
@@ -519,7 +536,7 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private async Task HandleSubscriptionExceptionAsync(Exception exception)
+        async Task HandleSubscriptionExceptionAsync(Exception exception)
         {
             _logger.Warning(exception, "Synchronizing subscriptions failed.");
 
@@ -530,16 +547,16 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private async Task<ReconnectionResult> ReconnectIfRequiredAsync()
+        async Task<ReconnectionResult> ReconnectIfRequiredAsync(CancellationToken cancellationToken)
         {
-            if (_mqttClient.IsConnected)
+            if (InternalClient.IsConnected)
             {
                 return ReconnectionResult.StillConnected;
             }
 
             try
             {
-                var result = await _mqttClient.ConnectAsync(Options.ClientOptions).ConfigureAwait(false);
+                var result = await InternalClient.ConnectAsync(Options.ClientOptions, cancellationToken).ConfigureAwait(false);
                 return result.IsSessionPresent ? ReconnectionResult.Recovered : ReconnectionResult.Reconnected;
             }
             catch (Exception exception)
@@ -554,34 +571,47 @@ namespace MQTTnet.Extensions.ManagedClient
             }
         }
 
-        private void StartPublishing()
+        void StartPublishing()
         {
             if (_publishingCancellationToken != null)
             {
                 StopPublishing();
             }
 
-            var cts = new CancellationTokenSource();
+            var cancellationTokenSource = new CancellationTokenSource();
-            _publishingCancellationToken = cts;
+            var cancellationToken = cancellationTokenSource.Token;
+            _publishingCancellationToken = cancellationTokenSource;
 
-            Task.Run(() => PublishQueuedMessagesAsync(cts.Token), cts.Token).Forget(_logger);
+            Task.Run(() => PublishQueuedMessagesAsync(cancellationToken), cancellationToken).RunInBackground(_logger);
         }
 
-        private void StopPublishing()
+        void StopPublishing()
         {
-            _publishingCancellationToken?.Cancel(false);
+            try
-            _publishingCancellationToken?.Dispose();
+            {
-            _publishingCancellationToken = null;
+                _publishingCancellationToken?.Cancel(false);
+            }
+            finally
+            {
+                _publishingCancellationToken?.Dispose();
+                _publishingCancellationToken = null;
+            }
         }
 
-        private void StopMaintainingConnection()
+        void StopMaintainingConnection()
         {
-            _connectionCancellationToken?.Cancel(false);
+            try
-            _connectionCancellationToken?.Dispose();
+            {
-            _connectionCancellationToken = null;
+                _connectionCancellationToken?.Cancel(false);
+            }
+            finally
+            {
+                _connectionCancellationToken?.Dispose();
+                _connectionCancellationToken = null;
+            }
         }
 
-        private TimeSpan GetRemainingTime(DateTime endTime)
+        static TimeSpan GetRemainingTime(DateTime endTime)
         {
             var remainingTime = endTime - DateTime.UtcNow;
             return remainingTime < TimeSpan.Zero ? TimeSpan.Zero : remainingTime;

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClientOptions.cs

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

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClientOptionsBuilder.cs

@@ -1,5 +1,4 @@
 using System;
-using MQTTnet.Client;
 using MQTTnet.Client.Options;
 using MQTTnet.Server;
 
@@ -7,8 +6,8 @@ namespace MQTTnet.Extensions.ManagedClient
 {
     public class ManagedMqttClientOptionsBuilder
     {
-        private readonly ManagedMqttClientOptions _options = new ManagedMqttClientOptions();
+        readonly ManagedMqttClientOptions _options = new ManagedMqttClientOptions();
-        private MqttClientOptionsBuilder _clientOptionsBuilder;
+        MqttClientOptionsBuilder _clientOptionsBuilder;
 
         public ManagedMqttClientOptionsBuilder WithMaxPendingMessages(int value)
         {
@@ -69,7 +68,7 @@ namespace MQTTnet.Extensions.ManagedClient
             options(_clientOptionsBuilder);
             return this;
         }
-
+        
         public ManagedMqttClientOptions Build()
         {
             if (_clientOptionsBuilder != null)

Source/MQTTnet.Extensions.Rpc/IMqttRpcClient.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Extensions.Rpc
+{
+    public interface IMqttRpcClient : IDisposable
+    {
+        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel);
+
+        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken);
+
+        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel);
+
+        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken);
+    }
+}

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;net5.0</TargetFrameworks>
     <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
     <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' AND '$(SolutionName)' != 'MQTTnet.noUWP' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
     <Product />

Source/MQTTnet.Extensions.Rpc/MqttRpcClient.cs

@@ -11,12 +11,12 @@ using System.Threading.Tasks;
 
 namespace MQTTnet.Extensions.Rpc
 {
-    public sealed class MqttRpcClient : IDisposable
+    public sealed class MqttRpcClient : IMqttRpcClient
     {
-        private readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
+        readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
-        private readonly IMqttClient _mqttClient;
+        readonly IMqttClient _mqttClient;
-        private readonly IMqttRpcClientOptions _options;
+        readonly IMqttRpcClientOptions _options;
-        private readonly RpcAwareApplicationMessageReceivedHandler _applicationMessageReceivedHandler;
+        readonly RpcAwareApplicationMessageReceivedHandler _applicationMessageReceivedHandler;
 
         [Obsolete("Use MqttRpcClient(IMqttClient mqttClient, IMqttRpcClientOptions options).")]
         public MqttRpcClient(IMqttClient mqttClient) : this(mqttClient, new MqttRpcClientOptions())
@@ -54,11 +54,6 @@ namespace MQTTnet.Extensions.Rpc
         {
             if (methodName == null) throw new ArgumentNullException(nameof(methodName));
 
-            if (methodName.Contains("/") || methodName.Contains("+") || methodName.Contains("#"))
-            {
-                throw new ArgumentException("The method name cannot contain /, + or #.");
-            }
-
             if (!(_mqttClient.ApplicationMessageReceivedHandler is RpcAwareApplicationMessageReceivedHandler))
             {
                 throw new InvalidOperationException("The application message received handler was modified.");
@@ -139,7 +134,7 @@ namespace MQTTnet.Extensions.Rpc
             }
         }
 
-        private Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
+        Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
         {
             if (!_waitingCalls.TryRemove(eventArgs.ApplicationMessage.Topic, out var tcs))
             {

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

@@ -2,7 +2,7 @@
 
 namespace MQTTnet.Extensions.Rpc.Options
 {
-    public class MqttRpcClientOptions : IMqttRpcClientOptions
+    public sealed class MqttRpcClientOptions : IMqttRpcClientOptions
     {
         public IMqttRpcClientTopicGenerationStrategy TopicGenerationStrategy { get; set; } = new DefaultMqttRpcClientTopicGenerationStrategy();
     }

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

@@ -3,7 +3,7 @@ using System;
 
 namespace MQTTnet.Extensions.Rpc.Options
 {
-    public class MqttRpcClientOptionsBuilder
+    public sealed class MqttRpcClientOptionsBuilder
     {
         IMqttRpcClientTopicGenerationStrategy _topicGenerationStrategy = new DefaultMqttRpcClientTopicGenerationStrategy();
 

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

@@ -1,6 +1,6 @@
 namespace MQTTnet.Extensions.Rpc.Options
 {
-    public class MqttRpcTopicPair
+    public sealed class MqttRpcTopicPair
     {
         public string RequestTopic { get; set; }
 

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

@@ -2,10 +2,15 @@
 
 namespace MQTTnet.Extensions.Rpc.Options.TopicGeneration
 {
-    public class DefaultMqttRpcClientTopicGenerationStrategy : IMqttRpcClientTopicGenerationStrategy
+    public sealed class DefaultMqttRpcClientTopicGenerationStrategy : IMqttRpcClientTopicGenerationStrategy
     {
         public MqttRpcTopicPair CreateRpcTopics(TopicGenerationContext context)
         {
+            if (context.MethodName.Contains("/") || context.MethodName.Contains("+") || context.MethodName.Contains("#"))
+            {
+                throw new ArgumentException("The method name cannot contain /, + or #.");
+            }
+            
             var requestTopic = $"MQTTnet.RPC/{Guid.NewGuid():N}/{context.MethodName}";
             var responseTopic = requestTopic + "/response";
 

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

@@ -3,10 +3,18 @@ using MQTTnet.Protocol;
 
 namespace MQTTnet.Extensions.Rpc.Options.TopicGeneration
 {
-    public class TopicGenerationContext
+    public sealed class TopicGenerationContext
     {
         public string MethodName { get; set; }
 
+        /// <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).
+        /// </summary>
         public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
 
         public IMqttClient MqttClient { get; set; }

Source/MQTTnet.Extensions.Rpc/RpcAwareApplicationMessageReceivedHandler.cs

@@ -4,9 +4,9 @@ using MQTTnet.Client.Receiving;
 
 namespace MQTTnet.Extensions.Rpc
 {
-    public class RpcAwareApplicationMessageReceivedHandler : IMqttApplicationMessageReceivedHandler
+    public sealed class RpcAwareApplicationMessageReceivedHandler : IMqttApplicationMessageReceivedHandler
     {
-        private readonly Func<MqttApplicationMessageReceivedEventArgs, Task> _handleReceivedApplicationMessageAsync;
+        readonly Func<MqttApplicationMessageReceivedEventArgs, Task> _handleReceivedApplicationMessageAsync;
 
         public RpcAwareApplicationMessageReceivedHandler(
             IMqttApplicationMessageReceivedHandler originalHandler,
@@ -18,14 +18,14 @@ namespace MQTTnet.Extensions.Rpc
 
         public IMqttApplicationMessageReceivedHandler OriginalHandler { get; }
 
-        public async Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
+        public Task HandleApplicationMessageReceivedAsync(MqttApplicationMessageReceivedEventArgs eventArgs)
         {
             if (OriginalHandler != null)
             {
-                await OriginalHandler.HandleApplicationMessageReceivedAsync(eventArgs).ConfigureAwait(false);
+                return OriginalHandler.HandleApplicationMessageReceivedAsync(eventArgs);
             }
 
-            await _handleReceivedApplicationMessageAsync(eventArgs).ConfigureAwait(false);
+            return _handleReceivedApplicationMessageAsync(eventArgs);
         }
     }
 }

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1</TargetFrameworks>
+    <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;net5.0</TargetFrameworks>
     <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
     <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' AND '$(SolutionName)' != 'MQTTnet.noUWP' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
     <Product />

Source/MQTTnet.Extensions.WebSocket4Net/WebSocket4NetMqttChannel.cs

@@ -16,14 +16,14 @@ using WebSocket4Net;
 
 namespace MQTTnet.Extensions.WebSocket4Net
 {
-    public class WebSocket4NetMqttChannel : IMqttChannel
+    public sealed class WebSocket4NetMqttChannel : IMqttChannel
     {
-        private readonly BlockingCollection<byte> _receiveBuffer = new BlockingCollection<byte>();
+        readonly BlockingCollection<byte> _receiveBuffer = new BlockingCollection<byte>();
 
-        private readonly IMqttClientOptions _clientOptions;
+        readonly IMqttClientOptions _clientOptions;
-        private readonly MqttClientWebSocketOptions _webSocketOptions;
+        readonly MqttClientWebSocketOptions _webSocketOptions;
 
-        private WebSocket _webSocket;
+        WebSocket _webSocket;
 
         public WebSocket4NetMqttChannel(IMqttClientOptions clientOptions, MqttClientWebSocketOptions webSocketOptions)
         {
@@ -166,12 +166,12 @@ namespace MQTTnet.Extensions.WebSocket4Net
             _webSocket = null;
         }
 
-        private void OnError(object sender, ErrorEventArgs e)
+        static void OnError(object sender, ErrorEventArgs e)
         {
             System.Diagnostics.Debug.Write(e.Exception.ToString());
         }
 
-        private void OnDataReceived(object sender, DataReceivedEventArgs e)
+        void OnDataReceived(object sender, DataReceivedEventArgs e)
         {
             foreach (var @byte in e.Data)
             {
@@ -179,7 +179,7 @@ namespace MQTTnet.Extensions.WebSocket4Net
             }
         }
 
-        private async Task ConnectInternalAsync(CancellationToken cancellationToken)
+        async Task ConnectInternalAsync(CancellationToken cancellationToken)
         {
             _webSocket.Error += OnError;
             _webSocket.DataReceived += OnDataReceived;
@@ -201,7 +201,9 @@ namespace MQTTnet.Extensions.WebSocket4Net
                 _webSocket.Opened += SuccessHandler;
                 _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
 
                 var exception = await MqttTaskTimeout.WaitAsync(c =>
                 {

Source/MQTTnet.Extensions.WebSocket4Net/WebSocket4NetMqttClientAdapterFactory.cs

@@ -7,7 +7,7 @@ using System;
 
 namespace MQTTnet.Extensions.WebSocket4Net
 {
-    public class WebSocket4NetMqttClientAdapterFactory : IMqttClientAdapterFactory
+    public sealed class WebSocket4NetMqttClientAdapterFactory : IMqttClientAdapterFactory
     {
         readonly IMqttNetLogger _logger;
 
@@ -23,14 +23,22 @@ namespace MQTTnet.Extensions.WebSocket4Net
             switch (options.ChannelOptions)
             {
                 case MqttClientTcpOptions _:
-                    {
+                {
-                        return new MqttChannelAdapter(new MqttTcpChannel(options), new MqttPacketFormatterAdapter(options.ProtocolVersion), _logger);
+                    return new MqttChannelAdapter(
-                    }
+                        new MqttTcpChannel(options),
+                        new MqttPacketFormatterAdapter(options.ProtocolVersion),
+                        options.PacketInspector,
+                        _logger);
+                }
 
                 case MqttClientWebSocketOptions webSocketOptions:
-                    {
+                {
-                        return new MqttChannelAdapter(new WebSocket4NetMqttChannel(options, webSocketOptions), new MqttPacketFormatterAdapter(options.ProtocolVersion), _logger);
+                    return new MqttChannelAdapter(
-                    }
+                        new WebSocket4NetMqttChannel(options, webSocketOptions),
+                        new MqttPacketFormatterAdapter(options.ProtocolVersion), 
+                        options.PacketInspector,
+                        _logger);
+                }
 
                 default:
                     {

Source/MQTTnet.Extensions.Wrappers.WebSocket4Net/WebSocket4NetMqttClientAdapterFactory.cs

@@ -1,134 +0,0 @@
-using MQTTnet.Client;
-using System;
-using System.Collections.Concurrent;
-using System.Linq;
-using System.Security.Authentication;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Adapter;
-using MQTTnet.Channel;
-using MQTTnet.Diagnostics;
-using MQTTnet.Serializer;
-using WebSocket4Net;
-
-namespace MQTTnet.TestApp.NetCore
-{
-    public class WebSocket4NetMqttClientAdapterFactory : IMqttClientAdapterFactory
-    {
-        public IMqttChannelAdapter CreateClientAdapter(IMqttClientOptions options, IMqttNetChildLogger logger)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-            if (logger == null) throw new ArgumentNullException(nameof(logger));
-
-            if (!(options.ChannelOptions is MqttClientWebSocketOptions))
-            {
-                throw new NotSupportedException("Only WebSocket connections are supported.");
-            }
-
-            return new MqttChannelAdapter(new WebSocket4NetMqttChannel(options), new MqttPacketSerializer(), logger);
-        }
-
-        private class WebSocket4NetMqttChannel : IMqttChannel
-        {
-            private readonly BlockingCollection<byte> _receiveBuffer = new BlockingCollection<byte>();
-
-            private readonly IMqttClientOptions _clientOptions;
-            private WebSocket4Net.WebSocket _webSocket;
-
-            public WebSocket4NetMqttChannel(IMqttClientOptions clientOptions)
-            {
-                _clientOptions = clientOptions ?? throw new ArgumentNullException(nameof(clientOptions));
-            }
-
-            public string Endpoint { get; } = "";
-
-            public Task ConnectAsync(CancellationToken cancellationToken)
-            {
-                var channelOptions = (MqttClientWebSocketOptions)_clientOptions.ChannelOptions;
-
-                var uri = "ws://" + channelOptions.Uri;
-                var sslProtocols = SslProtocols.None;
-
-                if (channelOptions.TlsOptions.UseTls)
-                {
-                    uri = "wss://" + channelOptions.Uri;
-                    sslProtocols = SslProtocols.Tls12;
-                }
-
-                var subProtocol = channelOptions.SubProtocols.FirstOrDefault() ?? string.Empty;
-
-                _webSocket = new WebSocket4Net.WebSocket(uri, subProtocol, sslProtocols: sslProtocols);
-                _webSocket.DataReceived += OnDataReceived;
-                _webSocket.Open();
-                SpinWait.SpinUntil(() => _webSocket.State == WebSocketState.Open, _clientOptions.CommunicationTimeout);
-
-                return Task.FromResult(0);
-            }
-
-            public Task DisconnectAsync()
-            {
-                if (_webSocket != null)
-                {
-                    _webSocket.DataReceived -= OnDataReceived;
-                    _webSocket.Close();
-                    SpinWait.SpinUntil(() => _webSocket.State == WebSocketState.Closed, _clientOptions.CommunicationTimeout);
-                }
-
-                _webSocket = null;
-
-                return Task.FromResult(0);
-            }
-
-            public Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
-            {
-                var readBytes = 0;
-                while (count > 0 && !cancellationToken.IsCancellationRequested)
-                {
-                    byte @byte;
-                    if (readBytes == 0)
-                    {
-                        // Block until at lease one byte was received.
-                        @byte = _receiveBuffer.Take(cancellationToken);
-                    }
-                    else
-                    {
-                        if (!_receiveBuffer.TryTake(out @byte))
-                        {
-                            return Task.FromResult(readBytes);
-                        }
-                    }
-                    
-                    buffer[offset] = @byte;
-                    offset++;
-                    count--;
-                    readBytes++;
-                }
-
-                return Task.FromResult(readBytes);
-            }
-
-            public Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
-            {
-                _webSocket.Send(buffer, offset, count);
-                return Task.FromResult(0);
-            }
-
-            public void Dispose()
-            {
-                if (_webSocket != null)
-                {
-                    _webSocket.DataReceived -= OnDataReceived;
-                    _webSocket.Dispose();
-                }
-            }
-
-            private void OnDataReceived(object sender, WebSocket4Net.DataReceivedEventArgs e)
-            {
-                foreach (var @byte in e.Data)
-                {
-                    _receiveBuffer.Add(@byte);
-                }
-            }
-        }
-    }
-}

Source/MQTTnet.Server/MQTTnet.Server.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp3.1</TargetFramework>
+    <TargetFrameworks>net5.0</TargetFrameworks>
     <AspNetCoreHostingModel>InProcess</AspNetCoreHostingModel>
     <AssemblyName>MQTTnet.Server</AssemblyName>
     <RootNamespace>MQTTnet.Server</RootNamespace>
@@ -39,12 +39,19 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="IronPython" Version="2.7.10" />
+    <PackageReference Include="IronPython" Version="2.7.11" />
-    <PackageReference Include="IronPython.StdLib" Version="2.7.10" />
+    <PackageReference Include="IronPython.StdLib" Version="2.7.11" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="3.1.5" />
     <PackageReference Include="MSTest.TestAdapter" Version="2.1.2" />
-    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="5.5.1" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerGen" Version="5.6.3" />
-    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="5.5.1" />
+    <PackageReference Include="Swashbuckle.AspNetCore.SwaggerUI" Version="5.6.3" />
+  </ItemGroup>
+  
+  <ItemGroup Condition="'$(TargetFramework)' != 'net5.0'">
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="3.1.5" />
+  </ItemGroup>
+  
+  <ItemGroup Condition="'$(TargetFramework)' == 'net5.0'">
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.NewtonsoftJson" Version="5.0.0" />
   </ItemGroup>
 
   <ItemGroup>

Source/MQTTnet.Server/Mqtt/MqttServerService.cs

@@ -212,9 +212,15 @@ namespace MQTTnet.Server.Mqtt
             // Configure encrypted connections
             if (_settings.EncryptedTcpEndPoint.Enabled)
             {
+#if NETCOREAPP3_1 || NET5_0
+                options
+                    .WithEncryptedEndpoint()
+                    .WithEncryptionSslProtocol(SslProtocols.Tls13);
+#else
                 options
                     .WithEncryptedEndpoint()
                     .WithEncryptionSslProtocol(SslProtocols.Tls12);
+#endif
 
                 if (!string.IsNullOrEmpty(_settings.EncryptedTcpEndPoint?.Certificate?.Path))
                 {

Source/MQTTnet.Server/Web/Startup.cs

@@ -116,10 +116,15 @@ namespace MQTTnet.Server.Web
             {
                 var securityScheme = new OpenApiSecurityScheme
                 {
-                    Scheme = "Basic",
+                    Scheme = "basic",
                     Name = HeaderNames.Authorization,
                     Type = SecuritySchemeType.Http,
-                    In = ParameterLocation.Header
+                    In = ParameterLocation.Header,
+                    Reference = new OpenApiReference
+                    {
+                        Type = ReferenceType.SecurityScheme,
+                        Id = "Swagger"
+                    }
                 };
 
                 c.AddSecurityDefinition("Swagger", securityScheme);
@@ -181,8 +186,7 @@ namespace MQTTnet.Server.Web
 
             var webSocketOptions = new WebSocketOptions
             {
-                KeepAliveInterval = TimeSpan.FromSeconds(mqttSettings.WebSocketEndPoint.KeepAliveInterval),
+                KeepAliveInterval = TimeSpan.FromSeconds(mqttSettings.WebSocketEndPoint.KeepAliveInterval)
-                ReceiveBufferSize = mqttSettings.WebSocketEndPoint.ReceiveBufferSize
             };
 
             if (mqttSettings.WebSocketEndPoint.AllowedOrigins?.Any() == true)

Source/MQTTnet/Adapter/IMqttChannelAdapter.cs

@@ -21,17 +21,15 @@ namespace MQTTnet.Adapter
 
         long BytesReceived { get; }
 
-        Action ReadingPacketStartedCallback { get; set; }
+        bool IsReadingPacket { get; }
-
-        Action ReadingPacketCompletedCallback { get; set; }
 
         Task ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken);
 
         Task DisconnectAsync(TimeSpan timeout, CancellationToken cancellationToken);
 
-        Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout, CancellationToken cancellationToken);
+        Task SendPacketAsync(MqttBasePacket packet, CancellationToken cancellationToken);
 
-        Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken);
+        Task<MqttBasePacket> ReceivePacketAsync(CancellationToken cancellationToken);
 
         void ResetStatistics();
     }

Source/MQTTnet/Adapter/MqttChannelAdapter.cs

@@ -11,6 +11,7 @@ using System.Runtime.InteropServices;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Diagnostics.PacketInspection;
 
 namespace MQTTnet.Adapter
 {
@@ -19,26 +20,26 @@ namespace MQTTnet.Adapter
         const uint ErrorOperationAborted = 0x800703E3;
         const int ReadBufferSize = 4096;
 
+        readonly byte[] _singleByteBuffer = new byte[1];
+        readonly byte[] _fixedHeaderBuffer = new byte[2];
+
+        readonly MqttPacketInspectorHandler _packetInspectorHandler;
         readonly IMqttNetScopedLogger _logger;
         readonly IMqttChannel _channel;
-        readonly MqttPacketReader _packetReader;
-
-        readonly byte[] _fixedHeaderBuffer = new byte[2];
 
         readonly AsyncLock _syncRoot = new AsyncLock();
 
         long _bytesReceived;
         long _bytesSent;
 
-        public MqttChannelAdapter(IMqttChannel channel, MqttPacketFormatterAdapter packetFormatterAdapter, IMqttNetLogger logger)
+        public MqttChannelAdapter(IMqttChannel channel, MqttPacketFormatterAdapter packetFormatterAdapter, IMqttPacketInspector packetInspector, IMqttNetLogger logger)
         {
-            if (logger == null) throw new ArgumentNullException(nameof(logger));
-
             _channel = channel ?? throw new ArgumentNullException(nameof(channel));
             PacketFormatterAdapter = packetFormatterAdapter ?? throw new ArgumentNullException(nameof(packetFormatterAdapter));
 
-            _packetReader = new MqttPacketReader(_channel);
+            _packetInspectorHandler = new MqttPacketInspectorHandler(packetInspector, logger);
 
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
             _logger = logger.CreateScopedLogger(nameof(MqttChannelAdapter));
         }
 
@@ -51,10 +52,10 @@ namespace MQTTnet.Adapter
         public MqttPacketFormatterAdapter PacketFormatterAdapter { get; }
 
         public long BytesSent => Interlocked.Read(ref _bytesSent);
+
         public long BytesReceived => Interlocked.Read(ref _bytesReceived);
 
-        public Action ReadingPacketStartedCallback { get; set; }
+        public bool IsReadingPacket { get; private set; }
-        public Action ReadingPacketCompletedCallback { get; set; }
 
         public async Task ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken)
         {
@@ -79,7 +80,7 @@ namespace MQTTnet.Adapter
                     throw;
                 }
 
-                WrapException(exception);
+                WrapAndThrowException(exception);
             }
         }
 
@@ -107,97 +108,78 @@ namespace MQTTnet.Adapter
                     throw;
                 }
 
-                WrapException(exception);
+                WrapAndThrowException(exception);
             }
         }
 
-        public async Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout, CancellationToken cancellationToken)
+        public async Task SendPacketAsync(MqttBasePacket packet, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            ThrowIfDisposed();
+
+            using (await _syncRoot.WaitAsync(cancellationToken).ConfigureAwait(false))
+            {
+                // Check for cancellation here again because "WaitAsync" might take some time.
+                cancellationToken.ThrowIfCancellationRequested();
+
+                try
+                {
+                    var packetData = PacketFormatterAdapter.Encode(packet);
+                    _packetInspectorHandler.BeginSendPacket(packetData);
+
+                    await _channel.WriteAsync(packetData.Array, packetData.Offset, packetData.Count, cancellationToken).ConfigureAwait(false);
+
+                    Interlocked.Add(ref _bytesReceived, packetData.Count);
+
+                    _logger.Verbose("TX ({0} bytes) >>> {1}", packetData.Count, packet);
+                }
+                catch (Exception exception)
+                {
+                    if (IsWrappedException(exception))
+                    {
+                        throw;
+                    }
+
+                    WrapAndThrowException(exception);
+                }
+                finally
+                {
+                    PacketFormatterAdapter.FreeBuffer();
+                }
+            }
+        }
+
+        public async Task<MqttBasePacket> ReceivePacketAsync(CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
             ThrowIfDisposed();
 
             try
             {
-                using (await _syncRoot.WaitAsync(cancellationToken).ConfigureAwait(false))
+                _packetInspectorHandler.BeginReceivePacket();
-                {
-                    // Check for cancellation here again because "WaitAsync" might take some time.
-                    cancellationToken.ThrowIfCancellationRequested();
 
-                    try
+                var receivedPacket = await ReceiveAsync(cancellationToken).ConfigureAwait(false);
-                    {
+                if (receivedPacket == null || cancellationToken.IsCancellationRequested)
-                        var packetData = PacketFormatterAdapter.Encode(packet);
-
-                        if (timeout == TimeSpan.Zero)
-                        {
-                            await _channel.WriteAsync(packetData.Array, packetData.Offset, packetData.Count, cancellationToken).ConfigureAwait(false);
-                        }
-                        else
-                        {
-                            await MqttTaskTimeout.WaitAsync(
-                                t => _channel.WriteAsync(packetData.Array, packetData.Offset, packetData.Count, t), timeout, cancellationToken).ConfigureAwait(false);
-                        }
-
-                        Interlocked.Add(ref _bytesReceived, packetData.Count);
-
-                        _logger.Verbose("TX ({0} bytes) >>> {1}", packetData.Count, packet);
-                    }
-                    catch (Exception exception)
-                    {
-                        if (IsWrappedException(exception))
-                        {
-                            throw;
-                        }
-
-                        WrapException(exception);
-                    }
-                    finally
-                    {
-                        PacketFormatterAdapter.FreeBuffer();
-                    }
-                }
-            }
-            catch (ObjectDisposedException)
-            {
-                throw new OperationCanceledException();
-            }
-        }
-
-        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
-        {
-            cancellationToken.ThrowIfCancellationRequested();
-            ThrowIfDisposed();
-
-            try
-            {
-                ReceivedMqttPacket receivedMqttPacket;
-                if (timeout == TimeSpan.Zero)
-                {
-                    receivedMqttPacket = await ReceiveAsync(cancellationToken).ConfigureAwait(false);
-                }
-                else
-                {
-                    receivedMqttPacket = await MqttTaskTimeout.WaitAsync(ReceiveAsync, timeout, cancellationToken).ConfigureAwait(false);
-                }
-
-                if (receivedMqttPacket == null || cancellationToken.IsCancellationRequested)
                 {
                     return null;
                 }
 
-                Interlocked.Add(ref _bytesSent, receivedMqttPacket.TotalLength);
+                _packetInspectorHandler.EndReceivePacket();
+
+                Interlocked.Add(ref _bytesSent, receivedPacket.TotalLength);
 
                 if (PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.Unknown)
                 {
-                    PacketFormatterAdapter.DetectProtocolVersion(receivedMqttPacket);
+                    PacketFormatterAdapter.DetectProtocolVersion(receivedPacket);
                 }
 
-                var packet = PacketFormatterAdapter.Decode(receivedMqttPacket);
+                var packet = PacketFormatterAdapter.Decode(receivedPacket);
                 if (packet == null)
                 {
                     throw new MqttProtocolViolationException("Received malformed packet.");
                 }
 
-                _logger.Verbose("RX ({0} bytes) <<< {1}", receivedMqttPacket.TotalLength, packet);
+                _logger.Verbose("RX ({0} bytes) <<< {1}", receivedPacket.TotalLength, packet);
 
                 return packet;
             }
@@ -214,7 +196,7 @@ namespace MQTTnet.Adapter
                     throw;
                 }
 
-                WrapException(exception);
+                WrapAndThrowException(exception);
             }
 
             return null;
@@ -239,31 +221,38 @@ namespace MQTTnet.Adapter
 
         async Task<ReceivedMqttPacket> ReceiveAsync(CancellationToken cancellationToken)
         {
-            var readFixedHeaderResult = await _packetReader.ReadFixedHeaderAsync(_fixedHeaderBuffer, cancellationToken).ConfigureAwait(false);
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return null;
+            }
+
+            var readFixedHeaderResult = await ReadFixedHeaderAsync(cancellationToken).ConfigureAwait(false);
 
             if (cancellationToken.IsCancellationRequested)
             {
                 return null;
             }
 
+            if (readFixedHeaderResult.ConnectionClosed)
+            {
+                return null;
+            }
+
             try
             {
-                if (readFixedHeaderResult.ConnectionClosed)
+                IsReadingPacket = true;
-                {
-                    return null;
-                }
-
-                ReadingPacketStartedCallback?.Invoke();
 
                 var fixedHeader = readFixedHeaderResult.FixedHeader;
                 if (fixedHeader.RemainingLength == 0)
                 {
-                    return new ReceivedMqttPacket(fixedHeader.Flags, null, 2);
+                    return new ReceivedMqttPacket(fixedHeader.Flags, new MqttPacketBodyReader(new byte[0], 0, 0), 2);
                 }
 
-                var body = new byte[fixedHeader.RemainingLength];
+                var bodyLength = fixedHeader.RemainingLength;
+                var body = new byte[bodyLength];
+
                 var bodyOffset = 0;
-                var chunkSize = Math.Min(ReadBufferSize, fixedHeader.RemainingLength);
+                var chunkSize = Math.Min(ReadBufferSize, bodyLength);
 
                 do
                 {
@@ -286,25 +275,126 @@ namespace MQTTnet.Adapter
                     }
 
                     bodyOffset += readBytes;
-                } while (bodyOffset < body.Length);
+                } while (bodyOffset < bodyLength);
 
-                var bodyReader = new MqttPacketBodyReader(body, 0, body.Length);
+                _packetInspectorHandler.FillReceiveBuffer(body);
+
+                var bodyReader = new MqttPacketBodyReader(body, 0, bodyLength);
                 return new ReceivedMqttPacket(fixedHeader.Flags, bodyReader, fixedHeader.TotalLength);
             }
             finally
             {
-                ReadingPacketCompletedCallback?.Invoke();
+                IsReadingPacket = false;
             }
         }
 
+        async Task<ReadFixedHeaderResult> ReadFixedHeaderAsync(CancellationToken cancellationToken)
+        {
+            // The MQTT fixed header contains 1 byte of flags and at least 1 byte for the remaining data length.
+            // So in all cases at least 2 bytes must be read for a complete MQTT packet.
+            var buffer = _fixedHeaderBuffer;
+            var totalBytesRead = 0;
+
+            while (totalBytesRead < buffer.Length)
+            {
+                var bytesRead = await _channel.ReadAsync(buffer, totalBytesRead, buffer.Length - totalBytesRead, cancellationToken).ConfigureAwait(false);
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return null;
+                }
+
+                if (bytesRead == 0)
+                {
+                    return new ReadFixedHeaderResult
+                    {
+                        ConnectionClosed = true
+                    };
+                }
+
+                totalBytesRead += bytesRead;
+            }
+
+            _packetInspectorHandler.FillReceiveBuffer(buffer);
+
+            var hasRemainingLength = buffer[1] != 0;
+            if (!hasRemainingLength)
+            {
+                return new ReadFixedHeaderResult
+                {
+                    FixedHeader = new MqttFixedHeader(buffer[0], 0, totalBytesRead)
+                };
+            }
+
+            var bodyLength = await ReadBodyLengthAsync(buffer[1], cancellationToken).ConfigureAwait(false);
+
+            if (!bodyLength.HasValue)
+            {
+                return new ReadFixedHeaderResult
+                {
+                    ConnectionClosed = true
+                };
+            }
+
+            totalBytesRead += bodyLength.Value;
+            return new ReadFixedHeaderResult
+            {
+                FixedHeader = new MqttFixedHeader(buffer[0], bodyLength.Value, totalBytesRead)
+            };
+        }
+
+        async Task<int?> ReadBodyLengthAsync(byte initialEncodedByte, CancellationToken cancellationToken)
+        {
+            var offset = 0;
+            var multiplier = 128;
+            var value = initialEncodedByte & 127;
+            int encodedByte = initialEncodedByte;
+
+            while ((encodedByte & 128) != 0)
+            {
+                offset++;
+                if (offset > 3)
+                {
+                    throw new MqttProtocolViolationException("Remaining length is invalid.");
+                }
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return null;
+                }
+
+                var readCount = await _channel.ReadAsync(_singleByteBuffer, 0, 1, cancellationToken).ConfigureAwait(false);
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return null;
+                }
+
+                if (readCount == 0)
+                {
+                    return null;
+                }
+
+                _packetInspectorHandler.FillReceiveBuffer(_singleByteBuffer);
+
+                encodedByte = _singleByteBuffer[0];
+
+                value += (encodedByte & 127) * multiplier;
+                multiplier *= 128;
+            }
+
+            return value;
+        }
+
         static bool IsWrappedException(Exception exception)
         {
             return exception is OperationCanceledException ||
                    exception is MqttCommunicationTimedOutException ||
-                   exception is MqttCommunicationException;
+                   exception is MqttCommunicationException ||
+                   exception is MqttProtocolViolationException;
         }
 
-        static void WrapException(Exception exception)
+        static void WrapAndThrowException(Exception exception)
         {
             if (exception is IOException && exception.InnerException is SocketException innerException)
             {
@@ -313,11 +403,15 @@ namespace MQTTnet.Adapter
 
             if (exception is SocketException socketException)
             {
-                if (socketException.SocketErrorCode == SocketError.ConnectionAborted ||
+                if (socketException.SocketErrorCode == SocketError.OperationAborted)
-                    socketException.SocketErrorCode == SocketError.OperationAborted)
                 {
                     throw new OperationCanceledException();
                 }
+
+                if (socketException.SocketErrorCode == SocketError.ConnectionAborted)
+                {
+                    throw new MqttCommunicationException(socketException);
+                }
             }
 
             if (exception is COMException comException)

Source/MQTTnet/Adapter/MqttPacketInspectorHandler.cs

@@ -0,0 +1,84 @@
+using System;
+using System.IO;
+using System.Linq;
+using MQTTnet.Diagnostics;
+using MQTTnet.Diagnostics.PacketInspection;
+
+namespace MQTTnet.Adapter
+{
+    public sealed class MqttPacketInspectorHandler
+    {
+        readonly MemoryStream _receivedPacketBuffer;
+        readonly IMqttPacketInspector _packetInspector;
+        readonly IMqttNetScopedLogger _logger;
+
+        public MqttPacketInspectorHandler(IMqttPacketInspector packetInspector, IMqttNetLogger logger)
+        {
+            _packetInspector = packetInspector;
+
+            if (packetInspector != null)
+            {
+                _receivedPacketBuffer = new MemoryStream();
+            }
+
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+            _logger = logger.CreateScopedLogger(nameof(MqttPacketInspectorHandler));
+        }
+
+        public void BeginReceivePacket()
+        {
+            _receivedPacketBuffer?.SetLength(0);
+        }
+
+        public void EndReceivePacket()
+        {
+            if (_packetInspector == null)
+            {
+                return;
+            }
+
+            var buffer = _receivedPacketBuffer.ToArray();
+            _receivedPacketBuffer.SetLength(0);
+
+            InspectPacket(buffer, MqttPacketFlowDirection.Inbound);
+        }
+
+        public void BeginSendPacket(ArraySegment<byte> buffer)
+        {
+            if (_packetInspector == null)
+            {
+                return;
+            }
+
+            // Create a copy of the actual packet so that the inspector gets no access
+            // to the internal buffers. This is waste of memory but this feature is only
+            // intended for debugging etc. so that this is OK.
+            var bufferCopy = buffer.ToArray();
+
+            InspectPacket(bufferCopy, MqttPacketFlowDirection.Outbound);
+        }
+
+        public void FillReceiveBuffer(byte[] buffer)
+        {
+            _receivedPacketBuffer?.Write(buffer, 0, buffer.Length);
+        }
+
+        void InspectPacket(byte[] buffer, MqttPacketFlowDirection direction)
+        {
+            try
+            {
+                var context = new ProcessMqttPacketContext
+                {
+                    Buffer = buffer,
+                    Direction = direction
+                };
+
+                _packetInspector.ProcessMqttPacket(context);
+            }
+            catch (Exception exception)
+            {
+                _logger.Error(exception, "Error while inspecting packet.");
+            }
+        }
+    }
+}

Source/MQTTnet/Adapter/ReceivedMqttPacket.cs

@@ -1,19 +1,20 @@
-using MQTTnet.Formatter;
+using System;
+using MQTTnet.Formatter;
 
 namespace MQTTnet.Adapter
 {
-    public class ReceivedMqttPacket
+    public sealed class ReceivedMqttPacket
     {
-        public ReceivedMqttPacket(byte fixedHeader, IMqttPacketBodyReader body, int totalLength)
+        public ReceivedMqttPacket(byte fixedHeader, IMqttPacketBodyReader bodyReader, int totalLength)
         {
             FixedHeader = fixedHeader;
-            Body = body;
+            BodyReader = bodyReader ?? throw new ArgumentNullException(nameof(bodyReader));
             TotalLength = totalLength;
         }
 
-        public byte FixedHeader { get; set; }
+        public byte FixedHeader { get; }
 
-        public IMqttPacketBodyReader Body { get; }
+        public IMqttPacketBodyReader BodyReader { get; }
 
         public int TotalLength { get; }
     }

Source/MQTTnet/Client/Connecting/MqttClientAuthenticateResult.cs

@@ -1,11 +1,16 @@
 using System.Collections.Generic;
 using MQTTnet.Packets;
+using MQTTnet.Protocol;
 
 namespace MQTTnet.Client.Connecting
 {
     // TODO: Consider renaming this to _MqttClientConnectResult_
     public class MqttClientAuthenticateResult
     {
+        /// <summary>
+        /// Gets or sets the result code.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttClientConnectResultCode ResultCode { get; set; }
 
         public bool IsSessionPresent { get; set; }
@@ -16,16 +21,34 @@ namespace MQTTnet.Client.Connecting
 
         public string AssignedClientIdentifier { get; set; }
 
+        /// <summary>
+        /// Gets or sets the authentication method.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string AuthenticationMethod { get; set; }
 
+        /// <summary>
+        /// Gets or sets the authentication data.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public byte[] AuthenticationData { get; set; }
 
         public uint? MaximumPacketSize { get; set; }
 
+        /// <summary>
+        /// Gets or sets the reason string.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string ReasonString { get; set; }
 
         public ushort? ReceiveMaximum { get; set; }
+        
+        public MqttQualityOfServiceLevel MaximumQoS { get; set; }
 
+        /// <summary>
+        /// Gets or sets the response information.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string ResponseInformation { get; set; }
 
         public ushort? TopicAliasMaximum { get; set; }
@@ -36,10 +59,25 @@ namespace MQTTnet.Client.Connecting
 
         public uint? SessionExpiryInterval { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the subscription identifiers are available or not.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public bool? SubscriptionIdentifiersAvailable { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether the shared subscriptions are available or not.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public bool? SharedSubscriptionAvailable { 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.
+        /// </summary>
         public List<MqttUserProperty> UserProperties { get; set; }
     }
 }

Source/MQTTnet/Client/Connecting/MqttClientConnectedEventArgs.cs

@@ -9,6 +9,10 @@ namespace MQTTnet.Client.Connecting
             AuthenticateResult = authenticateResult ?? throw new ArgumentNullException(nameof(authenticateResult));
         }
 
+        /// <summary>
+        /// Gets the authentication result.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttClientAuthenticateResult AuthenticateResult { get; }
     }
 }

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectOptions.cs

@@ -1,9 +1,17 @@
 namespace MQTTnet.Client.Disconnecting
 {
-    public class MqttClientDisconnectOptions
+    public sealed class MqttClientDisconnectOptions
     {
+        /// <summary>
+        /// Gets or sets the reason code.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttClientDisconnectReason ReasonCode { get; set; } = MqttClientDisconnectReason.NormalDisconnection;
 
+        /// <summary>
+        /// Gets or sets the reason string.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string ReasonString { get; set; }
     }
 }

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectedEventArgs.cs

@@ -3,22 +3,35 @@ using MQTTnet.Client.Connecting;
 
 namespace MQTTnet.Client.Disconnecting
 {
-    public class MqttClientDisconnectedEventArgs : EventArgs
+    public sealed class MqttClientDisconnectedEventArgs : EventArgs
     {
-        public MqttClientDisconnectedEventArgs(bool clientWasConnected, Exception exception, MqttClientAuthenticateResult authenticateResult, MqttClientDisconnectReason reasonCode)
+        public MqttClientDisconnectedEventArgs(bool clientWasConnected, Exception exception, MqttClientAuthenticateResult authenticateResult, MqttClientDisconnectReason reason)
         {
             ClientWasConnected = clientWasConnected;
             Exception = exception;
             AuthenticateResult = authenticateResult;
-            ReasonCode = reasonCode;
+            Reason = reason;
+
+            ReasonCode = reason;
         }
 
         public bool ClientWasConnected { get; }
 
         public Exception Exception { get; }
 
+        /// <summary>
+        /// Gets the authentication result.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttClientAuthenticateResult AuthenticateResult { get; }
 
-        public MqttClientDisconnectReason ReasonCode { get; set; } = MqttClientDisconnectReason.NormalDisconnection;
+        /// <summary>
+        /// Gets or sets the reason.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
+        public MqttClientDisconnectReason Reason { get; set; }
+
+        [Obsolete("Please use 'Reason' instead. This property will be removed in the future!")]
+        public MqttClientDisconnectReason ReasonCode { get; set; }
     }
 }

Source/MQTTnet/Client/ExtendedAuthenticationExchange/MqttExtendedAuthenticationExchangeContext.cs

@@ -20,14 +20,37 @@ namespace MQTTnet.Client.ExtendedAuthenticationExchange
             Client = client ?? throw new ArgumentNullException(nameof(client));
         }
 
+        /// <summary>
+        /// Gets the reason code.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttAuthenticateReasonCode ReasonCode { get; }
 
+        /// <summary>
+        /// Gets the reason string.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string ReasonString { get; }
 
+        /// <summary>
+        /// Gets the authentication method.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string AuthenticationMethod { get; }
 
+        /// <summary>
+        /// Gets the authentication data.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public byte[] AuthenticationData { get; }
 
+        /// <summary>
+        /// Gets 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 List<MqttUserProperty> UserProperties { get; }
 
         public IMqttClient Client { get; }

Source/MQTTnet/Client/ExtendedAuthenticationExchange/MqttExtendedAuthenticationExchangeData.cs

@@ -6,12 +6,33 @@ namespace MQTTnet.Client.ExtendedAuthenticationExchange
 {
     public class MqttExtendedAuthenticationExchangeData
     {
+        /// <summary>
+        /// Gets or sets the reason code.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttAuthenticateReasonCode ReasonCode { get; set; }
 
+        /// <summary>
+        /// Gets or sets the reason string.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string ReasonString { get; set; }
 
+        /// <summary>
+        /// Gets or sets the authentication data.
+        /// Authentication data is binary information used to transmit multiple iterations of cryptographic secrets of protocol steps.
+        /// The content of the authentication data is highly dependent on the specific implementation of the authentication method.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public byte[] AuthenticationData { 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.
+        /// </summary>
         public List<MqttUserProperty> UserProperties { get; }
     }
 }

Source/MQTTnet/Client/IMqttClient.cs

@@ -13,18 +13,38 @@ namespace MQTTnet.Client
     public interface IMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
     {
         bool IsConnected { get; }
+
         IMqttClientOptions Options { get; }
 
+        /// <summary>
+        /// Gets or sets the connected handler that is fired after the client has connected to the server successfully.
+        /// Hint: Initialize handlers before you connect the client to avoid issues.
+        /// </summary>
         IMqttClientConnectedHandler ConnectedHandler { get; set; }
 
+        /// <summary>
+        /// Gets or sets the disconnected handler that is fired after the client has disconnected from the server.
+        /// Hint: Initialize handlers before you connect the client to avoid issues.
+        /// </summary>
         IMqttClientDisconnectedHandler DisconnectedHandler { get; set; }
 
         Task<MqttClientAuthenticateResult> ConnectAsync(IMqttClientOptions options, CancellationToken cancellationToken);
+
         Task DisconnectAsync(MqttClientDisconnectOptions options, CancellationToken cancellationToken);
+
         Task PingAsync(CancellationToken cancellationToken);
 
+        /// <summary>
+        /// Sends extended authentication data.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
+        /// <param name="data">The extended data.</param>
+        /// <param name="cancellationToken">A cancellation token to stop the task.</param>
+        /// <returns>A <see cref="Task"/> representing any asynchronous operation.</returns>
         Task SendExtendedAuthenticationExchangeDataAsync(MqttExtendedAuthenticationExchangeData data, CancellationToken cancellationToken);
+
         Task<MqttClientSubscribeResult> SubscribeAsync(MqttClientSubscribeOptions options, CancellationToken cancellationToken);
+
         Task<MqttClientUnsubscribeResult> UnsubscribeAsync(MqttClientUnsubscribeOptions options, CancellationToken cancellationToken);
     }
 }

Source/MQTTnet/Client/IMqttClientFactory.cs

@@ -1,5 +1,4 @@
-using System;
+using MQTTnet.Adapter;
-using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 using MQTTnet.LowLevelClient;
 

Source/MQTTnet/Client/MqttClient.cs

@@ -17,6 +17,7 @@ using System;
 using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Implementations;
 
 namespace MQTTnet.Client
 {
@@ -42,6 +43,7 @@ namespace MQTTnet.Client
         bool _cleanDisconnectInitiated;
         long _isDisconnectPending;
         bool _isConnected;
+        MqttClientDisconnectReason _disconnectReason;
 
         public MqttClient(IMqttClientAdapterFactory channelFactory, IMqttNetLogger logger)
         {
@@ -77,7 +79,7 @@ namespace MQTTnet.Client
                 Options = options;
 
                 _packetIdentifierProvider.Reset();
-                _packetDispatcher.Reset();
+                _packetDispatcher.Cancel();
 
                 _backgroundCancellationTokenSource = new CancellationTokenSource();
                 var backgroundCancellationToken = _backgroundCancellationTokenSource.Token;
@@ -88,8 +90,8 @@ namespace MQTTnet.Client
 
                 using (var combined = CancellationTokenSource.CreateLinkedTokenSource(backgroundCancellationToken, cancellationToken))
                 {
-                    _logger.Verbose($"Trying to connect with server '{options.ChannelOptions}' (Timeout={options.CommunicationTimeout}).");
+                    _logger.Verbose("Trying to connect with server '{0}' (Timeout={1}).", options.ChannelOptions, options.CommunicationTimeout);
-                    await _adapter.ConnectAsync(options.CommunicationTimeout, combined.Token).ConfigureAwait(false);
+                    await adapter.ConnectAsync(options.CommunicationTimeout, combined.Token).ConfigureAwait(false);
                     _logger.Verbose("Connection with server established.");
 
                     _publishPacketReceiverQueue = new AsyncQueue<MqttPublishPacket>();
@@ -122,6 +124,8 @@ namespace MQTTnet.Client
             }
             catch (Exception exception)
             {
+                _disconnectReason = MqttClientDisconnectReason.UnspecifiedError;
+
                 _logger.Error(exception, "Error while connecting with server.");
 
                 if (!DisconnectIsPending())
@@ -139,11 +143,17 @@ namespace MQTTnet.Client
 
             ThrowIfDisposed();
 
+            if (DisconnectIsPending())
+            {
+                return;
+            }
+
             try
             {
+                _disconnectReason = MqttClientDisconnectReason.NormalDisconnection;
                 _cleanDisconnectInitiated = true;
 
-                if (IsConnected)
+                if (_isConnected)
                 {
                     var disconnectPacket = _adapter.PacketFormatterAdapter.DataConverter.CreateDisconnectPacket(options);
                     await SendAsync(disconnectPacket, cancellationToken).ConfigureAwait(false);
@@ -151,10 +161,7 @@ namespace MQTTnet.Client
             }
             finally
             {
-                if (!DisconnectIsPending())
+                await DisconnectInternalAsync(null, null, null).ConfigureAwait(false);
-                {
-                    await DisconnectInternalAsync(null, null, null).ConfigureAwait(false);
-                }
             }
         }
 
@@ -213,9 +220,9 @@ namespace MQTTnet.Client
 
         public Task<MqttClientPublishResult> PublishAsync(MqttApplicationMessage applicationMessage, CancellationToken cancellationToken)
         {
-            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
+            cancellationToken.ThrowIfCancellationRequested();
 
-            MqttTopicValidator.ThrowIfInvalid(applicationMessage.Topic);
+            MqttTopicValidator.ThrowIfInvalid(applicationMessage);
 
             ThrowIfDisposed();
             ThrowIfNotConnected();
@@ -245,24 +252,27 @@ namespace MQTTnet.Client
 
         void Cleanup()
         {
-            _backgroundCancellationTokenSource?.Cancel(false);
+            try
-            _backgroundCancellationTokenSource?.Dispose();
+            {
-            _backgroundCancellationTokenSource = null;
+                _backgroundCancellationTokenSource?.Cancel(false);
+            }
+            finally
+            {
+                _backgroundCancellationTokenSource?.Dispose();
+                _backgroundCancellationTokenSource = null;
 
-            _publishPacketReceiverQueue?.Dispose();
+                _publishPacketReceiverQueue?.Dispose();
-            _publishPacketReceiverQueue = null;
+                _publishPacketReceiverQueue = null;
 
-            _adapter?.Dispose();
+                _adapter?.Dispose();
+            }
         }
 
-
         protected override void Dispose(bool disposing)
         {
             if (disposing)
             {
                 Cleanup();
-
-                DisconnectedHandler = null;
             }
 
             base.Dispose(disposing);
@@ -302,8 +312,7 @@ namespace MQTTnet.Client
 
         async Task DisconnectInternalAsync(Task sender, Exception exception, MqttClientAuthenticateResult authenticateResult)
         {
-            var clientWasConnected = IsConnected;
+            var clientWasConnected = _isConnected;
-            var reasonCode = MqttClientDisconnectReason.NormalDisconnection;
 
             TryInitiateDisconnect();
             _isConnected = false;
@@ -321,7 +330,6 @@ namespace MQTTnet.Client
             catch (Exception adapterException)
             {
                 _logger.Warning(adapterException, "Error while disconnecting from adapter.");
-                reasonCode = MqttClientDisconnectReason.UnspecifiedError;
             }
 
             try
@@ -337,7 +345,6 @@ namespace MQTTnet.Client
             catch (Exception e)
             {
                 _logger.Warning(e, "Error while waiting for internal tasks.");
-                reasonCode = MqttClientDisconnectReason.UnspecifiedError;
             }
             finally
             {
@@ -351,7 +358,7 @@ namespace MQTTnet.Client
                 {
                     // This handler must be executed in a new thread because otherwise a dead lock may happen
                     // when trying to reconnect in that handler etc.
-                    Task.Run(() => disconnectedHandler.HandleDisconnectedAsync(new MqttClientDisconnectedEventArgs(clientWasConnected, exception, authenticateResult, reasonCode))).Forget(_logger);
+                    Task.Run(() => disconnectedHandler.HandleDisconnectedAsync(new MqttClientDisconnectedEventArgs(clientWasConnected, exception, authenticateResult, _disconnectReason))).RunInBackground(_logger);
                 }
             }
         }
@@ -362,11 +369,6 @@ namespace MQTTnet.Client
             {
                 try
                 {
-                    if (_backgroundCancellationTokenSource?.IsCancellationRequested == true)
-                    {
-                        return;
-                    }
-
                     _backgroundCancellationTokenSource?.Cancel(false);
                 }
                 catch (Exception exception)
@@ -382,17 +384,17 @@ namespace MQTTnet.Client
 
             _sendTracker.Restart();
 
-            return _adapter.SendPacketAsync(packet, Options.CommunicationTimeout, cancellationToken);
+            return _adapter.SendPacketAsync(packet, cancellationToken);
         }
 
         async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket, CancellationToken cancellationToken) where TResponsePacket : MqttBasePacket
         {
             cancellationToken.ThrowIfCancellationRequested();
-            
+
             ushort identifier = 0;
-            if (requestPacket is IMqttPacketWithIdentifier packetWithIdentifier && packetWithIdentifier.PacketIdentifier.HasValue)
+            if (requestPacket is IMqttPacketWithIdentifier packetWithIdentifier && packetWithIdentifier.PacketIdentifier > 0)
             {
-                identifier = packetWithIdentifier.PacketIdentifier.Value;
+                identifier = packetWithIdentifier.PacketIdentifier;
             }
 
             using (var packetAwaiter = _packetDispatcher.AddAwaiter<TResponsePacket>(identifier))
@@ -400,12 +402,11 @@ namespace MQTTnet.Client
                 try
                 {
                     _sendTracker.Restart();
-
+                    await _adapter.SendPacketAsync(requestPacket, cancellationToken).ConfigureAwait(false);
-                    await _adapter.SendPacketAsync(requestPacket, Options.CommunicationTimeout, cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception e)
                 {
-                    _logger.Warning(e, "Error when sending packet of type '{0}'.", typeof(TResponsePacket).Name);
+                    _logger.Warning(e, "Error when sending request packet ({0}).", requestPacket.GetType().Name);
                     packetAwaiter.Cancel();
                 }
 
@@ -417,7 +418,7 @@ namespace MQTTnet.Client
                 {
                     if (exception is MqttCommunicationTimedOutException)
                     {
-                        _logger.Warning(null, "Timeout while waiting for packet of type '{0}'.", typeof(TResponsePacket).Name);
+                        _logger.Warning(null, "Timeout while waiting for response packet ({0}).", typeof(TResponsePacket).Name);
                     }
 
                     throw;
@@ -437,10 +438,10 @@ namespace MQTTnet.Client
                 {
                     // Values described here: [MQTT-3.1.2-24].
                     var waitTime = keepAlivePeriod - _sendTracker.Elapsed;
-                    
+
                     if (waitTime <= TimeSpan.Zero)
                     {
-                        await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket(), cancellationToken).ConfigureAwait(false);
+                        await SendAndReceiveAsync<MqttPingRespPacket>(MqttPingReqPacket.Instance, cancellationToken).ConfigureAwait(false);
                     }
 
                     // Wait a fixed time in all cases. Calculation of the remaining time is complicated
@@ -459,6 +460,7 @@ namespace MQTTnet.Client
 
                 if (exception is OperationCanceledException)
                 {
+                    return;
                 }
                 else if (exception is MqttCommunicationException)
                 {
@@ -488,7 +490,7 @@ namespace MQTTnet.Client
 
                 while (!cancellationToken.IsCancellationRequested)
                 {
-                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+                    var packet = await _adapter.ReceivePacketAsync(cancellationToken).ConfigureAwait(false);
 
                     if (cancellationToken.IsCancellationRequested)
                     {
@@ -550,32 +552,25 @@ namespace MQTTnet.Client
                 {
                     EnqueueReceivedPublishPacket(publishPacket);
                 }
+                else if (packet is MqttPubRecPacket pubRecPacket)
+                {
+                    await ProcessReceivedPubRecPacket(pubRecPacket, cancellationToken).ConfigureAwait(false);
+                }
                 else if (packet is MqttPubRelPacket pubRelPacket)
                 {
-                    await SendAsync(new MqttPubCompPacket
+                    await ProcessReceivedPubRelPacket(pubRelPacket, cancellationToken).ConfigureAwait(false);
-                    {
-                        PacketIdentifier = pubRelPacket.PacketIdentifier,
-                        ReasonCode = MqttPubCompReasonCode.Success
-                    }, cancellationToken).ConfigureAwait(false);
                 }
                 else if (packet is MqttPingReqPacket)
                 {
-                    await SendAsync(new MqttPingRespPacket(), cancellationToken).ConfigureAwait(false);
+                    await SendAsync(MqttPingRespPacket.Instance, cancellationToken).ConfigureAwait(false);
                 }
-                else if (packet is MqttDisconnectPacket)
+                else if (packet is MqttDisconnectPacket disconnectPacket)
                 {
-                    // Also dispatch disconnect to waiting threads to generate a proper exception.
+                    await ProcessReceivedDisconnectPacket(disconnectPacket).ConfigureAwait(false);
-                    _packetDispatcher.Dispatch(packet);
-
-                    await DisconnectAsync(null, cancellationToken).ConfigureAwait(false);
                 }
                 else if (packet is MqttAuthPacket authPacket)
                 {
-                    var extendedAuthenticationExchangeHandler = Options.ExtendedAuthenticationExchangeHandler;
+                    await ProcessReceivedAuthPacket(authPacket).ConfigureAwait(false);
-                    if (extendedAuthenticationExchangeHandler != null)
-                    {
-                        await extendedAuthenticationExchangeHandler.HandleRequestAsync(new MqttExtendedAuthenticationExchangeContext(authPacket, this)).ConfigureAwait(false);
-                    }
                 }
                 else
                 {
@@ -618,7 +613,7 @@ namespace MQTTnet.Client
             }
             catch (Exception exception)
             {
-                _logger.Error(exception, "Error while enqueueing application message.");
+                _logger.Error(exception, "Error while queueing application message.");
             }
         }
 
@@ -628,8 +623,7 @@ namespace MQTTnet.Client
             {
                 try
                 {
-                    var publishPacketDequeueResult = await _publishPacketReceiverQueue.TryDequeueAsync(cancellationToken);
+                    var publishPacketDequeueResult = await _publishPacketReceiverQueue.TryDequeueAsync(cancellationToken).ConfigureAwait(false);
-
                     if (!publishPacketDequeueResult.IsSuccess)
                     {
                         return;
@@ -643,26 +637,28 @@ namespace MQTTnet.Client
                     }
                     else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
                     {
-                        if (await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false))
+                        var eventArgs = await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false);
+
+                        if (!eventArgs.ProcessingFailed)
                         {
                             await SendAsync(new MqttPubAckPacket
                             {
                                 PacketIdentifier = publishPacket.PacketIdentifier,
-                                ReasonCode = MqttPubAckReasonCode.Success
+                                ReasonCode = (MqttPubAckReasonCode)eventArgs.ReasonCode
                             }, cancellationToken).ConfigureAwait(false);
                         }
                     }
                     else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
                     {
-                        if (await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false))
+                        var eventArgs = await HandleReceivedApplicationMessageAsync(publishPacket).ConfigureAwait(false);
+
+                        if (!eventArgs.ProcessingFailed)
                         {
-                            var pubRecPacket = new MqttPubRecPacket
+                            await SendAsync(new MqttPubRecPacket
                             {
                                 PacketIdentifier = publishPacket.PacketIdentifier,
-                                ReasonCode = MqttPubRecReasonCode.Success
+                                ReasonCode = (MqttPubRecReasonCode)eventArgs.ReasonCode
-                            };
+                            }, cancellationToken).ConfigureAwait(false);
-
-                            await SendAsync(pubRecPacket, cancellationToken).ConfigureAwait(false);
                         }
                     }
                     else
@@ -670,6 +666,9 @@ namespace MQTTnet.Client
                         throw new MqttProtocolViolationException("Received a not supported QoS level.");
                     }
                 }
+                catch (OperationCanceledException)
+                {
+                }
                 catch (Exception exception)
                 {
                     _logger.Error(exception, "Error while handling application message.");
@@ -677,6 +676,57 @@ namespace MQTTnet.Client
             }
         }
 
+        Task ProcessReceivedPubRecPacket(MqttPubRecPacket pubRecPacket, CancellationToken cancellationToken)
+        {
+            if (!_packetDispatcher.TryDispatch(pubRecPacket))
+            {
+                // 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.
+                return SendAsync(new MqttPubRelPacket
+                {
+                    PacketIdentifier = pubRecPacket.PacketIdentifier,
+                    ReasonCode = MqttPubRelReasonCode.PacketIdentifierNotFound
+                }, cancellationToken);
+            }
+
+            return PlatformAbstractionLayer.CompletedTask;
+        }
+
+        Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
+        {
+            return SendAsync(new MqttPubCompPacket
+            {
+                PacketIdentifier = pubRelPacket.PacketIdentifier,
+                ReasonCode = MqttPubCompReasonCode.Success
+            }, cancellationToken);
+        }
+
+        Task ProcessReceivedDisconnectPacket(MqttDisconnectPacket disconnectPacket)
+        {
+            _disconnectReason = (MqttClientDisconnectReason)(disconnectPacket.ReasonCode ?? MqttDisconnectReasonCode.NormalDisconnection);
+
+            // Also dispatch disconnect to waiting threads to generate a proper exception.
+            _packetDispatcher.Dispatch(disconnectPacket);
+
+            if (!DisconnectIsPending())
+            {
+                return DisconnectInternalAsync(_packetReceiverTask, null, null);
+            }
+
+            return PlatformAbstractionLayer.CompletedTask;
+        }
+
+        Task ProcessReceivedAuthPacket(MqttAuthPacket authPacket)
+        {
+            var extendedAuthenticationExchangeHandler = Options.ExtendedAuthenticationExchangeHandler;
+            if (extendedAuthenticationExchangeHandler != null)
+            {
+                return extendedAuthenticationExchangeHandler.HandleRequestAsync(new MqttExtendedAuthenticationExchangeContext(authPacket, this));
+            }
+
+            return PlatformAbstractionLayer.CompletedTask;
+        }
+
         async Task<MqttClientPublishResult> PublishAtMostOnce(MqttPublishPacket publishPacket, CancellationToken cancellationToken)
         {
             // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
@@ -708,19 +758,18 @@ namespace MQTTnet.Client
             return _adapter.PacketFormatterAdapter.DataConverter.CreatePublishResult(pubRecPacket, pubCompPacket);
         }
 
-        async Task<bool> HandleReceivedApplicationMessageAsync(MqttPublishPacket publishPacket)
+        async Task<MqttApplicationMessageReceivedEventArgs> HandleReceivedApplicationMessageAsync(MqttPublishPacket publishPacket)
         {
             var applicationMessage = _adapter.PacketFormatterAdapter.DataConverter.CreateApplicationMessage(publishPacket);
+            var eventArgs = new MqttApplicationMessageReceivedEventArgs(Options.ClientId, applicationMessage);
 
             var handler = ApplicationMessageReceivedHandler;
             if (handler != null)
             {
-                var eventArgs = new MqttApplicationMessageReceivedEventArgs(Options.ClientId, applicationMessage);
                 await handler.HandleApplicationMessageReceivedAsync(eventArgs).ConfigureAwait(false);
-                return !eventArgs.ProcessingFailed;
             }
 
-            return true;
+            return eventArgs;
         }
 
         async Task WaitForTaskAsync(Task task, Task sender)
@@ -756,6 +805,8 @@ namespace MQTTnet.Client
 
         bool DisconnectIsPending()
         {
+            // This will read the _isDisconnectPending and set it to "1" afterwards regardless of the value.
+            // So the first caller will get a "false" and all subsequent ones will get "true".
             return Interlocked.CompareExchange(ref _isDisconnectPending, 1, 0) != 0;
         }
     }

Source/MQTTnet/Client/MqttClientExtensions.cs

@@ -128,7 +128,21 @@ namespace MQTTnet.Client
         {
             if (client == null) throw new ArgumentNullException(nameof(client));
 
-            return client.DisconnectAsync(new MqttClientDisconnectOptions());
+            return client.DisconnectAsync(CancellationToken.None);
+        }
+
+        public static Task DisconnectAsync(this IMqttClient client, MqttClientDisconnectOptions options)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+
+            return client.DisconnectAsync(options, CancellationToken.None);
+        }
+
+        public static Task DisconnectAsync(this IMqttClient client, CancellationToken cancellationToken)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+
+            return client.DisconnectAsync(new MqttClientDisconnectOptions(), cancellationToken);
         }
 
         public static Task<MqttClientSubscribeResult> SubscribeAsync(this IMqttClient client, params MqttTopicFilter[] topicFilters)
@@ -176,13 +190,6 @@ namespace MQTTnet.Client
             return client.ConnectAsync(options, CancellationToken.None);
         }
 
-        public static Task DisconnectAsync(this IMqttClient client, MqttClientDisconnectOptions options)
-        {
-            if (client == null) throw new ArgumentNullException(nameof(client));
-
-            return client.DisconnectAsync(options, CancellationToken.None);
-        }
-
         public static Task SendExtendedAuthenticationExchangeDataAsync(this IMqttClient client, MqttExtendedAuthenticationExchangeData data)
         {
             if (client == null) throw new ArgumentNullException(nameof(client));

Source/MQTTnet/Client/MqttPacketIdentifierProvider.cs

@@ -1,9 +1,10 @@
 namespace MQTTnet.Client
 {
-    public class MqttPacketIdentifierProvider
+    public sealed class MqttPacketIdentifierProvider
     {
-        private readonly object _syncRoot = new object();
+        readonly object _syncRoot = new object();
-        private ushort _value;
+
+        ushort _value;
 
         public void Reset()
         {

Source/MQTTnet/Client/Options/IMqttClientOptions.cs

@@ -3,31 +3,112 @@ using MQTTnet.Formatter;
 using MQTTnet.Packets;
 using System;
 using System.Collections.Generic;
+using MQTTnet.Diagnostics.PacketInspection;
 
 namespace MQTTnet.Client.Options
 {
     public interface IMqttClientOptions
     {
+        /// <summary>
+        /// Gets the client identifier.
+        /// Hint: This identifier needs to be unique over all used clients / devices on the broker to avoid connection issues.
+        /// </summary>
         string ClientId { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether clean sessions are used or not.
+        /// When a client connects to a broker it can connect using either a non persistent connection (clean session) or a persistent connection.
+        /// With a non persistent connection the broker doesn't store any subscription information or undelivered messages for the client.
+        /// This mode is ideal when the client only publishes messages.
+        /// It can also connect as a durable client using a persistent connection.
+        /// In this mode, the broker will store subscription information, and undelivered messages for the client.
+        /// </summary>
         bool CleanSession { get; }
+
         IMqttClientCredentials Credentials { get; }
+
         IMqttExtendedAuthenticationExchangeHandler ExtendedAuthenticationExchangeHandler { get; }
+
         MqttProtocolVersion ProtocolVersion { get; }
+
         IMqttClientChannelOptions ChannelOptions { get; }
 
         TimeSpan CommunicationTimeout { get; }
+
+        /// <summary>
+        /// Gets the keep alive period.
+        /// The connection is normally left open by the client so that is can send and receive data at any time.
+        /// If no data flows over an open connection for a certain time period then the client will generate a PINGREQ and expect to receive a PINGRESP from the broker.
+        /// This message exchange confirms that the connection is open and working.
+        /// This period is known as the keep alive period. 
+        /// </summary>
         TimeSpan KeepAlivePeriod { get; }
+
+        /// <summary>
+        /// Gets the last will message.
+        /// In MQTT, you use the last will message feature to notify other clients about an ungracefully disconnected client.
+        /// </summary>
         MqttApplicationMessage WillMessage { get; }
+
+        /// <summary>
+        /// Gets the will delay interval.
+        /// This is the time between the client disconnect and the time the will message will be sent.
+        /// </summary>
         uint? WillDelayInterval { get; }
 
+        /// <summary>
+        /// Gets the authentication method.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         string AuthenticationMethod { get; }
+
+        /// <summary>
+        /// Gets the authentication data.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         byte[] AuthenticationData { get; }
+
         uint? MaximumPacketSize { get; }
+
+        /// <summary>
+        /// Gets the receive maximum.
+        /// This gives the maximum length of the receive messages.
+        /// </summary>
         ushort? ReceiveMaximum { get; }
+
+        /// <summary>
+        /// Gets the request problem information.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         bool? RequestProblemInformation { get; }
+
+        /// <summary>
+        /// Gets the request response information.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         bool? RequestResponseInformation { get; }
+
+        /// <summary>
+        /// Gets the session expiry interval.
+        /// The time after a session expires when it's not actively used.
+        /// </summary>
         uint? SessionExpiryInterval { get; }
+
+        /// <summary>
+        /// Gets the topic alias maximum.
+        /// This gives the maximum length of the topic alias.
+        /// </summary>
         ushort? TopicAliasMaximum { get; }
+
+        /// <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.
+        /// </summary>
         List<MqttUserProperty> UserProperties { get; set; }
+
+        IMqttPacketInspector PacketInspector { get; set; }
     }
 }

Source/MQTTnet/Client/Options/MqttClientOptions.cs

@@ -3,33 +3,112 @@ using MQTTnet.Formatter;
 using MQTTnet.Packets;
 using System;
 using System.Collections.Generic;
+using MQTTnet.Diagnostics.PacketInspection;
 
 namespace MQTTnet.Client.Options
 {
     public class MqttClientOptions : IMqttClientOptions
     {
+        /// <summary>
+        /// Gets the client identifier.
+        /// Hint: This identifier needs to be unique over all used clients / devices on the broker to avoid connection issues.
+        /// </summary>
         public string ClientId { get; set; } = Guid.NewGuid().ToString("N");
+
+        /// <summary>
+        /// Gets or sets a value indicating whether clean sessions are used or not.
+        /// When a client connects to a broker it can connect using either a non persistent connection (clean session) or a persistent connection.
+        /// With a non persistent connection the broker doesn't store any subscription information or undelivered messages for the client.
+        /// This mode is ideal when the client only publishes messages.
+        /// It can also connect as a durable client using a persistent connection.
+        /// In this mode, the broker will store subscription information, and undelivered messages for the client.
+        /// </summary>
         public bool CleanSession { get; set; } = true;
+
         public IMqttClientCredentials Credentials { get; set; }
+
         public IMqttExtendedAuthenticationExchangeHandler ExtendedAuthenticationExchangeHandler { get; set; }
+
         public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
 
         public IMqttClientChannelOptions ChannelOptions { get; set; }
+
         public TimeSpan CommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
+        /// <summary>
+        /// Gets or sets the keep alive period.
+        /// The connection is normally left open by the client so that is can send and receive data at any time.
+        /// If no data flows over an open connection for a certain time period then the client will generate a PINGREQ and expect to receive a PINGRESP from the broker.
+        /// This message exchange confirms that the connection is open and working.
+        /// This period is known as the keep alive period. 
+        /// </summary>
         public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(15);
 
+        /// <summary>
+        /// Gets or sets the last will message.
+        /// In MQTT, you use the last will message feature to notify other clients about an ungracefully disconnected client.
+        /// </summary>
         public MqttApplicationMessage WillMessage { get; set; }
+
+        /// <summary>
+        /// Gets or sets the will delay interval.
+        /// This is the time between the client disconnect and the time the will message will be sent.
+        /// </summary>
         public uint? WillDelayInterval { get; set; }
 
+        /// <summary>
+        /// Gets or sets the authentication method.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public string AuthenticationMethod { get; set; }
+
+        /// <summary>
+        /// Gets or sets the authentication data.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public byte[] AuthenticationData { get; set; }
 
         public uint? MaximumPacketSize { get; set; }
+
+        /// <summary>
+        /// Gets or sets the receive maximum.
+        /// This gives the maximum length of the receive messages.
+        /// </summary>
         public ushort? ReceiveMaximum { get; set; }
+
+        /// <summary>
+        /// Gets or sets the request problem information.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public bool? RequestProblemInformation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the request response information.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public bool? RequestResponseInformation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the session expiry interval.
+        /// The time after a session expires when it's not actively used.
+        /// </summary>
         public uint? SessionExpiryInterval { get; set; }
+
+        /// <summary>
+        /// Gets or sets the topic alias maximum.
+        /// This gives the maximum length of the topic alias.
+        /// </summary>
         public ushort? TopicAliasMaximum { 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.
+        /// </summary>
         public List<MqttUserProperty> UserProperties { get; set; }
+
+        public IMqttPacketInspector PacketInspector { get; set; }
     }
 }

Source/MQTTnet/Client/Options/MqttClientOptionsBuilder.cs

@@ -5,6 +5,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using MQTTnet.Diagnostics.PacketInspection;
 
 namespace MQTTnet.Client.Options
 {
@@ -256,6 +257,12 @@ namespace MQTTnet.Client.Options
             return this;
         }
 
+        public MqttClientOptionsBuilder WithPacketInspector(IMqttPacketInspector packetInspector)
+        {
+            _options.PacketInspector = packetInspector;
+            return this;
+        }
+
         public IMqttClientOptions Build()
         {
             if (_tcpOptions == null && _webSocketOptions == null)
@@ -280,7 +287,9 @@ namespace MQTTnet.Client.Options
 #pragma warning disable CS0618 // Type or member is obsolete
                         CertificateValidationCallback = _tlsParameters.CertificateValidationCallback,
 #pragma warning restore CS0618 // Type or member is obsolete
-
+#if NETCOREAPP3_1
+                        ApplicationProtocols = _tlsParameters.ApplicationProtocols,
+#endif
                         CertificateValidationHandler = _tlsParameters.CertificateValidationHandler,
                         IgnoreCertificateChainErrors = _tlsParameters.IgnoreCertificateChainErrors,
                         IgnoreCertificateRevocationErrors = _tlsParameters.IgnoreCertificateRevocationErrors

Source/MQTTnet/Client/Options/MqttClientOptionsBuilderTlsParameters.cs

@@ -19,7 +19,11 @@ namespace MQTTnet.Client.Options
 
         public Func<MqttClientCertificateValidationCallbackContext, bool> CertificateValidationHandler { get; set; }
 
+#if NETCOREAPP3_1 || NET5_0
+        public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls13;
+#else
         public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls12;
+#endif
 
 #if WINDOWS_UWP
         public IEnumerable<IEnumerable<byte>> Certificates { get; set; }
@@ -27,7 +31,11 @@ namespace MQTTnet.Client.Options
         public IEnumerable<X509Certificate> Certificates { get; set; }
 #endif
 
-        public bool AllowUntrustedCertificates { get; set; }
+#if NETCOREAPP3_1
+	    public List<SslApplicationProtocol> ApplicationProtocols { get;set; }
+#endif 
+
+	    public bool AllowUntrustedCertificates { get; set; }
 
         public bool IgnoreCertificateChainErrors { get; set; }
 

Source/MQTTnet/Client/Options/MqttClientTcpOptions.cs

@@ -8,7 +8,7 @@ namespace MQTTnet.Client.Options
 
         public int? Port { get; set; }
 
-        public int BufferSize { get; set; } = 65536;
+        public int BufferSize { get; set; } = 8192;
 
         public bool? DualMode { get; set; }
 

Source/MQTTnet/Client/Options/MqttClientTlsOptions.cs

@@ -22,7 +22,15 @@ namespace MQTTnet.Client.Options
         public List<X509Certificate> Certificates { get; set; }
 #endif
 
+#if NETCOREAPP3_1
+        public List<SslApplicationProtocol> ApplicationProtocols { get; set; }
+#endif
+
+#if NETCOREAPP3_1 || NET5_0
+        public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls13;
+#else
         public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls12;
+#endif
 
         [Obsolete("This property will be removed soon. Use CertificateValidationHandler instead.")]
         public Func<X509Certificate, X509Chain, SslPolicyErrors, IMqttClientOptions, bool> CertificateValidationCallback { get; set; }

Source/MQTTnet/Client/Publishing/MqttClientPublishResult.cs

@@ -8,10 +8,25 @@ namespace MQTTnet.Client.Publishing
     {
         public ushort? PacketIdentifier { get; set; }
 
+        /// <summary>
+        /// 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.
+        /// </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.
+        /// </summary>
         public List<MqttUserProperty> UserProperties { get; set; }
     }
 }

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeOptions.cs

@@ -5,10 +5,28 @@ namespace MQTTnet.Client.Subscribing
 {
     public class MqttClientSubscribeOptions
     {
+        /// <summary>
+        /// Gets or sets a list of topic filters the client wants to subscribe to.
+        /// Topic filters can include regular topics or wild cards.
+        /// </summary>
         public List<MqttTopicFilter> TopicFilters { get; set; } = new List<MqttTopicFilter>();
 
+        /// <summary>
+        /// Gets or sets the subscription identifier.
+        /// The client can specify a subscription identifier when subscribing.
+        /// The broker will establish and store the mapping relationship between this subscription and subscription identifier when successfully create or modify subscription.
+        /// The broker will return the subscription identifier associated with this PUBLISH packet and the PUBLISH packet to the client when need to forward PUBLISH packets matching this subscription to this client.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public uint? SubscriptionIdentifier { 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.
+        /// </summary>
         public List<MqttUserProperty> UserProperties { get; set; }
     }
 }

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeOptionsBuilder.cs

@@ -9,6 +9,13 @@ namespace MQTTnet.Client.Subscribing
     {
         private readonly MqttClientSubscribeOptions _subscribeOptions = new MqttClientSubscribeOptions();
 
+        /// <summary>
+        /// Adds the user property to the subscribe options.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <param name="value">The property value.</param>
+        /// <returns>A new instance of the <see cref="MqttApplicationMessageBuilder"/> class.</returns>
         public MqttClientSubscribeOptionsBuilder WithUserProperty(string name, string value)
         {
             if (name == null) throw new ArgumentNullException(nameof(name));
@@ -27,7 +34,6 @@ namespace MQTTnet.Client.Subscribing
         public MqttClientSubscribeOptionsBuilder WithSubscriptionIdentifier(uint? subscriptionIdentifier)
         {
             _subscribeOptions.SubscriptionIdentifier = subscriptionIdentifier;
-
             return this;
         }
 

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeResultItem.cs

@@ -10,8 +10,16 @@ namespace MQTTnet.Client.Subscribing
             ResultCode = resultCode;
         }
 
+        /// <summary>
+        /// Gets or sets the topic filter.
+        /// The topic filter can contain topics and wildcards.
+        /// </summary>
         public MqttTopicFilter TopicFilter { get; }
 
+        /// <summary>
+        /// Gets or sets the result code.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttClientSubscribeResultCode ResultCode { get; }
     }
 }

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeOptions.cs

@@ -5,8 +5,19 @@ namespace MQTTnet.Client.Unsubscribing
 {
     public class MqttClientUnsubscribeOptions
     {
+        /// <summary>
+        /// Gets or sets a list of topic filters the client wants to unsubscribe from.
+        /// Topic filters can include regular topics or wild cards.
+        /// </summary>
         public List<string> TopicFilters { get; set; } = new List<string>();
 
+        /// <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.
+        /// </summary>
         public List<MqttUserProperty> UserProperties { get; set; } = new List<MqttUserProperty>();
     }
 }

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeOptionsBuilder.cs

@@ -8,6 +8,13 @@ namespace MQTTnet.Client.Unsubscribing
     {
         private readonly MqttClientUnsubscribeOptions _unsubscribeOptions = new MqttClientUnsubscribeOptions();
 
+        /// <summary>
+        /// Adds the user property to the unsubscribe options.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
+        /// <param name="name">The property name.</param>
+        /// <param name="value">The property value.</param>
+        /// <returns>A new instance of the <see cref="MqttClientUnsubscribeOptionsBuilder"/> class.</returns>
         public MqttClientUnsubscribeOptionsBuilder WithUserProperty(string name, string value)
         {
             if (name is null) throw new ArgumentNullException(nameof(name));
@@ -16,6 +23,12 @@ namespace MQTTnet.Client.Unsubscribing
             return WithUserProperty(new MqttUserProperty(name, value));
         }
 
+        /// <summary>
+        /// Adds the user property to the unsubscribe options.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
+        /// <param name="userProperty">The user property.</param>
+        /// <returns>A new instance of the <see cref="MqttClientUnsubscribeOptionsBuilder"/> class.</returns>
         public MqttClientUnsubscribeOptionsBuilder WithUserProperty(MqttUserProperty userProperty)
         {
             if (userProperty is null) throw new ArgumentNullException(nameof(userProperty));

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeResultItem.cs

@@ -10,8 +10,16 @@ namespace MQTTnet.Client.Unsubscribing
             ReasonCode = reasonCode;
         }
 
+        /// <summary>
+        /// Gets or sets the topic filter.
+        /// The topic filter can contain topics and wildcards.
+        /// </summary>
         public string TopicFilter { get; }
 
+        /// <summary>
+        /// Gets or sets the result code.
+        /// Hint: MQTT 5 feature only.
+        /// </summary>
         public MqttClientUnsubscribeResultCode ReasonCode { get; }
     }
 }

Source/MQTTnet/Diagnostics/IMqttNetLogger.cs

@@ -4,8 +4,6 @@ namespace MQTTnet.Diagnostics
 {
     public interface IMqttNetLogger
     {
-        event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
-
         IMqttNetScopedLogger CreateScopedLogger(string source);
 
         void Publish(MqttNetLogLevel logLevel, string source, string message, object[] parameters, Exception exception);

Source/MQTTnet/Diagnostics/MqttNetGlobalLogger.cs

@@ -2,6 +2,7 @@
 
 namespace MQTTnet.Diagnostics
 {
+    [Obsolete("Please pass an instance of the IMqttNetLogger to the factory/server or client. The global logger will be deleted in the future.")]
     public static class MqttNetGlobalLogger
     {
         public static event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
@@ -10,8 +11,6 @@ namespace MQTTnet.Diagnostics
 
         public static void Publish(MqttNetLogMessage logMessage)
         {
-            if (logMessage == null) throw new ArgumentNullException(nameof(logMessage));
-
             LogMessagePublished?.Invoke(null, new MqttNetLogMessagePublishedEventArgs(logMessage));
         }
     }

Source/MQTTnet/Diagnostics/MqttNetLogMessage.cs

@@ -2,7 +2,7 @@
 
 namespace MQTTnet.Diagnostics
 {
-    public class MqttNetLogMessage
+    public sealed class MqttNetLogMessage
     {
         public string LogId { get; set; }
 

Source/MQTTnet/Diagnostics/MqttNetLogMessagePublishedEventArgs.cs

@@ -2,18 +2,18 @@
 
 namespace MQTTnet.Diagnostics
 {
-    public class MqttNetLogMessagePublishedEventArgs : EventArgs
+    public sealed class MqttNetLogMessagePublishedEventArgs : EventArgs
     {
         public MqttNetLogMessagePublishedEventArgs(MqttNetLogMessage logMessage)
         {
             LogMessage = logMessage ?? throw new ArgumentNullException(nameof(logMessage));
 
 #pragma warning disable CS0618 // Type or member is obsolete
-            TraceMessage = logMessage ?? throw new ArgumentNullException(nameof(logMessage));
+            TraceMessage = logMessage;
 #pragma warning restore CS0618 // Type or member is obsolete
         }
 
-        [Obsolete("Use new proeprty LogMessage instead.")]
+        [Obsolete("Use new property LogMessage instead.")]
         public MqttNetLogMessage TraceMessage { get; }
 
         public MqttNetLogMessage LogMessage { get; }

Source/MQTTnet/Diagnostics/MqttNetLogger.cs

@@ -36,13 +36,16 @@ namespace MQTTnet.Diagnostics
                 return;
             }
 
-            try
+            if (parameters?.Length > 0 && message?.Length > 0)
             {
-                message = string.Format(message ?? string.Empty, parameters);
+                try
-            }
+                {
-            catch (FormatException)
+                    message = string.Format(message, parameters);
-            {
+                }
-                message = "MESSAGE FORMAT INVALID: " + message;
+                catch (FormatException)
+                {
+                    message = "MESSAGE FORMAT INVALID: " + message;
+                }
             }
 
             var logMessage = new MqttNetLogMessage

Source/MQTTnet/Diagnostics/MqttNetScopedLoggerExtensions.cs

@@ -18,6 +18,11 @@ namespace MQTTnet.Diagnostics
         {
             logger.Publish(MqttNetLogLevel.Warning, message, parameters, exception);
         }
+        
+        public static void Warning(this IMqttNetScopedLogger logger, string message, params object[] parameters)
+        {
+            logger.Publish(MqttNetLogLevel.Warning, message, parameters, null);
+        }
 
         public static void Error(this IMqttNetScopedLogger logger, Exception exception, string message, params object[] parameters)
         {

Source/MQTTnet/Diagnostics/PacketInspection/IMqttPacketInspector.cs

@@ -0,0 +1,7 @@
+namespace MQTTnet.Diagnostics.PacketInspection
+{
+    public interface IMqttPacketInspector
+    {
+        void ProcessMqttPacket(ProcessMqttPacketContext context);
+    }
+}

Source/MQTTnet/Diagnostics/PacketInspection/MqttPacketFlowDirection.cs

@@ -0,0 +1,9 @@
+namespace MQTTnet.Diagnostics.PacketInspection
+{
+    public enum MqttPacketFlowDirection
+    {
+        Inbound,
+
+        Outbound
+    }
+}

Source/MQTTnet/Diagnostics/PacketInspection/ProcessMqttPacketContext.cs

@@ -0,0 +1,9 @@
+namespace MQTTnet.Diagnostics.PacketInspection
+{
+    public sealed class ProcessMqttPacketContext
+    {
+        public MqttPacketFlowDirection Direction { get; set; }
+
+        public byte[] Buffer { get; set; }
+    }
+}

Source/MQTTnet/Diagnostics/TargetFrameworkProvider.cs

@@ -20,6 +20,10 @@
                 return "netstandard2.1";
 #elif WINDOWS_UWP
                 return "uap10.0";
+#elif NETCOREAPP3_1
+                return "netcoreapp3.1";
+#elif NET5_0
+                return "net5.0";
 #endif
             }
         }

Source/MQTTnet/Exceptions/MqttCommunicationException.cs

@@ -13,8 +13,8 @@ namespace MQTTnet.Exceptions
         {
         }
 
-        public MqttCommunicationException(string message)
+        public MqttCommunicationException(string message, Exception innerException = null)
-            : base(message)
+            : base(message, innerException)
         {
         }
     }

Source/MQTTnet/Formatter/IMqttDataConverter.cs

@@ -1,10 +1,12 @@
-using MQTTnet.Client.Connecting;
+using System.Collections.Generic;
+using MQTTnet.Client.Connecting;
 using MQTTnet.Client.Disconnecting;
 using MQTTnet.Client.Options;
 using MQTTnet.Client.Publishing;
 using MQTTnet.Client.Subscribing;
 using MQTTnet.Client.Unsubscribing;
 using MQTTnet.Packets;
+using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MqttClientSubscribeResult = MQTTnet.Client.Subscribing.MqttClientSubscribeResult;
 
@@ -16,6 +18,8 @@ namespace MQTTnet.Formatter
 
         MqttPubAckPacket CreatePubAckPacket(MqttPublishPacket publishPacket);
 
+        MqttBasePacket CreatePubRecPacket(MqttPublishPacket publishPacket);
+
         MqttApplicationMessage CreateApplicationMessage(MqttPublishPacket publishPacket);
 
         MqttClientAuthenticateResult CreateClientConnectResult(MqttConnAckPacket connAckPacket);
@@ -30,8 +34,12 @@ namespace MQTTnet.Formatter
 
         MqttSubscribePacket CreateSubscribePacket(MqttClientSubscribeOptions options);
 
+        MqttSubAckPacket CreateSubAckPacket(MqttSubscribePacket subscribePacket, Server.MqttClientSubscribeResult subscribeResult);
+
         MqttUnsubscribePacket CreateUnsubscribePacket(MqttClientUnsubscribeOptions options);
 
+        MqttUnsubAckPacket CreateUnsubAckPacket(MqttUnsubscribePacket unsubscribePacket, List<MqttUnsubscribeReasonCode> reasonCodes);
+
         MqttDisconnectPacket CreateDisconnectPacket(MqttClientDisconnectOptions options);
 
         MqttClientPublishResult CreatePublishResult(MqttPubAckPacket pubAckPacket);

Source/MQTTnet/Formatter/IMqttPacketBodyReader.cs

@@ -1,6 +1,4 @@
-using System;
+namespace MQTTnet.Formatter
-
-namespace MQTTnet.Formatter
 {
     public interface IMqttPacketBodyReader
     {

Source/MQTTnet/Formatter/MqttPacketBodyReader.cs

@@ -6,13 +6,13 @@ using MQTTnet.Exceptions;
 
 namespace MQTTnet.Formatter
 {
-    public class MqttPacketBodyReader : IMqttPacketBodyReader
+    public sealed class MqttPacketBodyReader : IMqttPacketBodyReader
     {
-        private readonly byte[] _buffer;
+        readonly byte[] _buffer;
-        private readonly int _initialOffset;
+        readonly int _initialOffset;
-        private readonly int _length;
+        readonly int _length;
 
-        private int _offset;
+        int _offset;
 
         public MqttPacketBodyReader(byte[] buffer, int offset, int length)
         {

Source/MQTTnet/Formatter/MqttPacketFormatterAdapter.cs

@@ -8,10 +8,10 @@ using MQTTnet.Packets;
 
 namespace MQTTnet.Formatter
 {
-    public class MqttPacketFormatterAdapter
+    public sealed class MqttPacketFormatterAdapter
     {
         IMqttPacketFormatter _formatter;
-               
+
         public MqttPacketFormatterAdapter(MqttProtocolVersion protocolVersion)
             : this(protocolVersion, new MqttPacketWriter())
         {
@@ -26,7 +26,7 @@ namespace MQTTnet.Formatter
         public MqttPacketFormatterAdapter(IMqttPacketWriter writer)
         {
             Writer = writer;
-        }        
+        }
 
         public MqttProtocolVersion ProtocolVersion { get; private set; } = MqttProtocolVersion.Unknown;
 
@@ -39,7 +39,7 @@ namespace MQTTnet.Formatter
                 return _formatter.DataConverter;
             }
         }
-                
+
         public IMqttPacketWriter Writer { get; }
 
         public ArraySegment<byte> Encode(MqttBasePacket packet)
@@ -69,32 +69,21 @@ namespace MQTTnet.Formatter
         {
             var protocolVersion = ParseProtocolVersion(receivedMqttPacket);
 
-            // Reset the position of the stream because the protocol version is part of 
+            // Reset the position of the stream because the protocol version is part of
             // the regular CONNECT packet. So it will not properly deserialized if this
             // data is missing.
-            receivedMqttPacket.Body.Seek(0);
+            receivedMqttPacket.BodyReader.Seek(0);
 
             UseProtocolVersion(protocolVersion);
         }
 
-        private void UseProtocolVersion(MqttProtocolVersion protocolVersion)
-        {
-            if (protocolVersion == MqttProtocolVersion.Unknown)
-            {
-                throw new InvalidOperationException("MQTT protocol version is invalid.");
-            }
-
-            ProtocolVersion = protocolVersion;
-            _formatter = GetMqttPacketFormatter(protocolVersion, Writer);
-        }
-
         public static IMqttPacketFormatter GetMqttPacketFormatter(MqttProtocolVersion protocolVersion, IMqttPacketWriter writer)
         {
             if (protocolVersion == MqttProtocolVersion.Unknown)
             {
                 throw new InvalidOperationException("MQTT protocol version is invalid.");
             }
-            
+
             switch (protocolVersion)
             {
                 case MqttProtocolVersion.V500:
@@ -116,11 +105,22 @@ namespace MQTTnet.Formatter
             }
         }
 
-        MqttProtocolVersion ParseProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
+        void UseProtocolVersion(MqttProtocolVersion protocolVersion)
+        {
+            if (protocolVersion == MqttProtocolVersion.Unknown)
+            {
+                throw new InvalidOperationException("MQTT protocol version is invalid.");
+            }
+
+            ProtocolVersion = protocolVersion;
+            _formatter = GetMqttPacketFormatter(protocolVersion, Writer);
+        }
+
+        static MqttProtocolVersion ParseProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
         {
             if (receivedMqttPacket == null) throw new ArgumentNullException(nameof(receivedMqttPacket));
 
-            if (receivedMqttPacket.Body.Length < 7)
+            if (receivedMqttPacket.BodyReader.Length < 7)
             {
                 // 2 byte protocol name length
                 // at least 4 byte protocol name
@@ -128,8 +128,8 @@ namespace MQTTnet.Formatter
                 throw new MqttProtocolViolationException("CONNECT packet must have at least 7 bytes.");
             }
 
-            var protocolName = receivedMqttPacket.Body.ReadStringWithLengthPrefix();
+            var protocolName = receivedMqttPacket.BodyReader.ReadStringWithLengthPrefix();
-            var protocolLevel = receivedMqttPacket.Body.ReadByte();
+            var protocolLevel = receivedMqttPacket.BodyReader.ReadByte();
 
             if (protocolName == "MQTT")
             {

Source/MQTTnet/Formatter/MqttPacketReader.cs

@@ -1,114 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Channel;
-using MQTTnet.Exceptions;
-
-namespace MQTTnet.Formatter
-{
-    public class MqttPacketReader
-    {
-        private readonly byte[] _singleByteBuffer = new byte[1];
-
-        private readonly IMqttChannel _channel;
-
-        public MqttPacketReader(IMqttChannel channel)
-        {
-            _channel = channel ?? throw new ArgumentNullException(nameof(channel));
-        }
-
-        public async Task<ReadFixedHeaderResult> ReadFixedHeaderAsync(byte[] fixedHeaderBuffer, CancellationToken cancellationToken)
-        {
-            // The MQTT fixed header contains 1 byte of flags and at least 1 byte for the remaining data length.
-            // So in all cases at least 2 bytes must be read for a complete MQTT packet.
-            var buffer = fixedHeaderBuffer;
-            var totalBytesRead = 0;
-
-            while (totalBytesRead < buffer.Length)
-            {
-                var bytesRead = await _channel.ReadAsync(buffer, totalBytesRead, buffer.Length - totalBytesRead, cancellationToken).ConfigureAwait(false);
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return null;
-                }
-                
-                if (bytesRead == 0)
-                {
-                    return new ReadFixedHeaderResult
-                    {
-                        ConnectionClosed = true
-                    };
-                }
-                
-                totalBytesRead += bytesRead;
-            }
-
-            var hasRemainingLength = buffer[1] != 0;
-            if (!hasRemainingLength)
-            {
-                return new ReadFixedHeaderResult
-                {
-                    FixedHeader = new MqttFixedHeader(buffer[0], 0, totalBytesRead)
-                };
-            }
-
-            var bodyLength = await ReadBodyLengthAsync(buffer[1], cancellationToken).ConfigureAwait(false);
-
-            if (!bodyLength.HasValue)
-            {
-                return new ReadFixedHeaderResult
-                {
-                    ConnectionClosed = true
-                };
-            }
-
-            totalBytesRead += bodyLength.Value;
-            return new ReadFixedHeaderResult
-            {
-                FixedHeader = new MqttFixedHeader(buffer[0], bodyLength.Value, totalBytesRead)
-            };
-        }
-
-        private async Task<int?> ReadBodyLengthAsync(byte initialEncodedByte, CancellationToken cancellationToken)
-        {
-            var offset = 0;
-            var multiplier = 128;
-            var value = initialEncodedByte & 127;
-            int encodedByte = initialEncodedByte;
-
-            while ((encodedByte & 128) != 0)
-            {
-                offset++;
-                if (offset > 3)
-                {
-                    throw new MqttProtocolViolationException("Remaining length is invalid.");
-                }
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return null;
-                }
-
-                var readCount = await _channel.ReadAsync(_singleByteBuffer, 0, 1, cancellationToken).ConfigureAwait(false);
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return null;
-                }
-
-                if (readCount == 0)
-                {
-                    return null;
-                }
-
-                encodedByte = _singleByteBuffer[0];
-
-                value += (encodedByte & 127) * multiplier;
-                multiplier *= 128;
-            }
-
-            return value;
-        }
-    }
-}

Source/MQTTnet/Formatter/MqttPacketWriter.cs

@@ -13,11 +13,9 @@ namespace MQTTnet.Formatter
     /// </summary>
     public sealed class MqttPacketWriter : IMqttPacketWriter
     {
-        static readonly ArraySegment<byte> ZeroVariableLengthIntegerArray = new ArraySegment<byte>(new byte[1], 0, 1);
+        public static int InitialBufferSize = 4096;
-        static readonly ArraySegment<byte> ZeroTwoByteIntegerArray = new ArraySegment<byte>(new byte[2], 0, 2);
 
-        public static int InitialBufferSize = 128;
+        public static int MaxBufferSize = 4096 * 4;
-        public static int MaxBufferSize = 4096;
 
         byte[] _buffer = new byte[InitialBufferSize];
 
@@ -38,59 +36,72 @@ namespace MQTTnet.Formatter
             var x = value;
             do
             {
-                x = x / 128;
+                x /= 128;
                 result++;
             } while (x > 0);
 
             return result;
         }
 
-        public static ArraySegment<byte> EncodeVariableLengthInteger(uint value)
+        public void WriteVariableLengthInteger(uint value)
         {
             if (value == 0)
             {
-                return ZeroVariableLengthIntegerArray;
+                _buffer[_offset] = 0;
+                IncreasePosition(1);
+
+                return;
             }
 
             if (value <= 127)
             {
-                return new ArraySegment<byte>(new[] { (byte)value }, 0, 1);
+                _buffer[_offset] = (byte)value;
+                IncreasePosition(1);
+
+                return;
             }
 
-            var buffer = new byte[4];
+            var size = 0;
-            var bufferOffset = 0;
-
             var x = value;
             do
             {
                 var encodedByte = x % 128;
-                x = x / 128;
+                x /= 128;
                 if (x > 0)
                 {
-                    encodedByte = encodedByte | 128;
+                    encodedByte |= 128;
                 }
 
-                buffer[bufferOffset] = (byte)encodedByte;
+                _buffer[_offset + size] = (byte)encodedByte;
-                bufferOffset++;
+                size++;
             } while (x > 0);
 
-            return new ArraySegment<byte>(buffer, 0, bufferOffset);
+            IncreasePosition(size);
-        }
-
-        public void WriteVariableLengthInteger(uint value)
-        {
-            Write(EncodeVariableLengthInteger(value));
         }
 
         public void WriteWithLengthPrefix(string value)
         {
             if (string.IsNullOrEmpty(value))
             {
-                Write(ZeroTwoByteIntegerArray);
+                EnsureAdditionalCapacity(2);
+
+                _buffer[_offset] = 0;
+                _buffer[_offset + 1] = 0;
+
+                IncreasePosition(2);
             }
             else
             {
-                WriteWithLengthPrefix(Encoding.UTF8.GetBytes(value));
+                var bufferSize = Encoding.UTF8.GetByteCount(value);
+
+                EnsureAdditionalCapacity(bufferSize + 2);
+
+                _buffer[_offset] = (byte)(bufferSize >> 8);
+                _buffer[_offset + 1] = (byte)bufferSize;
+
+                Encoding.UTF8.GetBytes(value, 0, value.Length, _buffer, _offset + 2);
+
+                IncreasePosition(bufferSize + 2);
             }
         }
 
@@ -98,13 +109,22 @@ namespace MQTTnet.Formatter
         {
             if (value == null || value.Length == 0)
             {
-                Write(ZeroTwoByteIntegerArray);
+                EnsureAdditionalCapacity(2);
+
+                _buffer[_offset] = 0;
+                _buffer[_offset + 1] = 0;
+
+                IncreasePosition(2);
             }
             else
             {
                 EnsureAdditionalCapacity(value.Length + 2);
-                Write((ushort)value.Length);
+
-                Write(value, 0, value.Length);
+                _buffer[_offset] = (byte)(value.Length >> 8);
+                _buffer[_offset + 1] = (byte)value.Length;
+
+                Array.Copy(value, 0, _buffer, _offset + 2, value.Length);
+                IncreasePosition(value.Length + 2);
             }
         }
 
@@ -143,8 +163,6 @@ namespace MQTTnet.Formatter
 
         public void Write(IMqttPacketWriter propertyWriter)
         {
-            if (propertyWriter == null) throw new ArgumentNullException(nameof(propertyWriter));
-
             if (propertyWriter is MqttPacketWriter writer)
             {
                 if (writer.Length == 0)
@@ -156,7 +174,12 @@ namespace MQTTnet.Formatter
                 return;
             }
 
-            throw new InvalidOperationException($"{nameof(propertyWriter)} must be of type {typeof(MqttPacketWriter).Name}");
+            if (propertyWriter == null)
+            {
+                throw new ArgumentNullException(nameof(propertyWriter));
+            }
+
+            throw new InvalidOperationException($"{nameof(propertyWriter)} must be of type {nameof(MqttPacketWriter)}");
         }
 
         public void Reset(int length)
@@ -179,8 +202,8 @@ namespace MQTTnet.Formatter
         {
             // This method frees the used memory by shrinking the buffer. This is required because the buffer
             // is used across several messages. In general this is not a big issue because subsequent Ping packages
-            // have the same size but a very big publish package with 100 MB of payload will increase the buffer 
+            // have the same size but a very big publish package with 100 MB of payload will increase the buffer
-            // a lot and the size will never reduced. So this method tries to find a size which can be held in 
+            // a lot and the size will never reduced. So this method tries to find a size which can be held in
             // memory for a long time without causing troubles.
 
             if (_buffer.Length < MaxBufferSize)
@@ -191,11 +214,6 @@ namespace MQTTnet.Formatter
             Array.Resize(ref _buffer, MaxBufferSize);
         }
 
-        void Write(ArraySegment<byte> buffer)
-        {
-            Write(buffer.Array, buffer.Offset, buffer.Count);
-        }
-
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         void EnsureAdditionalCapacity(int additionalCapacity)
         {

Source/MQTTnet/Formatter/V3/MqttV310DataConverter.cs

@@ -9,6 +9,7 @@ using MQTTnet.Packets;
 using MQTTnet.Protocol;
 using MQTTnet.Server;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using MqttClientSubscribeResult = MQTTnet.Client.Subscribing.MqttClientSubscribeResult;
 
@@ -39,6 +40,15 @@ namespace MQTTnet.Formatter.V3
             };
         }
 
+        public MqttBasePacket CreatePubRecPacket(MqttPublishPacket publishPacket)
+        {
+            return new MqttPubRecPacket
+            {
+                PacketIdentifier = publishPacket.PacketIdentifier,
+                ReasonCode = MqttPubRecReasonCode.Success
+            };
+        }
+
         public MqttApplicationMessage CreateApplicationMessage(MqttPublishPacket publishPacket)
         {
             if (publishPacket == null) throw new ArgumentNullException(nameof(publishPacket));
@@ -172,6 +182,18 @@ namespace MQTTnet.Formatter.V3
             return subscribePacket;
         }
 
+        public MqttSubAckPacket CreateSubAckPacket(MqttSubscribePacket subscribePacket, Server.MqttClientSubscribeResult subscribeResult)
+        {
+            var subackPacket = new MqttSubAckPacket
+            {
+                PacketIdentifier = subscribePacket.PacketIdentifier
+            };
+
+            subackPacket.ReturnCodes.AddRange(subscribeResult.ReturnCodes);
+
+            return subackPacket;
+        }
+
         public MqttUnsubscribePacket CreateUnsubscribePacket(MqttClientUnsubscribeOptions options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
@@ -182,6 +204,15 @@ namespace MQTTnet.Formatter.V3
             return unsubscribePacket;
         }
 
+        public MqttUnsubAckPacket CreateUnsubAckPacket(MqttUnsubscribePacket unsubscribePacket, List<MqttUnsubscribeReasonCode> reasonCodes)
+        {
+            return new MqttUnsubAckPacket
+            {
+                PacketIdentifier = unsubscribePacket.PacketIdentifier,
+                ReasonCodes = reasonCodes
+            };
+        }
+
         public MqttDisconnectPacket CreateDisconnectPacket(MqttClientDisconnectOptions options)
         {
             if (options.ReasonCode != MqttClientDisconnectReason.NormalDisconnection || options.ReasonString != null)

Source/MQTTnet/Formatter/V3/MqttV310PacketFormatter.cs

@@ -63,20 +63,20 @@ namespace MQTTnet.Formatter.V3
 
             switch ((MqttControlPacketType)controlPacketType)
             {
-                case MqttControlPacketType.Connect: return DecodeConnectPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Connect: return DecodeConnectPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.ConnAck: return DecodeConnAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.ConnAck: return DecodeConnAckPacket(receivedMqttPacket.BodyReader);
                 case MqttControlPacketType.Disconnect: return DisconnectPacket;
                 case MqttControlPacketType.Publish: return DecodePublishPacket(receivedMqttPacket);
-                case MqttControlPacketType.PubAck: return DecodePubAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubAck: return DecodePubAckPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.PubRec: return DecodePubRecPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubRec: return DecodePubRecPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.PubRel: return DecodePubRelPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubRel: return DecodePubRelPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.PubComp: return DecodePubCompPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubComp: return DecodePubCompPacket(receivedMqttPacket.BodyReader);
                 case MqttControlPacketType.PingReq: return PingReqPacket;
                 case MqttControlPacketType.PingResp: return PingRespPacket;
-                case MqttControlPacketType.Subscribe: return DecodeSubscribePacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Subscribe: return DecodeSubscribePacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.SubAck: return DecodeSubAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.SubAck: return DecodeSubAckPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.Unsubscibe: return DecodeUnsubscribePacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Unsubscibe: return DecodeUnsubscribePacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.UnsubAck: return DecodeUnsubAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.UnsubAck: return DecodeUnsubAckPacket(receivedMqttPacket.BodyReader);
 
                 default: throw new MqttProtocolViolationException($"Packet type ({controlPacketType}) not supported.");
             }
@@ -202,18 +202,18 @@ namespace MQTTnet.Formatter.V3
 
         static MqttBasePacket DecodePublishPacket(ReceivedMqttPacket receivedMqttPacket)
         {
-            ThrowIfBodyIsEmpty(receivedMqttPacket.Body);
+            ThrowIfBodyIsEmpty(receivedMqttPacket.BodyReader);
 
             var retain = (receivedMqttPacket.FixedHeader & 0x1) > 0;
             var qualityOfServiceLevel = (MqttQualityOfServiceLevel)(receivedMqttPacket.FixedHeader >> 1 & 0x3);
             var dup = (receivedMqttPacket.FixedHeader & 0x8) > 0;
 
-            var topic = receivedMqttPacket.Body.ReadStringWithLengthPrefix();
+            var topic = receivedMqttPacket.BodyReader.ReadStringWithLengthPrefix();
 
-            ushort? packetIdentifier = null;
+            ushort packetIdentifier = 0;
             if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
             {
-                packetIdentifier = receivedMqttPacket.Body.ReadTwoByteInteger();
+                packetIdentifier = receivedMqttPacket.BodyReader.ReadTwoByteInteger();
             }
 
             var packet = new MqttPublishPacket
@@ -225,9 +225,9 @@ namespace MQTTnet.Formatter.V3
                 Dup = dup
             };
 
-            if (!receivedMqttPacket.Body.EndOfStream)
+            if (!receivedMqttPacket.BodyReader.EndOfStream)
             {
-                packet.Payload = receivedMqttPacket.Body.ReadRemainingData();
+                packet.Payload = receivedMqttPacket.BodyReader.ReadRemainingData();
             }
 
             return packet;
@@ -414,12 +414,12 @@ namespace MQTTnet.Formatter.V3
 
         static byte EncodePubRelPacket(MqttPubRelPacket packet, IMqttPacketWriter packetWriter)
         {
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("PubRel packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02);
         }
@@ -432,12 +432,12 @@ namespace MQTTnet.Formatter.V3
 
             if (packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
             {
-                if (!packet.PacketIdentifier.HasValue)
+                if (packet.PacketIdentifier == 0)
                 {
                     throw new MqttProtocolViolationException("Publish packet has no packet identifier.");
                 }
 
-                packetWriter.Write(packet.PacketIdentifier.Value);
+                packetWriter.Write(packet.PacketIdentifier);
             }
             else
             {
@@ -471,36 +471,36 @@ namespace MQTTnet.Formatter.V3
 
         static byte EncodePubAckPacket(MqttPubAckPacket packet, IMqttPacketWriter packetWriter)
         {
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("PubAck packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubAck);
         }
 
         static byte EncodePubRecPacket(MqttPubRecPacket packet, IMqttPacketWriter packetWriter)
         {
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("PubRec packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRec);
         }
 
         static byte EncodePubCompPacket(MqttPubCompPacket packet, IMqttPacketWriter packetWriter)
         {
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("PubComp packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubComp);
         }
@@ -509,12 +509,12 @@ namespace MQTTnet.Formatter.V3
         {
             if (!packet.TopicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.8.3-3].");
 
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("Subscribe packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             if (packet.TopicFilters?.Count > 0)
             {
@@ -530,12 +530,12 @@ namespace MQTTnet.Formatter.V3
 
         static byte EncodeSubAckPacket(MqttSubAckPacket packet, IMqttPacketWriter packetWriter)
         {
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("SubAck packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             if (packet.ReturnCodes?.Any() == true)
             {
@@ -552,12 +552,12 @@ namespace MQTTnet.Formatter.V3
         {
             if (!packet.TopicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.10.3-2].");
 
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("Unsubscribe packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             if (packet.TopicFilters?.Any() == true)
             {
@@ -572,12 +572,12 @@ namespace MQTTnet.Formatter.V3
 
         static byte EncodeUnsubAckPacket(MqttUnsubAckPacket packet, IMqttPacketWriter packetWriter)
         {
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("UnsubAck packet has no packet identifier.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.UnsubAck);
         }
 

Source/MQTTnet/Formatter/V3/MqttV311PacketFormatter.cs

@@ -4,7 +4,7 @@ using MQTTnet.Protocol;
 
 namespace MQTTnet.Formatter.V3
 {
-    public class MqttV311PacketFormatter : MqttV310PacketFormatter
+    public sealed class MqttV311PacketFormatter : MqttV310PacketFormatter
     {
         public MqttV311PacketFormatter(IMqttPacketWriter packetWriter)
             : base(packetWriter)

Source/MQTTnet/Formatter/V5/MqttV500DataConverter.cs

@@ -58,6 +58,15 @@ namespace MQTTnet.Formatter.V5
             };
         }
 
+        public MqttBasePacket CreatePubRecPacket(MqttPublishPacket publishPacket)
+        {
+            return new MqttPubRecPacket
+            {
+                PacketIdentifier = publishPacket.PacketIdentifier,
+                ReasonCode = MqttPubRecReasonCode.Success
+            };
+        }
+
         public MqttApplicationMessage CreateApplicationMessage(MqttPublishPacket publishPacket)
         {
             return new MqttApplicationMessage
@@ -93,6 +102,7 @@ namespace MQTTnet.Formatter.V5
                 MaximumPacketSize = connAckPacket.Properties?.MaximumPacketSize,
                 ReasonString = connAckPacket.Properties?.ReasonString,
                 ReceiveMaximum = connAckPacket.Properties?.ReceiveMaximum,
+                MaximumQoS = connAckPacket.Properties?.MaximumQoS ?? MqttQualityOfServiceLevel.ExactlyOnce,
                 ResponseInformation = connAckPacket.Properties?.ResponseInformation,
                 TopicAliasMaximum = connAckPacket.Properties?.TopicAliasMaximum,
                 ServerReference = connAckPacket.Properties?.ServerReference,
@@ -143,7 +153,8 @@ namespace MQTTnet.Formatter.V5
                     AuthenticationMethod = connectionValidatorContext.AuthenticationMethod,
                     AuthenticationData = connectionValidatorContext.ResponseAuthenticationData,
                     AssignedClientIdentifier = connectionValidatorContext.AssignedClientIdentifier,
-                    ReasonString = connectionValidatorContext.ReasonString
+                    ReasonString = connectionValidatorContext.ReasonString,
+                    TopicAliasMaximum = ushort.MaxValue
                 }
             };
         }
@@ -200,6 +211,18 @@ namespace MQTTnet.Formatter.V5
             return packet;
         }
 
+        public MqttSubAckPacket CreateSubAckPacket(MqttSubscribePacket subscribePacket, Server.MqttClientSubscribeResult subscribeResult)
+        {
+            var subackPacket = new MqttSubAckPacket
+            {
+                PacketIdentifier = subscribePacket.PacketIdentifier
+            };
+
+            subackPacket.ReasonCodes.AddRange(subscribeResult.ReasonCodes);
+
+            return subackPacket;
+        }
+
         public MqttUnsubscribePacket CreateUnsubscribePacket(MqttClientUnsubscribeOptions options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
@@ -215,6 +238,15 @@ namespace MQTTnet.Formatter.V5
             return packet;
         }
 
+        public MqttUnsubAckPacket CreateUnsubAckPacket(MqttUnsubscribePacket unsubscribePacket, List<MqttUnsubscribeReasonCode> reasonCodes)
+        {
+            return new MqttUnsubAckPacket
+            {
+                PacketIdentifier = unsubscribePacket.PacketIdentifier,
+                ReasonCodes = reasonCodes
+            };
+        }
+
         public MqttDisconnectPacket CreateDisconnectPacket(MqttClientDisconnectOptions options)
         {
             var packet = new MqttDisconnectPacket();

Source/MQTTnet/Formatter/V5/MqttV500PacketDecoder.cs

@@ -25,21 +25,21 @@ namespace MQTTnet.Formatter.V5
 
             switch ((MqttControlPacketType)controlPacketType)
             {
-                case MqttControlPacketType.Connect: return DecodeConnectPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Connect: return DecodeConnectPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.ConnAck: return DecodeConnAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.ConnAck: return DecodeConnAckPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.Disconnect: return DecodeDisconnectPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Disconnect: return DecodeDisconnectPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.Publish: return DecodePublishPacket(receivedMqttPacket.FixedHeader, receivedMqttPacket.Body);
+                case MqttControlPacketType.Publish: return DecodePublishPacket(receivedMqttPacket.FixedHeader, receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.PubAck: return DecodePubAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubAck: return DecodePubAckPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.PubRec: return DecodePubRecPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubRec: return DecodePubRecPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.PubRel: return DecodePubRelPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubRel: return DecodePubRelPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.PubComp: return DecodePubCompPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.PubComp: return DecodePubCompPacket(receivedMqttPacket.BodyReader);
                 case MqttControlPacketType.PingReq: return DecodePingReqPacket();
                 case MqttControlPacketType.PingResp: return DecodePingRespPacket();
-                case MqttControlPacketType.Subscribe: return DecodeSubscribePacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Subscribe: return DecodeSubscribePacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.SubAck: return DecodeSubAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.SubAck: return DecodeSubAckPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.Unsubscibe: return DecodeUnsubscribePacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Unsubscibe: return DecodeUnsubscribePacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.UnsubAck: return DecodeUnsubAckPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.UnsubAck: return DecodeUnsubAckPacket(receivedMqttPacket.BodyReader);
-                case MqttControlPacketType.Auth: return DecodeAuthPacket(receivedMqttPacket.Body);
+                case MqttControlPacketType.Auth: return DecodeAuthPacket(receivedMqttPacket.BodyReader);
 
                 default: throw new MqttProtocolViolationException($"Packet type ({controlPacketType}) not supported.");
             }
@@ -254,6 +254,10 @@ namespace MQTTnet.Formatter.V5
                 {
                     packet.Properties.ReceiveMaximum = propertiesReader.ReadReceiveMaximum();
                 }
+                else if (propertiesReader.CurrentPropertyId == MqttPropertyId.MaximumQoS)
+                {
+                    packet.Properties.MaximumQoS = propertiesReader.ReadMaximumQoS();
+                }
                 else if (propertiesReader.CurrentPropertyId == MqttPropertyId.AssignedClientIdentifier)
                 {
                     packet.Properties.AssignedClientIdentifier = propertiesReader.ReadAssignedClientIdentifier();

Source/MQTTnet/Formatter/V5/MqttV500PacketEncoder.cs

@@ -6,22 +6,15 @@ using MQTTnet.Protocol;
 
 namespace MQTTnet.Formatter.V5
 {
-    public class MqttV500PacketEncoder
+    public sealed class MqttV500PacketEncoder
     {
-        private readonly IMqttPacketWriter _packetWriter;
+        readonly IMqttPacketWriter _packetWriter;
-
-        public MqttV500PacketEncoder()
-            : this(new MqttPacketWriter())
-        {
-
-        }
 
         public MqttV500PacketEncoder(IMqttPacketWriter packetWriter)
         {
-            _packetWriter = packetWriter;
+            _packetWriter = packetWriter ?? throw new ArgumentNullException(nameof(packetWriter));
         }
 
-
         public ArraySegment<byte> Encode(MqttBasePacket packet)
         {
             if (packet == null) throw new ArgumentNullException(nameof(packet));
@@ -52,7 +45,7 @@ namespace MQTTnet.Formatter.V5
             _packetWriter.FreeBuffer();
         }
 
-        private static byte EncodePacket(MqttBasePacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodePacket(MqttBasePacket packet, IMqttPacketWriter packetWriter)
         {
             switch (packet)
             {
@@ -76,7 +69,7 @@ namespace MQTTnet.Formatter.V5
             }
         }
 
-        private static byte EncodeConnectPacket(MqttConnectPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeConnectPacket(MqttConnectPacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet == null) throw new ArgumentNullException(nameof(packet));
             if (packetWriter == null) throw new ArgumentNullException(nameof(packetWriter));
@@ -176,7 +169,7 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Connect);
         }
 
-        private static byte EncodeConnAckPacket(MqttConnAckPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeConnAckPacket(MqttConnAckPacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet == null) throw new ArgumentNullException(nameof(packet));
             if (packetWriter == null) throw new ArgumentNullException(nameof(packetWriter));
@@ -203,6 +196,7 @@ namespace MQTTnet.Formatter.V5
                 propertiesWriter.WriteAuthenticationData(packet.Properties.AuthenticationData);
                 propertiesWriter.WriteRetainAvailable(packet.Properties.RetainAvailable);
                 propertiesWriter.WriteReceiveMaximum(packet.Properties.ReceiveMaximum);
+                propertiesWriter.WriteMaximumQoS(packet.Properties.MaximumQoS);
                 propertiesWriter.WriteAssignedClientIdentifier(packet.Properties.AssignedClientIdentifier);
                 propertiesWriter.WriteTopicAliasMaximum(packet.Properties.TopicAliasMaximum);
                 propertiesWriter.WriteReasonString(packet.Properties.ReasonString);
@@ -221,7 +215,7 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.ConnAck);
         }
 
-        private static byte EncodePublishPacket(MqttPublishPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodePublishPacket(MqttPublishPacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet == null) throw new ArgumentNullException(nameof(packet));
             if (packetWriter == null) throw new ArgumentNullException(nameof(packetWriter));
@@ -235,12 +229,12 @@ namespace MQTTnet.Formatter.V5
 
             if (packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
             {
-                if (!packet.PacketIdentifier.HasValue)
+                if (packet.PacketIdentifier == 0)
                 {
                     throw new MqttProtocolViolationException("Publish packet has no packet identifier.");
                 }
 
-                packetWriter.Write(packet.PacketIdentifier.Value);
+                packetWriter.Write(packet.PacketIdentifier);
             }
             else
             {
@@ -253,13 +247,18 @@ namespace MQTTnet.Formatter.V5
             var propertiesWriter = new MqttV500PropertiesWriter();
             if (packet.Properties != null)
             {
-                propertiesWriter.WritePayloadFormatIndicator(packet.Properties.PayloadFormatIndicator);
+                if (packet.Properties.TopicAlias == 0)
-                propertiesWriter.WriteMessageExpiryInterval(packet.Properties.MessageExpiryInterval);
+                {
-                propertiesWriter.WriteTopicAlias(packet.Properties.TopicAlias);
+                    throw new MqttProtocolViolationException("A Topic Alias of 0 is not permitted. A sender MUST NOT send a PUBLISH packet containing a Topic Alias which has the value 0 [MQTT-3.3.2-8].");
-                propertiesWriter.WriteResponseTopic(packet.Properties.ResponseTopic);
+                }
-                propertiesWriter.WriteCorrelationData(packet.Properties.CorrelationData);
+
-                propertiesWriter.WriteSubscriptionIdentifiers(packet.Properties.SubscriptionIdentifiers);
                 propertiesWriter.WriteContentType(packet.Properties.ContentType);
+                propertiesWriter.WriteCorrelationData(packet.Properties.CorrelationData);
+                propertiesWriter.WriteMessageExpiryInterval(packet.Properties.MessageExpiryInterval);
+                propertiesWriter.WritePayloadFormatIndicator(packet.Properties.PayloadFormatIndicator);
+                propertiesWriter.WriteResponseTopic(packet.Properties.ResponseTopic);
+                propertiesWriter.WriteSubscriptionIdentifiers(packet.Properties.SubscriptionIdentifiers);
+                propertiesWriter.WriteTopicAlias(packet.Properties.TopicAlias);
                 propertiesWriter.WriteUserProperties(packet.Properties.UserProperties);
             }
 
@@ -287,12 +286,12 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Publish, fixedHeader);
         }
 
-        private static byte EncodePubAckPacket(MqttPubAckPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodePubAckPacket(MqttPubAckPacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet == null) throw new ArgumentNullException(nameof(packet));
             if (packetWriter == null) throw new ArgumentNullException(nameof(packetWriter));
 
-            if (!packet.PacketIdentifier.HasValue)
+            if (packet.PacketIdentifier == 0)
             {
                 throw new MqttProtocolViolationException("PubAck packet has no packet identifier.");
             }
@@ -302,7 +301,7 @@ namespace MQTTnet.Formatter.V5
                 throw new MqttProtocolViolationException("PubAck packet must contain a reason code.");
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
             
             var propertiesWriter = new MqttV500PropertiesWriter();
             if (packet.Properties != null)
@@ -320,9 +319,9 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubAck);
         }
 
-        private static byte EncodePubRecPacket(MqttPubRecPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodePubRecPacket(MqttPubRecPacket packet, IMqttPacketWriter packetWriter)
         {
-            ThrowIfPacketIdentifierIsInvalid(packet);
+            ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
 
             if (!packet.ReasonCode.HasValue)
             {
@@ -336,7 +335,7 @@ namespace MQTTnet.Formatter.V5
                 propertiesWriter.WriteUserProperties(packet.Properties.UserProperties);
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             if (packetWriter.Length > 0 || packet.ReasonCode.Value != MqttPubRecReasonCode.Success)
             {
@@ -347,9 +346,9 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRec);
         }
 
-        private static byte EncodePubRelPacket(MqttPubRelPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodePubRelPacket(MqttPubRelPacket packet, IMqttPacketWriter packetWriter)
         {
-            ThrowIfPacketIdentifierIsInvalid(packet);
+            ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
 
             if (!packet.ReasonCode.HasValue)
             {
@@ -363,7 +362,7 @@ namespace MQTTnet.Formatter.V5
                 propertiesWriter.WriteUserProperties(packet.Properties.UserProperties);
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
             
             if (propertiesWriter.Length > 0 || packet.ReasonCode.Value != MqttPubRelReasonCode.Success)
             {
@@ -374,16 +373,16 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02);
         }
 
-        private static byte EncodePubCompPacket(MqttPubCompPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodePubCompPacket(MqttPubCompPacket packet, IMqttPacketWriter packetWriter)
         {
-            ThrowIfPacketIdentifierIsInvalid(packet);
+            ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
 
             if (!packet.ReasonCode.HasValue)
             {
                 ThrowReasonCodeNotSetException();
             }
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
             
             var propertiesWriter = new MqttV500PropertiesWriter();
             if (packet.Properties != null)
@@ -401,13 +400,13 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubComp);
         }
 
-        private static byte EncodeSubscribePacket(MqttSubscribePacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeSubscribePacket(MqttSubscribePacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet.TopicFilters?.Any() != true) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.8.3-3].");
 
-            ThrowIfPacketIdentifierIsInvalid(packet);
+            ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             var propertiesWriter = new MqttV500PropertiesWriter();
             if (packet.Properties != null)
@@ -448,13 +447,13 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Subscribe, 0x02);
         }
 
-        private static byte EncodeSubAckPacket(MqttSubAckPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeSubAckPacket(MqttSubAckPacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet.ReasonCodes?.Any() != true) throw new MqttProtocolViolationException("At least one reason code must be set[MQTT - 3.8.3 - 3].");
 
-            ThrowIfPacketIdentifierIsInvalid(packet);
+            ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             var propertiesWriter = new MqttV500PropertiesWriter();
             if (packet.Properties != null)
@@ -473,13 +472,13 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.SubAck);
         }
 
-        private static byte EncodeUnsubscribePacket(MqttUnsubscribePacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeUnsubscribePacket(MqttUnsubscribePacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet.TopicFilters?.Any() != true) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.10.3-2].");
 
-            ThrowIfPacketIdentifierIsInvalid(packet);
+            ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
 
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             var propertiesWriter = new MqttV500PropertiesWriter();
             if (packet.Properties != null)
@@ -497,13 +496,13 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Unsubscibe, 0x02);
         }
 
-        private static byte EncodeUnsubAckPacket(MqttUnsubAckPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeUnsubAckPacket(MqttUnsubAckPacket packet, IMqttPacketWriter packetWriter)
         {
             if (packet.ReasonCodes?.Any() != true) throw new MqttProtocolViolationException("At least one reason code must be set[MQTT - 3.8.3 - 3].");
 
-            ThrowIfPacketIdentifierIsInvalid(packet);
+            ThrowIfPacketIdentifierIsInvalid(packet.PacketIdentifier, packet);
             
-            packetWriter.Write(packet.PacketIdentifier.Value);
+            packetWriter.Write(packet.PacketIdentifier);
 
             var propertiesWriter = new MqttV500PropertiesWriter();
             if (packet.Properties != null)
@@ -522,7 +521,7 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.UnsubAck);
         }
 
-        private static byte EncodeDisconnectPacket(MqttDisconnectPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeDisconnectPacket(MqttDisconnectPacket packet, IMqttPacketWriter packetWriter)
         {
             if (!packet.ReasonCode.HasValue)
             {
@@ -545,17 +544,17 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Disconnect);
         }
 
-        private static byte EncodePingReqPacket()
+        static byte EncodePingReqPacket()
         {
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PingReq);
         }
 
-        private static byte EncodePingRespPacket()
+        static byte EncodePingRespPacket()
         {
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PingResp);
         }
 
-        private static byte EncodeAuthPacket(MqttAuthPacket packet, IMqttPacketWriter packetWriter)
+        static byte EncodeAuthPacket(MqttAuthPacket packet, IMqttPacketWriter packetWriter)
         {
             packetWriter.Write((byte)packet.ReasonCode);
 
@@ -573,14 +572,16 @@ namespace MQTTnet.Formatter.V5
             return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Auth);
         }
 
-        private static void ThrowReasonCodeNotSetException()
+        static void ThrowReasonCodeNotSetException()
         {
             throw new MqttProtocolViolationException("The ReasonCode must be set for MQTT version 5.");
         }
 
-        private static void ThrowIfPacketIdentifierIsInvalid(IMqttPacketWithIdentifier packet)
+        static void ThrowIfPacketIdentifierIsInvalid(ushort packetIdentifier, MqttBasePacket packet)
         {
-            if (!packet.PacketIdentifier.HasValue)
+            // SUBSCRIBE, UNSUBSCRIBE, and PUBLISH(in cases where QoS > 0) Control Packets MUST contain a non-zero 16 - bit Packet Identifier[MQTT - 2.3.1 - 1]. 
+
+            if (packetIdentifier == 0)
             {
                 throw new MqttProtocolViolationException($"Packet identifier is not set for {packet.GetType().Name}.");
             }

Source/MQTTnet/Formatter/V5/MqttV500PacketFormatter.cs

@@ -4,15 +4,10 @@ using MQTTnet.Packets;
 
 namespace MQTTnet.Formatter.V5
 {
-    public class MqttV500PacketFormatter : IMqttPacketFormatter
+    public sealed class MqttV500PacketFormatter : IMqttPacketFormatter
     {
-        private readonly MqttV500PacketEncoder _encoder;
+        readonly MqttV500PacketDecoder _decoder = new MqttV500PacketDecoder();
-        private readonly MqttV500PacketDecoder _decoder = new MqttV500PacketDecoder();
+        readonly MqttV500PacketEncoder _encoder;
-
-        public MqttV500PacketFormatter()
-        {
-            _encoder = new MqttV500PacketEncoder();
-        }
 
         public MqttV500PacketFormatter(IMqttPacketWriter writer)
         {

Source/MQTTnet/Formatter/V5/MqttV500PropertiesReader.cs

@@ -82,6 +82,17 @@ namespace MQTTnet.Formatter.V5
             return _body.ReadTwoByteInteger();
         }
 
+        public MqttQualityOfServiceLevel ReadMaximumQoS()
+        {
+            byte value = _body.ReadByte();
+            if (value > 1)
+            {
+                throw new MqttProtocolViolationException($"Unexpected Maximum QoS value: {value}");
+            }
+            
+            return (MqttQualityOfServiceLevel)value;
+        }
+
         public string ReadAssignedClientIdentifier()
         {
             return _body.ReadStringWithLengthPrefix();

Source/MQTTnet/Formatter/V5/MqttV500PropertiesWriter.cs

@@ -5,10 +5,9 @@ using MQTTnet.Protocol;
 
 namespace MQTTnet.Formatter.V5
 {
-    public class MqttV500PropertiesWriter
+    public sealed class MqttV500PropertiesWriter
     {
-        // TODO: Consider lazy init on first write to avoid useless allocations.
+        readonly MqttPacketWriter _packetWriter = new MqttPacketWriter();
-        private readonly MqttPacketWriter _packetWriter = new MqttPacketWriter();
 
         public int Length => _packetWriter.Length;
 
@@ -133,6 +132,17 @@ namespace MQTTnet.Formatter.V5
             Write(MqttPropertyId.ReceiveMaximum, value);
         }
 
+        public void WriteMaximumQoS(MqttQualityOfServiceLevel? value)
+        {
+            if (!value.HasValue || value.Value > MqttQualityOfServiceLevel.AtLeastOnce)
+            {
+                return;
+            }
+
+            _packetWriter.Write((byte)MqttPropertyId.MaximumQoS);
+            _packetWriter.Write((byte)value.Value);
+        }
+
         public void WriteMaximumPacketSize(uint? value)
         {
             WriteAsFourByteInteger(MqttPropertyId.MaximumPacketSize, value);
@@ -178,7 +188,7 @@ namespace MQTTnet.Formatter.V5
             Write(MqttPropertyId.ResponseInformation, value);
         }
 
-        private void Write(MqttPropertyId id, bool? value)
+        void Write(MqttPropertyId id, bool? value)
         {
             if (!value.HasValue)
             {
@@ -189,7 +199,7 @@ namespace MQTTnet.Formatter.V5
             _packetWriter.Write(value.Value ? (byte)0x1 : (byte)0x0);
         }
 
-        private void Write(MqttPropertyId id, byte? value)
+        void Write(MqttPropertyId id, byte? value)
         {
             if (!value.HasValue)
             {
@@ -200,7 +210,7 @@ namespace MQTTnet.Formatter.V5
             _packetWriter.Write(value.Value);
         }
 
-        private void Write(MqttPropertyId id, ushort? value)
+        void Write(MqttPropertyId id, ushort? value)
         {
             if (!value.HasValue)
             {
@@ -211,7 +221,7 @@ namespace MQTTnet.Formatter.V5
             _packetWriter.Write(value.Value);
         }
 
-        private void WriteAsVariableLengthInteger(MqttPropertyId id, uint? value)
+        void WriteAsVariableLengthInteger(MqttPropertyId id, uint? value)
         {
             if (!value.HasValue)
             {
@@ -222,7 +232,7 @@ namespace MQTTnet.Formatter.V5
             _packetWriter.WriteVariableLengthInteger(value.Value);
         }
 
-        private void WriteAsFourByteInteger(MqttPropertyId id, uint? value)
+        void WriteAsFourByteInteger(MqttPropertyId id, uint? value)
         {
             if (!value.HasValue)
             {
@@ -236,7 +246,7 @@ namespace MQTTnet.Formatter.V5
             _packetWriter.Write((byte)value.Value);
         }
 
-        private void Write(MqttPropertyId id, string value)
+        void Write(MqttPropertyId id, string value)
         {
             if (value == null)
             {
@@ -247,7 +257,7 @@ namespace MQTTnet.Formatter.V5
             _packetWriter.WriteWithLengthPrefix(value);
         }
 
-        private void Write(MqttPropertyId id, byte[] value)
+        void Write(MqttPropertyId id, byte[] value)
         {
             if (value == null)
             {

Source/MQTTnet/IApplicationMessageReceiver.cs

@@ -4,6 +4,10 @@ namespace MQTTnet
 {
     public interface IApplicationMessageReceiver
     {
+        /// <summary>
+        /// Gets or sets the application message received handler that is fired every time a new message is received on the client's subscriptions.
+        /// Hint: Initialize handlers before you connect the client to avoid issues.
+        /// </summary>
         IMqttApplicationMessageReceivedHandler ApplicationMessageReceivedHandler { get; set; }
     }
 }

Source/MQTTnet/Implementations/CrossPlatformSocket.cs

@@ -4,6 +4,7 @@ using System.Net;
 using System.Net.Sockets;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Exceptions;
 
 namespace MQTTnet.Implementations
 {
@@ -33,6 +34,9 @@ namespace MQTTnet.Implementations
 
         public bool NoDelay
         {
+            // We cannot use the _NoDelay_ property from the socket because there is an issue in .NET 4.5.2, 4.6.
+            // The decompiled code is: this.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.Debug, value ? 1 : 0);
+            // Which is wrong because the "NoDelay" should be set and not "Debug".
             get => (int)_socket.GetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay) > 0;
             set => _socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, value ? 1 : 0);
         }
@@ -48,13 +52,19 @@ namespace MQTTnet.Implementations
             get => _socket.ReceiveBufferSize;
             set => _socket.ReceiveBufferSize = value;
         }
-
+        
         public int SendBufferSize
         {
             get => _socket.SendBufferSize;
             set => _socket.SendBufferSize = value;
         }
 
+        public int SendTimeout
+        {
+            get => _socket.SendTimeout;
+            set => _socket.SendTimeout = value;
+        }
+
         public EndPoint RemoteEndPoint => _socket.RemoteEndPoint;
 
         public bool ReuseAddress
@@ -69,11 +79,10 @@ namespace MQTTnet.Implementations
             {
 #if NET452 || NET461
                 var clientSocket = await Task.Factory.FromAsync(_socket.BeginAccept, _socket.EndAccept, null).ConfigureAwait(false);
-                return new CrossPlatformSocket(clientSocket);
 #else
                 var clientSocket = await _socket.AcceptAsync().ConfigureAwait(false);
-                return new CrossPlatformSocket(clientSocket);
 #endif
+                return new CrossPlatformSocket(clientSocket);
             }
             catch (ObjectDisposedException)
             {
@@ -115,9 +124,19 @@ namespace MQTTnet.Implementations
                     _networkStream = new NetworkStream(_socket, true);
                 }
             }
+            catch (SocketException socketException)
+            {
+                if (socketException.SocketErrorCode == SocketError.OperationAborted)
+                {
+                    throw new OperationCanceledException();
+                }
+
+                throw new MqttCommunicationException($"Error while connecting with host '{host}:{port}'.", socketException);
+            }
             catch (ObjectDisposedException)
             {
                 // This will happen when _socket.EndConnect gets called by Task library but the socket is already disposed.
+                cancellationToken.ThrowIfCancellationRequested();
             }
         }
 

Source/MQTTnet/Implementations/MqttClientAdapterFactory.cs

@@ -3,6 +3,7 @@ using MQTTnet.Client.Options;
 using MQTTnet.Diagnostics;
 using MQTTnet.Formatter;
 using System;
+using MQTTnet.Channel;
 
 namespace MQTTnet.Implementations
 {
@@ -19,16 +20,19 @@ namespace MQTTnet.Implementations
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
+            IMqttChannel channel;
             switch (options.ChannelOptions)
             {
                 case MqttClientTcpOptions _:
                     {
-                        return new MqttChannelAdapter(new MqttTcpChannel(options), new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttPacketWriter()), _logger);
+                        channel = new MqttTcpChannel(options);
+                        break;
                     }
 
                 case MqttClientWebSocketOptions webSocketOptions:
                     {
-                        return new MqttChannelAdapter(new MqttWebSocketChannel(webSocketOptions), new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttPacketWriter()), _logger);
+                        channel = new MqttWebSocketChannel(webSocketOptions);
+                        break;
                     }
 
                 default:
@@ -36,6 +40,9 @@ namespace MQTTnet.Implementations
                         throw new NotSupportedException();
                     }
             }
+
+            var packetFormatterAdapter = new MqttPacketFormatterAdapter(options.ProtocolVersion, new MqttPacketWriter());
+            return new MqttChannelAdapter(channel, packetFormatterAdapter, options.PacketInspector, _logger);
         }
     }
 }

Source/MQTTnet/Implementations/MqttTcpChannel.Uwp.cs

@@ -75,11 +75,23 @@ namespace MQTTnet.Implementations
                     _socket.Control.IgnorableServerCertificateErrors.Add(ignorableChainValidationResult);
                 }
 
+#if NETCOREAPP3_1 || NET5_0
+                var socketProtectionLevel = SocketProtectionLevel.Tls13;
+                if (_options.TlsOptions.SslProtocol == SslProtocols.Tls12)
+                {
+                    socketProtectionLevel = SocketProtectionLevel.Tls12;
+                }
+                else if (_options.TlsOptions.SslProtocol == SslProtocols.Tls11)
+                {
+                    socketProtectionLevel = SocketProtectionLevel.Tls11;
+                }
+#else
                 var socketProtectionLevel = SocketProtectionLevel.Tls12;
                 if (_options.TlsOptions.SslProtocol == SslProtocols.Tls11)
                 {
                     socketProtectionLevel = SocketProtectionLevel.Tls11;
                 }
+#endif
                 else if (_options.TlsOptions.SslProtocol == SslProtocols.Tls)
                 {
                     socketProtectionLevel = SocketProtectionLevel.Tls10;
@@ -129,7 +141,7 @@ namespace MQTTnet.Implementations
 
             if (options.TlsOptions.Certificates.Count > 1)
             {
-                throw new NotSupportedException("Only one client certificate is supported for UWP.");
+                throw new NotSupportedException("Only one client certificate is supported when using 'uap10.0'.");
             }
 
             return new Certificate(options.TlsOptions.Certificates.First().AsBuffer());

Source/MQTTnet/Implementations/MqttTcpChannel.cs

@@ -10,20 +10,21 @@ using System.Runtime.ExceptionServices;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Exceptions;
 
 namespace MQTTnet.Implementations
 {
     public sealed class MqttTcpChannel : IMqttChannel
     {
         readonly IMqttClientOptions _clientOptions;
-        readonly MqttClientTcpOptions _options;
+        readonly MqttClientTcpOptions _tcpOptions;
 
         Stream _stream;
 
         public MqttTcpChannel(IMqttClientOptions clientOptions)
         {
             _clientOptions = clientOptions ?? throw new ArgumentNullException(nameof(clientOptions));
-            _options = (MqttClientTcpOptions)clientOptions.ChannelOptions;
+            _tcpOptions = (MqttClientTcpOptions)clientOptions.ChannelOptions;
 
             IsSecureConnection = clientOptions.ChannelOptions?.TlsOptions?.UseTls == true;
         }
@@ -49,43 +50,57 @@ namespace MQTTnet.Implementations
             CrossPlatformSocket socket = null;
             try
             {
-                if (_options.AddressFamily == AddressFamily.Unspecified)
+                if (_tcpOptions.AddressFamily == AddressFamily.Unspecified)
                 {
                     socket = new CrossPlatformSocket();
                 }
                 else
                 {
-                    socket = new CrossPlatformSocket(_options.AddressFamily);
+                    socket = new CrossPlatformSocket(_tcpOptions.AddressFamily);
                 }
 
-                socket.ReceiveBufferSize = _options.BufferSize;
+                socket.ReceiveBufferSize = _tcpOptions.BufferSize;
-                socket.SendBufferSize = _options.BufferSize;
+                socket.SendBufferSize = _tcpOptions.BufferSize;
-                socket.NoDelay = _options.NoDelay;
+                socket.SendTimeout = (int)_clientOptions.CommunicationTimeout.TotalMilliseconds;
+                socket.NoDelay = _tcpOptions.NoDelay;
 
-                if (_options.DualMode.HasValue)
+                if (_tcpOptions.DualMode.HasValue)
                 {
                     // It is important to avoid setting the flag if no specific value is set by the user
                     // because on IPv4 only networks the setter will always throw an exception. Regardless
                     // of the actual value.
-                    socket.DualMode = _options.DualMode.Value;
+                    socket.DualMode = _tcpOptions.DualMode.Value;
                 }
 
-                await socket.ConnectAsync(_options.Server, _options.GetPort(), cancellationToken).ConfigureAwait(false);
+                await socket.ConnectAsync(_tcpOptions.Server, _tcpOptions.GetPort(), cancellationToken).ConfigureAwait(false);
 
                 cancellationToken.ThrowIfCancellationRequested();
 
                 var networkStream = socket.GetStream();
 
-                if (_options.TlsOptions?.UseTls == true)
+                if (_tcpOptions.TlsOptions?.UseTls == true)
                 {
                     var sslStream = new SslStream(networkStream, false, InternalUserCertificateValidationCallback);
                     try
                     {
-                        await sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(), _options.TlsOptions.SslProtocol, !_options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
+#if NETCOREAPP3_1
+                        var sslOptions = new SslClientAuthenticationOptions
+                        {
+                            ApplicationProtocols = _tcpOptions.TlsOptions.ApplicationProtocols,
+                            ClientCertificates = LoadCertificates(),
+                            EnabledSslProtocols = _tcpOptions.TlsOptions.SslProtocol,
+                            CertificateRevocationCheckMode = _tcpOptions.TlsOptions.IgnoreCertificateRevocationErrors ? X509RevocationMode.NoCheck : X509RevocationMode.Online,
+                            TargetHost = _tcpOptions.Server
+                        };
+
+                        await sslStream.AuthenticateAsClientAsync(sslOptions, cancellationToken).ConfigureAwait(false);
+#else
+                        await sslStream.AuthenticateAsClientAsync(_tcpOptions.Server, LoadCertificates(), _tcpOptions.TlsOptions.SslProtocol, !_tcpOptions.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
+#endif
                     }
                     catch
                     {
-#if NETSTANDARD2_1
+#if NETSTANDARD2_1 || NETCOREAPP3_1
                         await sslStream.DisposeAsync().ConfigureAwait(false);
 #else
                         sslStream.Dispose();
@@ -118,22 +133,25 @@ namespace MQTTnet.Implementations
 
         public async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
-            if (buffer is null) throw new ArgumentNullException(nameof(buffer));
-
             cancellationToken.ThrowIfCancellationRequested();
 
             try
             {
+                var stream = _stream;
+
+                if (stream == null)
+                {
+                    return 0;
+                }
+
+                if (!stream.CanRead)
+                {
+                    return 0;
+                }
+
                 // Workaround for: https://github.com/dotnet/corefx/issues/24430
                 using (cancellationToken.Register(Dispose))
                 {
-                    var stream = _stream;
-
-                    if (stream == null)
-                    {
-                        throw new ObjectDisposedException(nameof(stream));
-                    }
-
                     return await stream.ReadAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
                 }
             }
@@ -155,8 +173,6 @@ namespace MQTTnet.Implementations
 
         public async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
         {
-            if (buffer is null) throw new ArgumentNullException(nameof(buffer));
-
             cancellationToken.ThrowIfCancellationRequested();
 
             try
@@ -168,7 +184,7 @@ namespace MQTTnet.Implementations
 
                     if (stream == null)
                     {
-                        throw new ObjectDisposedException(nameof(stream));
+                        throw new MqttCommunicationException("The TCP connection is closed.");
                     }
 
                     await stream.WriteAsync(buffer, offset, count, cancellationToken).ConfigureAwait(false);
@@ -176,6 +192,7 @@ namespace MQTTnet.Implementations
             }
             catch (ObjectDisposedException)
             {
+                throw new MqttCommunicationException("The TCP connection is closed.");
             }
             catch (IOException exception)
             {
@@ -209,18 +226,18 @@ namespace MQTTnet.Implementations
 
         bool InternalUserCertificateValidationCallback(object sender, X509Certificate x509Certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
         {
-#region OBSOLETE
+            #region OBSOLETE
 
 #pragma warning disable CS0618 // Type or member is obsolete
-            var certificateValidationCallback = _options?.TlsOptions?.CertificateValidationCallback;
+            var certificateValidationCallback = _tcpOptions?.TlsOptions?.CertificateValidationCallback;
 #pragma warning restore CS0618 // Type or member is obsolete
             if (certificateValidationCallback != null)
             {
                 return certificateValidationCallback(x509Certificate, chain, sslPolicyErrors, _clientOptions);
             }
-#endregion
+            #endregion
 
-            var certificateValidationHandler = _options?.TlsOptions?.CertificateValidationHandler;
+            var certificateValidationHandler = _tcpOptions?.TlsOptions?.CertificateValidationHandler;
             if (certificateValidationHandler != null)
             {
                 var context = new MqttClientCertificateValidationCallbackContext
@@ -228,7 +245,7 @@ namespace MQTTnet.Implementations
                     Certificate = x509Certificate,
                     Chain = chain,
                     SslPolicyErrors = sslPolicyErrors,
-                    ClientOptions = _options
+                    ClientOptions = _tcpOptions
                 };
 
                 return certificateValidationHandler(context);
@@ -241,7 +258,7 @@ namespace MQTTnet.Implementations
 
             if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.RevocationStatusUnknown || c.Status == X509ChainStatusFlags.Revoked || c.Status == X509ChainStatusFlags.OfflineRevocation))
             {
-                if (_options?.TlsOptions?.IgnoreCertificateRevocationErrors != true)
+                if (_tcpOptions?.TlsOptions?.IgnoreCertificateRevocationErrors != true)
                 {
                     return false;
                 }
@@ -249,24 +266,24 @@ namespace MQTTnet.Implementations
 
             if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.PartialChain))
             {
-                if (_options?.TlsOptions?.IgnoreCertificateChainErrors != true)
+                if (_tcpOptions?.TlsOptions?.IgnoreCertificateChainErrors != true)
                 {
                     return false;
                 }
             }
 
-            return _options?.TlsOptions?.AllowUntrustedCertificates == true;
+            return _tcpOptions?.TlsOptions?.AllowUntrustedCertificates == true;
         }
 
         X509CertificateCollection LoadCertificates()
         {
             var certificates = new X509CertificateCollection();
-            if (_options.TlsOptions.Certificates == null)
+            if (_tcpOptions.TlsOptions.Certificates == null)
             {
                 return certificates;
             }
 
-            foreach (var certificate in _options.TlsOptions.Certificates)
+            foreach (var certificate in _tcpOptions.TlsOptions.Certificates)
             {
                 certificates.Add(certificate);
             }

Source/MQTTnet/Implementations/MqttTcpServerAdapter.Uwp.cs

@@ -48,7 +48,7 @@ namespace MQTTnet.Implementations
 
             if (options.TlsEndpointOptions.IsEnabled)
             {
-                throw new NotSupportedException("TLS servers are not supported for UWP apps.");
+                throw new NotSupportedException("TLS servers are not supported when using 'uap10.0'.");
             }
         }
 
@@ -89,7 +89,7 @@ namespace MQTTnet.Implementations
                         }
                     }
                     
-                    using (var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(args.Socket, clientCertificate, _options), new MqttPacketFormatterAdapter(new MqttPacketWriter()), _rootLogger))
+                    using (var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(args.Socket, clientCertificate, _options), new MqttPacketFormatterAdapter(new MqttPacketWriter()), null, _rootLogger))
                     {
                         await clientHandler(clientAdapter).ConfigureAwait(false);
                     }
@@ -113,7 +113,7 @@ namespace MQTTnet.Implementations
                 }
                 catch (Exception exception)
                 { 
-                    _logger.Error(exception, "Error while cleaning up client connection");
+                    _logger.Error(exception, "Error while cleaning up client connection.");
                 }
             }
         }

Source/MQTTnet/Implementations/MqttTcpServerAdapter.cs

@@ -47,7 +47,7 @@ namespace MQTTnet.Implementations
                 {
                     throw new ArgumentException("TLS certificate is not set.");
                 }
-                
+
                 var tlsCertificate = options.TlsEndpointOptions.CertificateProvider.GetCertificate();
                 if (!tlsCertificate.HasPrivateKey)
                 {
@@ -73,16 +73,22 @@ namespace MQTTnet.Implementations
 
         void Cleanup()
         {
-            _cancellationTokenSource?.Cancel(false);
+            try
-            _cancellationTokenSource?.Dispose();
-            _cancellationTokenSource = null;
-
-            foreach (var listener in _listeners)
             {
-                listener.Dispose();
+                _cancellationTokenSource?.Cancel(false);
             }
+            finally
+            {
+                _cancellationTokenSource?.Dispose();
+                _cancellationTokenSource = null;
 
-            _listeners.Clear();
+                foreach (var listener in _listeners)
+                {
+                    listener.Dispose();
+                }
+
+                _listeners.Clear();
+            }
         }
 
         void RegisterListeners(MqttServerTcpEndpointBaseOptions options, X509Certificate2 tlsCertificate, CancellationToken cancellationToken)

Source/MQTTnet/Implementations/MqttTcpServerListener.cs

@@ -59,7 +59,7 @@ namespace MQTTnet.Implementations
 
                 _localEndPoint = new IPEndPoint(boundIp, _options.Port);
 
-                _logger.Info($"Starting TCP listener for {_localEndPoint} TLS={_tlsCertificate != null}.");
+                _logger.Info("Starting TCP listener for {0} TLS={1}.", _localEndPoint, _tlsCertificate != null);
 
                 _socket = new CrossPlatformSocket(_addressFamily);
 
@@ -77,8 +77,8 @@ namespace MQTTnet.Implementations
 
                 _socket.Bind(_localEndPoint);
                 _socket.Listen(_options.ConnectionBacklog);
-
+                
-                Task.Run(() => AcceptClientConnectionsAsync(cancellationToken), cancellationToken).Forget(_logger);
+                Task.Run(() => AcceptClientConnectionsAsync(cancellationToken), cancellationToken).RunInBackground(_logger);
 
                 return true;
             }
@@ -115,7 +115,7 @@ namespace MQTTnet.Implementations
                         continue;
                     }
 
-                    Task.Run(() => TryHandleClientConnectionAsync(clientSocket), cancellationToken).Forget(_logger);
+                    Task.Run(() => TryHandleClientConnectionAsync(clientSocket), cancellationToken).RunInBackground(_logger);
                 }
                 catch (OperationCanceledException)
                 {
@@ -131,7 +131,7 @@ namespace MQTTnet.Implementations
                         }
                     }
 
-                    _logger.Error(exception, $"Error while accepting connection at TCP listener {_localEndPoint} TLS={_tlsCertificate != null}.");
+                    _logger.Error(exception, "Error while accepting connection at TCP listener {0} TLS={1}.", _localEndPoint, _tlsCertificate != null);
                     await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
                 }
             }
@@ -152,9 +152,7 @@ namespace MQTTnet.Implementations
                     _addressFamily == AddressFamily.InterNetwork ? "ipv4" : "ipv6");
 
                 clientSocket.NoDelay = _options.NoDelay;
-
                 stream = clientSocket.GetStream();
-
                 X509Certificate2 clientCertificate = null;
 
                 if (_tlsCertificate != null)
@@ -180,7 +178,11 @@ namespace MQTTnet.Implementations
                 var clientHandler = ClientHandler;
                 if (clientHandler != null)
                 {
-                    using (var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(stream, remoteEndPoint, clientCertificate), new MqttPacketFormatterAdapter(new MqttPacketWriter()), _rootLogger))
+                    using (var clientAdapter = new MqttChannelAdapter(
+                        new MqttTcpChannel(stream, remoteEndPoint, clientCertificate),
+                        new MqttPacketFormatterAdapter(new MqttPacketWriter()),
+                        null,
+                        _rootLogger))
                     {
                         await clientHandler(clientAdapter).ConfigureAwait(false);
                     }
@@ -208,17 +210,17 @@ namespace MQTTnet.Implementations
                 {
                     stream?.Dispose();
                     clientSocket?.Dispose();
-
-                    _logger.Verbose("Client '{0}' disconnected at TCP listener '{1}, {2}'.",
-                        remoteEndPoint,
-                        _localEndPoint,
-                        _addressFamily == AddressFamily.InterNetwork ? "ipv4" : "ipv6");
                 }
                 catch (Exception disposeException)
                 {
                     _logger.Error(disposeException, "Error while cleaning up client connection");
                 }
             }
+
+            _logger.Verbose("Client '{0}' disconnected at TCP listener '{1}, {2}'.",
+                remoteEndPoint,
+                _localEndPoint,
+                _addressFamily == AddressFamily.InterNetwork ? "ipv4" : "ipv6");
         }
     }
 }

Source/MQTTnet/Implementations/MqttWebSocketChannel.cs

@@ -156,10 +156,20 @@ namespace MQTTnet.Implementations
             }
 
             var certificateValidationHandler = _options.TlsOptions?.CertificateValidationHandler;
-#if NETSTANDARD2_1
             if (certificateValidationHandler != null)
             {
-                clientWebSocket.Options.RemoteCertificateValidationCallback = new System.Net.Security.RemoteCertificateValidationCallback((sender, certificate, chain, sslPolicyErrors) =>
+#if NETSTANDARD1_3
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'netstandard1.3'.");
+#elif NETSTANDARD2_0
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'netstandard2.0'.");
+#elif WINDOWS_UWP
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'uap10.0'.");
+#elif NET452
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'net452'.");
+#elif NET461
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'net461'.");
+#else
+                clientWebSocket.Options.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) =>
                 {
                     // TODO: Find a way to add client options to same callback. Problem is that they have a different type.
                     var context = new MqttClientCertificateValidationCallbackContext
@@ -171,14 +181,9 @@ namespace MQTTnet.Implementations
                     };
 
                     return certificateValidationHandler(context);
-                });
+                };
-            }
-#else
-            if (certificateValidationHandler != null)
-            {
-                throw new NotSupportedException("The remote certificate validation callback for Web Sockets is only supported for netstandard 2.1+");
-            }
 #endif
+            }
         }
 
         void Cleanup()
@@ -207,9 +212,9 @@ namespace MQTTnet.Implementations
             }
 
 #if WINDOWS_UWP
-            throw new NotSupportedException("Proxies are not supported in UWP.");
+            throw new NotSupportedException("Proxies are not supported when using 'uap10.0'.");
 #elif NETSTANDARD1_3
-            throw new NotSupportedException("Proxies are not supported in netstandard 1.3.");
+            throw new NotSupportedException("Proxies are not supported when using 'netstandard 1.3'.");
 #else
             var proxyUri = new Uri(_options.ProxyOptions.Address);