Fix UWP build errors.

* Fix timestamp check in server keep-alive monitor

* Retain the original client statistics property name
- add comments to clarify meaning
- add separate public "received" timestamp property

* fix comment

.bettercodehub.yml

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

.editorconfig

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -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.
+```

.github/ISSUE_TEMPLATE/custom.md

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

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,67 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master ]
+  schedule:
+    - cron: '23 9 * * 6'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'csharp' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.github/workflows/deb-packaging.yml

@@ -0,0 +1,62 @@
+# This is a basic workflow to help you get started with Actions
+
+name: Deb Packaging
+
+# Controls when the action will run. 
+on:
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: Parse version
+        run: echo VERSION=$(grep '<Version>' Source/MQTTnet.Server/MQTTnet.Server.csproj | grep [0-9\.]* -o) >> $GITHUB_ENV
+
+      - name: Build MQTTnetServer
+        run: dotnet publish Source/MQTTnet.Server/MQTTnet.Server.csproj --configuration Release --self-contained --runtime linux-x64 --framework net5.0
+
+      - name: Set up installation directory
+        run: mkdir -p packaging/opt/MQTTnetServer
+
+      - name: Copy meta data
+        run: |
+          cp -R Build/deb-meta/* packaging/
+          chmod 755 packaging/DEBIAN/postinst
+          chmod 755 packaging/DEBIAN/postrm
+          chmod 755 packaging/DEBIAN/prerm
+
+      - name: Move artifacts to packaging directory
+        run: cp -R Source/MQTTnet.Server/bin/Release/net5.0/linux-x64/publish/* packaging/opt/MQTTnetServer
+
+      - name: Adjust files
+        run: |
+          rm packaging/opt/MQTTnetServer/appsettings.Development.json
+          mv packaging/opt/MQTTnetServer/appsettings.json packaging/opt/MQTTnetServer/appsettings.template.json
+
+      - name: Adjust permissions
+        run: |
+          cd packaging/opt/MQTTnetServer
+          find . -type f | xargs chmod -R 644
+          chmod 755 MQTTnet.Server
+
+      - name: Generate MD5s
+        run: |
+          cd packaging/          
+          md5sum $(find * -type f -not -path 'DEBIAN/*') > DEBIAN/md5sums
+      
+      - name: Patch meta
+        run: sed -i 's/\VERSIONPLACEHOLDER/${{ env.VERSION }}/' packaging/DEBIAN/control
+
+      - name: Package everything
+        run: dpkg-deb -v --build packaging/ mqttnet-server_${{ env.VERSION }}-1_amd64.deb
+      
+      - name: Save artifact
+        uses: actions/upload-artifact@v2
+        with:
+          name: mqttnet-server
+          path: mqttnet-server_${{ env.VERSION }}-1_amd64.deb

.gitignore

@@ -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,11 @@ __pycache__/
 *.odx.cs
 *.xsd.cs
 
-
-Build/nuget.exe
 *.js
 *.map
 
 /Tests/MQTTnet.TestApp.NetCore/RetainedMessages.json
+
+Build/NuGet/
+
+Build/nuget.exe

.travis.yml

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

Build/MQTTnet.AspNetCore.nuspec

@@ -2,27 +2,48 @@
 <package >
   <metadata>
     <id>MQTTnet.AspNetCore</id>
-    <version>2.7.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>
+    <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.0.
-    </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-2021</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.0" />
+        <dependency id="MQTTnet" version="$nugetVersion" />
+        <dependency id="Microsoft.AspNetCore.Http.Connections" version="1.0.0"  />
+      </group>
+
+      <group targetFramework="netcoreapp3.1">
+        <dependency id="MQTTnet" version="$nugetVersion" />
+      </group>
+
+      <group targetFramework="net5.0">
+        <dependency id="MQTTnet" version="$nugetVersion" />
       </group>
     </dependencies>
   </metadata>
 
   <files>
+    <!-- License -->
+    <file src="..\LICENSE" />
+
+    <!-- Images -->
+    <file src="..\Images\Logo_128x128.png" target="images\" />
+
+    <!-- .NET 5.0 -->
+    <file src="..\Source\MQTTnet.AspNetCore\bin\Release\net5.0\MQTTnet.AspNetCore.*" target="lib\net5.0\" />
+
     <!-- .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>

Build/MQTTnet.Extensions.ManagedClient.nuspec

@@ -0,0 +1,52 @@
+<?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-2021</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 5.0 -->
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\net5.0\MQTTnet.Extensions.ManagedClient.*" target="lib\net5.0\" />
+
+    <!-- .NET Standard 1.3 -->
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\netstandard1.3\MQTTnet.Extensions.ManagedClient.*" target="lib\netstandard1.3\" />
+
+    <!-- .NET Standard 2.0 -->
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\netstandard2.0\MQTTnet.Extensions.ManagedClient.*" target="lib\netstandard2.0\" />
+
+    <!-- .NET Standard 2.1 -->
+    <file src="..\Source\MQTTnet.Extensions.ManagedClient\bin\Release\netstandard2.1\MQTTnet.Extensions.ManagedClient.*" target="lib\netstandard2.1\" />
+
+    <!-- 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.ManagedClient.*" target="lib\net461\" />
+
+    <!-- Everything above .NET Framework 4.6.1 will use the binaries from 4.6.1. -->
+  </files>
+</package>

Build/MQTTnet.Extensions.Rpc.nuspec

@@ -2,46 +2,51 @@
 <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-2021</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 5.0 -->
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\net5.0\MQTTnet.Extensions.Rpc.*" target="lib\net5.0\" />
+
+    <!-- .NET Standard 1.3 -->
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\netstandard1.3\MQTTnet.Extensions.Rpc.*" target="lib\netstandard1.3\" />
+
     <!-- .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\" />
+
+    <!-- .NET Standard 2.1 -->
+    <file src="..\Source\MQTTnet.Extensions.Rpc\bin\Release\netstandard2.1\MQTTnet.Extensions.Rpc.*" target="lib\netstandard2.1\" />
+
+    <!-- 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>

Build/MQTTnet.Extensions.WebSocket4Net.nuspec

@@ -0,0 +1,53 @@
+<?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-2021</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" />
+      <dependency id="WebSocket4Net" version="0.15.2" />
+    </dependencies>
+  </metadata>
+
+  <files>
+    <!-- License -->
+    <file src="..\LICENSE" />
+
+    <!-- Images -->
+    <file src="..\Images\Logo_128x128.png" target="images\" />
+
+    <!-- .NET 5.0 -->
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\net5.0\MQTTnet.Extensions.WebSocket4Net.*" target="lib\net5.0\" />
+
+    <!-- .NET Standard 1.3 -->
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\netstandard1.3\MQTTnet.Extensions.WebSocket4Net.*" target="lib\netstandard1.3\" />
+
+    <!-- .NET Standard 2.0 -->
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\netstandard2.0\MQTTnet.Extensions.WebSocket4Net.*" target="lib\netstandard2.0\" />
+
+    <!-- .NET Standard 2.1 -->
+    <file src="..\Source\MQTTnet.Extensions.WebSocket4Net\bin\Release\netstandard2.1\MQTTnet.Extensions.WebSocket4Net.*" target="lib\netstandard2.1\" />
+
+    <!-- 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>

Build/MQTTnet.nuspec

@@ -2,69 +2,90 @@
 <package >
   <metadata>
     <id>MQTTnet</id>
-    <version>2.7.1</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] Fixed wrong parsing of ConnAck packet for protocol version 3.1.0.
-* [Core] Log messages are now overriding ToString() and providing a ready to use text representation.
-* [Client] Optimized package dispatcher and added several new exceptions.
-* [Client] The _ManagedClient_ now has an event which is fired after a queued application message was processed (including exception).
-* [Client] The _ManagedClient_ now supports unsubscribing (thanks to @lerppana)
-* [Server] Fixed some minor async issues.
-* [Server] Fixed wrong comparison of the topic and QoS for retained messages.
-* [Server] Added a property which provides access to the used options (read only).
-* [Server] Fixed a null ref expection when using an interceptor and publishing via the server directly.
+    <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>
+* [Core] Added all builders to the MQTT factory.
+* [Core] Removed global logger and refactored logging (BREAKING CHANGE!).
+* [Client] Renamed _MqttClientConnectResult_ to _MqttClientConnectResult_ (BREAKING CHANGE!).
+* [ManagedClient] Extended ReconnectAsync (thanks to @nvsnkv, #1202).
+* [ManagedClient] Improved Amazon AWS support (thanks to @scottbrogden-iheartmedia, #1209). 
+* [ManagedClient] Fixed bug that allowed invalid subscriptions (Thanks to @marcelwinh).
+* [Server] Added support for _RetainHandling_ (MQTTv5, BREAKING CHANGE!).
+* [Server] Added support for _NoLocal_ (MQTTv5, BREAKING CHANGE!).
+* [Server] Added support for _SubscriptionIdentifier_ (MQTTv5, BREAKING CHANGE!).
+* [Server] Server now reports supported features properly after successful connection (MQTTv5, BREAKING CHANGE!).
+* [Server] Fixed a memory/performance leak when using QoS Level 1.
+* [Server] Exposed connection timestamp in client status. 
+* [Server] Refactored connection management code. 
+* [Server] Exposed more details in _MqttServerClientConnectedEventArgs_. 
+* [Server] Processing all pending messages before stopping (thanks to @AblEdge, #1234).
+* [Server] Added support for a custom exception handler in _MqttServerMultiThreadedApplicationMessageInterceptorDelegate_.
+* [Server] Removed logger from _MqttServerMultiThreadedApplicationMessageInterceptorDelegate_ (BREAKING CHANGE!).
+* [Server] Fixed a memory leak when deleting sessions.
+* [Server] Fixed timestamp check in server keep-alive monitor (thanks to @logicaloud, #1277).
+* [MQTTnet.Server] Moved server project to a dedicated GitHub repository.
+Git commit: $gitCommit
     </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-2021</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="net452" />
+      <group targetFramework="net461" />
       <group targetFramework="netstandard1.3">
-        <dependency id="NETStandard.Library" version="1.3.0" />
+        <dependency id="NETStandard.Library" version="1.6.1" />
         <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" />
-      </group>
-      
+      <group targetFramework="netstandard2.0" />
+      <group targetFramework="netstandard2.1" />
+      <group targetFramework="netcoreapp3.1" />
+      <group targetFramework="net5.0" />
       <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 5.0 -->
+    <file src="..\Source\MQTTnet\bin\Release\net5.0\MQTTnet.*" target="lib\net5.0\" />
+
     <!-- .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\" />
+
+    <!-- .NET Standard 3.1 -->
+    <file src="..\Source\MQTTnet\bin\Release\netcoreapp3.1\MQTTnet.*" target="lib\netcoreapp3.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>

Build/build.ps1

@@ -4,32 +4,95 @@ 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="netcoreapp3.1" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="uap10.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=".\..\..\Build\codeSigningKey.pfx"
+&$msbuild ..\Source\MQTTnet\MQTTnet.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net5.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"
+&$msbuild ..\Source\MQTTnet.AspNetCore\MQTTnet.AspNetCore.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net5.0" /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"
+&$msbuild ..\Source\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net5.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"
+&$msbuild ..\Source\MQTTnet.Extensions.ManagedClient\MQTTnet.Extensions.ManagedClient.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net5.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"
+&$msbuild ..\Source\MQTTnet.Extensions.WebSocket4Net\MQTTnet.Extensions.WebSocket4Net.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net5.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
+
+$gitCommit = git log -1 --format=%h
+
+Copy-Item MQTTnet.nuspec -Destination MQTTnet.nuspec.old -Force
+(Get-Content MQTTnet.nuspec) -replace '\$gitCommit', $gitCommit | Set-Content MQTTnet.nuspec
+Copy-Item MQTTnet.AspNetCore.nuspec -Destination MQTTnet.AspNetCore.nuspec.old -Force
+(Get-Content MQTTnet.AspNetCore.nuspec) -replace '\$nugetVersion', $nugetVersion | Set-Content MQTTnet.AspNetCore.nuspec
+Copy-Item MQTTnet.Extensions.Rpc.nuspec -Destination MQTTnet.Extensions.Rpc.nuspec.old -Force
+(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.nuspec.old -Destination MQTTnet.nuspec -Force
+Move-Item MQTTnet.AspNetCore.nuspec.old -Destination MQTTnet.AspNetCore.nuspec -Force
+Move-Item MQTTnet.Extensions.Rpc.nuspec.old -Destination MQTTnet.Extensions.Rpc.nuspec -Force
+Move-Item MQTTnet.Extensions.ManagedClient.nuspec.old -Destination MQTTnet.Extensions.ManagedClient.nuspec -Force
+Move-Item MQTTnet.Extensions.WebSocket4Net.nuspec.old -Destination MQTTnet.Extensions.WebSocket4Net.nuspec -Force
+
+Remove-Item "nuget.exe" -Force -Recurse -ErrorAction SilentlyContinue

Build/deb-meta/DEBIAN/control

@@ -0,0 +1,10 @@
+Package: mqttnet-server
+Version: VERSIONPLACEHOLDER
+Section: base
+Priority: optional
+Architecture: amd64
+Depends: libssl1.1
+Suggests:
+Maintainer: Damian Wolgast <packages@asymetrixs.net>
+Description:
+  MQTTnet Server is a standalone cross platform MQTT server (like mosquitto) basing on this library.

Build/deb-meta/DEBIAN/copyright

@@ -0,0 +1,26 @@
+The source of MQTTnet is at:
+https://github.com/chkr1011/MQTTnet
+Project is maintained by Christian Kratky
+
+
+MIT License
+
+Copyright (c) 2021 Damian Wolgast
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Build/deb-meta/DEBIAN/postinst

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+# Check if user exits
+USER=mqttnetsrv
+USEREXISTS=$(id -u $USER >/dev/null 2>&1; echo $?)
+EC=0
+BASEPATH=/opt
+INSTALLPATH=$BASEPATH/MQTTnetServer
+
+# If user does not exist, create it
+if (( $USEREXISTS == 1 )); then
+    useradd -d $INSTALLPATH  -r $USER
+    EC=$(echo $?)
+
+    if (( $EC == 1 )); then
+        exit 1;
+    fi
+fi
+
+# Set permissions on files
+chown -R root:root $INSTALLPATH
+
+# Check if config does not exist and create it
+if [ ! -f "$INSTALLPATH/appsettings.json" ]; then
+    cp $INSTALLPATH/appsettings.template.json $INSTALLPATH/appsettings.json
+fi
+
+
+# Check if setcap exists, does not exist in docker containers
+SCAP=$(which setcap >/dev/null; echo $?)
+if [ "$SCAP" -eq "0" ]; then
+    # Enable MQTTServer.NET to bind to IP interface
+    setcap CAP_NET_BIND_SERVICE=+eip $INSTALLPATH/MQTTnet.Server
+fi
+
+chmod 644 /etc/systemd/system/mqttnet-server.service
+
+# Check if systemctl exists, does not exist in docker containers
+SCTL=$(which systemctl >/dev/null; echo $?)
+
+if [ "$SCTL" -eq "0" ]; then
+    # Reload systemd because of new service file
+    systemctl daemon-reload
+fi

Build/deb-meta/DEBIAN/postrm

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+# Check if systemctl exists, does not exist in docker containers
+SCTL=$(which systemctl >/dev/null; echo $?)
+if [ "$SCTL" -eq "0" ]; then
+    # Reload systemd because of new service file
+    systemctl daemon-reload
+fi

Build/deb-meta/DEBIAN/prerm

@@ -0,0 +1,18 @@
+#!/bin/bash
+
+BASEPATH=/opt
+INSTALLPATH=$BASEPATH/MQTTnetServer
+
+# Check if systemctl exists, does not exist in docker containers
+SCTL=$(which systemctl >/dev/null; echo $?)
+if [ "$SCTL" -eq "0" ]; then
+    # Stop service before uninstalling
+    systemctl stop mqttnet-server
+fi
+
+# Check if setcap exists, does not exist in docker containers
+SCAP=$(which setcap >/dev/null; echo $?)
+if [ "$SCAP" -eq "0" ]; then
+    # Remove permission to open ports
+    setcap CAP_NET_BIND_SERVICE=-eip $INSTALLPATH/MQTTnet.Server
+fi

Build/deb-meta/etc/systemd/system/mqttnet-server.service

@@ -0,0 +1,14 @@
+[Unit]
+Description=MQTTnetServer
+After=network.target
+
+[Service]
+ExecStart=/opt/MQTTnetServer/MQTTnet.Server
+WorkingDirectory=/opt/MQTTnetServer
+StandardOutput=inherit
+StandardError=inherit
+Restart=always
+User=mqttnetsrv
+
+[Install]
+WantedBy=multi-user.target

Build/upload.ps1

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

Documents/Import_CodeSigningKey.md

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

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

@@ -1,31 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFrameworks>netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
-    <AssemblyVersion>0.0.0.0</AssemblyVersion>
-    <FileVersion>0.0.0.0</FileVersion>
-    <Product />
-    <Company />
-    <Authors />
-    <PackageId />
-    <Version>0.0.0.0</Version>
-  </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>
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\Frameworks\MQTTnet.Netstandard\MQTTnet.NetStandard.csproj" />
-  </ItemGroup>
-
-</Project>

Extensions/MQTTnet.Extensions.Rpc/MqttRpcClient.cs

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

Extensions/MQTTnet.Extensions.Rpc/SampleCCode.c

@@ -1 +0,0 @@
-

Frameworks/MQTTnet.AspnetCore/ApplicationBuilderExtensions.cs

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

Frameworks/MQTTnet.AspnetCore/MQTTnet.AspnetCore.csproj

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

Frameworks/MQTTnet.AspnetCore/MqttWebSocketServerAdapter.cs

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

Frameworks/MQTTnet.AspnetCore/MqttWebSocketServerChannel.cs

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

Frameworks/MQTTnet.AspnetCore/ServiceCollectionExtensions.cs

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

Frameworks/MQTTnet.NetStandard/Adapter/IMqttChannelAdapter.cs

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

Frameworks/MQTTnet.NetStandard/Adapter/MqttChannelAdapter.cs

@@ -1,218 +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 class MqttChannelAdapter : IMqttChannelAdapter
-    {
-        private const uint ErrorOperationAborted = 0x800703E3;
-        private const int ReadBufferSize = 4096;  // TODO: Move buffer size to config
-
-        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)
-        {
-            _logger.Trace<MqttChannelAdapter>("Connecting [Timeout={0}]", timeout);
-
-            return ExecuteAndWrapExceptionAsync(() => _channel.ConnectAsync().TimeoutAfter(timeout));
-        }
-
-        public Task DisconnectAsync(TimeSpan timeout)
-        {
-            _logger.Trace<MqttChannelAdapter>("Disconnecting [Timeout={0}]", timeout);
-
-            return ExecuteAndWrapExceptionAsync(() => _channel.DisconnectAsync().TimeoutAfter(timeout));
-        }
-
-        public Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets)
-        {
-            return ExecuteAndWrapExceptionAsync(async () =>
-            {
-                await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
-                try
-                {
-                    foreach (var packet in packets)
-                    {
-                        if (packet == null)
-                        {
-                            continue;
-                        }
-
-                        _logger.Trace<MqttChannelAdapter>("TX >>> {0} [Timeout={1}]", packet, timeout);
-
-                        var chunks = PacketSerializer.Serialize(packet);
-                        foreach (var chunk in chunks)
-                        {
-                            await _channel.SendStream.WriteAsync(chunk.Array, chunk.Offset, chunk.Count, cancellationToken).ConfigureAwait(false);
-                        }
-                    }
-
-                    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)
-        {
-            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);
-            }
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Adapter/MqttChannelAdapterExtensions.cs

@@ -1,17 +0,0 @@
-using System;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Packets;
-
-namespace MQTTnet.Adapter
-{
-    public static class MqttChannelAdapterExtensions
-    {
-        public static Task SendPacketsAsync(this IMqttChannelAdapter adapter, TimeSpan timeout, CancellationToken cancellationToken, params MqttBasePacket[] packets)
-        {
-            if (adapter == null) throw new ArgumentNullException(nameof(adapter));
-
-            return adapter.SendPacketsAsync(timeout, cancellationToken, packets);
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Adapter/MqttConnectingFailedException.cs

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

Frameworks/MQTTnet.NetStandard/Adapter/MqttServerAdapterClientAcceptedEventArgs.cs

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

Frameworks/MQTTnet.NetStandard/Adapter/ReceivedMqttPacket.cs

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

Frameworks/MQTTnet.NetStandard/ApplicationMessagePublisherExtensions.cs

@@ -1,16 +0,0 @@
-using System;
-using System.Threading.Tasks;
-
-namespace MQTTnet
-{
-    public static class ApplicationMessagePublisherExtensions
-    {
-        public static Task PublishAsync(this IApplicationMessagePublisher client, params MqttApplicationMessage[] applicationMessages)
-        {
-            if (client == null) throw new ArgumentNullException(nameof(client));
-            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
-
-            return client.PublishAsync(applicationMessages);
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Channel/IMqttChannel.cs

@@ -1,14 +0,0 @@
-using System.IO;
-using System.Threading.Tasks;
-
-namespace MQTTnet.Channel
-{
-    public interface IMqttChannel
-    {
-        Stream SendStream { get; }
-        Stream ReceiveStream { get; }
-
-        Task ConnectAsync();
-        Task DisconnectAsync();
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/IMqttClient.cs

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

Frameworks/MQTTnet.NetStandard/Client/IMqttClientAdapterFactory.cs

@@ -1,10 +0,0 @@
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-
-namespace MQTTnet.Client
-{
-    public interface IMqttClientAdapterFactory
-    {
-        IMqttChannelAdapter CreateClientAdapter(IMqttClientChannelOptions options, IMqttNetLogger logger);
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/IMqttClientFactory.cs

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

Frameworks/MQTTnet.NetStandard/Client/IMqttClientOptions.cs

@@ -1,20 +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; }
-        MqttProtocolVersion ProtocolVersion { get; }
-
-        IMqttClientChannelOptions ChannelOptions { get; }
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/MqttClient.cs

@@ -1,475 +0,0 @@
-using System;
-using System.Collections.Generic;
-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 IMqttClientAdapterFactory _adapterFactory;
-        private readonly MqttPacketDispatcher _packetDispatcher;
-        private readonly IMqttNetLogger _logger;
-
-        private IMqttClientOptions _options;
-        private bool _isReceivingPackets;
-        private CancellationTokenSource _cancellationTokenSource;
-        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(_cancellationTokenSource.Token).ConfigureAwait(false);
-                var connectResponse = await AuthenticateAsync(options.WillMessage).ConfigureAwait(false);
-
-                _logger.Trace<MqttClient>("MQTT connection with server established.");
-
-                if (_options.KeepAlivePeriod != TimeSpan.Zero)
-                {
-                    StartSendingKeepAliveMessages(_cancellationTokenSource.Token);
-                }
-
-                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
-            {
-                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 _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, qosGroup).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);
-                                await SendAndReceiveAsync<MqttPubCompPacket>(pubRecPacket.CreateResponse<MqttPubRelPacket>()).ConfigureAwait(false);
-                            }
-
-                            break;
-                        }
-                    default:
-                        {
-                            throw new InvalidOperationException();
-                        }
-                }
-            }
-        }
-
-        public void Dispose()
-        {
-            _cancellationTokenSource?.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)
-        {
-            var clientWasConnected = IsConnected;
-            IsConnected = false;
-
-            var cts = _cancellationTokenSource;
-            if (cts == null || cts.IsCancellationRequested)
-            {
-                return;
-            }
-
-            cts.Cancel(false);
-            cts.Dispose();
-            _cancellationTokenSource = null;
-
-            try
-            {
-                await _adapter.DisconnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
-                _logger.Info<MqttClient>("Disconnected from adapter.");
-            }
-            catch (Exception adapterException)
-            {
-                _logger.Warning<MqttClient>(adapterException, "Error while disconnecting from adapter.");
-            }
-            finally
-            {
-                _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 (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)
-        {
-            return SendAsync(pubRelPacket.CreateResponse<MqttPubCompPacket>());
-        }
-
-        private Task SendAsync(MqttBasePacket packet)
-        {
-            return _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, packet);
-        }
-
-        private async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket) where TResponsePacket : MqttBasePacket
-        {
-            ushort identifier = 0;
-            if (requestPacket is IMqttPacketWithIdentifier requestPacketWithIdentifier)
-            {
-                identifier = requestPacketWithIdentifier.PacketIdentifier;
-            }
-
-            var packetAwaiter = _packetDispatcher.WaitForPacketAsync(typeof(TResponsePacket), identifier, _options.CommunicationTimeout);
-            await _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, requestPacket).ConfigureAwait(false);
-            return (TResponsePacket)await packetAwaiter.ConfigureAwait(false);
-        }
-
-        private async Task SendKeepAliveMessagesAsync(CancellationToken cancellationToken)
-        {
-            _logger.Info<MqttClient>("Start sending keep alive packets.");
-
-            try
-            {
-                while (!cancellationToken.IsCancellationRequested)
-                {
-                    await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket()).ConfigureAwait(false);
-                    await Task.Delay(_options.KeepAlivePeriod, cancellationToken).ConfigureAwait(false);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                await DisconnectInternalAsync(null).ConfigureAwait(false);
-            }
-            catch (MqttCommunicationException exception)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                _logger.Warning<MqttClient>(exception, "MQTT communication exception while sending/receiving keep alive packets.");
-                await DisconnectInternalAsync(exception).ConfigureAwait(false);
-            }
-            catch (Exception exception)
-            {
-                _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(CancellationToken cancellationToken)
-        {
-            _logger.Info<MqttClient>("Start receiving packets.");
-
-            try
-            {
-                while (!cancellationToken.IsCancellationRequested)
-                {
-                    _isReceivingPackets = true;
-
-                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
-
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        return;
-                    }
-
-                    StartProcessReceivedPacket(packet, cancellationToken);
-                }
-            }
-            catch (OperationCanceledException)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                await DisconnectInternalAsync(null).ConfigureAwait(false);
-            }
-            catch (MqttCommunicationException exception)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                _logger.Warning<MqttClient>(exception, "MQTT communication exception while receiving packets.");
-                await DisconnectInternalAsync(exception).ConfigureAwait(false);
-            }
-            catch (Exception exception)
-            {
-                _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, CancellationToken cancellationToken)
-        {
-#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 ProcessReceivedPacketAsync(packet).ConfigureAwait(false),
-                cancellationToken).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        }
-
-        private async Task StartReceivingPacketsAsync(CancellationToken cancellationToken)
-        {
-            _isReceivingPackets = false;
-
-#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 ReceivePacketsAsync(cancellationToken).ConfigureAwait(false),
-                cancellationToken).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-
-            while (!_isReceivingPackets && !cancellationToken.IsCancellationRequested)
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken).ConfigureAwait(false);
-            }
-        }
-
-        private void StartSendingKeepAliveMessages(CancellationToken cancellationToken)
-        {
-#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 SendKeepAliveMessagesAsync(cancellationToken).ConfigureAwait(false), 
-                cancellationToken).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/MqttClientConnectResult.cs

@@ -1,12 +0,0 @@
-namespace MQTTnet.Client
-{
-    public class MqttClientConnectResult
-    {
-        public MqttClientConnectResult(bool isSessionPresent)
-        {
-            IsSessionPresent = isSessionPresent;
-        }
-
-        public bool IsSessionPresent { get; }
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/MqttClientConnectedEventArgs.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace MQTTnet.Client
-{
-    public class MqttClientConnectedEventArgs : EventArgs
-    {
-        public MqttClientConnectedEventArgs(bool isSessionPresent)
-        {
-            IsSessionPresent = isSessionPresent;
-        }
-
-        public bool IsSessionPresent { get; }
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/MqttClientDisconnectedEventArgs.cs

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

Frameworks/MQTTnet.NetStandard/Client/MqttClientExtensions.cs

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

Frameworks/MQTTnet.NetStandard/Client/MqttClientOptions.cs

@@ -1,24 +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(5);
-
-        public TimeSpan CommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
-
-        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
-
-        public IMqttClientChannelOptions ChannelOptions { get; set; }
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/MqttClientOptionsBuilder.cs

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

Frameworks/MQTTnet.NetStandard/Client/MqttClientTcpOptions.cs

@@ -1,11 +0,0 @@
-namespace MQTTnet.Client
-{
-    public class MqttClientTcpOptions : IMqttClientChannelOptions
-    {
-        public string Server { get; set; }
-
-        public int? Port { get; set; }
-
-        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/MqttClientTlsOptions.cs

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

Frameworks/MQTTnet.NetStandard/Client/MqttPacketDispatcher.cs

@@ -1,87 +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, 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>();
-
-            var byId = _awaiters.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
-            if (!byId.TryAdd(identifier, 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)
-        {
-            var byId = _awaiters.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
-            byId.TryRemove(identifier, out var _);
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Client/MqttSubscribeResult.cs

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

Frameworks/MQTTnet.NetStandard/Diagnostics/IMqttNetLogger.cs

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

Frameworks/MQTTnet.NetStandard/Diagnostics/MqttNetGlobalLogger.cs

@@ -1,18 +0,0 @@
-using System;
-
-namespace MQTTnet.Diagnostics
-{
-    public static class MqttNetGlobalLogger
-    {
-        public static event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
-
-        public static bool HasListeners => LogMessagePublished != null;
-
-        public static void Publish(MqttNetLogMessage logMessage)
-        {
-            if (logMessage == null) throw new ArgumentNullException(nameof(logMessage));
-
-            LogMessagePublished?.Invoke(null, new MqttNetLogMessagePublishedEventArgs(logMessage));
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Diagnostics/MqttNetLogMessage.cs

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

Frameworks/MQTTnet.NetStandard/Diagnostics/MqttNetLogger.cs

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

Frameworks/MQTTnet.NetStandard/Exceptions/MqttCommunicationTimedOutException.cs

@@ -1,6 +0,0 @@
-namespace MQTTnet.Exceptions
-{
-    public sealed class MqttCommunicationTimedOutException : MqttCommunicationException
-    {
-    }
-}

Frameworks/MQTTnet.NetStandard/IApplicationMessagePublisher.cs

@@ -1,10 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace MQTTnet
-{
-    public interface IApplicationMessagePublisher
-    {
-        Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages);
-    }
-}

Frameworks/MQTTnet.NetStandard/IApplicationMessageReceiver.cs

@@ -1,9 +0,0 @@
-using System;
-
-namespace MQTTnet
-{
-    public interface IApplicationMessageReceiver
-    {
-        event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
-    }
-}

Frameworks/MQTTnet.NetStandard/Implementations/MqttClientAdapterFactory.cs

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

Frameworks/MQTTnet.NetStandard/Implementations/MqttServerAdapter.Uwp.cs

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

Frameworks/MQTTnet.NetStandard/Implementations/MqttServerAdapter.cs

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

Frameworks/MQTTnet.NetStandard/Implementations/MqttTcpChannel.Uwp.cs

@@ -1,133 +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, IDisposable
-    {
-        private readonly MqttClientTcpOptions _options;
-        private StreamSocket _socket;
-
-        public MqttTcpChannel(MqttClientTcpOptions options)
-        {
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-        }
-
-        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()
-        {
-            SendStream?.Dispose();
-            SendStream = null;
-
-            ReceiveStream?.Dispose();
-            ReceiveStream = null;
-
-            _socket?.Dispose();
-            _socket = null;
-        }
-
-        private void CreateStreams()
-        {
-            SendStream = _socket.OutputStream.AsStreamForWrite();
-            ReceiveStream = _socket.InputStream.AsStreamForRead();
-        }
-
-        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

Frameworks/MQTTnet.NetStandard/Implementations/MqttTcpChannel.cs

@@ -1,155 +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, IDisposable
-    {
-        private readonly MqttClientTcpOptions _options;
-
-        //todo: this can be used with min dependency NetStandard1.6
-#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.
-#endif
-
-        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));
-        }
-
-        /// <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(socket, sslStream);
-        }
-
-        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);
-            }
-
-            //todo: else brach can be used with min dependency NET46
-#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(_options), SslProtocols.Tls12, _options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
-            }
-            
-            CreateStreams(_socket, _sslStream);
-        }
-
-        public Task DisconnectAsync()
-        {
-            Dispose();
-            return Task.FromResult(0);
-        }
-
-        public void Dispose()
-        {
-            _socket?.Dispose();
-            _socket = null;
-
-            _sslStream?.Dispose();
-            _sslStream = 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 static X509CertificateCollection LoadCertificates(MqttClientTcpOptions options)
-        {
-            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(Socket socket, Stream sslStream)
-        {
-            var stream = sslStream ?? new NetworkStream(socket);
-            
-            //todo: if branch can be used with min dependency NetStandard1.6
-#if NET452 || NET461
-            SendStream = new BufferedStream(stream, BufferSize);
-            ReceiveStream = new BufferedStream(stream, BufferSize);
-#else
-            SendStream = stream;
-            ReceiveStream = stream;
-#endif
-        }
-
-    }
-}
-#endif

Frameworks/MQTTnet.NetStandard/Implementations/MqttWebSocketChannel.cs

@@ -1,103 +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()
-        {
-            _webSocket?.Dispose();
-            _webSocket = null;
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Implementations/WebSocketStream.cs

@@ -1,129 +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 WebSocket _webSocket;
-        private readonly byte[] _chunkBuffer = new byte[MqttWebSocketChannel.BufferSize];
-        private readonly Queue<byte> _buffer = new Queue<byte>(MqttWebSocketChannel.BufferSize);
-
-        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++;
-            }
-
-            if (count == 0)
-            {
-                return bytesRead;
-            }
-            
-            while (_webSocket.State == WebSocketState.Open)
-            {
-                await FetchChunkAsync(cancellationToken);
-
-                while (count > 0 && _buffer.Any())
-                {
-                    buffer[offset++] = _buffer.Dequeue();
-                    count--;
-                    bytesRead++;
-                }
-
-                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>(_chunkBuffer, 0, _chunkBuffer.Length), cancellationToken).ConfigureAwait(false);
-
-            for (var i = 0; i < response.Count; i++)
-            {
-                var @byte = _chunkBuffer[i];
-                _buffer.Enqueue(@byte);
-            }
-
-            if (response.MessageType == WebSocketMessageType.Close)
-            {
-                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
-            }
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Internal/MqttApplicationMessageExtensions.cs

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

Frameworks/MQTTnet.NetStandard/Internal/TaskExtensions.cs

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

Frameworks/MQTTnet.NetStandard/MQTTnet.Netstandard.csproj

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

Frameworks/MQTTnet.NetStandard/ManagedClient/IManagedMqttClient.cs

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

Frameworks/MQTTnet.NetStandard/ManagedClient/IManagedMqttClientOptions.cs

@@ -1,14 +0,0 @@
-using System;
-using MQTTnet.Client;
-
-namespace MQTTnet.ManagedClient
-{
-    public interface IManagedMqttClientOptions
-    {
-        IMqttClientOptions ClientOptions { get; }
-
-        TimeSpan AutoReconnectDelay { get; }
-
-        IManagedMqttClientStorage Storage { get; }
-    }
-}

Frameworks/MQTTnet.NetStandard/ManagedClient/IManagedMqttClientStorage.cs

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

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClient.cs

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

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClientExtensions.cs

@@ -1,31 +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 UnsubscribeAsync(this IManagedMqttClient managedClient, params string[] topicFilters)
-        {
-            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
-
-            return managedClient.UnsubscribeAsync(topicFilters);
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClientOptions.cs

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

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClientOptionsBuilder.cs

@@ -1,49 +0,0 @@
-using System;
-using MQTTnet.Client;
-
-namespace MQTTnet.ManagedClient
-{
-    public class ManagedMqttClientOptionsBuilder
-    {
-        private readonly ManagedMqttClientOptions _options = new ManagedMqttClientOptions();
-
-        public ManagedMqttClientOptionsBuilder WithAutoReconnectDelay(TimeSpan value)
-        {
-            _options.AutoReconnectDelay = value;
-            return this;
-        }
-
-        public ManagedMqttClientOptionsBuilder WithStorage(IManagedMqttClientStorage value)
-        {
-            _options.Storage = value;
-            return this;
-        }
-
-        public ManagedMqttClientOptionsBuilder WithClientOptions(IMqttClientOptions value)
-        {
-            _options.ClientOptions = value ?? throw new ArgumentNullException(nameof(value));
-            return this;
-        }
-
-        public ManagedMqttClientOptionsBuilder WithClientOptions(Action<MqttClientOptionsBuilder> options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            var builder = new MqttClientOptionsBuilder();
-            options(builder);
-            _options.ClientOptions = builder.Build();
-
-            return this;
-        }
-
-        public ManagedMqttClientOptions Build()
-        {
-            if (_options.ClientOptions == null)
-            {
-                throw new InvalidOperationException("The ClientOptions cannot be null.");
-            }
-
-            return _options;
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClientStorageManager.cs

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

Frameworks/MQTTnet.NetStandard/MqttApplicationMessage.cs

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

Frameworks/MQTTnet.NetStandard/MqttApplicationMessageBuilder.cs

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

Frameworks/MQTTnet.NetStandard/MqttApplicationMessageReceivedEventArgs.cs

@@ -1,17 +0,0 @@
-using System;
-
-namespace MQTTnet
-{
-    public sealed class MqttApplicationMessageReceivedEventArgs : EventArgs
-    {
-        public MqttApplicationMessageReceivedEventArgs(string clientId, MqttApplicationMessage applicationMessage)
-        {
-            ClientId = clientId;
-            ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
-        }
-
-        public string ClientId { get; }
-
-        public MqttApplicationMessage ApplicationMessage { get; }
-    }
-}

Frameworks/MQTTnet.NetStandard/MqttFactory.cs

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

Frameworks/MQTTnet.NetStandard/Packets/MqttBasePublishPacket.cs

@@ -1,7 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public class MqttBasePublishPacket : MqttBasePacket, IMqttPacketWithIdentifier
-    {
-        public ushort PacketIdentifier { get; set; }
-    }
-}

Frameworks/MQTTnet.NetStandard/Packets/MqttConnAckPacket.cs

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

Frameworks/MQTTnet.NetStandard/Packets/MqttConnectPacket.cs

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

Frameworks/MQTTnet.NetStandard/Packets/MqttDisconnectPacket.cs

@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttDisconnectPacket : MqttBasePacket
-    {
-        public override string ToString()
-        {
-            return "Disconnect";
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Packets/MqttPacketExtensions.cs

@@ -1,26 +0,0 @@
-using System;
-
-namespace MQTTnet.Packets
-{
-    public static class MqttPacketExtensions
-    {
-        public static TResponsePacket CreateResponse<TResponsePacket>(this MqttBasePacket packet)
-        {
-            if (packet == null) throw new ArgumentNullException(nameof(packet));
-
-            var responsePacket = Activator.CreateInstance<TResponsePacket>();
-
-            if (responsePacket is IMqttPacketWithIdentifier responsePacketWithIdentifier)
-            {
-                if (!(packet is IMqttPacketWithIdentifier requestPacketWithIdentifier))
-                {
-                    throw new InvalidOperationException("Response packet has PacketIdentifier but request packet does not.");
-                }
-
-                responsePacketWithIdentifier.PacketIdentifier = requestPacketWithIdentifier.PacketIdentifier;
-            }
-
-            return responsePacket;
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Packets/MqttPacketHeader.cs

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

Frameworks/MQTTnet.NetStandard/Packets/MqttPubAckPacket.cs

@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubAckPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubAck";
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Packets/MqttPubCompPacket.cs

@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubCompPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubComp";
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Packets/MqttPubRecPacket.cs

@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubRecPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubRec";
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Packets/MqttPubRelPacket.cs

@@ -1,10 +0,0 @@
-namespace MQTTnet.Packets
-{
-    public sealed class MqttPubRelPacket : MqttBasePublishPacket
-    {
-        public override string ToString()
-        {
-            return "PubRel";
-        }
-    }
-}

Frameworks/MQTTnet.NetStandard/Packets/MqttPublishPacket.cs

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

Frameworks/MQTTnet.NetStandard/Packets/MqttSubAckPacket.cs

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

Frameworks/MQTTnet.NetStandard/Packets/MqttUnsubAckPacket.cs

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

Frameworks/MQTTnet.NetStandard/Serializer/ByteReader.cs

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

Frameworks/MQTTnet.NetStandard/Serializer/ByteWriter.cs

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

Frameworks/MQTTnet.NetStandard/Serializer/IMqttPacketSerializer.cs

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

Frameworks/MQTTnet.NetStandard/Serializer/MqttPacketReader.cs

@@ -1,124 +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)
-        {
-            // 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;
-        }
-    }
-}