Fix null ref exception in low level client.

Fix UnitTests
Fix Unit Tests.
2026-10-15 00:15:15 +08:00 · 2020-08-05 20:49:11 +02:00 · 2020-07-26 20:07:52 +02:00 · 2020-07-26 12:01:33 +02:00 · 2020-07-25 23:47:29 +02:00 · 2020-07-25 23:34:30 +02:00
618 changed files with 32036 additions and 8687 deletions
@@ -1,8 +1,3 @@
-exclude:
- /Frameworks/.*
- /MQTTnet.TestApp.NetCore/Program.cs
- /Tests/MQTTnet.TestApp.NetFramework/.*
- /Tests/MQTTnet.TestApp.UniversalWindows/.*
-component_depth: 1
+component_depth: 2
 languages:
 - csharp
@@ -0,0 +1,5 @@
+[*.cs]
+
+
+# CA1031: Do not catch general exception types
+dotnet_diagnostic.CA1031.severity = none
@@ -0,0 +1,46 @@
+---
+name: Bug report
+about: Create a report to help us improve.
+title: ''
+labels: 'bug'
+assignees: ''
+
+---
+
+### Describe the bug
+A clear and concise description of what the bug is.
+
+### Which project is your bug related to?
+<!-- Remove the items which don't apply from the following list -->
+- Client
+- ManagedClient
+- MQTTnet.Server standalone
+- Server
+- Generic
+
+### To Reproduce
+Steps to reproduce the behavior:
+1. Using this version of MQTTnet '...'.
+2. Run this code '....'.
+3. With these arguments '....'.
+4. See error.
+
+### Expected behavior
+A clear and concise description of what you expected to happen.
+
+### Screenshots
+If applicable, add screenshots to help explain your problem.
+
+### Additional context / logging
+Add any other context about the problem here.
+Include debugging or logging information here:
+
+```batch
+\\ Put your logging output here.
+```
+### Code example
+ Please provide full code examples below where possible to make it easier for the developers to check your issues.
+ 
+```csharp
+\\ Put your code here.
+```
@@ -0,0 +1,19 @@
+---
+name: Custom issue template
+about: Do you have a question related to the project? Use this template.
+title: ''
+labels: 'question'
+assignees: ''
+
+---
+
+### Describe your question
+A clear and concise description of what you want to know.
+
+### Which project is your question related to?
+<!-- Remove the items which don't apply from the following list -->
+- Client
+- ManagedClient
+- MQTTnet.Server standalone
+- Server
+- Generic
@@ -0,0 +1,29 @@
+---
+name: Feature request
+about: Suggest an idea for this project.
+title: ''
+labels: 'feature-request'
+assignees: ''
+
+---
+
+### Describe the feature request
+Is your feature request related to a problem? Please describe.
+A clear and concise description of what the problem is. Example. I'm am trying to do [...] but [...]
+
+### Which project is your feature request related to?
+<!-- Remove the items which don't apply from the following list -->
+- Client
+- ManagedClient
+- MQTTnet.Server standalone
+- Server
+- Generic
+
+### Describe the solution you'd like
+A clear and concise description of what you want to happen.
+
+### Describe alternatives you've considered
+A clear and concise description of any alternative solutions or features you've considered.
+
+### Additional context
+Add any other context or screenshots about the feature request here.
@@ -235,6 +235,7 @@ FakesAssemblies/
 # Node.js Tools for Visual Studio
 .ntvs_analysis.dat
 node_modules/
+/*/**/package-lock.json

 # Typescript v1 declaration files
 typings/
@@ -287,9 +288,9 @@ __pycache__/
 *.odx.cs
 *.xsd.cs

-
-Build/nuget.exe
 *.js
 *.map

 /Tests/MQTTnet.TestApp.NetCore/RetainedMessages.json
+
+Build/NuGet/
@@ -1,10 +0,0 @@
-language: csharp
-solution: MQTTnet.sln
-
-matrix:
-  include:
-    - dotnet: 2.0.0
-      mono: none
-      dist: trusty
-      env: DOTNETCORE=1  # optional, can be used to take different code paths in your script
-    - mono: latest
@@ -2,27 +2,41 @@
 <package >
  <metadata>
    <id>MQTTnet.AspNetCore</id>
-    <version>2.7.3</version>
-    <authors>Christian Kratky</authors>
+    <version>0.0.0</version>
+    <authors>The contributors of MQTTnet</authors>
    <owners>Christian Kratky</owners>
-    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
+    <license type="file">LICENSE</license>
    <projectUrl>https://github.com/chkr1011/MQTTnet</projectUrl>
    <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <icon>images\Logo_128x128.png</icon>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
    <description>This is a support library to integrate MQTTnet into AspNetCore.</description>
-    <releaseNotes>* Updated to MQTTnet 2.7.3.
-    </releaseNotes>
-    <copyright>Copyright Christian Kratky 2016-2018</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</tags> 
+    <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>
    <dependencies>
      <group targetFramework="netstandard2.0">
-        <dependency id="MQTTnet" version="2.7.3" />
+        <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>
    </dependencies>
  </metadata>

  <files>
+    <!-- License -->
+    <file src="..\LICENSE" />
+
+    <!-- Images -->
+    <file src="..\Images\Logo_128x128.png" target="images\" />
+
    <!-- .NET Standard 2.0 -->
-    <file src="..\Frameworks\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\"/>
  </files>
-</package>
+</package>
@@ -0,0 +1,46 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>MQTTnet.Extensions.ManagedClient</id>
+    <version>0.0.0</version>
+    <authors>The contributors of MQTTnet</authors>
+    <owners>Christian Kratky</owners>
+    <license type="file">LICENSE</license>
+    <projectUrl>https://github.com/chkr1011/MQTTnet</projectUrl>
+    <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
+    <icon>images\Logo_128x128.png</icon>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <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> 
+    <dependencies>
+      <dependency id="MQTTnet" version="$nugetVersion" />
+    </dependencies>
+  </metadata>
+
+  <files>
+    <!-- License -->
+    <file src="..\LICENSE" />
+
+    <!-- Images -->
+    <file src="..\Images\Logo_128x128.png" target="images\" />
+
+    <!-- .NET Standard 1.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\"/>
+
+    <!-- Universal Windows -->
+    <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\"/>
+
+    <!-- .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\"/>
+
+    <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
+  </files>
+</package>
@@ -2,46 +2,45 @@
 <package >
  <metadata>
    <id>MQTTnet.Extensions.Rpc</id>
-    <version>2.6.0</version>
-    <authors>Christian Kratky</authors>
+    <version>0.0.0</version>
+    <authors>The contributors of MQTTnet</authors>
    <owners>Christian Kratky</owners>
-    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
+    <license type="file">LICENSE</license>
    <projectUrl>https://github.com/chkr1011/MQTTnet</projectUrl>
    <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>This is a extension library which allows executing synchronous device calls including a response using MQTTnet.</description>
-    <releaseNotes>* Initial version.
-    </releaseNotes>
-    <copyright>Copyright Christian Kratky 2016-2017</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</tags> 
+    <icon>images\Logo_128x128.png</icon>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <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> 
    <dependencies>
-      <group targetFramework="netstandard2.0">
-        <dependency id="MQTTnet" version="2.6.0-rc1" />
-      </group>
-      <group targetFramework="netstandard1.3">
-        <dependency id="MQTTnet" version="2.6.0-rc1" />  
-      </group>
-
-      <group targetFramework="netstandard2.0">
-        <dependency id="MQTTnet" version="2.6.0-rc1" />
-      </group>
-      
-      <group targetFramework="uap10.0">
-        <dependency id="MQTTnet" version="2.6.0-rc1" />
-      </group>
-        
-      <group targetFramework="net452">
-        <dependency id="MQTTnet" version="2.6.0-rc1" />
-      </group>
-
-      <group targetFramework="net461">
-        <dependency id="MQTTnet" version="2.6.0-rc1" />
-      </group>
+      <dependency id="MQTTnet" version="$nugetVersion" />
    </dependencies>
  </metadata>

  <files>
+    <!-- License -->
+    <file src="..\LICENSE" />
+
+    <!-- Images -->
+    <file src="..\Images\Logo_128x128.png" target="images\" />
+
+    <!-- .NET Standard 1.3 -->
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\netstandard1.3\MQTTnet.Extensions.Rpc.*" target="lib\netstandard1.3\"/>
+
    <!-- .NET Standard 2.0 -->
-    <file src="..\Frameworks\MQTTnet.AspNetCore\bin\Release\netstandard2.0\MQTTnet.AspNetCore.*" 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\"/>
+
+    <!-- .NET Framework -->
+    <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\"/>
+
+    <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
  </files>
-</package>
+</package>
@@ -0,0 +1,61 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>MQTTnet.Extensions.WebSocket4Net</id>
+    <version>0.0.0</version>
+    <authors>The contributors of MQTTnet</authors>
+    <owners>Christian Kratky</owners>
+    <license type="file">LICENSE</license>
+    <projectUrl>https://github.com/chkr1011/MQTTnet</projectUrl>
+    <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
+    <icon>images\Logo_128x128.png</icon>
+    <requireLicenseAcceptance>true</requireLicenseAcceptance>
+    <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> 
+    <dependencies>
+    <group targetFramework="netstandard1.3">
+        <dependency id="MQTTnet" version="$nugetVersion" />
+        <dependency id="WebSocket4Net" version="0.15.2" />
+      </group>
+      <group targetFramework="netstandard2.0">
+        <dependency id="MQTTnet" version="$nugetVersion" />
+        <dependency id="WebSocket4Net" version="0.15.2" />
+      </group>
+      <group targetFramework="netstandard2.1">
+        <dependency id="MQTTnet" version="$nugetVersion" />
+        <dependency id="WebSocket4Net" version="0.15.2" />
+      </group>
+      <group targetFramework="uap10.0">
+        <dependency id="MQTTnet" version="$nugetVersion" />
+        <dependency id="WebSocket4Net" version="0.15.2" />
+      </group>
+    </dependencies>
+  </metadata>
+
+  <files>
+    <!-- License -->
+    <file src="..\LICENSE" />
+
+    <!-- Images -->
+    <file src="..\Images\Logo_128x128.png" target="images\" />
+
+    <!-- .NET Standard 1.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\"/>
+
+    <!-- Universal Windows -->
+    <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\"/>
+
+    <!-- .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\"/>
+
+    <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
+  </files>
+</package>
@@ -2,68 +2,79 @@
 <package >
  <metadata>
    <id>MQTTnet</id>
-    <version>2.7.3</version>
-    <authors>Christian Kratky</authors>
+    <version>0.0.0</version>
+    <authors>The contributors of MQTTnet</authors>
    <owners>Christian Kratky</owners>
-    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
+    <license type="file">LICENSE</license>
    <projectUrl>https://github.com/chkr1011/MQTTnet</projectUrl>
    <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>MQTTnet is a high performance .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker).</description>
-    <releaseNotes>* [Core] Add several new extension methods.
-* [Client] Fixed an issue in _ManagedMqttClientOptionsBuilder_ when using _WithClientOptions_ and an options builder.
-* [Client] Added the "IsStarted" property for the managed client.
-* [Client] Optimized stream buffer for UWP apps.
-* [Client] Added the _BufferSize_ to the TCP options.
-* [Client] Fixed a race condition which leads to exceptions when reconnecting rapidly.
-* [Server] Fixed a race condition which leads to exceptions when clients are reconnecting rapidly.
-* [Core] Fixed some issues in stream and socket handling.
+    <icon>images\Logo_128x128.png</icon>
+    <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).      
+* [RcpClient] Adjusted some namespaces (BREAKING CHANGE!).
+* [AspNetCore] Adjusted some namespaces (BREAKING CHANGE!).
+* [Server] Adjusted some namespaces (BREAKING CHANGE!).
+* [Server] Added state checks (throw if not started etc.) for most server APIs.
+* [Server] Exposed real X509Certificate2 (instead byte array) to TLS options (thanks to @borigas).
+* [Server] Fixed memory leak with TCP sockets (MqttServer is now Disposable!) (BREAKING CHANGE!).
+* [Core] Fixed a null reference exception in the MqttTcpChannel with WriteAsync and ReadAsync.
+* [Core] Added server interceptor for undelivered messages (thanks to @cshark-inator).
+* [nuget] Added support for SourceLink (thanks to @JTOne123).
    </releaseNotes>
-    <copyright>Copyright Christian Kratky 2016-2018</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</tags> 
+    <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> 
    <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.1" />      
+        <dependency id="System.Net.WebSockets.Client" version="4.3.2" />      
      </group>
-
      <group targetFramework="netstandard2.0">
        <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.1" />
+        <dependency id="System.Net.WebSockets.Client" version="4.3.2" />
+      </group>
+      <group targetFramework="netstandard2.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="5.4.1" />
+        <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="6.2.10" />
      </group>
-        
-      <group targetFramework="net452">
-      </group>
-
-      <group targetFramework="net461">
-      </group>
-
    </dependencies>
  </metadata>

  <files>
-    
+    <!-- License -->
+    <file src="..\LICENSE" />
+
+    <!-- Images -->
+    <file src="..\Images\Logo_128x128.png" target="images\" />
+
    <!-- .NET Standard 1.3 -->
-    <file src="..\Frameworks\MQTTnet.Netstandard\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="..\Frameworks\MQTTnet.Netstandard\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\"/>

    <!-- Universal Windows -->
-    <file src="..\Frameworks\MQTTnet.Netstandard\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="..\Frameworks\MQTTnet.Netstandard\bin\Release\net452\MQTTnet.*" target="lib\net452\"/>
-    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\net461\MQTTnet.*" target="lib\net461\"/>
-    
+    <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\"/>
+
+    <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
  </files>
-</package>
+</package>
@@ -4,32 +4,130 @@ if ([string]::IsNullOrEmpty($assemblyVersion)) {$assemblyVersion = "0.0.1"}
 if ([string]::IsNullOrEmpty($nugetVersion)) {$nugetVersion = "0.0.1"}

 $vswhere = ${Env:\ProgramFiles(x86)} + '\Microsoft Visual Studio\Installer\vswhere'
+$msbuild = &$vswhere -products * -requires Microsoft.Component.MSBuild -latest -find MSBuild\**\Bin\MSBuild.exe

-$path = &$vswhere -latest -products * -requires Microsoft.Component.MSBuild -property installationPath
-if ($path) {
-    $msbuild = join-path $path 'MSBuild\15.0\Bin\MSBuild.exe'
+Write-Host
+Write-Host "Assembly version = $assemblyVersion"
+Write-Host "Nuget version    = $nugetVersion"
+Write-Host "MSBuild path     = $msbuild"
+Write-Host

-	# Build the core library
-    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
-    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net461" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
-    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.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 ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.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 ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.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
-	&$msbuild ..\Frameworks\MQTTnet.AspNetCore\MQTTnet.AspNetCore.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"
+Invoke-WebRequest -Uri "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe" -OutFile "nuget.exe"

-	# Build the RPC extension
-	&$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
-    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net461" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
-    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard1.3" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
-    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard2.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
-    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="uap10.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+.\nuget.exe restore ..\MQTTnet.sln

-    Remove-Item .\NuGet -Force -Recurse -ErrorAction SilentlyContinue
+# Build and execute tests
+&$msbuild ..\Tests\MQTTnet.Core.Tests\MQTTnet.Tests.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netcoreapp3.1" /verbosity:m
+&$msbuild ..\Tests\MQTTnet.AspNetCore.Tests\MQTTnet.AspNetCore.Tests.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netcoreapp3.1" /verbosity:m

-    New-Item -ItemType Directory -Force -Path .\NuGet
-    .\NuGet.exe pack MQTTnet.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $nugetVersion
-    .\NuGet.exe pack MQTTnet.AspNetCore.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $nugetVersion
-	.\NuGet.exe pack MQTTnet.Extensions.Rpc.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $nugetVersion
-}
+vstest.console.exe ..\Tests\MQTTnet.Core.Tests\bin\Release\netcoreapp3.1\MQTTnet.Tests.dll
+vstest.console.exe ..\Tests\MQTTnet.AspNetCore.Tests\bin\Release\netcoreapp3.1\MQTTnet.AspNetCore.Tests.dll
+
+# Build the core library
+&$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /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="net461" /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="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="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
+&$msbuild ..\Source\MQTTnet.AspNetCore\MQTTnet.AspNetCore.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.AspNetCore\MQTTnet.AspNetCore.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"
+
+# Build the RPC extension
+&$msbuild ..\Source\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net461" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.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.Extensions.Rpc\MQTTnet.Extensions.Rpc.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.Extensions.Rpc\MQTTnet.Extensions.Rpc.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.Extensions.Rpc\MQTTnet.Extensions.Rpc.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 Managed Client extension
+&$msbuild ..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net461" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.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.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.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.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.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.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.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 WebSocket4Net extension
+&$msbuild ..\Source\MQTTnet.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net461" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.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.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.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.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.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.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.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"
+
+# Create NuGet packages.
+
+Remove-Item .\NuGet -Force -Recurse -ErrorAction SilentlyContinue
+
+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
+(Get-Content MQTTnet.Extensions.Rpc.nuspec) -replace '\$nugetVersion', $nugetVersion | Set-Content MQTTnet.Extensions.Rpc.nuspec
+Copy-Item MQTTnet.Extensions.ManagedClient.nuspec -Destination MQTTnet.Extensions.ManagedClient.nuspec.old -Force
+(Get-Content MQTTnet.Extensions.ManagedClient.nuspec) -replace '\$nugetVersion', $nugetVersion | Set-Content MQTTnet.Extensions.ManagedClient.nuspec
+Copy-Item MQTTnet.Extensions.WebSocket4Net.nuspec -Destination MQTTnet.Extensions.WebSocket4Net.nuspec.old -Force
+(Get-Content MQTTnet.Extensions.WebSocket4Net.nuspec) -replace '\$nugetVersion', $nugetVersion | Set-Content MQTTnet.Extensions.WebSocket4Net.nuspec
+
+New-Item -ItemType Directory -Force -Path .\NuGet
+.\nuget.exe pack MQTTnet.nuspec -Verbosity detailed -Symbols -SymbolPackageFormat snupkg -OutputDir "NuGet" -Version $nugetVersion
+.\nuget.exe pack MQTTnet.AspNetCore.nuspec -Verbosity detailed -Symbols -SymbolPackageFormat snupkg -OutputDir "NuGet" -Version $nugetVersion
+.\nuget.exe pack MQTTnet.Extensions.Rpc.nuspec -Verbosity detailed -Symbols -SymbolPackageFormat snupkg -OutputDir "NuGet" -Version $nugetVersion
+.\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.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
+Move-Item MQTTnet.Extensions.WebSocket4Net.nuspec.old -Destination MQTTnet.Extensions.WebSocket4Net.nuspec -Force
+
+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
+
+$source = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\Release\netcoreapp3.1\publish"
+$destination = (Convert-Path .) + "\..\Source\MQTTnet.Server\bin\MQTTnet.Server-Portable-v$nugetVersion.zip"
+If(Test-path $destination) {Remove-item $destination}
+ Add-Type -assembly "system.io.compression.filesystem"
+[io.compression.zipfile]::CreateFromDirectory($source, $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 
+
+$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"
+If(Test-path $destination) {Remove-item $destination}
+ Add-Type -assembly "system.io.compression.filesystem"
+[io.compression.zipfile]::CreateFromDirectory($source, $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 
+
+$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"
+If(Test-path $destination) {Remove-item $destination}
+ Add-Type -assembly "system.io.compression.filesystem"
+[io.compression.zipfile]::CreateFromDirectory($source, $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
+
+$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"
+If(Test-path $destination) {Remove-item $destination}
+ Add-Type -assembly "system.io.compression.filesystem"
+[io.compression.zipfile]::CreateFromDirectory($source, $destination) 
+
+####################################################################
@@ -0,0 +1,13 @@
+param([string]$apiKey)
+
+Invoke-WebRequest -Uri "https://dist.nuget.org/win-x86-commandline/latest/nuget.exe" -OutFile "nuget.exe"
+
+$files = Get-ChildItem -Path ".\NuGet" -Filter "*.nupkg"
+foreach ($file in $files)
+{
+	Write-Host "Uploading: " $file
+
+	.\nuget.exe push $file.Fullname $apiKey -Source https://api.nuget.org/v3/index.json
+}
+
+Remove-Item "nuget.exe" -Force -Recurse -ErrorAction SilentlyContinue
@@ -1,9 +1,9 @@
 # Import codeSigningKey.pfx
 In order to import the key for code signing on a new developer machine use the following command within the VS developer command line:

-> sn –i codeSigningKey.pfx VS_KEY_EFCA4C5B6DFD4B4F
+sn –i .\codeSigningKey.pfx VS_KEY_62CA73019ED23333

 The container name may be different.

 # Check if the assembly has a strong name
-> sn -vf MQTTnet.dll
+sn -vf MQTTnet.dll
@@ -1,101 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Threading.Tasks;
-using MQTTnet.Client;
-using MQTTnet.Internal;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Extensions.Rpc
-{
-    public sealed class MqttRpcClient : IDisposable
-    {
-        private const string ResponseTopic = "$MQTTnet.RPC/+/+/response";
-        private readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
-        private readonly IMqttClient _mqttClient;
-        private bool _isEnabled;
-
-        public MqttRpcClient(IMqttClient mqttClient)
-        {
-            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
-
-            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
-        }
-
-        public async Task EnableAsync()
-        {
-            await _mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(ResponseTopic).WithAtLeastOnceQoS().Build());
-            _isEnabled = true;
-        }
-
-        public async Task DisableAsync()
-        {
-            await _mqttClient.UnsubscribeAsync(ResponseTopic);
-            _isEnabled = false;
-        }
-
-        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
-        {
-            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 (!_isEnabled)
-            {
-                throw new InvalidOperationException("The RPC client is not enabled.");
-            }
-
-            var requestTopic = $"$MQTTnet.RPC/{Guid.NewGuid():N}/{methodName}";
-            var responseTopic = requestTopic + "/response";
-
-            var requestMessage = new MqttApplicationMessageBuilder()
-                .WithTopic(requestTopic)
-                .WithPayload(payload)
-                .WithQualityOfServiceLevel(qualityOfServiceLevel)
-                .Build();
-
-            try
-            {
-                var tcs = new TaskCompletionSource<byte[]>();
-                if (!_waitingCalls.TryAdd(responseTopic, tcs))
-                {
-                    throw new InvalidOperationException();
-                }
-
-                await _mqttClient.PublishAsync(requestMessage);
-                return await tcs.Task.TimeoutAfter(timeout);
-            }
-            finally
-            {
-                _waitingCalls.TryRemove(responseTopic, out _);
-            }
-        }
-
-        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
-        {
-            if (!_waitingCalls.TryRemove(eventArgs.ApplicationMessage.Topic, out TaskCompletionSource<byte[]> tcs))
-            {
-                return;
-            }
-
-            if (tcs.Task.IsCompleted || tcs.Task.IsCanceled)
-            {
-                return;
-            }
-
-            tcs.TrySetResult(eventArgs.ApplicationMessage.Payload);
-        }
-
-        public void Dispose()
-        {
-            foreach (var tcs in _waitingCalls)
-            {
-                tcs.Value.SetCanceled();
-            }
-
-            _waitingCalls.Clear();
-        }
-    }
-}
@@ -1 +0,0 @@
-
@@ -1,52 +0,0 @@
-using System;
-using Microsoft.AspNetCore.Builder;
-using Microsoft.Extensions.DependencyInjection;
-using System.Linq;
-using MQTTnet.Server;
-
-namespace MQTTnet.AspNetCore
-{
-    public static class ApplicationBuilderExtensions
-    {
-        public static IApplicationBuilder UseMqttEndpoint(this IApplicationBuilder app, string path = "/mqtt")
-        {
-            app.UseWebSockets();
-            app.Use(async (context, next) =>
-            {
-                if (context.Request.Path == path && context.WebSockets.IsWebSocketRequest)
-                {
-                    string subprotocol = null;
-
-                    if (context.Request.Headers.TryGetValue("Sec-WebSocket-Protocol", out var requestedSubProtocolValues)
-                     && requestedSubProtocolValues.Count > 0
-                     && requestedSubProtocolValues.Any(v => v.ToLower() == "mqtt")
-                     )
-                    {
-                        subprotocol = "mqtt";
-                    }
-
-                    var adapter = app.ApplicationServices.GetRequiredService<MqttWebSocketServerAdapter>();
-                    using (var webSocket = await context.WebSockets.AcceptWebSocketAsync(subprotocol))
-                    {
-                        await adapter.AcceptWebSocketAsync(webSocket);
-                    }
-                }
-                else
-                {
-                    await next();
-                }
-            });
-
-            return app;
-        }
-
-        public static IApplicationBuilder UseMqttServer(this IApplicationBuilder app, Action<IMqttServer> configure)
-        {
-            var server = app.ApplicationServices.GetRequiredService<IMqttServer>();
-
-            configure(server);
-
-            return app;
-        }
-    }
-}
@@ -1,28 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netstandard2.0</TargetFramework>
-    <AssemblyVersion>0.0.0.0</AssemblyVersion>
-    <FileVersion>0.0.0.0</FileVersion>
-    <Version>0.0.0.0</Version>
-    <Product />
-    <Company />
-    <Authors />
-    <PackageId />
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
-    <DefineConstants>RELEASE;NETSTANDARD2_0</DefineConstants>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.0.1" />
-    <PackageReference Include="Microsoft.AspNetCore.WebSockets" Version="2.0.1" />
-    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="2.0.1" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\MQTTnet.Netstandard\MQTTnet.NetStandard.csproj" />
-  </ItemGroup>
-
-</Project>
@@ -1,42 +0,0 @@
-using System;
-using System.Net.WebSockets;
-using System.Threading.Tasks;
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-using MQTTnet.Serializer;
-using MQTTnet.Server;
-
-namespace MQTTnet.AspNetCore
-{
-    public sealed class MqttWebSocketServerAdapter : IMqttServerAdapter, IDisposable
-    {
-        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
-
-        public Task StartAsync(IMqttServerOptions options)
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task StopAsync()
-        {
-            return Task.CompletedTask;
-        }
-
-        public Task AcceptWebSocketAsync(WebSocket webSocket)
-        {
-            if (webSocket == null) throw new ArgumentNullException(nameof(webSocket));
-
-            var channel = new MqttWebSocketServerChannel(webSocket);
-            var clientAdapter = new MqttChannelAdapter(channel, new MqttPacketSerializer(), new MqttNetLogger());
-
-            var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
-            ClientAccepted?.Invoke(this, eventArgs);
-            return eventArgs.SessionTask;
-        }
-        
-        public void Dispose()
-        {
-            StopAsync();
-        }
-    }
-}
@@ -1,60 +0,0 @@
-using System;
-using System.IO;
-using System.Net.WebSockets;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Channel;
-using MQTTnet.Implementations;
-
-namespace MQTTnet.AspNetCore
-{
-    public class MqttWebSocketServerChannel : IMqttChannel, IDisposable
-    {
-        private WebSocket _webSocket;
-
-        public MqttWebSocketServerChannel(WebSocket webSocket)
-        {
-            _webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
-
-            SendStream = new WebSocketStream(_webSocket);
-            ReceiveStream = SendStream;
-        }
-
-        public Stream SendStream { get; private set; }
-        public Stream ReceiveStream { get; private set; }
-
-        public Task ConnectAsync()
-        {
-            return Task.CompletedTask;
-        }
-
-        public async Task DisconnectAsync()
-        {
-            if (_webSocket == null)
-            {
-                return;
-            }
-
-            try
-            {
-                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
-            }
-            finally
-            {
-                Dispose();
-            }
-        }
-
-        public void Dispose()
-        {
-            SendStream?.Dispose();
-            ReceiveStream?.Dispose();
-
-            _webSocket?.Dispose();
-
-            SendStream = null;
-            ReceiveStream = null;
-            _webSocket = null;
-        }
-    }
-}
@@ -1,28 +0,0 @@
-using System;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Hosting;
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-using MQTTnet.Server;
-
-namespace MQTTnet.AspNetCore
-{
-    public static class ServiceCollectionExtensions
-    {
-        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, IMqttServerOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            services.AddSingleton(options);
-            services.AddSingleton<IMqttNetLogger>(new MqttNetLogger());
-            services.AddSingleton<MqttHostedServer>();
-            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
-            services.AddSingleton<IMqttServer>(s => s.GetService<MqttHostedServer>());
-            
-            services.AddSingleton<MqttWebSocketServerAdapter>();
-            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttWebSocketServerAdapter>());
-
-            return services;
-        }
-    }
-}
@@ -1,22 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Packets;
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Adapter
-{
-    public interface IMqttChannelAdapter : IDisposable
-    {
-        IMqttPacketSerializer PacketSerializer { get; }
-
-        Task ConnectAsync(TimeSpan timeout);
-
-        Task DisconnectAsync(TimeSpan timeout);
-
-        Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets);
-
-        Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken);
-    }
-}
@@ -1,255 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Net.Sockets;
-using System.Runtime.InteropServices;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Channel;
-using MQTTnet.Diagnostics;
-using MQTTnet.Exceptions;
-using MQTTnet.Internal;
-using MQTTnet.Packets;
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Adapter
-{
-    public sealed class MqttChannelAdapter : IMqttChannelAdapter
-    {
-        private const uint ErrorOperationAborted = 0x800703E3;
-        private const int ReadBufferSize = 4096;  // TODO: Move buffer size to config
-
-        private bool _isDisposed;
-        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
-        private readonly IMqttNetLogger _logger;
-        private readonly IMqttChannel _channel;
-
-        public MqttChannelAdapter(IMqttChannel channel, IMqttPacketSerializer serializer, IMqttNetLogger logger)
-        {
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _channel = channel ?? throw new ArgumentNullException(nameof(channel));
-            PacketSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
-        }
-
-        public IMqttPacketSerializer PacketSerializer { get; }
-
-        public Task ConnectAsync(TimeSpan timeout)
-        {
-            ThrowIfDisposed();
-            _logger.Trace<MqttChannelAdapter>("Connecting [Timeout={0}]", timeout);
-
-            return ExecuteAndWrapExceptionAsync(() => _channel.ConnectAsync().TimeoutAfter(timeout));
-        }
-
-        public Task DisconnectAsync(TimeSpan timeout)
-        {
-            ThrowIfDisposed();
-            _logger.Trace<MqttChannelAdapter>("Disconnecting [Timeout={0}]", timeout);
-
-            return ExecuteAndWrapExceptionAsync(() => _channel.DisconnectAsync().TimeoutAfter(timeout));
-        }
-
-        public Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets)
-        {
-            ThrowIfDisposed();
-
-            return ExecuteAndWrapExceptionAsync(async () =>
-            {
-                await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
-                try
-                {
-                    foreach (var packet in packets)
-                    {
-                        if (cancellationToken.IsCancellationRequested)
-                        {
-                            return;
-                        }
-
-                        if (packet == null)
-                        {
-                            continue;
-                        }
-
-                        _logger.Trace<MqttChannelAdapter>("TX >>> {0} [Timeout={1}]", packet, timeout);
-
-                        var chunks = PacketSerializer.Serialize(packet);
-                        foreach (var chunk in chunks)
-                        {
-                            if (cancellationToken.IsCancellationRequested)
-                            {
-                                return;
-                            }
-
-                            await _channel.SendStream.WriteAsync(chunk.Array, chunk.Offset, chunk.Count, cancellationToken).ConfigureAwait(false);
-                        }
-                    }
-
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        return;
-                    }
-
-                    if (timeout > TimeSpan.Zero)
-                    {
-                        await _channel.SendStream.FlushAsync(cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        await _channel.SendStream.FlushAsync(cancellationToken).ConfigureAwait(false);
-                    }
-                }
-                finally
-                {
-                    _semaphore.Release();
-                }
-            });
-        }
-
-        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
-        {
-            ThrowIfDisposed();
-
-            MqttBasePacket packet = null;
-            await ExecuteAndWrapExceptionAsync(async () =>
-            {
-                ReceivedMqttPacket receivedMqttPacket = null;
-                try
-                {
-                    if (timeout > TimeSpan.Zero)
-                    {
-                        receivedMqttPacket = await ReceiveAsync(_channel.ReceiveStream, cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
-                    }
-                    else
-                    {
-                        receivedMqttPacket = await ReceiveAsync(_channel.ReceiveStream, cancellationToken).ConfigureAwait(false);
-                    }
-
-                    if (receivedMqttPacket == null || cancellationToken.IsCancellationRequested)
-                    {
-                        throw new TaskCanceledException();
-                    }
-
-                    packet = PacketSerializer.Deserialize(receivedMqttPacket.Header, receivedMqttPacket.Body);
-                    if (packet == null)
-                    {
-                        throw new MqttProtocolViolationException("Received malformed packet.");
-                    }
-
-                    _logger.Trace<MqttChannelAdapter>("RX <<< {0}", packet);
-                }
-                finally
-                {
-                    receivedMqttPacket?.Dispose();
-                }
-            }).ConfigureAwait(false);
-
-            return packet;
-        }
-
-        private static async Task<ReceivedMqttPacket> ReceiveAsync(Stream stream, CancellationToken cancellationToken)
-        {
-            var header = await MqttPacketReader.ReadHeaderAsync(stream, cancellationToken).ConfigureAwait(false);
-            if (header == null)
-            {
-                return null;
-            }
-
-            if (header.BodyLength == 0)
-            {
-                return new ReceivedMqttPacket(header, new MemoryStream(new byte[0], false));
-            }
-
-            var body = header.BodyLength <= ReadBufferSize ? new MemoryStream(header.BodyLength) : new MemoryStream();
-
-            var buffer = new byte[ReadBufferSize];
-            while (body.Length < header.BodyLength)
-            {
-                var bytesLeft = header.BodyLength - (int)body.Length;
-                if (bytesLeft > buffer.Length)
-                {
-                    bytesLeft = buffer.Length;
-                }
-
-                var readBytesCount = await stream.ReadAsync(buffer, 0, bytesLeft, cancellationToken).ConfigureAwait(false);
-
-                // Check if the client closed the connection before sending the full body.
-                if (readBytesCount == 0)
-                {
-                    throw new MqttCommunicationException("Connection closed while reading remaining packet body.");
-                }
-
-                // Here is no need to await because internally only an array is used and no real I/O operation is made.
-                // Using async here will only generate overhead.
-                body.Write(buffer, 0, readBytesCount);
-            }
-
-            body.Seek(0L, SeekOrigin.Begin);
-
-            return new ReceivedMqttPacket(header, body);
-        }
-
-        private static async Task ExecuteAndWrapExceptionAsync(Func<Task> action)
-        {
-            try
-            {
-                await action().ConfigureAwait(false);
-            }
-            catch (TaskCanceledException)
-            {
-                throw;
-            }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-            catch (MqttCommunicationTimedOutException)
-            {
-                throw;
-            }
-            catch (MqttCommunicationException)
-            {
-                throw;
-            }
-            catch (COMException comException)
-            {
-                if ((uint)comException.HResult == ErrorOperationAborted)
-                {
-                    throw new OperationCanceledException();
-                }
-
-                throw new MqttCommunicationException(comException);
-            }
-            catch (IOException exception)
-            {
-                if (exception.InnerException is SocketException socketException)
-                {
-                    if (socketException.SocketErrorCode == SocketError.ConnectionAborted)
-                    {
-                        throw new OperationCanceledException();
-                    }
-                }
-
-                throw new MqttCommunicationException(exception);
-            }
-            catch (Exception exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public void Dispose()
-        {
-            _isDisposed = true;
-            _semaphore?.Dispose();
-            _channel?.Dispose();
-        }
-
-        private void ThrowIfDisposed()
-        {
-            if (_isDisposed)
-            {
-                throw new ObjectDisposedException(nameof(MqttChannelAdapter));
-            }
-        }
-    }
-}
@@ -1,16 +0,0 @@
-using MQTTnet.Exceptions;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Adapter
-{
-    public class MqttConnectingFailedException : MqttCommunicationException
-    {
-        public MqttConnectingFailedException(MqttConnectReturnCode returnCode)
-            : base($"Connecting with MQTT server failed ({returnCode}).")
-        {
-            ReturnCode = returnCode;
-        }
-
-        public MqttConnectReturnCode ReturnCode { get; }
-    }
-}
@@ -1,17 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace MQTTnet.Adapter
-{
-    public class MqttServerAdapterClientAcceptedEventArgs : EventArgs
-    {
-        public MqttServerAdapterClientAcceptedEventArgs(IMqttChannelAdapter client)
-        {
-            Client = client ?? throw new ArgumentNullException(nameof(client));
-        }
-
-        public IMqttChannelAdapter Client { get; }
-
-        public Task SessionTask { get; set; }
-    }
-}
@@ -1,24 +0,0 @@
-using System;
-using System.IO;
-using MQTTnet.Packets;
-
-namespace MQTTnet.Adapter
-{
-    public sealed class ReceivedMqttPacket : IDisposable
-    {
-        public ReceivedMqttPacket(MqttPacketHeader header, MemoryStream body)
-        {
-            Header = header ?? throw new ArgumentNullException(nameof(header));
-            Body = body ?? throw new ArgumentNullException(nameof(body));
-        }
-
-        public MqttPacketHeader Header { get; }
-
-        public MemoryStream Body { get; }
-
-        public void Dispose()
-        {
-            Body?.Dispose();
-        }
-    }
-}
@@ -1,41 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using MQTTnet.Protocol;
-
-namespace MQTTnet
-{
-    public static class ApplicationMessagePublisherExtensions
-    {
-        public static Task PublishAsync(this IApplicationMessagePublisher publisher, params MqttApplicationMessage[] applicationMessages)
-        {
-            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
-            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
-
-            return publisher.PublishAsync(applicationMessages);
-        }
-
-        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic)
-        {
-            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
-            if (topic == null) throw new ArgumentNullException(nameof(topic));
-            
-            return publisher.PublishAsync(new MqttApplicationMessageBuilder().WithTopic(topic).Build());
-        }
-
-        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic, string payload)
-        {
-            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
-            if (topic == null) throw new ArgumentNullException(nameof(topic));
-
-            return publisher.PublishAsync(new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(payload).Build());
-        }
-
-        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
-        {
-            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
-            if (topic == null) throw new ArgumentNullException(nameof(topic));
-
-            return publisher.PublishAsync(new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(payload).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
-        }
-    }
-}
@@ -1,15 +0,0 @@
-using System;
-using System.IO;
-using System.Threading.Tasks;
-
-namespace MQTTnet.Channel
-{
-    public interface IMqttChannel : IDisposable
-    {
-        Stream SendStream { get; }
-        Stream ReceiveStream { get; }
-
-        Task ConnectAsync();
-        Task DisconnectAsync();
-    }
-}
@@ -1,20 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace MQTTnet.Client
-{
-    public interface IMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
-    {
-        bool IsConnected { get; }
-
-        event EventHandler<MqttClientConnectedEventArgs> Connected;
-        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
-
-        Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options);
-        Task DisconnectAsync();
-
-        Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
-        Task UnsubscribeAsync(IEnumerable<string> topics);
-    }
-}
@@ -1,10 +0,0 @@
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-
-namespace MQTTnet.Client
-{
-    public interface IMqttClientAdapterFactory
-    {
-        IMqttChannelAdapter CreateClientAdapter(IMqttClientChannelOptions options, IMqttNetLogger logger);
-    }
-}
@@ -1,16 +0,0 @@
-using MQTTnet.Diagnostics;
-using MQTTnet.ManagedClient;
-
-namespace MQTTnet.Client
-{
-    public interface IMqttClientFactory
-    {
-        IMqttClient CreateMqttClient();
-
-        IMqttClient CreateMqttClient(IMqttNetLogger logger);
-        
-        IManagedMqttClient CreateManagedMqttClient();
-
-        IManagedMqttClient CreateManagedMqttClient(IMqttNetLogger logger);
-    }
-}
@@ -1,22 +0,0 @@
-using System;
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Client
-{
-    public interface IMqttClientOptions
-    {
-        string ClientId { get; }
-
-        IMqttClientCredentials Credentials { get; }
-        bool CleanSession { get; }
-        MqttApplicationMessage WillMessage { get; }
-        
-        TimeSpan CommunicationTimeout { get; }
-        TimeSpan KeepAlivePeriod { get; }
-        TimeSpan? KeepAliveSendInterval { get; set; }
-
-        MqttProtocolVersion ProtocolVersion { get; }
-
-        IMqttClientChannelOptions ChannelOptions { get; }
-    }
-}
@@ -1,516 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-using MQTTnet.Exceptions;
-using MQTTnet.Internal;
-using MQTTnet.Packets;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Client
-{
-    public class MqttClient : IMqttClient
-    {
-        private readonly MqttPacketIdentifierProvider _packetIdentifierProvider = new MqttPacketIdentifierProvider();
-        private readonly Stopwatch _sendTracker = new Stopwatch();
-        private readonly SemaphoreSlim _disconnectLock = new SemaphoreSlim(1, 1);
-        private readonly IMqttClientAdapterFactory _adapterFactory;
-        private readonly MqttPacketDispatcher _packetDispatcher;
-        private readonly IMqttNetLogger _logger;
-
-        private IMqttClientOptions _options;
-        private bool _isReceivingPackets;
-        private CancellationTokenSource _cancellationTokenSource;
-        private Task _packetReceiverTask;
-        private Task _keepAliveMessageSenderTask;
-        private IMqttChannelAdapter _adapter;
-
-        public MqttClient(IMqttClientAdapterFactory channelFactory, IMqttNetLogger logger)
-        {
-            _adapterFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-
-            _packetDispatcher = new MqttPacketDispatcher(logger);
-        }
-
-        public event EventHandler<MqttClientConnectedEventArgs> Connected;
-        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
-        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
-
-        public bool IsConnected { get; private set; }
-
-        public async Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-            if (options.ChannelOptions == null) throw new ArgumentException("ChannelOptions are not set.");
-
-            ThrowIfConnected("It is not allowed to connect with a server after the connection is established.");
-
-            try
-            {
-                _options = options;
-                _cancellationTokenSource = new CancellationTokenSource();
-                _packetIdentifierProvider.Reset();
-                _packetDispatcher.Reset();
-
-                _adapter = _adapterFactory.CreateClientAdapter(options.ChannelOptions, _logger);
-
-                _logger.Trace<MqttClient>("Trying to connect with server.");
-                await _adapter.ConnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
-                _logger.Trace<MqttClient>("Connection with server established.");
-
-                await StartReceivingPacketsAsync().ConfigureAwait(false);
-
-                var connectResponse = await AuthenticateAsync(options.WillMessage).ConfigureAwait(false);
-                _logger.Trace<MqttClient>("MQTT connection with server established.");
-
-                _sendTracker.Restart();
-
-                if (_options.KeepAlivePeriod != TimeSpan.Zero)
-                {
-                    StartSendingKeepAliveMessages();
-                }
-
-                IsConnected = true;
-                Connected?.Invoke(this, new MqttClientConnectedEventArgs(connectResponse.IsSessionPresent));
-                return new MqttClientConnectResult(connectResponse.IsSessionPresent);
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<MqttClient>(exception, "Error while connecting with server.");
-                await DisconnectInternalAsync(exception).ConfigureAwait(false);
-
-                throw;
-            }
-        }
-
-        public async Task DisconnectAsync()
-        {
-            if (!IsConnected)
-            {
-                return;
-            }
-
-            try
-            {
-                if (!_cancellationTokenSource.IsCancellationRequested)
-                {
-                    await SendAsync(new MqttDisconnectPacket()).ConfigureAwait(false);
-                }
-            }
-            finally
-            {
-                await DisconnectInternalAsync(null).ConfigureAwait(false);
-            }
-        }
-
-        public async Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
-        {
-            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
-
-            ThrowIfNotConnected();
-
-            var subscribePacket = new MqttSubscribePacket
-            {
-                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
-                TopicFilters = topicFilters.ToList()
-            };
-
-            var response = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket).ConfigureAwait(false);
-
-            if (response.SubscribeReturnCodes.Count != subscribePacket.TopicFilters.Count)
-            {
-                throw new MqttProtocolViolationException("The return codes are not matching the topic filters [MQTT-3.9.3-1].");
-            }
-
-            return subscribePacket.TopicFilters.Select((t, i) => new MqttSubscribeResult(t, response.SubscribeReturnCodes[i])).ToList();
-        }
-
-        public async Task UnsubscribeAsync(IEnumerable<string> topicFilters)
-        {
-            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
-
-            ThrowIfNotConnected();
-
-            var unsubscribePacket = new MqttUnsubscribePacket
-            {
-                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
-                TopicFilters = topicFilters.ToList()
-            };
-
-            await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket).ConfigureAwait(false);
-        }
-
-        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
-        {
-            ThrowIfNotConnected();
-
-            var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
-            var packetGroups = publishPackets.GroupBy(p => p.QualityOfServiceLevel).OrderBy(g => g.Key);
-
-            foreach (var qosGroup in packetGroups)
-            {
-                switch (qosGroup.Key)
-                {
-                    case MqttQualityOfServiceLevel.AtMostOnce:
-                        {
-                            // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
-                            await SendAsync((MqttPublishPacket[])qosGroup.ToArray()).ConfigureAwait(false);
-                            break;
-                        }
-                    case MqttQualityOfServiceLevel.AtLeastOnce:
-                        {
-                            foreach (var publishPacket in qosGroup)
-                            {
-                                publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
-                                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket).ConfigureAwait(false);
-                            }
-
-                            break;
-                        }
-                    case MqttQualityOfServiceLevel.ExactlyOnce:
-                        {
-                            foreach (var publishPacket in qosGroup)
-                            {
-                                publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
-
-                                var pubRecPacket = await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket).ConfigureAwait(false);
-                                var pubRelPacket = new MqttPubRelPacket
-                                {
-                                    PacketIdentifier = pubRecPacket.PacketIdentifier
-                                };
-
-                                await SendAndReceiveAsync<MqttPubCompPacket>(pubRelPacket).ConfigureAwait(false);
-                            }
-
-                            break;
-                        }
-                    default:
-                        {
-                            throw new InvalidOperationException();
-                        }
-                }
-            }
-        }
-
-        public void Dispose()
-        {
-            _cancellationTokenSource?.Dispose();
-            _cancellationTokenSource = null;
-
-            _adapter?.Dispose();
-        }
-
-        private async Task<MqttConnAckPacket> AuthenticateAsync(MqttApplicationMessage willApplicationMessage)
-        {
-            var connectPacket = new MqttConnectPacket
-            {
-                ClientId = _options.ClientId,
-                Username = _options.Credentials?.Username,
-                Password = _options.Credentials?.Password,
-                CleanSession = _options.CleanSession,
-                KeepAlivePeriod = (ushort)_options.KeepAlivePeriod.TotalSeconds,
-                WillMessage = willApplicationMessage
-            };
-
-            var response = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket).ConfigureAwait(false);
-            if (response.ConnectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
-            {
-                throw new MqttConnectingFailedException(response.ConnectReturnCode);
-            }
-
-            return response;
-        }
-
-        private void ThrowIfNotConnected()
-        {
-            if (!IsConnected) throw new MqttCommunicationException("The client is not connected.");
-        }
-
-        private void ThrowIfConnected(string message)
-        {
-            if (IsConnected) throw new MqttProtocolViolationException(message);
-        }
-
-        private async Task DisconnectInternalAsync(Exception exception)
-        {
-            await _disconnectLock.WaitAsync();
-            var clientWasConnected = IsConnected;
-            try
-            {
-                IsConnected = false;
-
-                if (_cancellationTokenSource == null || _cancellationTokenSource.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                _cancellationTokenSource.Cancel(false);
-
-                if (_packetReceiverTask != null)
-                {
-                    Task.WaitAll(_packetReceiverTask);
-                }
-
-                if (_keepAliveMessageSenderTask != null)
-                {
-                    Task.WaitAll(_keepAliveMessageSenderTask);
-                }
-
-                await _adapter.DisconnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
-                _logger.Trace<MqttClient>("Disconnected from adapter.");
-            }
-            catch (Exception adapterException)
-            {
-                _logger.Warning<MqttClient>(adapterException, "Error while disconnecting from adapter.");
-            }
-            finally
-            {
-                _adapter?.Dispose();
-                _adapter = null;
-
-                _cancellationTokenSource?.Dispose();
-                _cancellationTokenSource = null;
-
-                _disconnectLock.Release();
-                
-                _logger.Info<MqttClient>("Disconnected.");
-                Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected, exception));
-            }
-        }
-
-        private async Task ProcessReceivedPacketAsync(MqttBasePacket packet)
-        {
-            try
-            {
-                _logger.Info<MqttClient>("Received <<< {0}", packet);
-
-                if (packet is MqttPublishPacket publishPacket)
-                {
-                    await ProcessReceivedPublishPacketAsync(publishPacket).ConfigureAwait(false);
-                    return;
-                }
-
-                if (packet is MqttPingReqPacket)
-                {
-                    await SendAsync(new MqttPingRespPacket()).ConfigureAwait(false);
-                    return;
-                }
-
-                if (packet is MqttDisconnectPacket)
-                {
-                    await DisconnectAsync().ConfigureAwait(false);
-                    return;
-                }
-
-                if (packet is MqttPubRelPacket pubRelPacket)
-                {
-                    await ProcessReceivedPubRelPacket(pubRelPacket).ConfigureAwait(false);
-                    return;
-                }
-
-                _packetDispatcher.Dispatch(packet);
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<MqttClient>(exception, "Unhandled exception while processing received packet.");
-            }
-        }
-
-        private void FireApplicationMessageReceivedEvent(MqttPublishPacket publishPacket)
-        {
-            try
-            {
-                var applicationMessage = publishPacket.ToApplicationMessage();
-                ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(_options.ClientId, applicationMessage));
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<MqttClient>(exception, "Unhandled exception while handling application message.");
-            }
-        }
-
-        private Task ProcessReceivedPublishPacketAsync(MqttPublishPacket publishPacket)
-        {
-            if (_cancellationTokenSource.IsCancellationRequested)
-            {
-                return Task.FromResult(0);
-            }
-
-            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
-            {
-                FireApplicationMessageReceivedEvent(publishPacket);
-                return Task.FromResult(0);
-            }
-
-            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
-            {
-                FireApplicationMessageReceivedEvent(publishPacket);
-                return SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier });
-            }
-
-            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
-            {
-                // QoS 2 is implement as method "B" [4.3.3 QoS 2: Exactly once delivery]
-                FireApplicationMessageReceivedEvent(publishPacket);
-                return SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier });
-            }
-
-            throw new MqttCommunicationException("Received a not supported QoS level.");
-        }
-
-        private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
-        {
-            var response = new MqttPubCompPacket
-            {
-                PacketIdentifier = pubRelPacket.PacketIdentifier
-            };
-
-            return SendAsync(response);
-        }
-
-        private Task SendAsync(params MqttBasePacket[] packets)
-        {
-            _sendTracker.Restart();
-            return _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, packets);
-        }
-
-        private async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket) where TResponsePacket : MqttBasePacket
-        {
-            ushort? identifier = null;
-            if (requestPacket is IMqttPacketWithIdentifier requestPacketWithIdentifier)
-            {
-                identifier = requestPacketWithIdentifier.PacketIdentifier;
-            }
-
-            var packetAwaiter = _packetDispatcher.WaitForPacketAsync(typeof(TResponsePacket), identifier, _options.CommunicationTimeout);
-            await SendAsync(requestPacket).ConfigureAwait(false);
-
-            return (TResponsePacket)await packetAwaiter.ConfigureAwait(false);
-        }
-
-        private async Task SendKeepAliveMessagesAsync()
-        {
-            _logger.Info<MqttClient>("Start sending keep alive packets.");
-
-            try
-            {
-                while (!_cancellationTokenSource.Token.IsCancellationRequested)
-                {
-                    var keepAliveSendInterval = TimeSpan.FromSeconds(_options.KeepAlivePeriod.TotalSeconds * 0.75);
-                    if (_options.KeepAliveSendInterval.HasValue)
-                    {
-                        keepAliveSendInterval = _options.KeepAliveSendInterval.Value;
-                    }
-
-                    if (_sendTracker.Elapsed > keepAliveSendInterval)
-                    {
-                        await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket()).ConfigureAwait(false);
-                    }
-
-                    await Task.Delay(keepAliveSendInterval, _cancellationTokenSource.Token).ConfigureAwait(false);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (Exception exception)
-            {
-                if (_cancellationTokenSource.Token.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                if (exception is MqttCommunicationException)
-                {
-                    _logger.Warning<MqttClient>(exception, "MQTT communication exception while sending/receiving keep alive packets.");
-                }
-                else
-                {
-                    _logger.Warning<MqttClient>(exception, "Unhandled exception while sending/receiving keep alive packets.");
-
-                }
-
-                await DisconnectInternalAsync(exception).ConfigureAwait(false);
-            }
-            finally
-            {
-                _logger.Info<MqttClient>("Stopped sending keep alive packets.");
-            }
-        }
-
-        private async Task ReceivePacketsAsync()
-        {
-            _logger.Info<MqttClient>("Start receiving packets.");
-
-            try
-            {
-                while (!_cancellationTokenSource.Token.IsCancellationRequested)
-                {
-                    _isReceivingPackets = true;
-
-                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, _cancellationTokenSource.Token).ConfigureAwait(false);
-
-                    if (_cancellationTokenSource.Token.IsCancellationRequested)
-                    {
-                        return;
-                    }
-
-                    StartProcessReceivedPacket(packet);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (Exception exception)
-            {
-                if (_cancellationTokenSource.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                if (exception is MqttCommunicationException)
-                {
-                    _logger.Warning<MqttClient>(exception, "MQTT communication exception while receiving packets.");
-                }
-                else
-                {
-                    _logger.Error<MqttClient>(exception, "Unhandled exception while receiving packets.");
-
-                }
-
-                await DisconnectInternalAsync(exception).ConfigureAwait(false);
-            }
-            finally
-            {
-                _logger.Info<MqttClient>("Stopped receiving packets.");
-            }
-        }
-
-        private void StartProcessReceivedPacket(MqttBasePacket packet)
-        {
-            Task.Run(() => ProcessReceivedPacketAsync(packet), _cancellationTokenSource.Token);
-        }
-
-        private async Task StartReceivingPacketsAsync()
-        {
-            _isReceivingPackets = false;
-
-            _packetReceiverTask = Task.Run(ReceivePacketsAsync, _cancellationTokenSource.Token);
-
-            while (!_isReceivingPackets && !_cancellationTokenSource.Token.IsCancellationRequested)
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(100), _cancellationTokenSource.Token).ConfigureAwait(false);
-            }
-        }
-
-        private void StartSendingKeepAliveMessages()
-        {
-            _keepAliveMessageSenderTask = Task.Run(SendKeepAliveMessagesAsync, _cancellationTokenSource.Token);
-        }
-    }
-}
@@ -1,12 +0,0 @@
-namespace MQTTnet.Client
-{
-    public class MqttClientConnectResult
-    {
-        public MqttClientConnectResult(bool isSessionPresent)
-        {
-            IsSessionPresent = isSessionPresent;
-        }
-
-        public bool IsSessionPresent { get; }
-    }
-}
@@ -1,14 +0,0 @@
-using System;
-
-namespace MQTTnet.Client
-{
-    public class MqttClientConnectedEventArgs : EventArgs
-    {
-        public MqttClientConnectedEventArgs(bool isSessionPresent)
-        {
-            IsSessionPresent = isSessionPresent;
-        }
-
-        public bool IsSessionPresent { get; }
-    }
-}
@@ -1,17 +0,0 @@
-using System;
-
-namespace MQTTnet.Client
-{
-    public class MqttClientDisconnectedEventArgs : EventArgs
-    {
-        public MqttClientDisconnectedEventArgs(bool clientWasConnected, Exception exception)
-        {
-            ClientWasConnected = clientWasConnected;
-            Exception = exception;
-        }
-
-        public bool ClientWasConnected { get; }
-
-        public Exception Exception { get; }
-    }
-}
@@ -1,43 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Client
-{
-    public static class MqttClientExtensions
-    {
-        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, params TopicFilter[] topicFilters)
-        {
-            if (client == null) throw new ArgumentNullException(nameof(client));
-            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
-
-            return client.SubscribeAsync(topicFilters.ToList());
-        }
-
-        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
-        {
-            if (client == null) throw new ArgumentNullException(nameof(client));
-            if (topic == null) throw new ArgumentNullException(nameof(topic));
-
-            return client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
-        }
-
-        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, string topic)
-        {
-            if (client == null) throw new ArgumentNullException(nameof(client));
-            if (topic == null) throw new ArgumentNullException(nameof(topic));
-
-            return client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build());
-        }
-
-        public static Task UnsubscribeAsync(this IMqttClient client, params string[] topicFilters)
-        {
-            if (client == null) throw new ArgumentNullException(nameof(client));
-            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
-
-            return client.UnsubscribeAsync(topicFilters.ToList());
-        }
-    }
-}
@@ -1,26 +0,0 @@
-using System;
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Client
-{
-    public class MqttClientOptions : IMqttClientOptions
-    {
-        public MqttApplicationMessage WillMessage { get; set; }
-
-        public string ClientId { get; set; } = Guid.NewGuid().ToString("N");
-
-        public bool CleanSession { get; set; } = true;
-
-        public IMqttClientCredentials Credentials { get; set; } = new MqttClientCredentials();
-
-        public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(15);
-
-        public TimeSpan? KeepAliveSendInterval { get; set; }
-
-        public TimeSpan CommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
-
-        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
-
-        public IMqttClientChannelOptions ChannelOptions { get; set; }
-    }
-}
@@ -1,135 +0,0 @@
-using System;
-using System.Linq;
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Client
-{
-    public class MqttClientOptionsBuilder
-    {
-        private readonly MqttClientOptions _options = new MqttClientOptions();
-        private MqttClientTcpOptions _tcpOptions;
-        private MqttClientWebSocketOptions _webSocketOptions;
-
-        private MqttClientTlsOptions _tlsOptions;
-
-        public MqttClientOptionsBuilder WithProtocolVersion(MqttProtocolVersion value)
-        {
-            _options.ProtocolVersion = value;
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithCommunicationTimeout(TimeSpan value)
-        {
-            _options.CommunicationTimeout = value;
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithCleanSession(bool value = true)
-        {
-            _options.CleanSession = value;
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithKeepAlivePeriod(TimeSpan value)
-        {
-            _options.KeepAlivePeriod = value;
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithClientId(string value)
-        {
-            _options.ClientId = value;
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithWillMessage(MqttApplicationMessage value)
-        {
-            _options.WillMessage = value;
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithCredentials(string username, string password = null)
-        {
-            _options.Credentials = new MqttClientCredentials
-            {
-                Username = username,
-                Password = password
-            };
-
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithTcpServer(string server, int? port = null)
-        {
-            _tcpOptions = new MqttClientTcpOptions
-            {
-                Server = server,
-                Port = port
-            };
-
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithWebSocketServer(string uri)
-        {
-            _webSocketOptions = new MqttClientWebSocketOptions
-            {
-                Uri = uri
-            };
-
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithTls(
-            bool allowUntrustedCertificates = false,
-            bool ignoreCertificateChainErrors = false,
-            bool ignoreCertificateRevocationErrors = false,
-            params byte[][] certificates)
-        {
-            _tlsOptions = new MqttClientTlsOptions
-            {
-                UseTls = true,
-                AllowUntrustedCertificates = allowUntrustedCertificates,
-                IgnoreCertificateChainErrors = ignoreCertificateChainErrors,
-                IgnoreCertificateRevocationErrors = ignoreCertificateRevocationErrors,
-                Certificates = certificates?.ToList()
-            };
-
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithTls()
-        {
-            _tlsOptions = new MqttClientTlsOptions
-            {
-                UseTls = true
-            };
-
-            return this;
-        }
-
-        public IMqttClientOptions Build()
-        {
-            if (_tlsOptions != null)
-            {
-                if (_tcpOptions == null && _webSocketOptions == null)
-                {
-                    throw new InvalidOperationException("A channel (TCP or WebSocket) must be set if TLS is configured.");
-                }
-
-                if (_tcpOptions != null)
-                {
-                    _tcpOptions.TlsOptions = _tlsOptions;
-                }
-                else if (_webSocketOptions != null)
-                {
-                    _webSocketOptions.TlsOptions = _tlsOptions;
-                }
-            }
-
-            _options.ChannelOptions = (IMqttClientChannelOptions)_tcpOptions ?? _webSocketOptions;
-
-            return _options;
-        }
-    }
-}
@@ -1,13 +0,0 @@
-namespace MQTTnet.Client
-{
-    public class MqttClientTcpOptions : IMqttClientChannelOptions
-    {
-        public string Server { get; set; }
-
-        public int? Port { get; set; }
-
-        public int BufferSize { get; set; } = 20 * 4096;
-
-        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
-    }
-}
@@ -1,17 +0,0 @@
-using System.Collections.Generic;
-
-namespace MQTTnet.Client
-{
-    public class MqttClientTlsOptions
-    {
-        public bool UseTls { get; set; }
-
-        public bool IgnoreCertificateRevocationErrors { get; set; }
-
-        public bool IgnoreCertificateChainErrors { get; set; }
-
-        public bool AllowUntrustedCertificates { get; set; }
-
-        public List<byte[]> Certificates { get; set; }
-    }
-}
@@ -1,97 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Threading.Tasks;
-using MQTTnet.Diagnostics;
-using MQTTnet.Exceptions;
-using MQTTnet.Internal;
-using MQTTnet.Packets;
-
-namespace MQTTnet.Client
-{
-    public class MqttPacketDispatcher
-    {
-        private readonly ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>> _awaiters = new ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>>();
-        private readonly IMqttNetLogger _logger;
-
-        public MqttPacketDispatcher(IMqttNetLogger logger)
-        {
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        }
-
-        public async Task<MqttBasePacket> WaitForPacketAsync(Type responseType, ushort? identifier, TimeSpan timeout)
-        {
-            var packetAwaiter = AddPacketAwaiter(responseType, identifier);
-            try
-            {
-                return await packetAwaiter.Task.TimeoutAfter(timeout).ConfigureAwait(false);
-            }
-            catch (MqttCommunicationTimedOutException)
-            {
-                _logger.Warning<MqttPacketDispatcher>("Timeout while waiting for packet of type '{0}'.", responseType.Name);
-                throw;
-            }
-            finally
-            {
-                RemovePacketAwaiter(responseType, identifier);
-            }
-        }
-
-        public void Dispatch(MqttBasePacket packet)
-        {
-            if (packet == null) throw new ArgumentNullException(nameof(packet));
-
-            var type = packet.GetType();
-
-            if (_awaiters.TryGetValue(type, out var byId))
-            {
-                ushort? identifier = 0;
-                if (packet is IMqttPacketWithIdentifier packetWithIdentifier)
-                {
-                    identifier = packetWithIdentifier.PacketIdentifier;
-                }
-
-                if (byId.TryRemove(identifier.Value, out var tcs))
-                {
-                    tcs.TrySetResult(packet);
-                    return;
-                }
-            }
-
-            throw new InvalidOperationException($"Packet of type '{type.Name}' not handled or dispatched.");
-        }
-
-        public void Reset()
-        {
-            _awaiters.Clear();
-        }
-
-        private TaskCompletionSource<MqttBasePacket> AddPacketAwaiter(Type responseType, ushort? identifier)
-        {
-            var tcs = new TaskCompletionSource<MqttBasePacket>();
-
-            if (!identifier.HasValue)
-            {
-                identifier = 0;
-            }
-
-            var byId = _awaiters.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
-            if (!byId.TryAdd(identifier.Value, tcs))
-            {
-                throw new InvalidOperationException($"The packet dispatcher already has an awaiter for packet of type '{responseType}' with identifier {identifier}.");
-            }
-
-            return tcs;
-        }
-
-        private void RemovePacketAwaiter(Type responseType, ushort? identifier)
-        {
-            if (!identifier.HasValue)
-            {
-                identifier = 0;
-            }
-
-            var byId = _awaiters.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
-            byId.TryRemove(identifier.Value, out var _);
-        }
-    }
-}
@@ -1,17 +0,0 @@
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Client
-{
-    public class MqttSubscribeResult
-    {
-        public MqttSubscribeResult(TopicFilter topicFilter, MqttSubscribeReturnCode returnCode)
-        {
-            TopicFilter = topicFilter;
-            ReturnCode = returnCode;
-        }
-
-        public TopicFilter TopicFilter { get; }
-
-        public MqttSubscribeReturnCode ReturnCode { get; }
-    }
-}
@@ -1,21 +0,0 @@
-using System;
-
-namespace MQTTnet.Diagnostics
-{
-    public interface IMqttNetLogger
-    {
-        event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
-
-        void Trace<TSource>(string message, params object[] parameters);
-
-        void Info<TSource>(string message, params object[] parameters);
-
-        void Warning<TSource>(Exception exception, string message, params object[] parameters);
-
-        void Warning<TSource>(string message, params object[] parameters);
-
-        void Error<TSource>(Exception exception, string message, params object[] parameters);
-
-        void Error<TSource>(string message, params object[] parameters);
-    }
-}
@@ -1,43 +0,0 @@
-using System;
-
-namespace MQTTnet.Diagnostics
-{
-    public sealed class MqttNetLogMessage
-    {
-        public MqttNetLogMessage(string logId, DateTime timestamp, int threadId, string source, MqttNetLogLevel level, string message, Exception exception)
-        {
-            LogId = logId;
-            Timestamp = timestamp;
-            ThreadId = threadId;
-            Source = source;
-            Level = level;
-            Message = message;
-            Exception = exception;
-        }
-
-        public string LogId { get; }
-
-        public DateTime Timestamp { get; }
-
-        public int ThreadId { get; }
-
-        public string Source { get; }
-
-        public MqttNetLogLevel Level { get; }
-
-        public string Message { get; }
-
-        public Exception Exception { get; }
-
-        public override string ToString()
-        {
-            var result = $"[{Timestamp:O}] [{LogId}] [{ThreadId}] [{Source}] [{Level}]: {Message}";
-            if (Exception != null)
-            {
-                result += Environment.NewLine + Exception;
-            }
-
-            return result;
-        }
-    }
-}
@@ -1,14 +0,0 @@
-using System;
-
-namespace MQTTnet.Diagnostics
-{
-    public sealed class MqttNetLogMessagePublishedEventArgs : EventArgs
-    {
-        public MqttNetLogMessagePublishedEventArgs(MqttNetLogMessage logMessage)
-        {
-            TraceMessage = logMessage ?? throw new ArgumentNullException(nameof(logMessage));
-        }
-
-        public MqttNetLogMessage TraceMessage { get; }
-    }
-}
@@ -1,74 +0,0 @@
-using System;
-
-namespace MQTTnet.Diagnostics
-{
-    public class MqttNetLogger : IMqttNetLogger
-    {
-        private readonly string _logId;
-
-        public MqttNetLogger(string logId = null)
-        {
-            _logId = logId;
-        }
-
-        public event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
-
-        public void Trace<TSource>(string message, params object[] parameters)
-        {
-            Publish<TSource>(MqttNetLogLevel.Verbose, null, message, parameters);
-        }
-
-        public void Info<TSource>(string message, params object[] parameters)
-        {
-            Publish<TSource>(MqttNetLogLevel.Info, null, message, parameters);
-        }
-
-        public void Warning<TSource>(Exception exception, string message, params object[] parameters)
-        {
-            Publish<TSource>(MqttNetLogLevel.Warning, exception, message, parameters);
-        }
-
-        public void Warning<TSource>(string message, params object[] parameters)
-        {
-            Warning<TSource>(null, message, parameters);
-        }
-
-        public void Error<TSource>(Exception exception, string message, params object[] parameters)
-        {
-            Publish<TSource>(MqttNetLogLevel.Error, exception, message, parameters);
-        }
-
-        public void Error<TSource>(string message, params object[] parameters)
-        {
-            Warning<TSource>(null, message, parameters);
-        }
-
-        private void Publish<TSource>(MqttNetLogLevel logLevel, Exception exception, string message, object[] parameters)
-        {
-            var hasLocalListeners = LogMessagePublished != null;
-            var hasGlobalListeners = MqttNetGlobalLogger.HasListeners;
-
-            if (!hasLocalListeners && !hasGlobalListeners)
-            {
-                return;
-            }
-
-            if (parameters.Length > 0)
-            {
-                message = string.Format(message, parameters);
-            }
-
-            var traceMessage = new MqttNetLogMessage(_logId, DateTime.Now, Environment.CurrentManagedThreadId, typeof(TSource).Name, logLevel, message, exception);
-
-            if (hasGlobalListeners)
-            {
-                MqttNetGlobalLogger.Publish(traceMessage);
-            }
-
-            if (hasLocalListeners)
-            {
-                LogMessagePublished?.Invoke(this, new MqttNetLogMessagePublishedEventArgs(traceMessage));
-            }
-        }
-    }
-}
@@ -1,6 +0,0 @@
-namespace MQTTnet.Exceptions
-{
-    public sealed class MqttCommunicationTimedOutException : MqttCommunicationException
-    {
-    }
-}
@@ -1,10 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace MQTTnet
-{
-    public interface IApplicationMessagePublisher
-    {
-        Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages);
-    }
-}
@@ -1,9 +0,0 @@
-using System;
-
-namespace MQTTnet
-{
-    public interface IApplicationMessageReceiver
-    {
-        event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
-    }
-}
@@ -1,26 +0,0 @@
-using System;
-using MQTTnet.Adapter;
-using MQTTnet.Client;
-using MQTTnet.Diagnostics;
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Implementations
-{
-    public class MqttClientAdapterFactory : IMqttClientAdapterFactory
-    {
-        public IMqttChannelAdapter CreateClientAdapter(IMqttClientChannelOptions options, IMqttNetLogger logger)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            switch (options)
-            {
-                case MqttClientTcpOptions tcpOptions:
-                    return new MqttChannelAdapter(new MqttTcpChannel(tcpOptions), new MqttPacketSerializer(), logger);
-                case MqttClientWebSocketOptions webSocketOptions:
-                    return new MqttChannelAdapter(new MqttWebSocketChannel(webSocketOptions), new MqttPacketSerializer(), logger);
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-    }
-}
@@ -1,75 +0,0 @@
-#if WINDOWS_UWP
-using System;
-using System.Threading.Tasks;
-using Windows.Networking.Sockets;
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-using MQTTnet.Serializer;
-using MQTTnet.Server;
-
-namespace MQTTnet.Implementations
-{
-    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
-    {
-        private readonly IMqttNetLogger _logger;
-        private StreamSocketListener _defaultEndpointSocket;
-
-        public MqttServerAdapter(IMqttNetLogger logger)
-        {
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        }
-
-        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
-
-        public async Task StartAsync(IMqttServerOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            if (_defaultEndpointSocket != null) throw new InvalidOperationException("Server is already started.");
-            
-            if (options.DefaultEndpointOptions.IsEnabled)
-            {
-                _defaultEndpointSocket = new StreamSocketListener();
-                await _defaultEndpointSocket.BindServiceNameAsync(options.GetDefaultEndpointPort().ToString(), SocketProtectionLevel.PlainSocket);
-                _defaultEndpointSocket.ConnectionReceived += AcceptDefaultEndpointConnectionsAsync;
-            }
-
-            if (options.TlsEndpointOptions.IsEnabled)
-            {
-                throw new NotSupportedException("TLS servers are not supported for UWP apps.");
-            }
-        }
-
-        public Task StopAsync()
-        {
-            if (_defaultEndpointSocket != null)
-            {
-                _defaultEndpointSocket.ConnectionReceived -= AcceptDefaultEndpointConnectionsAsync;
-            }
-
-            _defaultEndpointSocket?.Dispose();
-            _defaultEndpointSocket = null;
-
-            return Task.FromResult(0);
-        }
-
-        public void Dispose()
-        {
-            StopAsync();
-        }
-
-        private void AcceptDefaultEndpointConnectionsAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
-        {
-            try
-            {
-                var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(args.Socket), new MqttPacketSerializer(), _logger);
-                ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
-            }
-        }
-    }
-}
-#endif
@@ -1,162 +0,0 @@
-#if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
-using System;
-using System.Net;
-using System.Net.Security;
-using System.Net.Sockets;
-using System.Security.Authentication;
-using System.Security.Cryptography.X509Certificates;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-using MQTTnet.Serializer;
-using MQTTnet.Server;
-
-namespace MQTTnet.Implementations
-{
-    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
-    {
-        private readonly IMqttNetLogger _logger;
-
-        private CancellationTokenSource _cancellationTokenSource;
-        private Socket _defaultEndpointSocket;
-        private Socket _tlsEndpointSocket;
-        private X509Certificate2 _tlsCertificate;
-
-        public MqttServerAdapter(IMqttNetLogger logger)
-        {
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-        }
-
-        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
-
-        public Task StartAsync(IMqttServerOptions options)
-        {
-            if (_cancellationTokenSource != null) throw new InvalidOperationException("Server is already started.");
-
-            _cancellationTokenSource = new CancellationTokenSource();
-
-            if (options.DefaultEndpointOptions.IsEnabled)
-            {
-                _defaultEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-                _defaultEndpointSocket.Bind(new IPEndPoint(options.DefaultEndpointOptions.BoundIPAddress, options.GetDefaultEndpointPort()));
-                _defaultEndpointSocket.Listen(options.ConnectionBacklog);
-
-                Task.Run(async () => await AcceptDefaultEndpointConnectionsAsync(_cancellationTokenSource.Token).ConfigureAwait(false), _cancellationTokenSource.Token).ConfigureAwait(false);
-            }
-
-            if (options.TlsEndpointOptions.IsEnabled)
-            {
-                if (options.TlsEndpointOptions.Certificate == null)
-                {
-                    throw new ArgumentException("TLS certificate is not set.");
-                }
-
-                _tlsCertificate = new X509Certificate2(options.TlsEndpointOptions.Certificate);
-                if (!_tlsCertificate.HasPrivateKey)
-                {
-                    throw new InvalidOperationException("The certificate for TLS encryption must contain the private key.");
-                }
-
-                _tlsEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-                _tlsEndpointSocket.Bind(new IPEndPoint(options.TlsEndpointOptions.BoundIPAddress, options.GetTlsEndpointPort()));
-                _tlsEndpointSocket.Listen(options.ConnectionBacklog);
-
-                Task.Run(async () => await AcceptTlsEndpointConnectionsAsync(_cancellationTokenSource.Token).ConfigureAwait(false), _cancellationTokenSource.Token).ConfigureAwait(false);
-            }
-
-            return Task.FromResult(0);
-        }
-
-        public Task StopAsync()
-        {
-            _cancellationTokenSource?.Cancel(false);
-            _cancellationTokenSource?.Dispose();
-            _cancellationTokenSource = null;
-
-            _defaultEndpointSocket?.Dispose();
-            _defaultEndpointSocket = null;
-
-            _tlsCertificate = null;
-            
-            _tlsEndpointSocket?.Dispose();
-            _tlsEndpointSocket = null;
-
-            return Task.FromResult(0);
-        }
-
-        public void Dispose()
-        {
-            StopAsync();
-        }
-
-        private async Task AcceptDefaultEndpointConnectionsAsync(CancellationToken cancellationToken)
-        {
-            while (!cancellationToken.IsCancellationRequested)
-            {
-                try
-                {
-                    //todo: else branch can be used with min dependency NET46
-#if NET452 || NET461
-                    var clientSocket = await Task.Factory.FromAsync(_defaultEndpointSocket.BeginAccept, _defaultEndpointSocket.EndAccept, null).ConfigureAwait(false);
-#else
-                    var clientSocket = await _defaultEndpointSocket.AcceptAsync().ConfigureAwait(false);
-#endif
-
-                    var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, null), new MqttPacketSerializer(), _logger);
-                    ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
-                }
-                catch (ObjectDisposedException)
-                {
-                    // It can happen that the listener socket is accessed after the cancellation token is already set and the listener socket is disposed.
-                }
-                catch (Exception exception)
-                {
-                    if (exception is SocketException s && s.SocketErrorCode == SocketError.OperationAborted)
-                    {
-                        return;
-                    }
-
-                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
-                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
-                }
-            }
-        }
-
-        private async Task AcceptTlsEndpointConnectionsAsync(CancellationToken cancellationToken)
-        {
-            while (!cancellationToken.IsCancellationRequested)
-            {
-                try
-                {
-#if NET452 || NET461
-                    var clientSocket = await Task.Factory.FromAsync(_tlsEndpointSocket.BeginAccept, _tlsEndpointSocket.EndAccept, null).ConfigureAwait(false);
-#else
-                    var clientSocket = await _tlsEndpointSocket.AcceptAsync().ConfigureAwait(false);
-#endif
-
-                    var sslStream = new SslStream(new NetworkStream(clientSocket));
-                    await sslStream.AuthenticateAsServerAsync(_tlsCertificate, false, SslProtocols.Tls12, false).ConfigureAwait(false);
-                    
-                    var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, sslStream), new MqttPacketSerializer(), _logger);
-                    ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
-                }
-                catch (ObjectDisposedException)
-                {
-                    // It can happen that the listener socket is accessed after the cancellation token is already set and the listener socket is disposed.
-                }
-                catch (Exception exception)
-                {
-                    if (exception is SocketException s && s.SocketErrorCode == SocketError.OperationAborted)
-                    {
-                        return;
-                    }
-
-                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at TLS endpoint.");
-                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
-                }
-            }
-        }
-    }
-}
-#endif
@@ -1,176 +0,0 @@
-#if WINDOWS_UWP
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
-using System.Threading.Tasks;
-using Windows.Networking;
-using Windows.Networking.Sockets;
-using Windows.Security.Cryptography.Certificates;
-using MQTTnet.Channel;
-using MQTTnet.Client;
-
-namespace MQTTnet.Implementations
-{
-    public sealed class MqttTcpChannel : IMqttChannel
-    {
-        // ReSharper disable once MemberCanBePrivate.Global
-        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
-        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
-
-        private readonly int _bufferSize = BufferSize;
-        private readonly MqttClientTcpOptions _options;
-
-        private StreamSocket _socket;
-
-        public MqttTcpChannel(MqttClientTcpOptions options)
-        {
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-            _bufferSize = _options.BufferSize;
-        }
-
-        public MqttTcpChannel(StreamSocket socket)
-        {
-            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
-
-            CreateStreams();
-        }
-
-        public Stream SendStream { get; private set; }
-        public Stream ReceiveStream { get; private set; }
-
-        public static Func<MqttClientTcpOptions, IEnumerable<ChainValidationResult>> CustomIgnorableServerCertificateErrorsResolver { get; set; }
-
-        public async Task ConnectAsync()
-        {
-            if (_socket == null)
-            {
-                _socket = new StreamSocket();
-            }
-
-            if (!_options.TlsOptions.UseTls)
-            {
-                await _socket.ConnectAsync(new HostName(_options.Server), _options.GetPort().ToString());
-            }
-            else
-            {
-                _socket.Control.ClientCertificate = LoadCertificate(_options);
-
-                foreach (var ignorableChainValidationResult in ResolveIgnorableServerCertificateErrors())
-                {
-                    _socket.Control.IgnorableServerCertificateErrors.Add(ignorableChainValidationResult);
-                }
-
-                await _socket.ConnectAsync(new HostName(_options.Server), _options.GetPort().ToString(), SocketProtectionLevel.Tls12);
-            }
-
-            CreateStreams();
-        }
-
-        public Task DisconnectAsync()
-        {
-            Dispose();
-            return Task.FromResult(0);
-        }
-
-        public void Dispose()
-        {
-            try
-            {
-                SendStream?.Dispose();
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            catch (NullReferenceException)
-            {
-            }
-            finally
-            {
-                SendStream = null;
-            }
-
-            try
-            {
-                ReceiveStream?.Dispose();
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            catch (NullReferenceException)
-            {
-            }
-            finally
-            {
-                ReceiveStream = null;
-            }
-
-            try
-            {
-                _socket?.Dispose();
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            catch (NullReferenceException)
-            {
-            }
-            finally
-            {
-                _socket = null;
-            }
-        }
-
-        private void CreateStreams()
-        {
-            SendStream = _socket.OutputStream.AsStreamForWrite(_bufferSize);
-            ReceiveStream = _socket.InputStream.AsStreamForRead(_bufferSize);
-        }
-
-        private static Certificate LoadCertificate(MqttClientTcpOptions options)
-        {
-            if (options.TlsOptions.Certificates == null || !options.TlsOptions.Certificates.Any())
-            {
-                return null;
-            }
-
-            if (options.TlsOptions.Certificates.Count > 1)
-            {
-                throw new NotSupportedException("Only one client certificate is supported for UWP.");
-            }
-
-            return new Certificate(options.TlsOptions.Certificates.First().AsBuffer());
-        }
-
-        private IEnumerable<ChainValidationResult> ResolveIgnorableServerCertificateErrors()
-        {
-            if (CustomIgnorableServerCertificateErrorsResolver != null)
-            {
-                return CustomIgnorableServerCertificateErrorsResolver(_options);
-            }
-
-            var result = new List<ChainValidationResult>();
-
-            if (_options.TlsOptions.IgnoreCertificateRevocationErrors)
-            {
-                result.Add(ChainValidationResult.RevocationInformationMissing);
-                //_socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Revoked); Not supported.
-                result.Add(ChainValidationResult.RevocationFailure);
-            }
-
-            if (_options.TlsOptions.IgnoreCertificateChainErrors)
-            {
-                result.Add(ChainValidationResult.IncompleteChain);
-            }
-
-            if (_options.TlsOptions.AllowUntrustedCertificates)
-            {
-                result.Add(ChainValidationResult.Untrusted);
-            }
-
-            return result;
-        }
-    }
-}
-#endif
@@ -1,223 +0,0 @@
-#if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
-using System;
-using System.Net.Security;
-using System.Net.Sockets;
-using System.Security.Authentication;
-using System.Security.Cryptography.X509Certificates;
-using System.Threading.Tasks;
-using System.IO;
-using System.Linq;
-using MQTTnet.Channel;
-using MQTTnet.Client;
-
-namespace MQTTnet.Implementations
-{
-    public sealed class MqttTcpChannel : IMqttChannel
-    {
-#if NET452 || NET461
-        // ReSharper disable once MemberCanBePrivate.Global
-        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
-        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
-
-        private readonly int _bufferSize = BufferSize;
-#else
-        private readonly int _bufferSize = 0;
-#endif
-
-        private readonly MqttClientTcpOptions _options;
-
-        private Socket _socket;
-        private SslStream _sslStream;
-
-        /// <summary>
-        /// called on client sockets are created in connect
-        /// </summary>
-        public MqttTcpChannel(MqttClientTcpOptions options)
-        {
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-            _bufferSize = options.BufferSize;
-        }
-
-        /// <summary>
-        /// called on server, sockets are passed in
-        /// connect will not be called
-        /// </summary>
-        public MqttTcpChannel(Socket socket, SslStream sslStream)
-        {
-            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
-            _sslStream = sslStream;
-
-            CreateStreams();
-        }
-
-        public Stream SendStream { get; private set; }
-        public Stream ReceiveStream { get; private set; }
-
-        public static Func<X509Certificate, X509Chain, SslPolicyErrors, MqttClientTcpOptions, bool> CustomCertificateValidationCallback { get; set; }
-
-        public async Task ConnectAsync()
-        {
-            if (_socket == null)
-            {
-                _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-            }
-
-#if NET452 || NET461
-            await Task.Factory.FromAsync(_socket.BeginConnect, _socket.EndConnect, _options.Server, _options.GetPort(), null).ConfigureAwait(false);
-#else
-            await _socket.ConnectAsync(_options.Server, _options.GetPort()).ConfigureAwait(false);
-#endif
-
-            if (_options.TlsOptions.UseTls)
-            {
-                _sslStream = new SslStream(new NetworkStream(_socket, true), false, InternalUserCertificateValidationCallback);
-                await _sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(), SslProtocols.Tls12, _options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
-            }
-            
-            CreateStreams();
-        }
-
-        public Task DisconnectAsync()
-        {
-            Dispose();
-            return Task.FromResult(0);
-        }
-
-        public void Dispose()
-        {
-            var oneStreamIsUsed = SendStream != null && ReceiveStream != null && ReferenceEquals(SendStream, ReceiveStream);
-
-            try
-            {
-                SendStream?.Dispose();
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            catch (NullReferenceException)
-            {
-            }
-            finally
-            {
-                SendStream = null;
-            }
-
-            try
-            {
-                if (!oneStreamIsUsed)
-                {
-                    ReceiveStream?.Dispose();
-                }
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            catch (NullReferenceException)
-            {
-            }
-            finally
-            {
-                ReceiveStream = null;
-            }
-
-            try
-            {
-                _sslStream?.Dispose();
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            catch (NullReferenceException)
-            {
-            }
-            finally
-            {
-                _sslStream = null;
-            }
-
-            try
-            {
-                _socket?.Dispose();
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            catch (NullReferenceException)
-            {
-            }
-            finally
-            {
-                _socket = null;
-            }
-        }
-
-        private bool InternalUserCertificateValidationCallback(object sender, X509Certificate x509Certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
-        {
-            if (CustomCertificateValidationCallback != null)
-            {
-                return CustomCertificateValidationCallback(x509Certificate, chain, sslPolicyErrors, _options);
-            }
-
-            if (sslPolicyErrors == SslPolicyErrors.None)
-            {
-                return true;
-            }
-
-            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.RevocationStatusUnknown || c.Status == X509ChainStatusFlags.Revoked || c.Status == X509ChainStatusFlags.RevocationStatusUnknown))
-            {
-                if (!_options.TlsOptions.IgnoreCertificateRevocationErrors)
-                {
-                    return false;
-                }
-            }
-
-            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.PartialChain))
-            {
-                if (!_options.TlsOptions.IgnoreCertificateChainErrors)
-                {
-                    return false;
-                }
-            }
-
-            return _options.TlsOptions.AllowUntrustedCertificates;
-        }
-
-        private X509CertificateCollection LoadCertificates()
-        {
-            var certificates = new X509CertificateCollection();
-            if (_options.TlsOptions.Certificates == null)
-            {
-                return certificates;
-            }
-
-            foreach (var certificate in _options.TlsOptions.Certificates)
-            {
-                certificates.Add(new X509Certificate2(certificate));
-            }
-
-            return certificates;
-        }
-
-        private void CreateStreams()
-        {
-            Stream stream;
-            if (_sslStream != null)
-            {
-                stream = _sslStream;
-            }
-            else
-            {
-                stream = new NetworkStream(_socket, true);
-            }
-            
-#if NET452 || NET461
-            SendStream = new BufferedStream(stream, _bufferSize);
-            ReceiveStream = new BufferedStream(stream, _bufferSize);
-#else
-            SendStream = stream;
-            ReceiveStream = stream;
-#endif
-        }
-    }
-}
-#endif
@@ -1,112 +0,0 @@
-using System;
-using System.IO;
-using System.Net.WebSockets;
-using System.Security.Cryptography.X509Certificates;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Channel;
-using MQTTnet.Client;
-
-namespace MQTTnet.Implementations
-{
-    public sealed class MqttWebSocketChannel : IMqttChannel, IDisposable
-    {
-        // ReSharper disable once MemberCanBePrivate.Global
-        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
-        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
-
-        private readonly MqttClientWebSocketOptions _options;
-        private ClientWebSocket _webSocket;
-
-        public MqttWebSocketChannel(MqttClientWebSocketOptions options)
-        {
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-        }
-
-        public Stream SendStream { get; private set; }
-        public Stream ReceiveStream { get; private set; }
-
-        public async Task ConnectAsync()
-        {
-            var uri = _options.Uri;
-            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
-            {
-                if (_options.TlsOptions?.UseTls == false)
-                {
-                    uri = "ws://" + uri;
-                }
-                else
-                {
-                    uri = "wss://" + uri;
-                }
-            }
-
-            _webSocket = new ClientWebSocket();
-            
-            if (_options.RequestHeaders != null)
-            {
-                foreach (var requestHeader in _options.RequestHeaders)
-                {
-                    _webSocket.Options.SetRequestHeader(requestHeader.Key, requestHeader.Value);
-                }    
-            }
-
-            if (_options.SubProtocols != null)
-            {
-                foreach (var subProtocol in _options.SubProtocols)
-                {
-                    _webSocket.Options.AddSubProtocol(subProtocol);
-                }
-            }
-
-            if (_options.CookieContainer != null)
-            {
-                _webSocket.Options.Cookies = _options.CookieContainer;
-            }
-
-            if (_options.TlsOptions?.UseTls == true && _options.TlsOptions?.Certificates != null)
-            {
-                _webSocket.Options.ClientCertificates = new X509CertificateCollection();
-                foreach (var certificate in _options.TlsOptions.Certificates)
-                {
-                    _webSocket.Options.ClientCertificates.Add(new X509Certificate(certificate));
-                }
-            }
-
-            await _webSocket.ConnectAsync(new Uri(uri), CancellationToken.None).ConfigureAwait(false);
-
-            SendStream = new WebSocketStream(_webSocket);
-            ReceiveStream = SendStream;
-        }
-
-        public async Task DisconnectAsync()
-        {
-            if (_webSocket == null)
-            {
-                return;
-            }
-
-            if (_webSocket.State == WebSocketState.Open || _webSocket.State == WebSocketState.Connecting)
-            {
-                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
-            }
-
-            Dispose();
-        }
-
-        public void Dispose()
-        {
-            try
-            {
-                _webSocket?.Dispose();
-            }
-            catch (ObjectDisposedException)
-            {
-            }
-            finally
-            {
-                _webSocket = null;
-            }            
-        }
-    }
-}
@@ -1,137 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Net.WebSockets;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Exceptions;
-
-namespace MQTTnet.Implementations
-{
-    public class WebSocketStream : Stream
-    {
-        private readonly byte[] _chunckBuffer = new byte[MqttWebSocketChannel.BufferSize];
-        private readonly Queue<byte> _buffer = new Queue<byte>(MqttWebSocketChannel.BufferSize);
-        private readonly WebSocket _webSocket;
-
-        public WebSocketStream(WebSocket webSocket)
-        {
-            _webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
-        }
-
-        public override bool CanRead => true;
-
-        public override bool CanSeek => false;
-
-        public override bool CanWrite => true;
-
-        public override long Length => throw new NotSupportedException();
-
-        public override long Position
-        {
-            get => throw new NotSupportedException();
-            set => throw new NotSupportedException();
-        }
-
-        public override void Flush()
-        {
-        }
-
-        public override Task FlushAsync(CancellationToken cancellationToken)
-        {
-            return Task.FromResult(0);
-        }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
-        }
-
-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
-        {
-            var bytesRead = 0;
-
-            // Use existing date from buffer.
-            while (count > 0 && _buffer.Any())
-            {
-                buffer[offset] = _buffer.Dequeue();
-                count--;
-                bytesRead++;
-                offset++;
-            }
-
-            if (count == 0)
-            {
-                return bytesRead;
-            }
-
-            // Fetch new data if the buffer is not full.
-            while (_webSocket.State == WebSocketState.Open)
-            {
-                await FetchChunkAsync(cancellationToken).ConfigureAwait(false);
-
-                while (count > 0 && _buffer.Any())
-                {
-                    buffer[offset] = _buffer.Dequeue();
-                    count--;
-                    bytesRead++;
-                    offset++;
-                }
-
-                if (count == 0)
-                {
-                    return bytesRead;
-                }
-            }
-
-            if (_webSocket.State == WebSocketState.Closed)
-            {
-                throw new MqttCommunicationException("WebSocket connection closed.");
-            }
-
-            return bytesRead;
-        }
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
-        }
-
-        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
-        {
-            return _webSocket.SendAsync(new ArraySegment<byte>(buffer, offset, count), WebSocketMessageType.Binary, true, cancellationToken);
-        }
-
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            throw new NotSupportedException();
-        }
-
-        public override void SetLength(long value)
-        {
-            throw new NotSupportedException();
-        }
-
-        private async Task FetchChunkAsync(CancellationToken cancellationToken)
-        {   
-            var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(_chunckBuffer, 0, _chunckBuffer.Length), cancellationToken).ConfigureAwait(false);
-
-            if (response.MessageType == WebSocketMessageType.Close)
-            {
-                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
-            }
-            else if (response.MessageType == WebSocketMessageType.Binary)
-            {
-                for (var i = 0; i < response.Count; i++)
-                {
-                    _buffer.Enqueue(_chunckBuffer[i]);
-                }
-            }
-            else if (response.MessageType == WebSocketMessageType.Text)
-            {
-                throw new MqttProtocolViolationException("WebSocket channel received TEXT message.");
-            }
-        }
-    }
-}
@@ -1,35 +0,0 @@
-using MQTTnet.Packets;
-
-namespace MQTTnet.Internal
-{
-    internal static class MqttApplicationMessageExtensions
-    {
-        public static MqttApplicationMessage ToApplicationMessage(this MqttPublishPacket publishPacket)
-        {
-            return new MqttApplicationMessage
-            { 
-                Topic = publishPacket.Topic,
-                Payload = publishPacket.Payload,
-                QualityOfServiceLevel = publishPacket.QualityOfServiceLevel,
-                Retain = publishPacket.Retain
-            };
-        }
-
-        public static MqttPublishPacket ToPublishPacket(this MqttApplicationMessage applicationMessage)
-        {
-            if (applicationMessage == null)
-            {
-                return null;
-            }
-
-            return new MqttPublishPacket
-            {
-                Topic = applicationMessage.Topic,
-                Payload = applicationMessage.Payload,
-                QualityOfServiceLevel = applicationMessage.QualityOfServiceLevel,
-                Retain = applicationMessage.Retain,
-                Dup = false
-            };
-        }
-    }
-}
@@ -1,78 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Exceptions;
-
-namespace MQTTnet.Internal
-{
-    public static class TaskExtensions
-    {
-        public static async Task TimeoutAfter(this Task task, TimeSpan timeout)
-        {
-            if (task == null) throw new ArgumentNullException(nameof(task));
-
-            using (var timeoutCts = new CancellationTokenSource())
-            {
-                try
-                {
-                    var timeoutTask = Task.Delay(timeout, timeoutCts.Token);
-                    var finishedTask = await Task.WhenAny(timeoutTask, task).ConfigureAwait(false);
-                    
-                    if (finishedTask == timeoutTask)
-                    {
-                        throw new MqttCommunicationTimedOutException();
-                    }
-
-                    if (task.IsCanceled)
-                    {
-                        throw new TaskCanceledException();
-                    }
-
-                    if (task.IsFaulted)
-                    {
-                        throw new MqttCommunicationException(task.Exception?.GetBaseException());
-                    }
-                }
-                finally
-                {
-                    timeoutCts.Cancel();
-                }
-            }
-        }
-
-        public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout)
-        {
-            if (task == null) throw new ArgumentNullException(nameof(task));
-
-            using (var timeoutCts = new CancellationTokenSource())
-            {
-                try
-                {
-                    var timeoutTask = Task.Delay(timeout, timeoutCts.Token);
-                    var finishedTask = await Task.WhenAny(timeoutTask, task).ConfigureAwait(false);
-
-                    if (finishedTask == timeoutTask)
-                    {
-                        throw new MqttCommunicationTimedOutException();
-                    }
-
-                    if (task.IsCanceled)
-                    {
-                        throw new TaskCanceledException();
-                    }
-
-                    if (task.IsFaulted)
-                    {
-                        throw new MqttCommunicationException(task.Exception.GetBaseException());
-                    }
-
-                    return task.Result;
-                }
-                finally
-                {
-                    timeoutCts.Cancel();
-                }
-            }
-        }
-    }
-}
@@ -1,65 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
-    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.3;netstandard2.0</TargetFrameworks>
-    <AssemblyName>MQTTnet</AssemblyName>
-    <RootNamespace>MQTTnet</RootNamespace>
-    <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
-    <DebugType>Full</DebugType>
-    <AssemblyVersion>0.0.0.0</AssemblyVersion>
-    <FileVersion>0.0.0.0</FileVersion>
-    <Version>0.0.0.0</Version>
-    <Company />
-    <Product />
-    <Description />
-    <Authors />
-    <PackageId />
-    <SignAssembly>false</SignAssembly>
-    <DelaySign>false</DelaySign>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
-    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
-    <NugetTargetMoniker>UAP,Version=v10.0</NugetTargetMoniker>
-    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
-    <TargetPlatformVersion>10.0.16299.0</TargetPlatformVersion>
-    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
-    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
-    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
-    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
-    <DefaultLanguage>en</DefaultLanguage>
-    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'" />
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
-
-  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|netstandard1.3|AnyCPU'">
-    <DefineConstants>RELEASE;NETSTANDARD1_3</DefineConstants>
-  </PropertyGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">
-    <PackageReference Include="System.Net.Security" Version="4.3.2" />
-    <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
-    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='netstandard1.3'">
-    <PackageReference Include="System.Net.Security" Version="4.3.2" />
-    <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
-    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='uap10.0'">
-    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="5.4.1" />
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='net452'">
-  </ItemGroup>
-
-  <ItemGroup Condition="'$(TargetFramework)'=='net461'">
-  </ItemGroup>
-
-</Project>
@@ -1,24 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using MQTTnet.Client;
-
-namespace MQTTnet.ManagedClient
-{
-    public interface IManagedMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
-    {
-        bool IsStarted { get; }
-        bool IsConnected { get; }
-
-        event EventHandler<MqttClientConnectedEventArgs> Connected;
-        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
-
-        event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
-
-        Task StartAsync(IManagedMqttClientOptions options);
-        Task StopAsync();
-
-        Task SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
-        Task UnsubscribeAsync(IEnumerable<string> topics);
-    }
-}
@@ -1,14 +0,0 @@
-using System;
-using MQTTnet.Client;
-
-namespace MQTTnet.ManagedClient
-{
-    public interface IManagedMqttClientOptions
-    {
-        IMqttClientOptions ClientOptions { get; }
-
-        TimeSpan AutoReconnectDelay { get; }
-
-        IManagedMqttClientStorage Storage { get; }
-    }
-}
@@ -1,12 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace MQTTnet.ManagedClient
-{
-    public interface IManagedMqttClientStorage
-    {
-        Task SaveQueuedMessagesAsync(IList<MqttApplicationMessage> messages);
-
-        Task<IList<MqttApplicationMessage>> LoadQueuedMessagesAsync();
-    }
-}
@@ -1,396 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Client;
-using MQTTnet.Diagnostics;
-using MQTTnet.Exceptions;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.ManagedClient
-{
-    public class ManagedMqttClient : IManagedMqttClient
-    {
-        private readonly BlockingCollection<MqttApplicationMessage> _messageQueue = new BlockingCollection<MqttApplicationMessage>();
-        private readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
-        private readonly SemaphoreSlim _subscriptionsSemaphore = new SemaphoreSlim(1, 1);
-        private readonly List<string> _unsubscriptions = new List<string>();
-
-        private readonly IMqttClient _mqttClient;
-        private readonly IMqttNetLogger _logger;
-
-        private CancellationTokenSource _connectionCancellationToken;
-        private CancellationTokenSource _publishingCancellationToken;
-
-        private ManagedMqttClientStorageManager _storageManager;
-        private IManagedMqttClientOptions _options;
-
-        private bool _subscriptionsNotPushed;
-
-        public ManagedMqttClient(IMqttClient mqttClient, IMqttNetLogger logger)
-        {
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
-
-            _mqttClient.Connected += OnConnected;
-            _mqttClient.Disconnected += OnDisconnected;
-            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
-        }
-
-        public bool IsConnected => _mqttClient.IsConnected;
-        public bool IsStarted => _connectionCancellationToken != null;
-
-        public event EventHandler<MqttClientConnectedEventArgs> Connected;
-        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
-        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
-        public event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
-        public event EventHandler SynchronizingSubscriptionsFailed;
-
-        public async Task StartAsync(IManagedMqttClientOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-            if (options.ClientOptions == null) throw new ArgumentException("The client options are not set.", nameof(options));
-
-            if (!options.ClientOptions.CleanSession)
-            {
-                throw new NotSupportedException("The managed client does not support existing sessions.");
-            }
-
-            if (_connectionCancellationToken != null) throw new InvalidOperationException("The managed client is already started.");
-
-            _options = options;
-
-            if (_options.Storage != null)
-            {
-                _storageManager = new ManagedMqttClientStorageManager(_options.Storage);
-                await _storageManager.LoadQueuedMessagesAsync().ConfigureAwait(false);
-            }
-
-            _connectionCancellationToken = new CancellationTokenSource();
-
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(async () => await MaintainConnectionAsync(_connectionCancellationToken.Token).ConfigureAwait(false), _connectionCancellationToken.Token).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-
-            _logger.Info<ManagedMqttClient>("Started");
-        }
-
-        public Task StopAsync()
-        {
-            StopPublishing();
-            StopMaintainingConnection();
-
-            while (_messageQueue.Any())
-            {
-                _messageQueue.Take();
-            }
-
-            return Task.FromResult(0);
-        }
-
-        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
-        {
-            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
-
-            foreach (var applicationMessage in applicationMessages)
-            {
-                if (_storageManager != null)
-                {
-                    await _storageManager.AddAsync(applicationMessage).ConfigureAwait(false);
-                }
-
-                _messageQueue.Add(applicationMessage);
-            }
-        }
-
-        public async Task SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
-        {
-            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
-
-            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                foreach (var topicFilter in topicFilters)
-                {
-                    _subscriptions[topicFilter.Topic] = topicFilter.QualityOfServiceLevel;
-                    _subscriptionsNotPushed = true;
-                }
-            }
-            finally
-            {
-                _subscriptionsSemaphore.Release();
-            }
-        }
-
-        public async Task UnsubscribeAsync(IEnumerable<string> topics)
-        {
-            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                foreach (var topic in topics)
-                {
-                    if (_subscriptions.Remove(topic))
-                    {
-                        _unsubscriptions.Add(topic);
-                        _subscriptionsNotPushed = true;
-                    }
-                }
-            }
-            finally
-            {
-                _subscriptionsSemaphore.Release();
-            }
-        }
-
-        public void Dispose()
-        {
-            _messageQueue?.Dispose();
-            _subscriptionsSemaphore?.Dispose();
-            _connectionCancellationToken?.Dispose();
-            _publishingCancellationToken?.Dispose();
-        }
-
-        private async Task MaintainConnectionAsync(CancellationToken cancellationToken)
-        {
-            try
-            {
-                while (!cancellationToken.IsCancellationRequested)
-                {
-                    await TryMaintainConnectionAsync(cancellationToken).ConfigureAwait(false);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while maintaining connection.");
-            }
-            finally
-            {
-                await _mqttClient.DisconnectAsync().ConfigureAwait(false);
-                _logger.Info<ManagedMqttClient>("Stopped");
-            }
-        }
-
-        private async Task TryMaintainConnectionAsync(CancellationToken cancellationToken)
-        {
-            try
-            {
-                var connectionState = await ReconnectIfRequiredAsync().ConfigureAwait(false);
-                if (connectionState == ReconnectionResult.NotConnected)
-                {
-                    StopPublishing();
-                    await Task.Delay(_options.AutoReconnectDelay, cancellationToken).ConfigureAwait(false);
-                    return;
-                }
-
-                if (connectionState == ReconnectionResult.Reconnected || _subscriptionsNotPushed)
-                {
-                    await SynchronizeSubscriptionsAsync().ConfigureAwait(false);
-
-                    StartPublishing();
-
-
-                    return;
-                }
-
-                if (connectionState == ReconnectionResult.StillConnected)
-                {
-                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (MqttCommunicationException exception)
-            {
-                _logger.Warning<ManagedMqttClient>(exception, "Communication exception while maintaining connection.");
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while maintaining connection.");
-            }
-        }
-
-        private async Task PublishQueuedMessagesAsync(CancellationToken cancellationToken)
-        {
-            try
-            {
-                while (!cancellationToken.IsCancellationRequested)
-                {
-                    var message = _messageQueue.Take(cancellationToken);
-                    if (message == null)
-                    {
-                        continue;
-                    }
-
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        continue;
-                    }
-
-                    await TryPublishQueuedMessageAsync(message).ConfigureAwait(false);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while publishing queued application messages.");
-            }
-            finally
-            {
-                _logger.Trace<ManagedMqttClient>("Stopped publishing messages.");
-            }
-        }
-
-        private async Task TryPublishQueuedMessageAsync(MqttApplicationMessage message)
-        {
-            Exception transmitException = null;
-            try
-            {
-                await _mqttClient.PublishAsync(message).ConfigureAwait(false);
-
-                if (_storageManager != null)
-                {
-                    await _storageManager.RemoveAsync(message).ConfigureAwait(false);
-                }
-            }
-            catch (MqttCommunicationException exception)
-            {
-                transmitException = exception;
-
-                _logger.Warning<ManagedMqttClient>(exception, "Publishing application message failed.");
-
-                if (message.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
-                {
-                    _messageQueue.Add(message);
-                }
-            }
-            catch (Exception exception)
-            {
-                transmitException = exception;
-                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while publishing queued application message.");
-            }
-            finally
-            {
-                ApplicationMessageProcessed?.Invoke(this, new ApplicationMessageProcessedEventArgs(message, transmitException));
-            }
-        }
-
-        private async Task SynchronizeSubscriptionsAsync()
-        {
-            _logger.Info<ManagedMqttClient>(nameof(ManagedMqttClient), "Synchronizing subscriptions");
-
-            List<TopicFilter> subscriptions;
-            List<string> unsubscriptions;
-
-            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                subscriptions = _subscriptions.Select(i => new TopicFilter(i.Key, i.Value)).ToList();
-
-                unsubscriptions = new List<string>(_unsubscriptions);
-                _unsubscriptions.Clear();
-
-                _subscriptionsNotPushed = false;
-            }
-            finally
-            {
-                _subscriptionsSemaphore.Release();
-            }
-            
-            if (!subscriptions.Any() && !unsubscriptions.Any())
-            {
-                return;
-            }
-
-            try
-            {
-                if (subscriptions.Any())
-                {
-                    await _mqttClient.SubscribeAsync(subscriptions).ConfigureAwait(false);
-                }
-
-                if (unsubscriptions.Any())
-                {
-                    await _mqttClient.UnsubscribeAsync(unsubscriptions).ConfigureAwait(false);
-                }
-            }
-            catch (Exception exception)
-            {
-                _logger.Warning<ManagedMqttClient>(exception, "Synchronizing subscriptions failed.");
-                _subscriptionsNotPushed = true;
-
-                SynchronizingSubscriptionsFailed?.Invoke(this, EventArgs.Empty);
-            }
-        }
-
-        private async Task<ReconnectionResult> ReconnectIfRequiredAsync()
-        {
-            if (_mqttClient.IsConnected)
-            {
-                return ReconnectionResult.StillConnected;
-            }
-
-            try
-            {
-                await _mqttClient.ConnectAsync(_options.ClientOptions).ConfigureAwait(false);
-                return ReconnectionResult.Reconnected;
-            }
-            catch (Exception)
-            {
-                return ReconnectionResult.NotConnected;
-            }
-        }
-
-        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
-        {
-            ApplicationMessageReceived?.Invoke(this, eventArgs);
-        }
-
-        private void OnDisconnected(object sender, MqttClientDisconnectedEventArgs eventArgs)
-        {
-            Disconnected?.Invoke(this, eventArgs);
-        }
-
-        private void OnConnected(object sender, MqttClientConnectedEventArgs eventArgs)
-        {
-            Connected?.Invoke(this, eventArgs);
-        }
-
-        private void StartPublishing()
-        {
-            if (_publishingCancellationToken != null)
-            {
-                StopPublishing();
-            }
-
-            var cts = new CancellationTokenSource();
-
-            _publishingCancellationToken = cts;
-
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(async () => await PublishQueuedMessagesAsync(cts.Token).ConfigureAwait(false), cts.Token).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        }
-
-        private void StopPublishing()
-        {
-            _publishingCancellationToken?.Cancel(false);
-            _publishingCancellationToken?.Dispose();
-            _publishingCancellationToken = null;
-        }
-
-        private void StopMaintainingConnection()
-        {
-            _connectionCancellationToken?.Cancel(false);
-            _connectionCancellationToken?.Dispose();
-            _connectionCancellationToken = null;
-        }
-    }
-}
@@ -1,39 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.ManagedClient
-{
-    public static class ManagedMqttClientExtensions
-    {
-        public static Task SubscribeAsync(this IManagedMqttClient managedClient, params TopicFilter[] topicFilters)
-        {
-            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
-
-            return managedClient.SubscribeAsync(topicFilters);
-        }
-
-        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
-        {
-            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
-            if (topic == null) throw new ArgumentNullException(nameof(topic));
-
-            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
-        }
-
-        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic)
-        {
-            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
-            if (topic == null) throw new ArgumentNullException(nameof(topic));
-
-            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build());
-        }
-
-        public static Task UnsubscribeAsync(this IManagedMqttClient managedClient, params string[] topicFilters)
-        {
-            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
-
-            return managedClient.UnsubscribeAsync(topicFilters);
-        }
-    }
-}
@@ -1,14 +0,0 @@
-using System;
-using MQTTnet.Client;
-
-namespace MQTTnet.ManagedClient
-{
-    public class ManagedMqttClientOptions : IManagedMqttClientOptions
-    {
-        public IMqttClientOptions ClientOptions { get; set; }
-
-        public TimeSpan AutoReconnectDelay { get; set; } = TimeSpan.FromSeconds(5);
-
-        public IManagedMqttClientStorage Storage { get; set; }
-    }
-}
@@ -1,67 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-
-namespace MQTTnet.ManagedClient
-{
-    public class ManagedMqttClientStorageManager
-    {
-        private readonly List<MqttApplicationMessage> _applicationMessages = new List<MqttApplicationMessage>();
-        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
-        private readonly IManagedMqttClientStorage _storage;
-
-        public ManagedMqttClientStorageManager(IManagedMqttClientStorage storage)
-        {
-            _storage = storage ?? throw new ArgumentNullException(nameof(storage));
-        }
-
-        public async Task LoadQueuedMessagesAsync()
-        {
-            var loadedMessages = await _storage.LoadQueuedMessagesAsync().ConfigureAwait(false);
-            foreach (var loadedMessage in loadedMessages)
-            {
-                _applicationMessages.Add(loadedMessage);
-            }
-        }
-
-        public async Task AddAsync(MqttApplicationMessage applicationMessage)
-        {
-            await _semaphore.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                _applicationMessages.Add(applicationMessage);
-                await SaveAsync().ConfigureAwait(false);
-            }
-            finally
-            {
-                _semaphore.Release();
-            }
-        }
-
-        public async Task RemoveAsync(MqttApplicationMessage applicationMessage)
-        {
-            await _semaphore.WaitAsync().ConfigureAwait(false);
-            try
-            {
-                var index = _applicationMessages.IndexOf(applicationMessage);
-                if (index == -1)
-                {
-                    return;
-                }
-
-                _applicationMessages.RemoveAt(index);
-                await SaveAsync().ConfigureAwait(false);
-            }
-            finally
-            {
-                _semaphore.Release();
-            }
-        }
-
-        private Task SaveAsync()
-        {
-            return _storage.SaveQueuedMessagesAsync(_applicationMessages);
-        }
-    }
-}
@@ -1,29 +0,0 @@
-using System;
-using MQTTnet.Protocol;
-
-namespace MQTTnet
-{
-    public sealed class MqttApplicationMessage
-    {
-        public MqttApplicationMessage()
-        {
-        }
-
-        [Obsolete("Use object initializer or _MqttApplicationMessageBuilder_ instead.")]
-        public MqttApplicationMessage(string topic, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, bool retain)
-        {
-            Topic = topic ?? throw new ArgumentNullException(nameof(topic));
-            Payload = payload ?? throw new ArgumentNullException(nameof(payload));
-            QualityOfServiceLevel = qualityOfServiceLevel;
-            Retain = retain;
-        }
-
-        public string Topic { get; set; }
-
-        public byte[] Payload { get; set; }
-
-        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
-
-        public bool Retain { get; set; }
-    }
-}
@@ -1,114 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using MQTTnet.Exceptions;
-using MQTTnet.Protocol;
-
-namespace MQTTnet
-{
-    public class MqttApplicationMessageBuilder
-    {
-        private MqttQualityOfServiceLevel _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce;
-        private string _topic;
-        private byte[] _payload;
-        private bool _retain;
-
-        public MqttApplicationMessageBuilder WithTopic(string topic)
-        {
-            _topic = topic;
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithPayload(IEnumerable<byte> payload)
-        {
-            if (payload == null)
-            {
-                _payload = null;
-                return this;
-            }
-
-            _payload = payload.ToArray();
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithPayload(MemoryStream payload)
-        {
-            if (payload == null)
-            {
-                _payload = null;
-                return this;
-            }
-
-            if (payload.Length == 0)
-            {
-                _payload = new byte[0];
-            }
-            else
-            {
-                _payload = new byte[payload.Length - payload.Position];
-                payload.Read(_payload, 0, _payload.Length);
-            }
-
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithPayload(string payload)
-        {
-            if (payload == null)
-            {
-                _payload = null;
-                return this;
-            }
-
-            _payload = string.IsNullOrEmpty(payload) ? new byte[0] : Encoding.UTF8.GetBytes(payload);
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithQualityOfServiceLevel(MqttQualityOfServiceLevel qualityOfServiceLevel)
-        {
-            _qualityOfServiceLevel = qualityOfServiceLevel;
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithRetainFlag(bool value = true)
-        {
-            _retain = value;
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithAtLeastOnceQoS()
-        {
-            _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce;
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithAtMostOnceQoS()
-        {
-            _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce;
-            return this;
-        }
-
-        public MqttApplicationMessageBuilder WithExactlyOnceQoS()
-        {
-            _qualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce;
-            return this;
-        }
-
-        public MqttApplicationMessage Build()
-        {
-            if (string.IsNullOrEmpty(_topic))
-            {
-                throw new MqttProtocolViolationException("Topic is not set.");
-            }
-
-            return new MqttApplicationMessage
-            {
-                Topic = _topic,
-                Payload = _payload ?? new byte[0],
-                QualityOfServiceLevel = _qualityOfServiceLevel,
-                Retain = _retain
-            };
-        }
-    }
-}
@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using MQTTnet.Adapter;
-using MQTTnet.Client;
-using MQTTnet.Diagnostics;
-using MQTTnet.Implementations;
-using MQTTnet.ManagedClient;
-using MQTTnet.Server;
-
-namespace MQTTnet
-{
-    public class MqttFactory : IMqttClientFactory, IMqttServerFactory
-    {
-        public IMqttClient CreateMqttClient()
-        {
-            return CreateMqttClient(new MqttNetLogger());
-        }
-
-        public IMqttClient CreateMqttClient(IMqttNetLogger logger)
-        {
-            if (logger == null) throw new ArgumentNullException(nameof(logger));
-
-            return new MqttClient(new MqttClientAdapterFactory(), logger);
-        }
-
-        public IManagedMqttClient CreateManagedMqttClient()
-        {
-            return new ManagedMqttClient(CreateMqttClient(), new MqttNetLogger());
-        }
-
-        public IManagedMqttClient CreateManagedMqttClient(IMqttNetLogger logger)
-        {
-            if (logger == null) throw new ArgumentNullException(nameof(logger));
-
-            return new ManagedMqttClient(CreateMqttClient(), logger);
-        }
-
-        public IMqttServer CreateMqttServer()
-        {
-            var logger = new MqttNetLogger();
-            return CreateMqttServer(new List<IMqttServerAdapter> { new MqttServerAdapter(logger) }, logger);
-        }
-
-        public IMqttServer CreateMqttServer(IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
-        {
-            if (adapters == null) throw new ArgumentNullException(nameof(adapters));
-            if (logger == null) throw new ArgumentNullException(nameof(logger));
-
-            return new MqttServer(adapters, logger);
-        }
-    }
-}
@@ -1,16 +0,0 @@
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Packets
-{
-    public sealed class MqttConnAckPacket : MqttBasePacket
-    {
-        public bool IsSessionPresent { get; set; }
-
-        public MqttConnectReturnCode ConnectReturnCode { get; set; }
-
-        public override string ToString()
-        {
-            return "ConnAck: [ConnectReturnCode=" + ConnectReturnCode + "] [IsSessionPresent=" + IsSessionPresent + "]";
-        }
-    }
-}
@@ -1,26 +0,0 @@
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Packets
-{
-    public sealed class MqttConnectPacket : MqttBasePacket
-    {
-        public MqttProtocolVersion ProtocolVersion { get; set; }
-
-        public string ClientId { get; set; }
-
-        public string Username { get; set; }
-
-        public string Password { get; set; }
-
-        public ushort KeepAlivePeriod { get; set; }
-
-        public bool CleanSession { get; set; }
-
-        public MqttApplicationMessage WillMessage { get; set; }
-
-        public override string ToString()
-        {
-            return "Connect: [ClientId=" + ClientId + "] [Username=" + Username + "] [Password=" + Password + "] [KeepAlivePeriod=" + KeepAlivePeriod + "] [CleanSession=" + CleanSession + "]";
-        }
-    }
-}
@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttDisconnectPacket : MqttBasePacket
-    {
-        public override string ToString()
-        {
-            return "Disconnect";
-        }
-    }
-}
@@ -1,13 +0,0 @@
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Packets
-{
-    public class MqttPacketHeader
-    {
-        public MqttControlPacketType ControlPacketType { get; set; }
-
-        public byte FixedHeader { get; set; }
-
-        public int BodyLength { get; set; }
-    }
-}
@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubAckPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubAck";
-        }
-    }
-}
@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubCompPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubComp";
-        }
-    }
-}
@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubRecPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubRec";
-        }
-    }
-}
@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubRelPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubRel";
-        }
-    }
-}
@@ -1,27 +0,0 @@
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPublishPacket : MqttBasePublishPacket
-    {
-        public bool Retain { get; set; }
-
-        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
-
-        public bool Dup { get; set; }
-
-        public string Topic { get; set; }
-
-        public byte[] Payload { get; set; }
-
-        public override string ToString()
-        {
-            return "Publish: [Topic=" + Topic + "]" +
-                " [Payload.Length=" + Payload?.Length + "]" +
-                " [QoSLevel=" + QualityOfServiceLevel + "]" +
-                " [Dup=" + Dup + "]" +
-                " [Retain=" + Retain + "]" +
-                " [PacketIdentifier=" + PacketIdentifier + "]";
-        }
-    }
-}
@@ -1,19 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Packets
-{
-    public sealed class MqttSubAckPacket : MqttBasePacket, IMqttPacketWithIdentifier
-    {
-        public ushort? PacketIdentifier { get; set; }
-
-        public IList<MqttSubscribeReturnCode> SubscribeReturnCodes { get; } = new List<MqttSubscribeReturnCode>();
-
-        public override string ToString()
-        {
-            var subscribeReturnCodesText = string.Join(",", SubscribeReturnCodes.Select(f => f.ToString()));
-            return "SubAck: [PacketIdentifier=" + PacketIdentifier + "] [SubscribeReturnCodes=" + subscribeReturnCodesText + "]";
-        }
-    }
-}
@@ -1,18 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-
-namespace MQTTnet.Packets
-{
-    public sealed class MqttSubscribePacket : MqttBasePacket, IMqttPacketWithIdentifier
-    {
-        public ushort? PacketIdentifier { get; set; }
-
-        public IList<TopicFilter> TopicFilters { get; set; } = new List<TopicFilter>();
-
-        public override string ToString()
-        {
-            var topicFiltersText = string.Join(",", TopicFilters.Select(f => f.Topic + "@" + f.QualityOfServiceLevel));
-            return "Subscribe: [PacketIdentifier=" + PacketIdentifier + "] [TopicFilters=" + topicFiltersText + "]";
-        }
-    }
-}
@@ -1,12 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttUnsubAckPacket : MqttBasePacket, IMqttPacketWithIdentifier
-    {
-        public ushort? PacketIdentifier { get; set; }
-
-        public override string ToString()
-        {
-            return "UnsubAck: [PacketIdentifier=" + PacketIdentifier + "]";
-        }
-    }
-}
@@ -1,17 +0,0 @@
-using System.Collections.Generic;
-
-namespace MQTTnet.Packets
-{
-    public sealed class MqttUnsubscribePacket : MqttBasePacket, IMqttPacketWithIdentifier
-    {
-        public ushort? PacketIdentifier { get; set; }
-
-        public IList<string> TopicFilters { get; set; } = new List<string>();
-
-        public override string ToString()
-        {
-            var topicFiltersText = string.Join(",", TopicFilters);
-            return "Subscribe: [PacketIdentifier=" + PacketIdentifier + "] [TopicFilters=" + topicFiltersText + "]";
-        }
-    }
-}
@@ -1,48 +0,0 @@
-using System;
-
-namespace MQTTnet.Serializer
-{
-    public sealed class ByteReader
-    {
-        private readonly int _source;
-        private int _index;
-
-        public ByteReader(int source)
-        {
-            _source = source;
-        }
-
-        public bool Read()
-        {
-            if (_index >= 8)
-            {
-                throw new InvalidOperationException("End of byte reached.");
-            }
-
-            var result = ((1 << _index) & _source) > 0;
-            _index++;
-            return result;
-        }
-
-        public int Read(int count)
-        {
-            if (_index + count > 8)
-            {
-                throw new InvalidOperationException("End of byte will be reached.");
-            }
-
-            var result = 0;
-            for (var i = 0; i < count; i++)
-            {
-                if (((1 << _index) & _source) > 0)
-                {
-                    result |= 1 << i;
-                }
-
-                _index++;
-            }
-
-            return result;
-        }
-    }
-}
@@ -1,36 +0,0 @@
-using System;
-
-namespace MQTTnet.Serializer
-{
-    public sealed class ByteWriter
-    {
-        private int _index;
-        private int _byte;
-
-        public byte Value => (byte)_byte;
-
-        public void Write(int @byte, int count)
-        {
-            for (var i = 0; i < count; i++)
-            {
-                var value = ((1 << i) & @byte) > 0;
-                Write(value);
-            }
-        }
-
-        public void Write(bool bit)
-        {
-            if (_index >= 8)
-            {
-                throw new InvalidOperationException("End of the byte reached.");
-            }
-
-            if (bit)
-            {
-                _byte |= 1 << _index;
-            }
-
-            _index++;
-        }
-    }
-}
@@ -1,16 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using MQTTnet.Packets;
-
-namespace MQTTnet.Serializer
-{
-    public interface IMqttPacketSerializer
-    {
-        MqttProtocolVersion ProtocolVersion { get; set; }
-
-        ICollection<ArraySegment<byte>> Serialize(MqttBasePacket mqttPacket);
-
-        MqttBasePacket Deserialize(MqttPacketHeader header, MemoryStream body);
-    }
-}
@@ -1,129 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Exceptions;
-using MQTTnet.Packets;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Serializer
-{
-    public sealed class MqttPacketReader : BinaryReader
-    {
-        private readonly MqttPacketHeader _header;
-        
-        public MqttPacketReader(MqttPacketHeader header, Stream bodyStream)
-            : base(bodyStream, Encoding.UTF8, true)
-        {
-            _header = header;
-        }
-
-        public bool EndOfRemainingData => BaseStream.Position == _header.BodyLength;
-
-        public static async Task<MqttPacketHeader> ReadHeaderAsync(Stream stream, CancellationToken cancellationToken)
-        {
-            if (cancellationToken.IsCancellationRequested)
-            {
-                return null;
-            }
-
-            // Wait for the next package which starts with the header. At this point there will probably
-            // some large delay and thus the thread should be put back to the pool (await). So ReadByte()
-            // is not an option here.
-            var buffer = new byte[1];
-            var readCount = await stream.ReadAsync(buffer, 0, 1, cancellationToken).ConfigureAwait(false);
-            if (readCount <= 0)
-            {
-                return null;
-            }
-
-            var fixedHeader = buffer[0];
-            var controlPacketType = (MqttControlPacketType)(fixedHeader >> 4);
-            var bodyLength = await ReadBodyLengthAsync(stream, cancellationToken).ConfigureAwait(false);
-
-            return new MqttPacketHeader
-            {
-                FixedHeader = fixedHeader,
-                ControlPacketType = controlPacketType,
-                BodyLength = bodyLength
-            };
-        }
-
-        public override ushort ReadUInt16()
-        {
-            var buffer = ReadBytes(2);
-
-            var temp = buffer[0];
-            buffer[0] = buffer[1];
-            buffer[1] = temp;
-
-            return BitConverter.ToUInt16(buffer, 0);
-        }
-
-        public string ReadStringWithLengthPrefix()
-        {
-            var buffer = ReadWithLengthPrefix();
-            if (buffer.Length == 0)
-            {
-                return string.Empty;
-            }
-
-            return Encoding.UTF8.GetString(buffer, 0, buffer.Length);
-        }
-
-        public byte[] ReadWithLengthPrefix()
-        {
-            var length = ReadUInt16();
-            if (length == 0)
-            {
-                return new byte[0];
-            }
-
-            return ReadBytes(length);
-        }
-
-        public byte[] ReadRemainingData()
-        {
-            return ReadBytes(_header.BodyLength - (int)BaseStream.Position);
-        }
-
-        private static async Task<int> ReadBodyLengthAsync(Stream stream, CancellationToken cancellationToken)
-        {
-            // Alorithm taken from https://docs.oasis-open.org/mqtt/mqtt/v3.1.1/errata01/os/mqtt-v3.1.1-errata01-os-complete.html.
-            var multiplier = 1;
-            var value = 0;
-            byte encodedByte;
-
-            var buffer = new byte[1];
-            var readBytes = new List<byte>();
-            do
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    throw new TaskCanceledException();
-                }
-
-                var readCount = await stream.ReadAsync(buffer, 0, 1, cancellationToken).ConfigureAwait(false);
-                if (readCount <= 0)
-                {
-                    throw new MqttCommunicationException("Connection closed while reading remaining length data.");
-                }
-
-                encodedByte = buffer[0];
-                readBytes.Add(encodedByte);
-
-                value += (byte)(encodedByte & 127) * multiplier;
-                if (multiplier > 128 * 128 * 128)
-                {
-                    throw new MqttProtocolViolationException($"Remaining length is invalid (Data={string.Join(",", readBytes)}).");
-                }
-
-                multiplier *= 128;
-            } while ((encodedByte & 128) != 0);
-
-            return value;
-        }
-    }
-}
@@ -1,572 +0,0 @@
-using MQTTnet.Exceptions;
-using MQTTnet.Packets;
-using MQTTnet.Protocol;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-
-namespace MQTTnet.Serializer
-{
-    public sealed class MqttPacketSerializer : IMqttPacketSerializer
-    {
-        private static byte[] ProtocolVersionV311Name { get; } = Encoding.UTF8.GetBytes("MQTT");
-        private static byte[] ProtocolVersionV310Name { get; } = Encoding.UTF8.GetBytes("MQIs");
-
-        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
-
-        public ICollection<ArraySegment<byte>> Serialize(MqttBasePacket packet)
-        {
-            if (packet == null) throw new ArgumentNullException(nameof(packet));
-
-            using (var stream = new MemoryStream(128))
-            using (var writer = new MqttPacketWriter(stream))
-            {
-                var fixedHeader = SerializePacket(packet, writer);
-                var remainingLength = (int)stream.Length;
-                writer.Write(fixedHeader);
-                MqttPacketWriter.WriteRemainingLength(remainingLength, writer);
-                var headerLength = (int)stream.Length - remainingLength;
-
-#if NET461 || NET452 || NETSTANDARD2_0
-                var buffer = stream.GetBuffer();
-#else
-                var buffer = stream.ToArray();
-#endif
-                return new List<ArraySegment<byte>>
-                {
-                    new ArraySegment<byte>(buffer, remainingLength, headerLength),
-                    new ArraySegment<byte>(buffer, 0, remainingLength)
-                };
-            }
-        }
-
-        public MqttBasePacket Deserialize(MqttPacketHeader header, MemoryStream body)
-        {
-            if (header == null) throw new ArgumentNullException(nameof(header));
-            if (body == null) throw new ArgumentNullException(nameof(body));
-
-            using (var reader = new MqttPacketReader(header, body))
-            {
-                return Deserialize(header, reader);
-            }
-        }
-
-        private byte SerializePacket(MqttBasePacket packet, MqttPacketWriter writer)
-        {
-            switch (packet)
-            {
-                case MqttConnectPacket connectPacket: return Serialize(connectPacket, writer);
-                case MqttConnAckPacket connAckPacket: return Serialize(connAckPacket, writer);
-                case MqttDisconnectPacket _: return SerializeEmptyPacket(MqttControlPacketType.Disconnect);
-                case MqttPingReqPacket _: return SerializeEmptyPacket(MqttControlPacketType.PingReq);
-                case MqttPingRespPacket _: return SerializeEmptyPacket(MqttControlPacketType.PingResp);
-                case MqttPublishPacket publishPacket: return Serialize(publishPacket, writer);
-                case MqttPubAckPacket pubAckPacket: return Serialize(pubAckPacket, writer);
-                case MqttPubRecPacket pubRecPacket: return Serialize(pubRecPacket, writer);
-                case MqttPubRelPacket pubRelPacket: return Serialize(pubRelPacket, writer);
-                case MqttPubCompPacket pubCompPacket: return Serialize(pubCompPacket, writer);
-                case MqttSubscribePacket subscribePacket: return Serialize(subscribePacket, writer);
-                case MqttSubAckPacket subAckPacket: return Serialize(subAckPacket, writer);
-                case MqttUnsubscribePacket unsubscribePacket: return Serialize(unsubscribePacket, writer);
-                case MqttUnsubAckPacket unsubAckPacket: return Serialize(unsubAckPacket, writer);
-                default: throw new MqttProtocolViolationException("Packet type invalid.");
-            }
-        }
-
-        private MqttBasePacket Deserialize(MqttPacketHeader header, MqttPacketReader reader)
-        {
-            switch (header.ControlPacketType)
-            {
-                case MqttControlPacketType.Connect: return DeserializeConnect(reader);
-                case MqttControlPacketType.ConnAck: return DeserializeConnAck(reader);
-                case MqttControlPacketType.Disconnect: return new MqttDisconnectPacket();
-                case MqttControlPacketType.Publish: return DeserializePublish(reader, header);
-                case MqttControlPacketType.PubAck: return DeserializePubAck(reader);
-                case MqttControlPacketType.PubRec: return DeserializePubRec(reader);
-                case MqttControlPacketType.PubRel: return DeserializePubRel(reader);
-                case MqttControlPacketType.PubComp: return DeserializePubComp(reader);
-                case MqttControlPacketType.PingReq: return new MqttPingReqPacket();
-                case MqttControlPacketType.PingResp: return new MqttPingRespPacket();
-                case MqttControlPacketType.Subscribe: return DeserializeSubscribe(reader);
-                case MqttControlPacketType.SubAck: return DeserializeSubAck(reader);
-                case MqttControlPacketType.Unsubscibe: return DeserializeUnsubscribe(reader);
-                case MqttControlPacketType.UnsubAck: return DeserializeUnsubAck(reader);
-                default: throw new MqttProtocolViolationException($"Packet type ({(int)header.ControlPacketType}) not supported.");
-            }
-        }
-
-        private static MqttBasePacket DeserializeUnsubAck(MqttPacketReader reader)
-        {
-            return new MqttUnsubAckPacket
-            {
-                PacketIdentifier = reader.ReadUInt16()
-            };
-        }
-
-        private static MqttBasePacket DeserializePubComp(MqttPacketReader reader)
-        {
-            return new MqttPubCompPacket
-            {
-                PacketIdentifier = reader.ReadUInt16()
-            };
-        }
-
-        private static MqttBasePacket DeserializePubRel(MqttPacketReader reader)
-        {
-            return new MqttPubRelPacket
-            {
-                PacketIdentifier = reader.ReadUInt16()
-            };
-        }
-
-        private static MqttBasePacket DeserializePubRec(MqttPacketReader reader)
-        {
-            return new MqttPubRecPacket
-            {
-                PacketIdentifier = reader.ReadUInt16()
-            };
-        }
-
-        private static MqttBasePacket DeserializePubAck(MqttPacketReader reader)
-        {
-            return new MqttPubAckPacket
-            {
-                PacketIdentifier = reader.ReadUInt16()
-            };
-        }
-
-        private static MqttBasePacket DeserializeUnsubscribe(MqttPacketReader reader)
-        {
-            var packet = new MqttUnsubscribePacket
-            {
-                PacketIdentifier = reader.ReadUInt16(),
-            };
-
-            while (!reader.EndOfRemainingData)
-            {
-                packet.TopicFilters.Add(reader.ReadStringWithLengthPrefix());
-            }
-
-            return packet;
-        }
-
-        private static MqttBasePacket DeserializeSubscribe(MqttPacketReader reader)
-        {
-            var packet = new MqttSubscribePacket
-            {
-                PacketIdentifier = reader.ReadUInt16()
-            };
-
-            while (!reader.EndOfRemainingData)
-            {
-                packet.TopicFilters.Add(new TopicFilter(
-                    reader.ReadStringWithLengthPrefix(),
-                    (MqttQualityOfServiceLevel)reader.ReadByte()));
-            }
-
-            return packet;
-        }
-
-        private static MqttBasePacket DeserializePublish(MqttPacketReader reader, MqttPacketHeader mqttPacketHeader)
-        {
-            var fixedHeader = new ByteReader(mqttPacketHeader.FixedHeader);
-            var retain = fixedHeader.Read();
-            var qualityOfServiceLevel = (MqttQualityOfServiceLevel)fixedHeader.Read(2);
-            var dup = fixedHeader.Read();
-
-            var topic = reader.ReadStringWithLengthPrefix();
-
-            ushort packetIdentifier = 0;
-            if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
-            {
-                packetIdentifier = reader.ReadUInt16();
-            }
-
-            var packet = new MqttPublishPacket
-            {
-                Retain = retain,
-                QualityOfServiceLevel = qualityOfServiceLevel,
-                Dup = dup,
-                Topic = topic,
-                Payload = reader.ReadRemainingData(),
-                PacketIdentifier = packetIdentifier
-            };
-
-            return packet;
-        }
-
-        private static MqttBasePacket DeserializeConnect(MqttPacketReader reader)
-        {
-            reader.ReadBytes(2); // Skip 2 bytes
-
-            MqttProtocolVersion protocolVersion;
-            var protocolName = reader.ReadBytes(4);
-            if (protocolName.SequenceEqual(ProtocolVersionV310Name))
-            {
-                reader.ReadBytes(2);
-                protocolVersion = MqttProtocolVersion.V310;
-            }
-            else if (protocolName.SequenceEqual(ProtocolVersionV311Name))
-            {
-                protocolVersion = MqttProtocolVersion.V311;
-            }
-            else
-            {
-                throw new MqttProtocolViolationException("Protocol name is not supported.");
-            }
-
-            reader.ReadByte(); // Skip protocol level
-            var connectFlags = reader.ReadByte();
-
-            var connectFlagsReader = new ByteReader(connectFlags);
-            connectFlagsReader.Read(); // Reserved.
-
-            var packet = new MqttConnectPacket
-            {
-                ProtocolVersion = protocolVersion,
-                CleanSession = connectFlagsReader.Read()
-            };
-
-            var willFlag = connectFlagsReader.Read();
-            var willQoS = connectFlagsReader.Read(2);
-            var willRetain = connectFlagsReader.Read();
-            var passwordFlag = connectFlagsReader.Read();
-            var usernameFlag = connectFlagsReader.Read();
-
-            packet.KeepAlivePeriod = reader.ReadUInt16();
-            packet.ClientId = reader.ReadStringWithLengthPrefix();
-
-            if (willFlag)
-            {
-                packet.WillMessage = new MqttApplicationMessage
-                {
-                    Topic = reader.ReadStringWithLengthPrefix(),
-                    Payload = reader.ReadWithLengthPrefix(),
-                    QualityOfServiceLevel = (MqttQualityOfServiceLevel)willQoS,
-                    Retain = willRetain
-                };
-            }
-
-            if (usernameFlag)
-            {
-                packet.Username = reader.ReadStringWithLengthPrefix();
-            }
-
-            if (passwordFlag)
-            {
-                packet.Password = reader.ReadStringWithLengthPrefix();
-            }
-
-            ValidateConnectPacket(packet);
-            return packet;
-        }
-
-        private static MqttBasePacket DeserializeSubAck(MqttPacketReader reader)
-        {
-            var packet = new MqttSubAckPacket
-            {
-                PacketIdentifier = reader.ReadUInt16()
-            };
-
-            while (!reader.EndOfRemainingData)
-            {
-                packet.SubscribeReturnCodes.Add((MqttSubscribeReturnCode)reader.ReadByte());
-            }
-
-            return packet;
-        }
-
-        private MqttBasePacket DeserializeConnAck(MqttPacketReader reader)
-        {
-            var packet = new MqttConnAckPacket();
-
-            var firstByteReader = new ByteReader(reader.ReadByte());
-
-            if (ProtocolVersion == MqttProtocolVersion.V311)
-            {
-                packet.IsSessionPresent = firstByteReader.Read();
-            }
-
-            packet.ConnectReturnCode = (MqttConnectReturnCode)reader.ReadByte();
-
-            return packet;
-        }
-        
-        private static void ValidateConnectPacket(MqttConnectPacket packet)
-        {
-            if (packet == null) throw new ArgumentNullException(nameof(packet));
-
-            if (string.IsNullOrEmpty(packet.ClientId) && !packet.CleanSession)
-            {
-                throw new MqttProtocolViolationException("CleanSession must be set if ClientId is empty [MQTT-3.1.3-7].");
-            }
-        }
-
-        private static void ValidatePublishPacket(MqttPublishPacket packet)
-        {
-            if (packet == null) throw new ArgumentNullException(nameof(packet));
-
-            if (packet.QualityOfServiceLevel == 0 && packet.Dup)
-            {
-                throw new MqttProtocolViolationException("Dup flag must be false for QoS 0 packets [MQTT-3.3.1-2].");
-            }
-        }
-
-        private byte Serialize(MqttConnectPacket packet, MqttPacketWriter writer)
-        {
-            ValidateConnectPacket(packet);
-
-            // Write variable header
-            writer.Write(0x00, 0x04); // 3.1.2.1 Protocol Name
-            if (ProtocolVersion == MqttProtocolVersion.V311)
-            {
-                writer.Write(ProtocolVersionV311Name);
-                writer.Write(0x04); // 3.1.2.2 Protocol Level (4)
-            }
-            else
-            {
-                writer.Write(ProtocolVersionV310Name);
-                writer.Write(0x64, 0x70, 0x03); // Protocol Level (0x03)
-            }
-
-            var connectFlags = new ByteWriter(); // 3.1.2.3 Connect Flags
-            connectFlags.Write(false); // Reserved
-            connectFlags.Write(packet.CleanSession);
-            connectFlags.Write(packet.WillMessage != null);
-
-            if (packet.WillMessage != null)
-            {
-                connectFlags.Write((int)packet.WillMessage.QualityOfServiceLevel, 2);
-                connectFlags.Write(packet.WillMessage.Retain);
-            }
-            else
-            {
-                connectFlags.Write(0, 2);
-                connectFlags.Write(false);
-            }
-
-            connectFlags.Write(packet.Password != null);
-            connectFlags.Write(packet.Username != null);
-
-            writer.Write(connectFlags);
-            writer.Write(packet.KeepAlivePeriod);
-            writer.WriteWithLengthPrefix(packet.ClientId);
-
-            if (packet.WillMessage != null)
-            {
-                writer.WriteWithLengthPrefix(packet.WillMessage.Topic);
-                writer.WriteWithLengthPrefix(packet.WillMessage.Payload);
-            }
-
-            if (packet.Username != null)
-            {
-                writer.WriteWithLengthPrefix(packet.Username);
-            }
-
-            if (packet.Password != null)
-            {
-                writer.WriteWithLengthPrefix(packet.Password);
-            }
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Connect);
-        }
-
-        private byte Serialize(MqttConnAckPacket packet, MqttPacketWriter writer)
-        {
-            if (ProtocolVersion == MqttProtocolVersion.V310)
-            {
-                writer.Write(0);
-            }
-            else if (ProtocolVersion == MqttProtocolVersion.V311)
-            {
-                var connectAcknowledgeFlags = new ByteWriter();
-                connectAcknowledgeFlags.Write(packet.IsSessionPresent);
-                writer.Write(connectAcknowledgeFlags);
-            }
-            else
-            {
-                throw new MqttProtocolViolationException("Protocol version not supported.");
-            }
-
-            writer.Write((byte)packet.ConnectReturnCode);
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.ConnAck);
-        }
-
-        private static byte Serialize(MqttPubRelPacket packet, MqttPacketWriter writer)
-        {
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("PubRel packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02);
-        }
-
-        private static byte Serialize(MqttPublishPacket packet, MqttPacketWriter writer)
-        {
-            ValidatePublishPacket(packet);
-
-            writer.WriteWithLengthPrefix(packet.Topic);
-
-            if (packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
-            {
-                if (!packet.PacketIdentifier.HasValue)
-                {
-                    throw new MqttProtocolViolationException("Publish packet has no packet identifier.");
-                }
-
-                writer.Write(packet.PacketIdentifier.Value);
-            }
-            else
-            {
-                if (packet.PacketIdentifier > 0)
-                {
-                    throw new MqttProtocolViolationException("Packet identifier must be empty if QoS == 0 [MQTT-2.3.1-5].");
-                }
-            }
-
-            if (packet.Payload?.Length > 0)
-            {
-                writer.Write(packet.Payload);
-            }
-
-            byte fixedHeader = 0;
-
-            if (packet.Retain)
-            {
-                fixedHeader |= 0x01;
-            }
-
-            fixedHeader |= (byte)((byte)packet.QualityOfServiceLevel << 1);
-
-            if (packet.Dup)
-            {
-                fixedHeader |= 0x08;
-            }
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Publish, fixedHeader);
-        }
-
-        private static byte Serialize(MqttPubAckPacket packet, MqttPacketWriter writer)
-        {
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("PubAck packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubAck);
-        }
-
-        private static byte Serialize(MqttPubRecPacket packet, MqttPacketWriter writer)
-        {
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("PubRec packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRec);
-        }
-
-        private static byte Serialize(MqttPubCompPacket packet, MqttPacketWriter writer)
-        {
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("PubComp packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubComp);
-        }
-
-        private static byte Serialize(MqttSubscribePacket packet, MqttPacketWriter writer)
-        {
-            if (!packet.TopicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.8.3-3].");
-
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("Subscribe packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-
-            if (packet.TopicFilters?.Count > 0)
-            {
-                foreach (var topicFilter in packet.TopicFilters)
-                {
-                    writer.WriteWithLengthPrefix(topicFilter.Topic);
-                    writer.Write((byte)topicFilter.QualityOfServiceLevel);
-                }
-            }
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Subscribe, 0x02);
-        }
-
-        private static byte Serialize(MqttSubAckPacket packet, MqttPacketWriter writer)
-        {
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("SubAck packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-
-            if (packet.SubscribeReturnCodes?.Any() == true)
-            {
-                foreach (var packetSubscribeReturnCode in packet.SubscribeReturnCodes)
-                {
-                    writer.Write((byte)packetSubscribeReturnCode);
-                }
-            }
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.SubAck);
-        }
-
-        private static byte Serialize(MqttUnsubscribePacket packet, MqttPacketWriter writer)
-        {
-            if (!packet.TopicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.10.3-2].");
-
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("Unsubscribe packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-
-            if (packet.TopicFilters?.Any() == true)
-            {
-                foreach (var topicFilter in packet.TopicFilters)
-                {
-                    writer.WriteWithLengthPrefix(topicFilter);
-                }
-            }
-
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Unsubscibe, 0x02);
-        }
-
-        private static byte Serialize(MqttUnsubAckPacket packet, BinaryWriter writer)
-        {
-            if (!packet.PacketIdentifier.HasValue)
-            {
-                throw new MqttProtocolViolationException("UnsubAck packet has no packet identifier.");
-            }
-
-            writer.Write(packet.PacketIdentifier.Value);
-            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.UnsubAck);
-        }
-
-        private static byte SerializeEmptyPacket(MqttControlPacketType type)
-        {
-            return MqttPacketWriter.BuildFixedHeader(type);
-        }
-    }
-}
@@ -1,81 +0,0 @@
-using System;
-using System.IO;
-using System.Text;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Serializer
-{
-    public sealed class MqttPacketWriter : BinaryWriter
-    {
-        public MqttPacketWriter(Stream stream)
-            : base(stream, Encoding.UTF8, true)
-        {
-        }
-
-        public static byte BuildFixedHeader(MqttControlPacketType packetType, byte flags = 0)
-        {
-            var fixedHeader = (int)packetType << 4;
-            fixedHeader |= flags;
-            return (byte)fixedHeader;
-        }
-
-        public override void Write(ushort value)
-        {
-            var buffer = BitConverter.GetBytes(value);
-            Write(buffer[1], buffer[0]);
-        }
-
-        public new void Write(params byte[] values)
-        {
-            base.Write(values);
-        }
-
-        public new void Write(byte value)
-        {
-            base.Write(value);
-        }
-
-        public void Write(ByteWriter value)
-        {
-            if (value == null) throw new ArgumentNullException(nameof(value));
-
-            Write(value.Value);
-        }
-
-        public void WriteWithLengthPrefix(string value)
-        {
-            WriteWithLengthPrefix(Encoding.UTF8.GetBytes(value ?? string.Empty));
-        }
-
-        public void WriteWithLengthPrefix(byte[] value)
-        {
-            var length = (ushort)value.Length;
-
-            Write(length);
-            Write(value);
-        }
-
-        public static void WriteRemainingLength(int length, BinaryWriter target)
-        {
-            if (length == 0)
-            {
-                target.Write((byte)0);
-                return;
-            }
-
-            // Alorithm taken from http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html.
-            var x = length;
-            do
-            {
-                var encodedByte = x % 128;
-                x = x / 128;
-                if (x > 0)
-                {
-                    encodedByte = encodedByte | 128;
-                }
-
-                target.Write((byte)encodedByte);
-            } while (x > 0);
-        }
-    }
-}
@@ -1,8 +0,0 @@
-namespace MQTTnet.Serializer
-{
-    public enum MqttProtocolVersion
-    {
-        V311,
-        V310
-    }
-}
@@ -1,18 +0,0 @@
-using System;
-using MQTTnet.Serializer;
-
-namespace MQTTnet.Server
-{
-    public class ConnectedMqttClient
-    {
-        public string ClientId { get; set; }
-
-        public MqttProtocolVersion ProtocolVersion { get; set; }
-
-        public TimeSpan LastPacketReceived { get; set; }
-
-        public TimeSpan LastNonKeepAlivePacketReceived { get; set; }
-
-        public int PendingApplicationMessages { get; set; }
-    }
-}
@@ -1,9 +0,0 @@
-namespace MQTTnet.Server
-{
-    public sealed class GetOrCreateClientSessionResult
-    {
-        public bool IsExistingSession { get; set; }
-
-        public MqttClientSession Session { get; set; }
-    }
-}
@@ -1,26 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace MQTTnet.Server
-{
-    public interface IMqttServer : IApplicationMessageReceiver, IApplicationMessagePublisher
-    {
-        event EventHandler<MqttServerStartedEventArgs> Started;
-
-        event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
-        event EventHandler<MqttClientDisconnectedEventArgs> ClientDisconnected;
-        event EventHandler<MqttClientSubscribedTopicEventArgs> ClientSubscribedTopic;
-        event EventHandler<MqttClientUnsubscribedTopicEventArgs> ClientUnsubscribedTopic;
-        
-        IMqttServerOptions Options { get; }
-
-        Task<IList<ConnectedMqttClient>> GetConnectedClientsAsync();
-
-        Task SubscribeAsync(string clientId, IList<TopicFilter> topicFilters);
-        Task UnsubscribeAsync(string clientId, IList<string> topicFilters);
-
-        Task StartAsync(IMqttServerOptions options);
-        Task StopAsync();
-    }
-}
@@ -1,13 +0,0 @@
-using System.Collections.Generic;
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-
-namespace MQTTnet.Server
-{
-    public interface IMqttServerFactory
-    {
-        IMqttServer CreateMqttServer();
-
-        IMqttServer CreateMqttServer(IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger);
-    }
-}
@@ -1,19 +0,0 @@
-using System;
-
-namespace MQTTnet.Server
-{
-    public interface IMqttServerOptions
-    {
-        int ConnectionBacklog { get; }
-        TimeSpan DefaultCommunicationTimeout { get; }
-
-        Action<MqttConnectionValidatorContext> ConnectionValidator { get; }
-        Action<MqttSubscriptionInterceptorContext> SubscriptionInterceptor { get; }
-        Action<MqttApplicationMessageInterceptorContext> ApplicationMessageInterceptor { get; }
-
-        MqttServerDefaultEndpointOptions DefaultEndpointOptions { get; }
-        MqttServerTlsEndpointOptions TlsEndpointOptions { get; }
-
-        IMqttServerStorage Storage { get; }
-    }
-}
@@ -1,15 +0,0 @@
-namespace MQTTnet.Server
-{
-    public class MqttApplicationMessageInterceptorContext
-    {
-        public MqttApplicationMessageInterceptorContext(string clientId, MqttApplicationMessage applicationMessage)
-        {
-            ClientId = clientId;
-            ApplicationMessage = applicationMessage;
-        }
-
-        public string ClientId { get; }
-
-        public MqttApplicationMessage ApplicationMessage { get; set; }
-    }
-}
@@ -1,14 +0,0 @@
-using System;
-
-namespace MQTTnet.Server
-{
-    public class MqttClientConnectedEventArgs : EventArgs
-    {
-        public MqttClientConnectedEventArgs(ConnectedMqttClient client)
-        {
-            Client = client ?? throw new ArgumentNullException(nameof(client));
-        }
-
-        public ConnectedMqttClient Client { get; }
-    }
-}
@@ -1,14 +0,0 @@
-using System;
-
-namespace MQTTnet.Server
-{
-    public class MqttClientDisconnectedEventArgs : EventArgs
-    {
-        public MqttClientDisconnectedEventArgs(ConnectedMqttClient client)
-        {
-            Client = client ?? throw new ArgumentNullException(nameof(client));
-        }
-        
-        public ConnectedMqttClient Client { get; }
-    }
-}
@@ -1,98 +0,0 @@
-using System;
-using System.Diagnostics;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Diagnostics;
-using MQTTnet.Packets;
-
-namespace MQTTnet.Server
-{
-    public sealed class MqttClientKeepAliveMonitor
-    {
-        private readonly Stopwatch _lastPacketReceivedTracker = new Stopwatch();
-        private readonly Stopwatch _lastNonKeepAlivePacketReceivedTracker = new Stopwatch();
-
-        private readonly string _clientId;
-        private readonly Func<Task> _timeoutCallback;
-        private readonly IMqttNetLogger _logger;
-
-        private Task _workerTask;
-
-        public MqttClientKeepAliveMonitor(string clientId, Func<Task> timeoutCallback, IMqttNetLogger logger)
-        {
-            _clientId = clientId;
-            _timeoutCallback = timeoutCallback;
-            _logger = logger;
-        }
-
-        public TimeSpan LastPacketReceived => _lastPacketReceivedTracker.Elapsed;
-
-        public TimeSpan LastNonKeepAlivePacketReceived => _lastNonKeepAlivePacketReceivedTracker.Elapsed;
-
-        public void Start(int keepAlivePeriod, CancellationToken cancellationToken)
-        {
-            if (keepAlivePeriod == 0)
-            {
-                return;
-            }
-
-            _workerTask = Task.Run(() => RunAsync(keepAlivePeriod, cancellationToken).ConfigureAwait(false), cancellationToken);
-        }
-
-        public void WaitForCompletion()
-        {
-            if (_workerTask != null)
-            {
-                Task.WaitAll(_workerTask);
-            }
-        }
-
-        private async Task RunAsync(int keepAlivePeriod, CancellationToken cancellationToken)
-        {
-            try
-            {
-                _lastPacketReceivedTracker.Restart();
-                _lastNonKeepAlivePacketReceivedTracker.Restart();
-
-                while (!cancellationToken.IsCancellationRequested)
-                {
-                    // Values described here: [MQTT-3.1.2-24].
-                    if (_lastPacketReceivedTracker.Elapsed.TotalSeconds > keepAlivePeriod * 1.5D)
-                    {
-                        _logger.Warning<MqttClientSession>("Client '{0}': Did not receive any packet or keep alive signal.", _clientId);
-
-                        if (_timeoutCallback != null)
-                        {
-                            await _timeoutCallback().ConfigureAwait(false);
-                        }
-
-                        return;
-                    }
-
-                    await Task.Delay(keepAlivePeriod, cancellationToken).ConfigureAwait(false);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-            }
-            catch (Exception exception)
-            {
-                _logger.Error<MqttClientSession>(exception, "Client '{0}': Unhandled exception while checking keep alive timeouts.", _clientId);
-            }
-            finally
-            {
-                _logger.Trace<MqttClientSession>("Client {0}: Stopped checking keep alive timeout.", _clientId);
-            }
-        }
-
-        public void PacketReceived(MqttBasePacket packet)
-        {
-            _lastPacketReceivedTracker.Restart();
-
-            if (!(packet is MqttPingReqPacket))
-            {
-                _lastNonKeepAlivePacketReceivedTracker.Restart();
-            }
-        }
-    }
-}
--- a/Show More
+++ b/Show More