Fix build errors

Fix build errors due to merge conflicts
1546 possible bug in server repeatedly sending the same message to client subscribed with cleansession=false (#1569 )
2026-10-16 01:03:01 +08:00 · 2022-11-12 09:43:55 +01:00 · 2022-11-11 14:41:28 +01:00 · 2022-11-11 08:14:15 +01:00 · 2022-11-09 21:14:53 +01:00 · 2022-11-09 20:13:59 +01:00
627 changed files with 40525 additions and 11159 deletions
@@ -1,8 +0,0 @@
 exclude:
 - /Frameworks/.*
 - /MQTTnet.TestApp.NetCore/Program.cs
 - /Tests/MQTTnet.TestApp.NetFramework/.*
 - /Tests/MQTTnet.TestApp.UniversalWindows/.*
 component_depth: 1
 languages:
 - csharp
@@ -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
@@ -1,63 +1 @@
-###############################################################################
+* text=auto
 # Set default behavior to automatically normalize line endings.
 ###############################################################################
 * text=auto
 ###############################################################################
 # Set default behavior for command prompt diff.
 #
 # This is need for earlier builds of msysgit that does not have it on by
 # default for csharp files.
 # Note: This is only used by command line
 ###############################################################################
 #*.cs     diff=csharp
 ###############################################################################
 # Set the merge driver for project and solution files
 #
 # Merging from the command prompt will add diff markers to the files if there
 # are conflicts (Merging from VS is not affected by the settings below, in VS
 # the diff markers are never inserted). Diff markers may cause the following 
 # file extensions to fail to load in VS. An alternative would be to treat
 # these files as binary and thus will always conflict and require user
 # intervention with every merge. To do so, just uncomment the entries below
 ###############################################################################
 #*.sln       merge=binary
 #*.csproj    merge=binary
 #*.vbproj    merge=binary
 #*.vcxproj   merge=binary
 #*.vcproj    merge=binary
 #*.dbproj    merge=binary
 #*.fsproj    merge=binary
 #*.lsproj    merge=binary
 #*.wixproj   merge=binary
 #*.modelproj merge=binary
 #*.sqlproj   merge=binary
 #*.wwaproj   merge=binary
 ###############################################################################
 # behavior for image files
 #
 # image files are treated as binary by default.
 ###############################################################################
 #*.jpg   binary
 #*.png   binary
 #*.gif   binary
 ###############################################################################
 # diff behavior for common document formats
 # 
 # Convert binary document formats to text before diffing them. This feature
 # is only available from the command line. Turn it on by uncommenting the 
 # entries below.
 ###############################################################################
 #*.doc   diff=astextplain
 #*.DOC   diff=astextplain
 #*.docx  diff=astextplain
 #*.DOCX  diff=astextplain
 #*.dot   diff=astextplain
 #*.DOT   diff=astextplain
 #*.pdf   diff=astextplain
 #*.PDF   diff=astextplain
 #*.rtf   diff=astextplain
 #*.RTF   diff=astextplain
@@ -0,0 +1,57 @@
 ---
 name: Bug report
 about: Create a report to help us improve.
 title: ''
 labels: 'bug'
 assignees: ''
 ---
 ### Verification
 Before opening a bug make sure that the following conditions are met.
 <!-- Remove this chapter when all conditions are met. -->
 1. Performance issues are also appearing in RELEASE mode of your application.
 2. An increased memory consumption or high CPU load also happens when your application runs in RELEASE mode AND logging is DISABLED.
 3. Client issues with not received messages, connection drops etc. can be reproduced via another client application like "MQTTnetApp" (https://github.com/chkr1011/MQTTnetApp) or similar.
 4. The bug also appears in the VERY LATEST version of this library. There is no support for older version (due to limited resources) but pull requests for older versions are welcome.
 ### Describe the bug
 A clear and concise description of what the bug is.
 ### Which component is your bug related to?
 <!-- Remove the items which don't apply from the following list. -->
 - Client
 - ManagedClient
 - RpcClient
 - Server
 ### 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.
 **Ideally a Unit Test (which shows the error) is provided so that the behavior can be reproduced easily.**
 ```csharp
 \\ Put your code here.
 ```
@@ -0,0 +1,18 @@
 ---
 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
 - Server
 - Generic
@@ -0,0 +1,28 @@
 ---
 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
 - 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.
@@ -0,0 +1,8 @@
 * [Core] Fixed several dead locks by implementing a new async signal (#1552)
 * [Client] All waiting tasks will now fail when the client connection gets closed. This fixes several freezes (#1561)
 * [ManagedClient] The topic is no longer declared as invalid if a topic alias is used (#1395)
 * [Server] Fixed duplicated invocation of the event _ClientAcknowledgedPublishPacketAsync_ for QoS level 2 (#1550)
 * [Server] Fixed issue in upgrading and downgrading of QoS levels for subscriptions and retained messages (#1560)
 * [Server] Fixed memory leak when old sessions are discarded (#1553)
 * [Server] When using MQTTv5 the reason code _NoMatchingSubscribers_ is returned when no client is subscribed to a published topic (#802)
 * [Server] Fix sending of duplicate messages with QoS > 0 when session is recovered and session is reused (#1546)
@@ -0,0 +1,67 @@
 name: CI
 on: [push, pull_request]
 env:
  VERSION: "4.1.3.${{github.run_number}}"
 jobs:
  build:
    runs-on: windows-2022
    steps:
      - name: Setup Windows SDK
        uses: GuillaumeFalourd/setup-windows10-sdk-action@v1
        with:
          sdk-version: 18362
      - name: Setup .NET SDK
        uses: actions/setup-dotnet@v1.9.0
        with:
          dotnet-version: |
            3.1.x
            6.0.x
      - name: Setup MSBuild
        uses: microsoft/setup-msbuild@v1.1
      - name: Checkout Code
        uses: actions/checkout@v2
      - name: Setup Signing Certificate
        run: |
          $secret = '${{ secrets.SNC_BASE64 }}'
          $decoded = [System.Convert]::FromBase64CharArray($secret, 0, $secret.Length)
          Set-Content -Path ${{ github.workspace }}\certificate.snk -Value $decoded -AsByteStream
      - name: Restore nuget packages
        run: msbuild MQTTnet.sln /t:Restore /p:Configuration="Release" /verbosity:m
      - name: Build solution
        run: msbuild MQTTnet.sln /t:Build /p:Configuration="Release" /verbosity:m /p:FileVersion=${{ env.VERSION }} /p:AssemblyVersion=${{ env.VERSION }} /p:PackageVersion=${{ env.VERSION }} /p:SignAssembly=true /p:AssemblyOriginatorKeyFile=${{ github.workspace }}\certificate.snk
      - name: Collect nuget Packages
        uses: actions/upload-artifact@v2
        with:
          name: nuget Packages
          path: |
            **\*.nupkg
            **\*.snupkg
      - name: Setup VSTest
        uses: darenm/Setup-VSTest@v1
      - name: Core Tests
        run: vstest.console.exe Source\MQTTnet.Tests\bin\Release\net6.0\MQTTnet.Tests.dll
      - name: ASP.NET Tests
        run: vstest.console.exe Source\MQTTnet.AspNetCore.Tests\bin\Release\netcoreapp3.1\MQTTnet.AspNetCore.Tests.dll
      - name: Publish MyGet nugets
        if: ${{ github.event_name == 'push' }}
        run: dotnet nuget push **/*.nupkg -k ${{ secrets.MYGET_API_KEY }} -s https://www.myget.org/F/mqttnet/api/v3/index.json --skip-duplicate
 #      - name: Publish nugets
 #        if: ${{ github.event_name == 'push' && github.ref == 'refs/heads/master' }}
 #        run: dotnet nuget push **/*.nupkg -k ${{ secrets.NUGET_API_KEY }} -s https://api.nuget.org/v3/index.json --skip-duplicate
@@ -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
@@ -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
@@ -1,28 +0,0 @@
 <?xml version="1.0"?>
 <package >
  <metadata>
    <id>MQTTnet.AspNetCore</id>
    <version>2.7.5</version>
    <authors>Christian Kratky</authors>
    <owners>Christian Kratky</owners>
    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
    <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 support library to integrate MQTTnet into AspNetCore.</description>
    <releaseNotes>* Updated to MQTTnet 2.7.5.
    </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> 
    <dependencies>
      <group targetFramework="netstandard2.0">
        <dependency id="MQTTnet" version="2.7.5" />
      </group>
    </dependencies>
  </metadata>
  <files>
    <!-- .NET Standard 2.0 -->
    <file src="..\Frameworks\MQTTnet.AspNetCore\bin\Release\netstandard2.0\MQTTnet.AspNetCore.*" target="lib\netstandard2.0\"/>
  </files>
 </package>
@@ -1,47 +0,0 @@
 <?xml version="1.0"?>
 <package >
  <metadata>
    <id>MQTTnet.Extensions.Rpc</id>
    <version>2.7.5</version>
    <authors>Christian Kratky</authors>
    <owners>Christian Kratky</owners>
    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
    <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>* Updated to MQTTnet 2.7.5.
    </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> 
    <dependencies>
      <group targetFramework="netstandard2.0">
        <dependency id="MQTTnet" version="2.7.5" />
      </group>
      <group targetFramework="netstandard1.3">
        <dependency id="MQTTnet" version="2.7.5" />  
      </group>
      <group targetFramework="netstandard2.0">
        <dependency id="MQTTnet" version="2.7.5" />
      </group>
      <group targetFramework="uap10.0">
        <dependency id="MQTTnet" version="2.7.5" />
      </group>
      <group targetFramework="net452">
        <dependency id="MQTTnet" version="2.7.5" />
      </group>
      <group targetFramework="net461">
        <dependency id="MQTTnet" version="2.7.5" />
      </group>
    </dependencies>
  </metadata>
  <files>
    <!-- .NET Standard 2.0 -->
    <file src="..\Frameworks\MQTTnet.AspNetCore\bin\Release\netstandard2.0\MQTTnet.AspNetCore.*" target="lib\netstandard2.0\"/>
  </files>
 </package>
@@ -1,68 +0,0 @@
 <?xml version="1.0"?>
 <package >
  <metadata>
    <id>MQTTnet</id>
    <version>2.7.5</version>
    <authors>Christian Kratky</authors>
    <owners>Christian Kratky</owners>
    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
    <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> * [Client] Fixed a deadlock while the client disconnects.
 * [Client] Fixed broken support for protocol version 3.1.0.
 * [Server] The _MqttTcpServerAdapter_ is now added to the ASP.NET services.
 * [Server] _MqttServerAdapter_ is renamed to _MqttTcpServerAdapter_ (BREAKING CHANGE!).
 * [Server] The server no longer sends the will message of a client if the disconnect was clean (via _Disconnect_ packet).
 * [Server] The application message interceptor now allows closing the connection.
 * [Server] Added a new flag for the _ClientDisconnected_ event which contains a value indicating whether the disconnect was clean (via _Disconnect_ packet).
    </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> 
    <dependencies>
      <group targetFramework="netstandard1.3">
        <dependency id="NETStandard.Library" version="1.3.0" />
        <dependency id="System.Net.Security" version="4.3.2" />
        <dependency id="System.Net.WebSockets" version="4.3.0" />
        <dependency id="System.Net.WebSockets.Client" version="4.3.1" />      
      </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="uap10.0">
        <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="5.4.1" />
      </group>
      <group targetFramework="net452">
      </group>
      <group targetFramework="net461">
      </group>
    </dependencies>
  </metadata>
  <files>
    <!-- .NET Standard 1.3 -->
    <file src="..\Frameworks\MQTTnet.Netstandard\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\"/>
    <!-- Universal Windows -->
    <file src="..\Frameworks\MQTTnet.Netstandard\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\"/>
  </files>
 </package>
@@ -1,35 +0,0 @@
 param([string]$assemblyVersion, [string]$nugetVersion)
 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'
 $path = &$vswhere -latest -products * -requires Microsoft.Component.MSBuild -property installationPath
 if ($path) {
    $msbuild = join-path $path 'MSBuild\15.0\Bin\MSBuild.exe'
 	# 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"
 	# 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
    Remove-Item .\NuGet -Force -Recurse -ErrorAction SilentlyContinue
    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
 }
@@ -0,0 +1,6 @@
 # Code of Conduct
 This project has adopted the code of conduct defined by the Contributor Covenant
 to clarify expected behavior in our community.
 For more information, see the [.NET Foundation Code of Conduct](https://dotnetfoundation.org/code-of-conduct).
@@ -1,9 +0,0 @@
 # 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
 The container name may be different.
 # Check if the assembly has a strong name
 > sn -vf MQTTnet.dll
@@ -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>
@@ -1,101 +0,0 @@
 using System;
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 using MQTTnet.Client;
 using MQTTnet.Internal;
 using MQTTnet.Protocol;
 namespace MQTTnet.Extensions.Rpc
 {
    public sealed class MqttRpcClient : IDisposable
    {
        private const string ResponseTopic = "$MQTTnet.RPC/+/+/response";
        private readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
        private readonly IMqttClient _mqttClient;
        private bool _isEnabled;
        public MqttRpcClient(IMqttClient mqttClient)
        {
            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
        }
        public async Task EnableAsync()
        {
            await _mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(ResponseTopic).WithAtLeastOnceQoS().Build());
            _isEnabled = true;
        }
        public async Task DisableAsync()
        {
            await _mqttClient.UnsubscribeAsync(ResponseTopic);
            _isEnabled = false;
        }
        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
        {
            if (methodName == null) throw new ArgumentNullException(nameof(methodName));
            if (methodName.Contains("/") || methodName.Contains("+") || methodName.Contains("#"))
            {
                throw new ArgumentException("The method name cannot contain /, + or #.");
            }
            if (!_isEnabled)
            {
                throw new InvalidOperationException("The RPC client is not enabled.");
            }
            var requestTopic = $"$MQTTnet.RPC/{Guid.NewGuid():N}/{methodName}";
            var responseTopic = requestTopic + "/response";
            var requestMessage = new MqttApplicationMessageBuilder()
                .WithTopic(requestTopic)
                .WithPayload(payload)
                .WithQualityOfServiceLevel(qualityOfServiceLevel)
                .Build();
            try
            {
                var tcs = new TaskCompletionSource<byte[]>();
                if (!_waitingCalls.TryAdd(responseTopic, tcs))
                {
                    throw new InvalidOperationException();
                }
                await _mqttClient.PublishAsync(requestMessage);
                return await tcs.Task.TimeoutAfter(timeout);
            }
            finally
            {
                _waitingCalls.TryRemove(responseTopic, out _);
            }
        }
        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
        {
            if (!_waitingCalls.TryRemove(eventArgs.ApplicationMessage.Topic, out TaskCompletionSource<byte[]> tcs))
            {
                return;
            }
            if (tcs.Task.IsCompleted || tcs.Task.IsCanceled)
            {
                return;
            }
            tcs.TrySetResult(eventArgs.ApplicationMessage.Payload);
        }
        public void Dispose()
        {
            foreach (var tcs in _waitingCalls)
            {
                tcs.Value.SetCanceled();
            }
            _waitingCalls.Clear();
        }
    }
 }
@@ -1 +0,0 @@
@@ -1,52 +0,0 @@
 using System;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.Extensions.DependencyInjection;
 using System.Linq;
 using MQTTnet.Server;
 namespace MQTTnet.AspNetCore
 {
    public static class ApplicationBuilderExtensions
    {
        public static IApplicationBuilder UseMqttEndpoint(this IApplicationBuilder app, string path = "/mqtt")
        {
            app.UseWebSockets();
            app.Use(async (context, next) =>
            {
                if (context.Request.Path == path && context.WebSockets.IsWebSocketRequest)
                {
                    string subprotocol = null;
                    if (context.Request.Headers.TryGetValue("Sec-WebSocket-Protocol", out var requestedSubProtocolValues)
                     && requestedSubProtocolValues.Count > 0
                     && requestedSubProtocolValues.Any(v => v.ToLower() == "mqtt")
                     )
                    {
                        subprotocol = "mqtt";
                    }
                    var adapter = app.ApplicationServices.GetRequiredService<MqttWebSocketServerAdapter>();
                    using (var webSocket = await context.WebSockets.AcceptWebSocketAsync(subprotocol))
                    {
                        await adapter.AcceptWebSocketAsync(webSocket);
                    }
                }
                else
                {
                    await next();
                }
            });
            return app;
        }
        public static IApplicationBuilder UseMqttServer(this IApplicationBuilder app, Action<IMqttServer> configure)
        {
            var server = app.ApplicationServices.GetRequiredService<IMqttServer>();
            configure(server);
            return app;
        }
    }
 }
@@ -1,28 +0,0 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <AssemblyVersion>0.0.0.0</AssemblyVersion>
    <FileVersion>0.0.0.0</FileVersion>
    <Version>0.0.0.0</Version>
    <Product />
    <Company />
    <Authors />
    <PackageId />
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
    <DefineConstants>RELEASE;NETSTANDARD2_0</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.0.1" />
    <PackageReference Include="Microsoft.AspNetCore.WebSockets" Version="2.0.1" />
    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="2.0.1" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\MQTTnet.Netstandard\MQTTnet.NetStandard.csproj" />
  </ItemGroup>
 </Project>
@@ -1,31 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Hosting;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 using MQTTnet.Server;
 namespace MQTTnet.AspNetCore
 {
    public class MqttHostedServer : MqttServer, IHostedService
    {
        private readonly IMqttServerOptions _options;
        public MqttHostedServer(IMqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger) : base(adapters, logger)
        {
            _options = options ?? throw new ArgumentNullException(nameof(options));
        }
        public Task StartAsync(CancellationToken cancellationToken)
        {
            return StartAsync(_options);
        }
        public Task StopAsync(CancellationToken cancellationToken)
        {
            return StopAsync();
        }
    }
 }
@@ -1,42 +0,0 @@
 using System;
 using System.Net.WebSockets;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 using MQTTnet.Serializer;
 using MQTTnet.Server;
 namespace MQTTnet.AspNetCore
 {
    public sealed class MqttWebSocketServerAdapter : IMqttServerAdapter, IDisposable
    {
        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
        public Task StartAsync(IMqttServerOptions options)
        {
            return Task.CompletedTask;
        }
        public Task StopAsync()
        {
            return Task.CompletedTask;
        }
        public Task AcceptWebSocketAsync(WebSocket webSocket)
        {
            if (webSocket == null) throw new ArgumentNullException(nameof(webSocket));
            var channel = new MqttWebSocketServerChannel(webSocket);
            var clientAdapter = new MqttChannelAdapter(channel, new MqttPacketSerializer(), new MqttNetLogger());
            var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
            ClientAccepted?.Invoke(this, eventArgs);
            return eventArgs.SessionTask;
        }
        public void Dispose()
        {
            StopAsync();
        }
    }
 }
@@ -1,60 +0,0 @@
 using System;
 using System.IO;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Channel;
 using MQTTnet.Implementations;
 namespace MQTTnet.AspNetCore
 {
    public class MqttWebSocketServerChannel : IMqttChannel, IDisposable
    {
        private WebSocket _webSocket;
        public MqttWebSocketServerChannel(WebSocket webSocket)
        {
            _webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
            SendStream = new WebSocketStream(_webSocket);
            ReceiveStream = SendStream;
        }
        public Stream SendStream { get; private set; }
        public Stream ReceiveStream { get; private set; }
        public Task ConnectAsync()
        {
            return Task.CompletedTask;
        }
        public async Task DisconnectAsync()
        {
            if (_webSocket == null)
            {
                return;
            }
            try
            {
                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
            }
            finally
            {
                Dispose();
            }
        }
        public void Dispose()
        {
            SendStream?.Dispose();
            ReceiveStream?.Dispose();
            _webSocket?.Dispose();
            SendStream = null;
            ReceiveStream = null;
            _webSocket = null;
        }
    }
 }
@@ -1,31 +0,0 @@
 using System;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 using MQTTnet.Server;
 using MQTTnet.Implementations;
 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<MqttTcpServerAdapter>();
            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttWebSocketServerAdapter>()); 
            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttTcpServerAdapter>());
            return services;
        }
    }
 }
@@ -1,22 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Packets;
 using MQTTnet.Serializer;
 namespace MQTTnet.Adapter
 {
    public interface IMqttChannelAdapter : IDisposable
    {
        IMqttPacketSerializer PacketSerializer { get; }
        Task ConnectAsync(TimeSpan timeout);
        Task DisconnectAsync(TimeSpan timeout);
        Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets);
        Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken);
    }
 }
@@ -1,14 +0,0 @@
 using System;
 using System.Threading.Tasks;
 using MQTTnet.Server;
 namespace MQTTnet.Adapter
 {
    public interface IMqttServerAdapter
    {
        event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
        Task StartAsync(IMqttServerOptions options);
        Task StopAsync();
    }
 }
@@ -1,255 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Net.Sockets;
 using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Channel;
 using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Serializer;
 namespace MQTTnet.Adapter
 {
    public sealed class MqttChannelAdapter : IMqttChannelAdapter
    {
        private const uint ErrorOperationAborted = 0x800703E3;
        private const int ReadBufferSize = 4096;  // TODO: Move buffer size to config
        private bool _isDisposed;
        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
        private readonly IMqttNetLogger _logger;
        private readonly IMqttChannel _channel;
        public MqttChannelAdapter(IMqttChannel channel, IMqttPacketSerializer serializer, IMqttNetLogger logger)
        {
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
            _channel = channel ?? throw new ArgumentNullException(nameof(channel));
            PacketSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
        }
        public IMqttPacketSerializer PacketSerializer { get; }
        public Task ConnectAsync(TimeSpan timeout)
        {
            ThrowIfDisposed();
            _logger.Verbose<MqttChannelAdapter>("Connecting [Timeout={0}]", timeout);
            return ExecuteAndWrapExceptionAsync(() => _channel.ConnectAsync().TimeoutAfter(timeout));
        }
        public Task DisconnectAsync(TimeSpan timeout)
        {
            ThrowIfDisposed();
            _logger.Verbose<MqttChannelAdapter>("Disconnecting [Timeout={0}]", timeout);
            return ExecuteAndWrapExceptionAsync(() => _channel.DisconnectAsync().TimeoutAfter(timeout));
        }
        public Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets)
        {
            ThrowIfDisposed();
            return ExecuteAndWrapExceptionAsync(async () =>
            {
                await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
                try
                {
                    foreach (var packet in packets)
                    {
                        if (cancellationToken.IsCancellationRequested)
                        {
                            return;
                        }
                        if (packet == null)
                        {
                            continue;
                        }
                        _logger.Verbose<MqttChannelAdapter>("TX >>> {0} [Timeout={1}]", packet, timeout);
                        var chunks = PacketSerializer.Serialize(packet);
                        foreach (var chunk in chunks)
                        {
                            if (cancellationToken.IsCancellationRequested)
                            {
                                return;
                            }
                            await _channel.SendStream.WriteAsync(chunk.Array, chunk.Offset, chunk.Count, cancellationToken).ConfigureAwait(false);
                        }
                    }
                    if (cancellationToken.IsCancellationRequested)
                    {
                        return;
                    }
                    if (timeout > TimeSpan.Zero)
                    {
                        await _channel.SendStream.FlushAsync(cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
                    }
                    else
                    {
                        await _channel.SendStream.FlushAsync(cancellationToken).ConfigureAwait(false);
                    }
                }
                finally
                {
                    _semaphore.Release();
                }
            });
        }
        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
        {
            ThrowIfDisposed();
            MqttBasePacket packet = null;
            await ExecuteAndWrapExceptionAsync(async () =>
            {
                ReceivedMqttPacket receivedMqttPacket = null;
                try
                {
                    if (timeout > TimeSpan.Zero)
                    {
                        receivedMqttPacket = await ReceiveAsync(_channel.ReceiveStream, cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
                    }
                    else
                    {
                        receivedMqttPacket = await ReceiveAsync(_channel.ReceiveStream, cancellationToken).ConfigureAwait(false);
                    }
                    if (receivedMqttPacket == null || cancellationToken.IsCancellationRequested)
                    {
                        throw new TaskCanceledException();
                    }
                    packet = PacketSerializer.Deserialize(receivedMqttPacket.Header, receivedMqttPacket.Body);
                    if (packet == null)
                    {
                        throw new MqttProtocolViolationException("Received malformed packet.");
                    }
                    _logger.Verbose<MqttChannelAdapter>("RX <<< {0}", packet);
                }
                finally
                {
                    receivedMqttPacket?.Dispose();
                }
            }).ConfigureAwait(false);
            return packet;
        }
        private static async Task<ReceivedMqttPacket> ReceiveAsync(Stream stream, CancellationToken cancellationToken)
        {
            var header = await MqttPacketReader.ReadHeaderAsync(stream, cancellationToken).ConfigureAwait(false);
            if (header == null)
            {
                return null;
            }
            if (header.BodyLength == 0)
            {
                return new ReceivedMqttPacket(header, new MemoryStream(new byte[0], false));
            }
            var body = header.BodyLength <= ReadBufferSize ? new MemoryStream(header.BodyLength) : new MemoryStream();
            var buffer = new byte[ReadBufferSize];
            while (body.Length < header.BodyLength)
            {
                var bytesLeft = header.BodyLength - (int)body.Length;
                if (bytesLeft > buffer.Length)
                {
                    bytesLeft = buffer.Length;
                }
                var readBytesCount = await stream.ReadAsync(buffer, 0, bytesLeft, cancellationToken).ConfigureAwait(false);
                // Check if the client closed the connection before sending the full body.
                if (readBytesCount == 0)
                {
                    throw new MqttCommunicationException("Connection closed while reading remaining packet body.");
                }
                // Here is no need to await because internally only an array is used and no real I/O operation is made.
                // Using async here will only generate overhead.
                body.Write(buffer, 0, readBytesCount);
            }
            body.Seek(0L, SeekOrigin.Begin);
            return new ReceivedMqttPacket(header, body);
        }
        private static async Task ExecuteAndWrapExceptionAsync(Func<Task> action)
        {
            try
            {
                await action().ConfigureAwait(false);
            }
            catch (TaskCanceledException)
            {
                throw;
            }
            catch (OperationCanceledException)
            {
                throw;
            }
            catch (MqttCommunicationTimedOutException)
            {
                throw;
            }
            catch (MqttCommunicationException)
            {
                throw;
            }
            catch (COMException comException)
            {
                if ((uint)comException.HResult == ErrorOperationAborted)
                {
                    throw new OperationCanceledException();
                }
                throw new MqttCommunicationException(comException);
            }
            catch (IOException exception)
            {
                if (exception.InnerException is SocketException socketException)
                {
                    if (socketException.SocketErrorCode == SocketError.ConnectionAborted)
                    {
                        throw new OperationCanceledException();
                    }
                }
                throw new MqttCommunicationException(exception);
            }
            catch (Exception exception)
            {
                throw new MqttCommunicationException(exception);
            }
        }
        public void Dispose()
        {
            _isDisposed = true;
            _semaphore?.Dispose();
            _channel?.Dispose();
        }
        private void ThrowIfDisposed()
        {
            if (_isDisposed)
            {
                throw new ObjectDisposedException(nameof(MqttChannelAdapter));
            }
        }
    }
 }
@@ -1,16 +0,0 @@
 using MQTTnet.Exceptions;
 using MQTTnet.Protocol;
 namespace MQTTnet.Adapter
 {
    public class MqttConnectingFailedException : MqttCommunicationException
    {
        public MqttConnectingFailedException(MqttConnectReturnCode returnCode)
            : base($"Connecting with MQTT server failed ({returnCode}).")
        {
            ReturnCode = returnCode;
        }
        public MqttConnectReturnCode ReturnCode { get; }
    }
 }
@@ -1,17 +0,0 @@
 using System;
 using System.Threading.Tasks;
 namespace MQTTnet.Adapter
 {
    public class MqttServerAdapterClientAcceptedEventArgs : EventArgs
    {
        public MqttServerAdapterClientAcceptedEventArgs(IMqttChannelAdapter client)
        {
            Client = client ?? throw new ArgumentNullException(nameof(client));
        }
        public IMqttChannelAdapter Client { get; }
        public Task SessionTask { get; set; }
    }
 }
@@ -1,24 +0,0 @@
 using System;
 using System.IO;
 using MQTTnet.Packets;
 namespace MQTTnet.Adapter
 {
    public sealed class ReceivedMqttPacket : IDisposable
    {
        public ReceivedMqttPacket(MqttPacketHeader header, MemoryStream body)
        {
            Header = header ?? throw new ArgumentNullException(nameof(header));
            Body = body ?? throw new ArgumentNullException(nameof(body));
        }
        public MqttPacketHeader Header { get; }
        public MemoryStream Body { get; }
        public void Dispose()
        {
            Body?.Dispose();
        }
    }
 }
@@ -1,41 +0,0 @@
 using System;
 using System.Threading.Tasks;
 using MQTTnet.Protocol;
 namespace MQTTnet
 {
    public static class ApplicationMessagePublisherExtensions
    {
        public static Task PublishAsync(this IApplicationMessagePublisher publisher, params MqttApplicationMessage[] applicationMessages)
        {
            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
            return publisher.PublishAsync(applicationMessages);
        }
        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic)
        {
            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
            if (topic == null) throw new ArgumentNullException(nameof(topic));
            return publisher.PublishAsync(new MqttApplicationMessageBuilder().WithTopic(topic).Build());
        }
        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic, string payload)
        {
            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
            if (topic == null) throw new ArgumentNullException(nameof(topic));
            return publisher.PublishAsync(new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(payload).Build());
        }
        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
        {
            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
            if (topic == null) throw new ArgumentNullException(nameof(topic));
            return publisher.PublishAsync(new MqttApplicationMessageBuilder().WithTopic(topic).WithPayload(payload).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
        }
    }
 }
@@ -1,15 +0,0 @@
 using System;
 using System.IO;
 using System.Threading.Tasks;
 namespace MQTTnet.Channel
 {
    public interface IMqttChannel : IDisposable
    {
        Stream SendStream { get; }
        Stream ReceiveStream { get; }
        Task ConnectAsync();
        Task DisconnectAsync();
    }
 }
@@ -1,20 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 namespace MQTTnet.Client
 {
    public interface IMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
    {
        bool IsConnected { get; }
        event EventHandler<MqttClientConnectedEventArgs> Connected;
        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
        Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options);
        Task DisconnectAsync();
        Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
        Task UnsubscribeAsync(IEnumerable<string> topics);
    }
 }
@@ -1,10 +0,0 @@
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 namespace MQTTnet.Client
 {
    public interface IMqttClientAdapterFactory
    {
        IMqttChannelAdapter CreateClientAdapter(IMqttClientOptions options, IMqttNetLogger logger);
    }
 }
@@ -1,7 +0,0 @@
 namespace MQTTnet.Client
 {
    public interface IMqttClientChannelOptions
    {
        MqttClientTlsOptions TlsOptions { get; }
    }
 }
@@ -1,8 +0,0 @@
 namespace MQTTnet.Client
 {
    public interface IMqttClientCredentials
    {
        string Password { get; }
        string Username { get; }
    }
 }
@@ -1,16 +0,0 @@
 using MQTTnet.Diagnostics;
 using MQTTnet.ManagedClient;
 namespace MQTTnet.Client
 {
    public interface IMqttClientFactory
    {
        IMqttClient CreateMqttClient();
        IMqttClient CreateMqttClient(IMqttNetLogger logger);
        IManagedMqttClient CreateManagedMqttClient();
        IManagedMqttClient CreateManagedMqttClient(IMqttNetLogger logger);
    }
 }
@@ -1,22 +0,0 @@
 using System;
 using MQTTnet.Serializer;
 namespace MQTTnet.Client
 {
    public interface IMqttClientOptions
    {
        string ClientId { get; }
        IMqttClientCredentials Credentials { get; }
        bool CleanSession { get; }
        MqttApplicationMessage WillMessage { get; }
        TimeSpan CommunicationTimeout { get; }
        TimeSpan KeepAlivePeriod { get; }
        TimeSpan? KeepAliveSendInterval { get; }
        MqttProtocolVersion ProtocolVersion { get; }
        IMqttClientChannelOptions ChannelOptions { get; }
    }
 }
@@ -1,516 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 namespace MQTTnet.Client
 {
    public class MqttClient : IMqttClient
    {
        private readonly MqttPacketIdentifierProvider _packetIdentifierProvider = new MqttPacketIdentifierProvider();
        private readonly Stopwatch _sendTracker = new Stopwatch();
        private readonly SemaphoreSlim _disconnectLock = new SemaphoreSlim(1, 1);
        private readonly IMqttClientAdapterFactory _adapterFactory;
        private readonly MqttPacketDispatcher _packetDispatcher;
        private readonly IMqttNetLogger _logger;
        private IMqttClientOptions _options;
        private bool _isReceivingPackets;
        private CancellationTokenSource _cancellationTokenSource;
        private Task _packetReceiverTask;
        private Task _keepAliveMessageSenderTask;
        private IMqttChannelAdapter _adapter;
        public MqttClient(IMqttClientAdapterFactory channelFactory, IMqttNetLogger logger)
        {
            _adapterFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
            _packetDispatcher = new MqttPacketDispatcher(logger);
        }
        public event EventHandler<MqttClientConnectedEventArgs> Connected;
        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
        public bool IsConnected { get; private set; }
        public async Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options)
        {
            if (options == null) throw new ArgumentNullException(nameof(options));
            if (options.ChannelOptions == null) throw new ArgumentException("ChannelOptions are not set.");
            ThrowIfConnected("It is not allowed to connect with a server after the connection is established.");
            try
            {
                _options = options;
                _cancellationTokenSource = new CancellationTokenSource();
                _packetIdentifierProvider.Reset();
                _packetDispatcher.Reset();
                _adapter = _adapterFactory.CreateClientAdapter(options, _logger);
                _logger.Verbose<MqttClient>("Trying to connect with server.");
                await _adapter.ConnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
                _logger.Verbose<MqttClient>("Connection with server established.");
                await StartReceivingPacketsAsync().ConfigureAwait(false);
                var connectResponse = await AuthenticateAsync(options.WillMessage).ConfigureAwait(false);
                _logger.Verbose<MqttClient>("MQTT connection with server established.");
                _sendTracker.Restart();
                if (_options.KeepAlivePeriod != TimeSpan.Zero)
                {
                    StartSendingKeepAliveMessages();
                }
                IsConnected = true;
                Connected?.Invoke(this, new MqttClientConnectedEventArgs(connectResponse.IsSessionPresent));
                _logger.Info<MqttClient>("Connected.");
                return new MqttClientConnectResult(connectResponse.IsSessionPresent);
            }
            catch (Exception exception)
            {
                _logger.Error<MqttClient>(exception, "Error while connecting with server.");
                await DisconnectInternalAsync(null, exception).ConfigureAwait(false);
                throw;
            }
        }
        public async Task DisconnectAsync()
        {
            if (!IsConnected)
            {
                return;
            }
            try
            {
                if (!_cancellationTokenSource.IsCancellationRequested)
                {
                    await SendAsync(new MqttDisconnectPacket()).ConfigureAwait(false);
                }
            }
            finally
            {
                await DisconnectInternalAsync(null, null).ConfigureAwait(false);
            }
        }
        public async Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
        {
            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
            ThrowIfNotConnected();
            var subscribePacket = new MqttSubscribePacket
            {
                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
                TopicFilters = topicFilters.ToList()
            };
            var response = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket).ConfigureAwait(false);
            if (response.SubscribeReturnCodes.Count != subscribePacket.TopicFilters.Count)
            {
                throw new MqttProtocolViolationException("The return codes are not matching the topic filters [MQTT-3.9.3-1].");
            }
            return subscribePacket.TopicFilters.Select((t, i) => new MqttSubscribeResult(t, response.SubscribeReturnCodes[i])).ToList();
        }
        public async Task UnsubscribeAsync(IEnumerable<string> topicFilters)
        {
            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
            ThrowIfNotConnected();
            var unsubscribePacket = new MqttUnsubscribePacket
            {
                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
                TopicFilters = topicFilters.ToList()
            };
            await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket).ConfigureAwait(false);
        }
        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
        {
            ThrowIfNotConnected();
            var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
            var packetGroups = publishPackets.GroupBy(p => p.QualityOfServiceLevel).OrderBy(g => g.Key);
            foreach (var qosGroup in packetGroups)
            {
                switch (qosGroup.Key)
                {
                    case MqttQualityOfServiceLevel.AtMostOnce:
                        {
                            // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
                            await SendAsync(qosGroup.Cast<MqttBasePacket>().ToArray()).ConfigureAwait(false);
                            break;
                        }
                    case MqttQualityOfServiceLevel.AtLeastOnce:
                        {
                            foreach (var publishPacket in qosGroup)
                            {
                                publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
                                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket).ConfigureAwait(false);
                            }
                            break;
                        }
                    case MqttQualityOfServiceLevel.ExactlyOnce:
                        {
                            foreach (var publishPacket in qosGroup)
                            {
                                publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
                                var pubRecPacket = await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket).ConfigureAwait(false);
                                var pubRelPacket = new MqttPubRelPacket
                                {
                                    PacketIdentifier = pubRecPacket.PacketIdentifier
                                };
                                await SendAndReceiveAsync<MqttPubCompPacket>(pubRelPacket).ConfigureAwait(false);
                            }
                            break;
                        }
                    default:
                        {
                            throw new InvalidOperationException();
                        }
                }
            }
        }
        public void Dispose()
        {
            _cancellationTokenSource?.Dispose();
            _cancellationTokenSource = null;
            _adapter?.Dispose();
        }
        private async Task<MqttConnAckPacket> AuthenticateAsync(MqttApplicationMessage willApplicationMessage)
        {
            var connectPacket = new MqttConnectPacket
            {
                ClientId = _options.ClientId,
                Username = _options.Credentials?.Username,
                Password = _options.Credentials?.Password,
                CleanSession = _options.CleanSession,
                KeepAlivePeriod = (ushort)_options.KeepAlivePeriod.TotalSeconds,
                WillMessage = willApplicationMessage
            };
            var response = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket).ConfigureAwait(false);
            if (response.ConnectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
            {
                throw new MqttConnectingFailedException(response.ConnectReturnCode);
            }
            return response;
        }
        private void ThrowIfNotConnected()
        {
            if (!IsConnected) throw new MqttCommunicationException("The client is not connected.");
        }
        private void ThrowIfConnected(string message)
        {
            if (IsConnected) throw new MqttProtocolViolationException(message);
        }
        private async Task DisconnectInternalAsync(Task sender, Exception exception)
        {
            await _disconnectLock.WaitAsync();
            try
            {
                if (_cancellationTokenSource == null || _cancellationTokenSource.IsCancellationRequested)
                {
                    return;
                }
                _cancellationTokenSource.Cancel(false);
            }
            catch (Exception adapterException)
            {
                _logger.Warning<MqttClient>(adapterException, "Error while disconnecting from adapter.");
            }
            finally
            {
                _disconnectLock.Release();
            }
            var clientWasConnected = IsConnected;
            IsConnected = false;
            try
            {
                if (_packetReceiverTask != null && _packetReceiverTask != sender)
                {
                    _packetReceiverTask.Wait();
                }
                if (_keepAliveMessageSenderTask != null && _keepAliveMessageSenderTask != sender)
                {
                    _keepAliveMessageSenderTask.Wait();
                }
                if (_adapter != null)
                {
                    await _adapter.DisconnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
                }
                _logger.Verbose<MqttClient>("Disconnected from adapter.");
            }
            catch (Exception adapterException)
            {
                _logger.Warning<MqttClient>(adapterException, "Error while disconnecting from adapter.");
            }
            finally
            {
                _adapter?.Dispose();
                _adapter = null;
                _cancellationTokenSource?.Dispose();
                _cancellationTokenSource = null;
                _logger.Info<MqttClient>("Disconnected.");
                Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected, exception));
            }
        }
        private async Task ProcessReceivedPacketAsync(MqttBasePacket packet)
        {
            try
            {
                if (packet is MqttPublishPacket publishPacket)
                {
                    await ProcessReceivedPublishPacketAsync(publishPacket).ConfigureAwait(false);
                    return;
                }
                if (packet is MqttPingReqPacket)
                {
                    await SendAsync(new MqttPingRespPacket()).ConfigureAwait(false);
                    return;
                }
                if (packet is MqttDisconnectPacket)
                {
                    await DisconnectAsync().ConfigureAwait(false);
                    return;
                }
                if (packet is MqttPubRelPacket pubRelPacket)
                {
                    await ProcessReceivedPubRelPacket(pubRelPacket).ConfigureAwait(false);
                    return;
                }
                _packetDispatcher.Dispatch(packet);
            }
            catch (Exception exception)
            {
                _logger.Error<MqttClient>(exception, "Unhandled exception while processing received packet.");
            }
        }
        private void FireApplicationMessageReceivedEvent(MqttPublishPacket publishPacket)
        {
            try
            {
                var applicationMessage = publishPacket.ToApplicationMessage();
                ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(_options.ClientId, applicationMessage));
            }
            catch (Exception exception)
            {
                _logger.Error<MqttClient>(exception, "Unhandled exception while handling application message.");
            }
        }
        private Task ProcessReceivedPublishPacketAsync(MqttPublishPacket publishPacket)
        {
            if (_cancellationTokenSource.IsCancellationRequested)
            {
                return Task.FromResult(0);
            }
            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
            {
                FireApplicationMessageReceivedEvent(publishPacket);
                return Task.FromResult(0);
            }
            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
            {
                FireApplicationMessageReceivedEvent(publishPacket);
                return SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier });
            }
            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
            {
                // QoS 2 is implement as method "B" [4.3.3 QoS 2: Exactly once delivery]
                FireApplicationMessageReceivedEvent(publishPacket);
                return SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier });
            }
            throw new MqttCommunicationException("Received a not supported QoS level.");
        }
        private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
        {
            var response = new MqttPubCompPacket
            {
                PacketIdentifier = pubRelPacket.PacketIdentifier
            };
            return SendAsync(response);
        }
        private Task SendAsync(params MqttBasePacket[] packets)
        {
            _sendTracker.Restart();
            return _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, packets);
        }
        private async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket) where TResponsePacket : MqttBasePacket
        {
            ushort? identifier = null;
            if (requestPacket is IMqttPacketWithIdentifier requestPacketWithIdentifier)
            {
                identifier = requestPacketWithIdentifier.PacketIdentifier;
            }
            var packetAwaiter = _packetDispatcher.WaitForPacketAsync(typeof(TResponsePacket), identifier, _options.CommunicationTimeout);
            await SendAsync(requestPacket).ConfigureAwait(false);
            return (TResponsePacket)await packetAwaiter.ConfigureAwait(false);
        }
        private async Task SendKeepAliveMessagesAsync()
        {
            _logger.Verbose<MqttClient>("Start sending keep alive packets.");
            try
            {
                while (!_cancellationTokenSource.Token.IsCancellationRequested)
                {
                    var keepAliveSendInterval = TimeSpan.FromSeconds(_options.KeepAlivePeriod.TotalSeconds * 0.75);
                    if (_options.KeepAliveSendInterval.HasValue)
                    {
                        keepAliveSendInterval = _options.KeepAliveSendInterval.Value;
                    }
                    if (_sendTracker.Elapsed > keepAliveSendInterval)
                    {
                        await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket()).ConfigureAwait(false);
                    }
                    await Task.Delay(keepAliveSendInterval, _cancellationTokenSource.Token).ConfigureAwait(false);
                }
            }
            catch (Exception exception)
            {
                if (exception is OperationCanceledException)
                {
                }
                else if (exception is MqttCommunicationException)
                {
                    _logger.Warning<MqttClient>(exception, "MQTT communication exception while sending/receiving keep alive packets.");
                }
                else
                {
                    _logger.Error<MqttClient>(exception, "Unhandled exception while sending/receiving keep alive packets.");
                }
                await DisconnectInternalAsync(_keepAliveMessageSenderTask, exception).ConfigureAwait(false);
            }
            finally
            {
                _logger.Verbose<MqttClient>("Stopped sending keep alive packets.");
            }
        }
        private async Task ReceivePacketsAsync()
        {
            _logger.Verbose<MqttClient>("Start receiving packets.");
            try
            {
                while (!_cancellationTokenSource.Token.IsCancellationRequested)
                {
                    _isReceivingPackets = true;
                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, _cancellationTokenSource.Token).ConfigureAwait(false);
                    if (_cancellationTokenSource.Token.IsCancellationRequested)
                    {
                        return;
                    }
                    StartProcessReceivedPacket(packet);
                }
            }
            catch (Exception exception)
            {
                if (exception is OperationCanceledException)
                {
                }
                else if (exception is MqttCommunicationException)
                {
                    _logger.Warning<MqttClient>(exception, "MQTT communication exception while receiving packets.");
                }
                else
                {
                    _logger.Error<MqttClient>(exception, "Unhandled exception while receiving packets.");
                }
                await DisconnectInternalAsync(_packetReceiverTask, exception).ConfigureAwait(false);
            }
            finally
            {
                _logger.Verbose<MqttClient>("Stopped receiving packets.");
            }
        }
        private void StartProcessReceivedPacket(MqttBasePacket packet)
        {
            Task.Run(() => ProcessReceivedPacketAsync(packet), _cancellationTokenSource.Token);
        }
        private async Task StartReceivingPacketsAsync()
        {
            _isReceivingPackets = false;
            _packetReceiverTask = Task.Run(ReceivePacketsAsync, _cancellationTokenSource.Token);
            while (!_isReceivingPackets && !_cancellationTokenSource.Token.IsCancellationRequested)
            {
                await Task.Delay(TimeSpan.FromMilliseconds(100), _cancellationTokenSource.Token).ConfigureAwait(false);
            }
        }
        private void StartSendingKeepAliveMessages()
        {
            _keepAliveMessageSenderTask = Task.Run(SendKeepAliveMessagesAsync, _cancellationTokenSource.Token);
        }
    }
 }
@@ -1,12 +0,0 @@
 namespace MQTTnet.Client
 {
    public class MqttClientConnectResult
    {
        public MqttClientConnectResult(bool isSessionPresent)
        {
            IsSessionPresent = isSessionPresent;
        }
        public bool IsSessionPresent { get; }
    }
 }
@@ -1,14 +0,0 @@
 using System;
 namespace MQTTnet.Client
 {
    public class MqttClientConnectedEventArgs : EventArgs
    {
        public MqttClientConnectedEventArgs(bool isSessionPresent)
        {
            IsSessionPresent = isSessionPresent;
        }
        public bool IsSessionPresent { get; }
    }
 }
@@ -1,9 +0,0 @@
 namespace MQTTnet.Client
 {
    public class MqttClientCredentials : IMqttClientCredentials
    {
        public string Username { get; set; }
        public string Password { get; set; }
    }
 }
@@ -1,17 +0,0 @@
 using System;
 namespace MQTTnet.Client
 {
    public class MqttClientDisconnectedEventArgs : EventArgs
    {
        public MqttClientDisconnectedEventArgs(bool clientWasConnected, Exception exception)
        {
            ClientWasConnected = clientWasConnected;
            Exception = exception;
        }
        public bool ClientWasConnected { get; }
        public Exception Exception { get; }
    }
 }
@@ -1,43 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using MQTTnet.Protocol;
 namespace MQTTnet.Client
 {
    public static class MqttClientExtensions
    {
        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, params TopicFilter[] topicFilters)
        {
            if (client == null) throw new ArgumentNullException(nameof(client));
            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
            return client.SubscribeAsync(topicFilters.ToList());
        }
        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
        {
            if (client == null) throw new ArgumentNullException(nameof(client));
            if (topic == null) throw new ArgumentNullException(nameof(topic));
            return client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
        }
        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, string topic)
        {
            if (client == null) throw new ArgumentNullException(nameof(client));
            if (topic == null) throw new ArgumentNullException(nameof(topic));
            return client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build());
        }
        public static Task UnsubscribeAsync(this IMqttClient client, params string[] topicFilters)
        {
            if (client == null) throw new ArgumentNullException(nameof(client));
            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
            return client.UnsubscribeAsync(topicFilters.ToList());
        }
    }
 }
@@ -1,26 +0,0 @@
 using System;
 using MQTTnet.Serializer;
 namespace MQTTnet.Client
 {
    public class MqttClientOptions : IMqttClientOptions
    {
        public MqttApplicationMessage WillMessage { get; set; }
        public string ClientId { get; set; } = Guid.NewGuid().ToString("N");
        public bool CleanSession { get; set; } = true;
        public IMqttClientCredentials Credentials { get; set; } = new MqttClientCredentials();
        public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(15);
        public TimeSpan? KeepAliveSendInterval { get; set; }
        public TimeSpan CommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
        public IMqttClientChannelOptions ChannelOptions { get; set; }
    }
 }
@@ -1,135 +0,0 @@
 using System;
 using System.Linq;
 using MQTTnet.Serializer;
 namespace MQTTnet.Client
 {
    public class MqttClientOptionsBuilder
    {
        private readonly MqttClientOptions _options = new MqttClientOptions();
        private MqttClientTcpOptions _tcpOptions;
        private MqttClientWebSocketOptions _webSocketOptions;
        private MqttClientTlsOptions _tlsOptions;
        public MqttClientOptionsBuilder WithProtocolVersion(MqttProtocolVersion value)
        {
            _options.ProtocolVersion = value;
            return this;
        }
        public MqttClientOptionsBuilder WithCommunicationTimeout(TimeSpan value)
        {
            _options.CommunicationTimeout = value;
            return this;
        }
        public MqttClientOptionsBuilder WithCleanSession(bool value = true)
        {
            _options.CleanSession = value;
            return this;
        }
        public MqttClientOptionsBuilder WithKeepAlivePeriod(TimeSpan value)
        {
            _options.KeepAlivePeriod = value;
            return this;
        }
        public MqttClientOptionsBuilder WithClientId(string value)
        {
            _options.ClientId = value;
            return this;
        }
        public MqttClientOptionsBuilder WithWillMessage(MqttApplicationMessage value)
        {
            _options.WillMessage = value;
            return this;
        }
        public MqttClientOptionsBuilder WithCredentials(string username, string password = null)
        {
            _options.Credentials = new MqttClientCredentials
            {
                Username = username,
                Password = password
            };
            return this;
        }
        public MqttClientOptionsBuilder WithTcpServer(string server, int? port = null)
        {
            _tcpOptions = new MqttClientTcpOptions
            {
                Server = server,
                Port = port
            };
            return this;
        }
        public MqttClientOptionsBuilder WithWebSocketServer(string uri)
        {
            _webSocketOptions = new MqttClientWebSocketOptions
            {
                Uri = uri
            };
            return this;
        }
        public MqttClientOptionsBuilder WithTls(
            bool allowUntrustedCertificates = false,
            bool ignoreCertificateChainErrors = false,
            bool ignoreCertificateRevocationErrors = false,
            params byte[][] certificates)
        {
            _tlsOptions = new MqttClientTlsOptions
            {
                UseTls = true,
                AllowUntrustedCertificates = allowUntrustedCertificates,
                IgnoreCertificateChainErrors = ignoreCertificateChainErrors,
                IgnoreCertificateRevocationErrors = ignoreCertificateRevocationErrors,
                Certificates = certificates?.ToList()
            };
            return this;
        }
        public MqttClientOptionsBuilder WithTls()
        {
            _tlsOptions = new MqttClientTlsOptions
            {
                UseTls = true
            };
            return this;
        }
        public IMqttClientOptions Build()
        {
            if (_tlsOptions != null)
            {
                if (_tcpOptions == null && _webSocketOptions == null)
                {
                    throw new InvalidOperationException("A channel (TCP or WebSocket) must be set if TLS is configured.");
                }
                if (_tcpOptions != null)
                {
                    _tcpOptions.TlsOptions = _tlsOptions;
                }
                else if (_webSocketOptions != null)
                {
                    _webSocketOptions.TlsOptions = _tlsOptions;
                }
            }
            _options.ChannelOptions = (IMqttClientChannelOptions)_tcpOptions ?? _webSocketOptions;
            return _options;
        }
    }
 }
@@ -1,13 +0,0 @@
 namespace MQTTnet.Client
 {
    public class MqttClientTcpOptions : IMqttClientChannelOptions
    {
        public string Server { get; set; }
        public int? Port { get; set; }
        public int BufferSize { get; set; } = 20 * 4096;
        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
    }
 }
@@ -1,17 +0,0 @@
 using System.Collections.Generic;
 namespace MQTTnet.Client
 {
    public class MqttClientTlsOptions
    {
        public bool UseTls { get; set; }
        public bool IgnoreCertificateRevocationErrors { get; set; }
        public bool IgnoreCertificateChainErrors { get; set; }
        public bool AllowUntrustedCertificates { get; set; }
        public List<byte[]> Certificates { get; set; }
    }
 }
@@ -1,18 +0,0 @@
 using System.Collections.Generic;
 using System.Net;
 namespace MQTTnet.Client
 {
    public class MqttClientWebSocketOptions : IMqttClientChannelOptions
    {
        public string Uri { get; set; }
        public IDictionary<string, string> RequestHeaders { get; set; }
        public ICollection<string> SubProtocols { get; set; } = new List<string> { "mqtt" };
        public CookieContainer CookieContainer { get; set; }
        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
    }
 }
@@ -1,97 +0,0 @@
 using System;
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
 using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 namespace MQTTnet.Client
 {
    public class MqttPacketDispatcher
    {
        private readonly ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>> _awaiters = new ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>>();
        private readonly IMqttNetLogger _logger;
        public MqttPacketDispatcher(IMqttNetLogger logger)
        {
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
        }
        public async Task<MqttBasePacket> WaitForPacketAsync(Type responseType, ushort? identifier, TimeSpan timeout)
        {
            var packetAwaiter = AddPacketAwaiter(responseType, identifier);
            try
            {
                return await packetAwaiter.Task.TimeoutAfter(timeout).ConfigureAwait(false);
            }
            catch (MqttCommunicationTimedOutException)
            {
                _logger.Warning<MqttPacketDispatcher>("Timeout while waiting for packet of type '{0}'.", responseType.Name);
                throw;
            }
            finally
            {
                RemovePacketAwaiter(responseType, identifier);
            }
        }
        public void Dispatch(MqttBasePacket packet)
        {
            if (packet == null) throw new ArgumentNullException(nameof(packet));
            var type = packet.GetType();
            if (_awaiters.TryGetValue(type, out var byId))
            {
                ushort? identifier = 0;
                if (packet is IMqttPacketWithIdentifier packetWithIdentifier)
                {
                    identifier = packetWithIdentifier.PacketIdentifier;
                }
                if (byId.TryRemove(identifier.Value, out var tcs))
                {
                    tcs.TrySetResult(packet);
                    return;
                }
            }
            throw new InvalidOperationException($"Packet of type '{type.Name}' not handled or dispatched.");
        }
        public void Reset()
        {
            _awaiters.Clear();
        }
        private TaskCompletionSource<MqttBasePacket> AddPacketAwaiter(Type responseType, ushort? identifier)
        {
            var tcs = new TaskCompletionSource<MqttBasePacket>();
            if (!identifier.HasValue)
            {
                identifier = 0;
            }
            var byId = _awaiters.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
            if (!byId.TryAdd(identifier.Value, tcs))
            {
                throw new InvalidOperationException($"The packet dispatcher already has an awaiter for packet of type '{responseType}' with identifier {identifier}.");
            }
            return tcs;
        }
        private void RemovePacketAwaiter(Type responseType, ushort? identifier)
        {
            if (!identifier.HasValue)
            {
                identifier = 0;
            }
            var byId = _awaiters.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
            byId.TryRemove(identifier.Value, out var _);
        }
    }
 }
@@ -1,17 +0,0 @@
 using MQTTnet.Protocol;
 namespace MQTTnet.Client
 {
    public class MqttSubscribeResult
    {
        public MqttSubscribeResult(TopicFilter topicFilter, MqttSubscribeReturnCode returnCode)
        {
            TopicFilter = topicFilter;
            ReturnCode = returnCode;
        }
        public TopicFilter TopicFilter { get; }
        public MqttSubscribeReturnCode ReturnCode { get; }
    }
 }
@@ -1,21 +0,0 @@
 using System;
 namespace MQTTnet.Diagnostics
 {
    public interface IMqttNetLogger
    {
        event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
        void Verbose<TSource>(string message, params object[] parameters);
        void Info<TSource>(string message, params object[] parameters);
        void Warning<TSource>(Exception exception, string message, params object[] parameters);
        void Warning<TSource>(string message, params object[] parameters);
        void Error<TSource>(Exception exception, string message, params object[] parameters);
        void Error<TSource>(string message, params object[] parameters);
    }
 }
@@ -1,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));
        }
    }
 }
@@ -1,13 +0,0 @@
 namespace MQTTnet.Diagnostics
 {
    public enum MqttNetLogLevel
    {
        Verbose,
        Info,
        Warning,
        Error
    }
 }
@@ -1,43 +0,0 @@
 using System;
 namespace MQTTnet.Diagnostics
 {
    public sealed class MqttNetLogMessage
    {
        public MqttNetLogMessage(string logId, DateTime timestamp, int threadId, string source, MqttNetLogLevel level, string message, Exception exception)
        {
            LogId = logId;
            Timestamp = timestamp;
            ThreadId = threadId;
            Source = source;
            Level = level;
            Message = message;
            Exception = exception;
        }
        public string LogId { get; }
        public DateTime Timestamp { get; }
        public int ThreadId { get; }
        public string Source { get; }
        public MqttNetLogLevel Level { get; }
        public string Message { get; }
        public Exception Exception { get; }
        public override string ToString()
        {
            var result = $"[{Timestamp:O}] [{LogId}] [{ThreadId}] [{Source}] [{Level}]: {Message}";
            if (Exception != null)
            {
                result += Environment.NewLine + Exception;
            }
            return result;
        }
    }
 }
@@ -1,14 +0,0 @@
 using System;
 namespace MQTTnet.Diagnostics
 {
    public sealed class MqttNetLogMessagePublishedEventArgs : EventArgs
    {
        public MqttNetLogMessagePublishedEventArgs(MqttNetLogMessage logMessage)
        {
            TraceMessage = logMessage ?? throw new ArgumentNullException(nameof(logMessage));
        }
        public MqttNetLogMessage TraceMessage { get; }
    }
 }
@@ -1,74 +0,0 @@
 using System;
 namespace MQTTnet.Diagnostics
 {
    public class MqttNetLogger : IMqttNetLogger
    {
        private readonly string _logId;
        public MqttNetLogger(string logId = null)
        {
            _logId = logId;
        }
        public event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
        public void Verbose<TSource>(string message, params object[] parameters)
        {
            Publish<TSource>(MqttNetLogLevel.Verbose, null, message, parameters);
        }
        public void Info<TSource>(string message, params object[] parameters)
        {
            Publish<TSource>(MqttNetLogLevel.Info, null, message, parameters);
        }
        public void Warning<TSource>(Exception exception, string message, params object[] parameters)
        {
            Publish<TSource>(MqttNetLogLevel.Warning, exception, message, parameters);
        }
        public void Warning<TSource>(string message, params object[] parameters)
        {
            Warning<TSource>(null, message, parameters);
        }
        public void Error<TSource>(Exception exception, string message, params object[] parameters)
        {
            Publish<TSource>(MqttNetLogLevel.Error, exception, message, parameters);
        }
        public void Error<TSource>(string message, params object[] parameters)
        {
            Warning<TSource>(null, message, parameters);
        }
        private void Publish<TSource>(MqttNetLogLevel logLevel, Exception exception, string message, object[] parameters)
        {
            var hasLocalListeners = LogMessagePublished != null;
            var hasGlobalListeners = MqttNetGlobalLogger.HasListeners;
            if (!hasLocalListeners && !hasGlobalListeners)
            {
                return;
            }
            if (parameters.Length > 0)
            {
                message = string.Format(message, parameters);
            }
            var traceMessage = new MqttNetLogMessage(_logId, DateTime.Now, Environment.CurrentManagedThreadId, typeof(TSource).Name, logLevel, message, exception);
            if (hasGlobalListeners)
            {
                MqttNetGlobalLogger.Publish(traceMessage);
            }
            if (hasLocalListeners)
            {
                LogMessagePublished?.Invoke(this, new MqttNetLogMessagePublishedEventArgs(traceMessage));
            }
        }
    }
 }
@@ -1,23 +0,0 @@
 namespace MQTTnet.Diagnostics
 {
    public static class TargetFrameworkInfoProvider
    {
        public static string TargetFramework
        {
            get
            {
 #if NET452
                return "net452";
 #elif NET461
                return "net461";
 #elif NETSTANDARD1_3
                return "netstandard1.3";
 #elif NETSTANDARD2_0
                return "netstandard2.0";
 #elif WINDOWS_UWP
                return "uap10.0";
 #endif
            }
        }
    }
 }
@@ -1,21 +0,0 @@
 using System;
 namespace MQTTnet.Exceptions
 {
    public class MqttCommunicationException : Exception
    {
        protected MqttCommunicationException()
        {
        }
        public MqttCommunicationException(Exception innerException)
            : base(innerException.Message, innerException)
        {
        }
        public MqttCommunicationException(string message)
            : base(message)
        {
        }
    }
 }
@@ -1,6 +0,0 @@
 namespace MQTTnet.Exceptions
 {
    public sealed class MqttCommunicationTimedOutException : MqttCommunicationException
    {
    }
 }
@@ -1,12 +0,0 @@
 using System;
 namespace MQTTnet.Exceptions
 {
    public sealed class MqttProtocolViolationException : Exception
    {
        public MqttProtocolViolationException(string message)
            : base(message)
        {
        }
    }
 }
@@ -1,10 +0,0 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 namespace MQTTnet
 {
    public interface IApplicationMessagePublisher
    {
        Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages);
    }
 }
@@ -1,9 +0,0 @@
 using System;
 namespace MQTTnet
 {
    public interface IApplicationMessageReceiver
    {
        event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
    }
 }
@@ -1,36 +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(IMqttClientOptions options, IMqttNetLogger logger)
        {
            if (options == null) throw new ArgumentNullException(nameof(options));
            var serializer = new MqttPacketSerializer { ProtocolVersion = options.ProtocolVersion };
            switch (options.ChannelOptions)
            {
                case MqttClientTcpOptions tcpOptions:
                    {
                        return new MqttChannelAdapter(new MqttTcpChannel(tcpOptions), serializer, logger);
                    }
                case MqttClientWebSocketOptions webSocketOptions:
                    {
                        return new MqttChannelAdapter(new MqttWebSocketChannel(webSocketOptions), serializer, logger);
                    }
                default:
                    {
                        throw new NotSupportedException();
                    }
            }
        }
    }
 }
@@ -1,176 +0,0 @@
 #if WINDOWS_UWP
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Runtime.InteropServices.WindowsRuntime;
 using System.Threading.Tasks;
 using Windows.Networking;
 using Windows.Networking.Sockets;
 using Windows.Security.Cryptography.Certificates;
 using MQTTnet.Channel;
 using MQTTnet.Client;
 namespace MQTTnet.Implementations
 {
    public sealed class MqttTcpChannel : IMqttChannel
    {
        // ReSharper disable once MemberCanBePrivate.Global
        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
        private readonly int _bufferSize = BufferSize;
        private readonly MqttClientTcpOptions _options;
        private StreamSocket _socket;
        public MqttTcpChannel(MqttClientTcpOptions options)
        {
            _options = options ?? throw new ArgumentNullException(nameof(options));
            _bufferSize = _options.BufferSize;
        }
        public MqttTcpChannel(StreamSocket socket)
        {
            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
            CreateStreams();
        }
        public Stream SendStream { get; private set; }
        public Stream ReceiveStream { get; private set; }
        public static Func<MqttClientTcpOptions, IEnumerable<ChainValidationResult>> CustomIgnorableServerCertificateErrorsResolver { get; set; }
        public async Task ConnectAsync()
        {
            if (_socket == null)
            {
                _socket = new StreamSocket();
            }
            if (!_options.TlsOptions.UseTls)
            {
                await _socket.ConnectAsync(new HostName(_options.Server), _options.GetPort().ToString());
            }
            else
            {
                _socket.Control.ClientCertificate = LoadCertificate(_options);
                foreach (var ignorableChainValidationResult in ResolveIgnorableServerCertificateErrors())
                {
                    _socket.Control.IgnorableServerCertificateErrors.Add(ignorableChainValidationResult);
                }
                await _socket.ConnectAsync(new HostName(_options.Server), _options.GetPort().ToString(), SocketProtectionLevel.Tls12);
            }
            CreateStreams();
        }
        public Task DisconnectAsync()
        {
            Dispose();
            return Task.FromResult(0);
        }
        public void Dispose()
        {
            try
            {
                SendStream?.Dispose();
            }
            catch (ObjectDisposedException)
            {
            }
            catch (NullReferenceException)
            {
            }
            finally
            {
                SendStream = null;
            }
            try
            {
                ReceiveStream?.Dispose();
            }
            catch (ObjectDisposedException)
            {
            }
            catch (NullReferenceException)
            {
            }
            finally
            {
                ReceiveStream = null;
            }
            try
            {
                _socket?.Dispose();
            }
            catch (ObjectDisposedException)
            {
            }
            catch (NullReferenceException)
            {
            }
            finally
            {
                _socket = null;
            }
        }
        private void CreateStreams()
        {
            SendStream = _socket.OutputStream.AsStreamForWrite(_bufferSize);
            ReceiveStream = _socket.InputStream.AsStreamForRead(_bufferSize);
        }
        private static Certificate LoadCertificate(MqttClientTcpOptions options)
        {
            if (options.TlsOptions.Certificates == null || !options.TlsOptions.Certificates.Any())
            {
                return null;
            }
            if (options.TlsOptions.Certificates.Count > 1)
            {
                throw new NotSupportedException("Only one client certificate is supported for UWP.");
            }
            return new Certificate(options.TlsOptions.Certificates.First().AsBuffer());
        }
        private IEnumerable<ChainValidationResult> ResolveIgnorableServerCertificateErrors()
        {
            if (CustomIgnorableServerCertificateErrorsResolver != null)
            {
                return CustomIgnorableServerCertificateErrorsResolver(_options);
            }
            var result = new List<ChainValidationResult>();
            if (_options.TlsOptions.IgnoreCertificateRevocationErrors)
            {
                result.Add(ChainValidationResult.RevocationInformationMissing);
                //_socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Revoked); Not supported.
                result.Add(ChainValidationResult.RevocationFailure);
            }
            if (_options.TlsOptions.IgnoreCertificateChainErrors)
            {
                result.Add(ChainValidationResult.IncompleteChain);
            }
            if (_options.TlsOptions.AllowUntrustedCertificates)
            {
                result.Add(ChainValidationResult.Untrusted);
            }
            return result;
        }
    }
 }
 #endif
@@ -1,223 +0,0 @@
 #if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
 using System;
 using System.Net.Security;
 using System.Net.Sockets;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using System.IO;
 using System.Linq;
 using MQTTnet.Channel;
 using MQTTnet.Client;
 namespace MQTTnet.Implementations
 {
    public sealed class MqttTcpChannel : IMqttChannel
    {
 #if NET452 || NET461
        // ReSharper disable once MemberCanBePrivate.Global
        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
        private readonly int _bufferSize = BufferSize;
 #else
        private readonly int _bufferSize = 0;
 #endif
        private readonly MqttClientTcpOptions _options;
        private Socket _socket;
        private SslStream _sslStream;
        /// <summary>
        /// called on client sockets are created in connect
        /// </summary>
        public MqttTcpChannel(MqttClientTcpOptions options)
        {
            _options = options ?? throw new ArgumentNullException(nameof(options));
            _bufferSize = options.BufferSize;
        }
        /// <summary>
        /// called on server, sockets are passed in
        /// connect will not be called
        /// </summary>
        public MqttTcpChannel(Socket socket, SslStream sslStream)
        {
            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
            _sslStream = sslStream;
            CreateStreams();
        }
        public Stream SendStream { get; private set; }
        public Stream ReceiveStream { get; private set; }
        public static Func<X509Certificate, X509Chain, SslPolicyErrors, MqttClientTcpOptions, bool> CustomCertificateValidationCallback { get; set; }
        public async Task ConnectAsync()
        {
            if (_socket == null)
            {
                _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
            }
 #if NET452 || NET461
            await Task.Factory.FromAsync(_socket.BeginConnect, _socket.EndConnect, _options.Server, _options.GetPort(), null).ConfigureAwait(false);
 #else
            await _socket.ConnectAsync(_options.Server, _options.GetPort()).ConfigureAwait(false);
 #endif
            if (_options.TlsOptions.UseTls)
            {
                _sslStream = new SslStream(new NetworkStream(_socket, true), false, InternalUserCertificateValidationCallback);
                await _sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(), SslProtocols.Tls12, _options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
            }
            CreateStreams();
        }
        public Task DisconnectAsync()
        {
            Dispose();
            return Task.FromResult(0);
        }
        public void Dispose()
        {
            var oneStreamIsUsed = SendStream != null && ReceiveStream != null && ReferenceEquals(SendStream, ReceiveStream);
            try
            {
                SendStream?.Dispose();
            }
            catch (ObjectDisposedException)
            {
            }
            catch (NullReferenceException)
            {
            }
            finally
            {
                SendStream = null;
            }
            try
            {
                if (!oneStreamIsUsed)
                {
                    ReceiveStream?.Dispose();
                }
            }
            catch (ObjectDisposedException)
            {
            }
            catch (NullReferenceException)
            {
            }
            finally
            {
                ReceiveStream = null;
            }
            try
            {
                _sslStream?.Dispose();
            }
            catch (ObjectDisposedException)
            {
            }
            catch (NullReferenceException)
            {
            }
            finally
            {
                _sslStream = null;
            }
            try
            {
                _socket?.Dispose();
            }
            catch (ObjectDisposedException)
            {
            }
            catch (NullReferenceException)
            {
            }
            finally
            {
                _socket = null;
            }
        }
        private bool InternalUserCertificateValidationCallback(object sender, X509Certificate x509Certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
        {
            if (CustomCertificateValidationCallback != null)
            {
                return CustomCertificateValidationCallback(x509Certificate, chain, sslPolicyErrors, _options);
            }
            if (sslPolicyErrors == SslPolicyErrors.None)
            {
                return true;
            }
            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.RevocationStatusUnknown || c.Status == X509ChainStatusFlags.Revoked || c.Status == X509ChainStatusFlags.RevocationStatusUnknown))
            {
                if (!_options.TlsOptions.IgnoreCertificateRevocationErrors)
                {
                    return false;
                }
            }
            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.PartialChain))
            {
                if (!_options.TlsOptions.IgnoreCertificateChainErrors)
                {
                    return false;
                }
            }
            return _options.TlsOptions.AllowUntrustedCertificates;
        }
        private X509CertificateCollection LoadCertificates()
        {
            var certificates = new X509CertificateCollection();
            if (_options.TlsOptions.Certificates == null)
            {
                return certificates;
            }
            foreach (var certificate in _options.TlsOptions.Certificates)
            {
                certificates.Add(new X509Certificate2(certificate));
            }
            return certificates;
        }
        private void CreateStreams()
        {
            Stream stream;
            if (_sslStream != null)
            {
                stream = _sslStream;
            }
            else
            {
                stream = new NetworkStream(_socket, true);
            }
 #if NET452 || NET461
            SendStream = new BufferedStream(stream, _bufferSize);
            ReceiveStream = new BufferedStream(stream, _bufferSize);
 #else
            SendStream = stream;
            ReceiveStream = stream;
 #endif
        }
    }
 }
 #endif
@@ -1,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 MqttTcpServerAdapter : IMqttServerAdapter, IDisposable
    {
        private readonly IMqttNetLogger _logger;
        private StreamSocketListener _defaultEndpointSocket;
        public MqttTcpServerAdapter(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<MqttTcpServerAdapter>(exception, "Error while accepting connection at default endpoint.");
            }
        }
    }
 }
 #endif
@@ -1,162 +0,0 @@
 #if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
 using System;
 using System.Net;
 using System.Net.Security;
 using System.Net.Sockets;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
 using MQTTnet.Serializer;
 using MQTTnet.Server;
 namespace MQTTnet.Implementations
 {
    public class MqttTcpServerAdapter : IMqttServerAdapter, IDisposable
    {
        private readonly IMqttNetLogger _logger;
        private CancellationTokenSource _cancellationTokenSource;
        private Socket _defaultEndpointSocket;
        private Socket _tlsEndpointSocket;
        private X509Certificate2 _tlsCertificate;
        public MqttTcpServerAdapter(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<MqttTcpServerAdapter>(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<MqttTcpServerAdapter>(exception, "Error while accepting connection at TLS endpoint.");
                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
                }
            }
        }
    }
 }
 #endif
@@ -1,112 +0,0 @@
 using System;
 using System.IO;
 using System.Net.WebSockets;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Channel;
 using MQTTnet.Client;
 namespace MQTTnet.Implementations
 {
    public sealed class MqttWebSocketChannel : IMqttChannel
    {
        // ReSharper disable once MemberCanBePrivate.Global
        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
        private readonly MqttClientWebSocketOptions _options;
        private ClientWebSocket _webSocket;
        public MqttWebSocketChannel(MqttClientWebSocketOptions options)
        {
            _options = options ?? throw new ArgumentNullException(nameof(options));
        }
        public Stream SendStream { get; private set; }
        public Stream ReceiveStream { get; private set; }
        public async Task ConnectAsync()
        {
            var uri = _options.Uri;
            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
            {
                if (_options.TlsOptions?.UseTls == false)
                {
                    uri = "ws://" + uri;
                }
                else
                {
                    uri = "wss://" + uri;
                }
            }
            _webSocket = new ClientWebSocket();
            if (_options.RequestHeaders != null)
            {
                foreach (var requestHeader in _options.RequestHeaders)
                {
                    _webSocket.Options.SetRequestHeader(requestHeader.Key, requestHeader.Value);
                }    
            }
            if (_options.SubProtocols != null)
            {
                foreach (var subProtocol in _options.SubProtocols)
                {
                    _webSocket.Options.AddSubProtocol(subProtocol);
                }
            }
            if (_options.CookieContainer != null)
            {
                _webSocket.Options.Cookies = _options.CookieContainer;
            }
            if (_options.TlsOptions?.UseTls == true && _options.TlsOptions?.Certificates != null)
            {
                _webSocket.Options.ClientCertificates = new X509CertificateCollection();
                foreach (var certificate in _options.TlsOptions.Certificates)
                {
                    _webSocket.Options.ClientCertificates.Add(new X509Certificate(certificate));
                }
            }
            await _webSocket.ConnectAsync(new Uri(uri), CancellationToken.None).ConfigureAwait(false);
            SendStream = new WebSocketStream(_webSocket);
            ReceiveStream = SendStream;
        }
        public async Task DisconnectAsync()
        {
            if (_webSocket == null)
            {
                return;
            }
            if (_webSocket.State == WebSocketState.Open || _webSocket.State == WebSocketState.Connecting)
            {
                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
            }
            Dispose();
        }
        public void Dispose()
        {
            try
            {
                _webSocket?.Dispose();
            }
            catch (ObjectDisposedException)
            {
            }
            finally
            {
                _webSocket = null;
            }            
        }
    }
 }
@@ -1,137 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Exceptions;
 namespace MQTTnet.Implementations
 {
    public class WebSocketStream : Stream
    {
        private readonly byte[] _chunckBuffer = new byte[MqttWebSocketChannel.BufferSize];
        private readonly Queue<byte> _buffer = new Queue<byte>(MqttWebSocketChannel.BufferSize);
        private readonly WebSocket _webSocket;
        public WebSocketStream(WebSocket webSocket)
        {
            _webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
        }
        public override bool CanRead => true;
        public override bool CanSeek => false;
        public override bool CanWrite => true;
        public override long Length => throw new NotSupportedException();
        public override long Position
        {
            get => throw new NotSupportedException();
            set => throw new NotSupportedException();
        }
        public override void Flush()
        {
        }
        public override Task FlushAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(0);
        }
        public override int Read(byte[] buffer, int offset, int count)
        {
            return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
        }
        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            var bytesRead = 0;
            // Use existing date from buffer.
            while (count > 0 && _buffer.Any())
            {
                buffer[offset] = _buffer.Dequeue();
                count--;
                bytesRead++;
                offset++;
            }
            if (count == 0)
            {
                return bytesRead;
            }
            // Fetch new data if the buffer is not full.
            while (_webSocket.State == WebSocketState.Open)
            {
                await FetchChunkAsync(cancellationToken).ConfigureAwait(false);
                while (count > 0 && _buffer.Any())
                {
                    buffer[offset] = _buffer.Dequeue();
                    count--;
                    bytesRead++;
                    offset++;
                }
                if (count == 0)
                {
                    return bytesRead;
                }
            }
            if (_webSocket.State == WebSocketState.Closed)
            {
                throw new MqttCommunicationException("WebSocket connection closed.");
            }
            return bytesRead;
        }
        public override void Write(byte[] buffer, int offset, int count)
        {
            WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
        }
        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            return _webSocket.SendAsync(new ArraySegment<byte>(buffer, offset, count), WebSocketMessageType.Binary, true, cancellationToken);
        }
        public override long Seek(long offset, SeekOrigin origin)
        {
            throw new NotSupportedException();
        }
        public override void SetLength(long value)
        {
            throw new NotSupportedException();
        }
        private async Task FetchChunkAsync(CancellationToken cancellationToken)
        {   
            var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(_chunckBuffer, 0, _chunckBuffer.Length), cancellationToken).ConfigureAwait(false);
            if (response.MessageType == WebSocketMessageType.Close)
            {
                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
            }
            else if (response.MessageType == WebSocketMessageType.Binary)
            {
                for (var i = 0; i < response.Count; i++)
                {
                    _buffer.Enqueue(_chunckBuffer[i]);
                }
            }
            else if (response.MessageType == WebSocketMessageType.Text)
            {
                throw new MqttProtocolViolationException("WebSocket channel received TEXT message.");
            }
        }
    }
 }
@@ -1,35 +0,0 @@
 using MQTTnet.Packets;
 namespace MQTTnet.Internal
 {
    internal static class MqttApplicationMessageExtensions
    {
        public static MqttApplicationMessage ToApplicationMessage(this MqttPublishPacket publishPacket)
        {
            return new MqttApplicationMessage
            { 
                Topic = publishPacket.Topic,
                Payload = publishPacket.Payload,
                QualityOfServiceLevel = publishPacket.QualityOfServiceLevel,
                Retain = publishPacket.Retain
            };
        }
        public static MqttPublishPacket ToPublishPacket(this MqttApplicationMessage applicationMessage)
        {
            if (applicationMessage == null)
            {
                return null;
            }
            return new MqttPublishPacket
            {
                Topic = applicationMessage.Topic,
                Payload = applicationMessage.Payload,
                QualityOfServiceLevel = applicationMessage.QualityOfServiceLevel,
                Retain = applicationMessage.Retain,
                Dup = false
            };
        }
    }
 }
@@ -1,78 +0,0 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Exceptions;
 namespace MQTTnet.Internal
 {
    public static class TaskExtensions
    {
        public static async Task TimeoutAfter(this Task task, TimeSpan timeout)
        {
            if (task == null) throw new ArgumentNullException(nameof(task));
            using (var timeoutCts = new CancellationTokenSource())
            {
                try
                {
                    var timeoutTask = Task.Delay(timeout, timeoutCts.Token);
                    var finishedTask = await Task.WhenAny(timeoutTask, task).ConfigureAwait(false);
                    if (finishedTask == timeoutTask)
                    {
                        throw new MqttCommunicationTimedOutException();
                    }
                    if (task.IsCanceled)
                    {
                        throw new TaskCanceledException();
                    }
                    if (task.IsFaulted)
                    {
                        throw new MqttCommunicationException(task.Exception?.GetBaseException());
                    }
                }
                finally
                {
                    timeoutCts.Cancel();
                }
            }
        }
        public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout)
        {
            if (task == null) throw new ArgumentNullException(nameof(task));
            using (var timeoutCts = new CancellationTokenSource())
            {
                try
                {
                    var timeoutTask = Task.Delay(timeout, timeoutCts.Token);
                    var finishedTask = await Task.WhenAny(timeoutTask, task).ConfigureAwait(false);
                    if (finishedTask == timeoutTask)
                    {
                        throw new MqttCommunicationTimedOutException();
                    }
                    if (task.IsCanceled)
                    {
                        throw new TaskCanceledException();
                    }
                    if (task.IsFaulted)
                    {
                        throw new MqttCommunicationException(task.Exception.GetBaseException());
                    }
                    return task.Result;
                }
                finally
                {
                    timeoutCts.Cancel();
                }
            }
        }
    }
 }
@@ -1,65 +0,0 @@
 <Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.3;netstandard2.0</TargetFrameworks>
    <AssemblyName>MQTTnet</AssemblyName>
    <RootNamespace>MQTTnet</RootNamespace>
    <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
    <DebugType>Full</DebugType>
    <AssemblyVersion>0.0.0.0</AssemblyVersion>
    <FileVersion>0.0.0.0</FileVersion>
    <Version>0.0.0.0</Version>
    <Company />
    <Product />
    <Description />
    <Authors />
    <PackageId />
    <SignAssembly>false</SignAssembly>
    <DelaySign>false</DelaySign>
  </PropertyGroup>
  <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
    <NugetTargetMoniker>UAP,Version=v10.0</NugetTargetMoniker>
    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
    <TargetPlatformVersion>10.0.16299.0</TargetPlatformVersion>
    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
    <DefaultLanguage>en</DefaultLanguage>
    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'" />
  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|netstandard1.3|AnyCPU'">
    <DefineConstants>RELEASE;NETSTANDARD1_3</DefineConstants>
  </PropertyGroup>
  <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">
    <PackageReference Include="System.Net.Security" Version="4.3.2" />
    <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
  </ItemGroup>
  <ItemGroup Condition="'$(TargetFramework)'=='netstandard1.3'">
    <PackageReference Include="System.Net.Security" Version="4.3.2" />
    <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
  </ItemGroup>
  <ItemGroup Condition="'$(TargetFramework)'=='uap10.0'">
    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="5.4.1" />
  </ItemGroup>
  <ItemGroup Condition="'$(TargetFramework)'=='net452'">
  </ItemGroup>
  <ItemGroup Condition="'$(TargetFramework)'=='net461'">
  </ItemGroup>
 </Project>
@@ -1,19 +0,0 @@
 using System;
 namespace MQTTnet.ManagedClient
 {
    public class ApplicationMessageProcessedEventArgs : EventArgs
    {
        public ApplicationMessageProcessedEventArgs(MqttApplicationMessage applicationMessage, Exception exception)
        {
            ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
            Exception = exception;
        }
        public MqttApplicationMessage ApplicationMessage { get; }
        public Exception Exception { get; }
        public bool HasFailed => Exception != null;
        public bool HasSucceeded => Exception == null;
    }
 }
@@ -1,24 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
 using MQTTnet.Client;
 namespace MQTTnet.ManagedClient
 {
    public interface IManagedMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
    {
        bool IsStarted { get; }
        bool IsConnected { get; }
        event EventHandler<MqttClientConnectedEventArgs> Connected;
        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
        event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
        Task StartAsync(IManagedMqttClientOptions options);
        Task StopAsync();
        Task SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
        Task UnsubscribeAsync(IEnumerable<string> topics);
    }
 }
@@ -1,14 +0,0 @@
 using System;
 using MQTTnet.Client;
 namespace MQTTnet.ManagedClient
 {
    public interface IManagedMqttClientOptions
    {
        IMqttClientOptions ClientOptions { get; }
        TimeSpan AutoReconnectDelay { get; }
        IManagedMqttClientStorage Storage { get; }
    }
 }
@@ -1,12 +0,0 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
 namespace MQTTnet.ManagedClient
 {
    public interface IManagedMqttClientStorage
    {
        Task SaveQueuedMessagesAsync(IList<MqttApplicationMessage> messages);
        Task<IList<MqttApplicationMessage>> LoadQueuedMessagesAsync();
    }
 }
@@ -1,396 +0,0 @@
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Client;
 using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Protocol;
 namespace MQTTnet.ManagedClient
 {
    public class ManagedMqttClient : IManagedMqttClient
    {
        private readonly BlockingCollection<MqttApplicationMessage> _messageQueue = new BlockingCollection<MqttApplicationMessage>();
        private readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
        private readonly SemaphoreSlim _subscriptionsSemaphore = new SemaphoreSlim(1, 1);
        private readonly List<string> _unsubscriptions = new List<string>();
        private readonly IMqttClient _mqttClient;
        private readonly IMqttNetLogger _logger;
        private CancellationTokenSource _connectionCancellationToken;
        private CancellationTokenSource _publishingCancellationToken;
        private ManagedMqttClientStorageManager _storageManager;
        private IManagedMqttClientOptions _options;
        private bool _subscriptionsNotPushed;
        public ManagedMqttClient(IMqttClient mqttClient, IMqttNetLogger logger)
        {
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
            _mqttClient.Connected += OnConnected;
            _mqttClient.Disconnected += OnDisconnected;
            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
        }
        public bool IsConnected => _mqttClient.IsConnected;
        public bool IsStarted => _connectionCancellationToken != null;
        public event EventHandler<MqttClientConnectedEventArgs> Connected;
        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
        public event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
        public event EventHandler SynchronizingSubscriptionsFailed;
        public async Task StartAsync(IManagedMqttClientOptions options)
        {
            if (options == null) throw new ArgumentNullException(nameof(options));
            if (options.ClientOptions == null) throw new ArgumentException("The client options are not set.", nameof(options));
            if (!options.ClientOptions.CleanSession)
            {
                throw new NotSupportedException("The managed client does not support existing sessions.");
            }
            if (_connectionCancellationToken != null) throw new InvalidOperationException("The managed client is already started.");
            _options = options;
            if (_options.Storage != null)
            {
                _storageManager = new ManagedMqttClientStorageManager(_options.Storage);
                await _storageManager.LoadQueuedMessagesAsync().ConfigureAwait(false);
            }
            _connectionCancellationToken = new CancellationTokenSource();
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            Task.Run(async () => await MaintainConnectionAsync(_connectionCancellationToken.Token).ConfigureAwait(false), _connectionCancellationToken.Token).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            _logger.Info<ManagedMqttClient>("Started");
        }
        public Task StopAsync()
        {
            StopPublishing();
            StopMaintainingConnection();
            while (_messageQueue.Any())
            {
                _messageQueue.Take();
            }
            return Task.FromResult(0);
        }
        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
        {
            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
            foreach (var applicationMessage in applicationMessages)
            {
                if (_storageManager != null)
                {
                    await _storageManager.AddAsync(applicationMessage).ConfigureAwait(false);
                }
                _messageQueue.Add(applicationMessage);
            }
        }
        public async Task SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
        {
            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                foreach (var topicFilter in topicFilters)
                {
                    _subscriptions[topicFilter.Topic] = topicFilter.QualityOfServiceLevel;
                    _subscriptionsNotPushed = true;
                }
            }
            finally
            {
                _subscriptionsSemaphore.Release();
            }
        }
        public async Task UnsubscribeAsync(IEnumerable<string> topics)
        {
            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                foreach (var topic in topics)
                {
                    if (_subscriptions.Remove(topic))
                    {
                        _unsubscriptions.Add(topic);
                        _subscriptionsNotPushed = true;
                    }
                }
            }
            finally
            {
                _subscriptionsSemaphore.Release();
            }
        }
        public void Dispose()
        {
            _messageQueue?.Dispose();
            _subscriptionsSemaphore?.Dispose();
            _connectionCancellationToken?.Dispose();
            _publishingCancellationToken?.Dispose();
        }
        private async Task MaintainConnectionAsync(CancellationToken cancellationToken)
        {
            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    await TryMaintainConnectionAsync(cancellationToken).ConfigureAwait(false);
                }
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception exception)
            {
                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while maintaining connection.");
            }
            finally
            {
                await _mqttClient.DisconnectAsync().ConfigureAwait(false);
                _logger.Info<ManagedMqttClient>("Stopped");
            }
        }
        private async Task TryMaintainConnectionAsync(CancellationToken cancellationToken)
        {
            try
            {
                var connectionState = await ReconnectIfRequiredAsync().ConfigureAwait(false);
                if (connectionState == ReconnectionResult.NotConnected)
                {
                    StopPublishing();
                    await Task.Delay(_options.AutoReconnectDelay, cancellationToken).ConfigureAwait(false);
                    return;
                }
                if (connectionState == ReconnectionResult.Reconnected || _subscriptionsNotPushed)
                {
                    await SynchronizeSubscriptionsAsync().ConfigureAwait(false);
                    StartPublishing();
                    return;
                }
                if (connectionState == ReconnectionResult.StillConnected)
                {
                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
                }
            }
            catch (OperationCanceledException)
            {
            }
            catch (MqttCommunicationException exception)
            {
                _logger.Warning<ManagedMqttClient>(exception, "Communication exception while maintaining connection.");
            }
            catch (Exception exception)
            {
                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while maintaining connection.");
            }
        }
        private async Task PublishQueuedMessagesAsync(CancellationToken cancellationToken)
        {
            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
                    var message = _messageQueue.Take(cancellationToken);
                    if (message == null)
                    {
                        continue;
                    }
                    if (cancellationToken.IsCancellationRequested)
                    {
                        continue;
                    }
                    await TryPublishQueuedMessageAsync(message).ConfigureAwait(false);
                }
            }
            catch (OperationCanceledException)
            {
            }
            catch (Exception exception)
            {
                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while publishing queued application messages.");
            }
            finally
            {
                _logger.Verbose<ManagedMqttClient>("Stopped publishing messages.");
            }
        }
        private async Task TryPublishQueuedMessageAsync(MqttApplicationMessage message)
        {
            Exception transmitException = null;
            try
            {
                await _mqttClient.PublishAsync(message).ConfigureAwait(false);
                if (_storageManager != null)
                {
                    await _storageManager.RemoveAsync(message).ConfigureAwait(false);
                }
            }
            catch (MqttCommunicationException exception)
            {
                transmitException = exception;
                _logger.Warning<ManagedMqttClient>(exception, "Publishing application message failed.");
                if (message.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
                {
                    _messageQueue.Add(message);
                }
            }
            catch (Exception exception)
            {
                transmitException = exception;
                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while publishing queued application message.");
            }
            finally
            {
                ApplicationMessageProcessed?.Invoke(this, new ApplicationMessageProcessedEventArgs(message, transmitException));
            }
        }
        private async Task SynchronizeSubscriptionsAsync()
        {
            _logger.Info<ManagedMqttClient>(nameof(ManagedMqttClient), "Synchronizing subscriptions");
            List<TopicFilter> subscriptions;
            List<string> unsubscriptions;
            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                subscriptions = _subscriptions.Select(i => new TopicFilter(i.Key, i.Value)).ToList();
                unsubscriptions = new List<string>(_unsubscriptions);
                _unsubscriptions.Clear();
                _subscriptionsNotPushed = false;
            }
            finally
            {
                _subscriptionsSemaphore.Release();
            }
            if (!subscriptions.Any() && !unsubscriptions.Any())
            {
                return;
            }
            try
            {
                if (subscriptions.Any())
                {
                    await _mqttClient.SubscribeAsync(subscriptions).ConfigureAwait(false);
                }
                if (unsubscriptions.Any())
                {
                    await _mqttClient.UnsubscribeAsync(unsubscriptions).ConfigureAwait(false);
                }
            }
            catch (Exception exception)
            {
                _logger.Warning<ManagedMqttClient>(exception, "Synchronizing subscriptions failed.");
                _subscriptionsNotPushed = true;
                SynchronizingSubscriptionsFailed?.Invoke(this, EventArgs.Empty);
            }
        }
        private async Task<ReconnectionResult> ReconnectIfRequiredAsync()
        {
            if (_mqttClient.IsConnected)
            {
                return ReconnectionResult.StillConnected;
            }
            try
            {
                await _mqttClient.ConnectAsync(_options.ClientOptions).ConfigureAwait(false);
                return ReconnectionResult.Reconnected;
            }
            catch (Exception)
            {
                return ReconnectionResult.NotConnected;
            }
        }
        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
        {
            ApplicationMessageReceived?.Invoke(this, eventArgs);
        }
        private void OnDisconnected(object sender, MqttClientDisconnectedEventArgs eventArgs)
        {
            Disconnected?.Invoke(this, eventArgs);
        }
        private void OnConnected(object sender, MqttClientConnectedEventArgs eventArgs)
        {
            Connected?.Invoke(this, eventArgs);
        }
        private void StartPublishing()
        {
            if (_publishingCancellationToken != null)
            {
                StopPublishing();
            }
            var cts = new CancellationTokenSource();
            _publishingCancellationToken = cts;
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
            Task.Run(async () => await PublishQueuedMessagesAsync(cts.Token).ConfigureAwait(false), cts.Token).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }
        private void StopPublishing()
        {
            _publishingCancellationToken?.Cancel(false);
            _publishingCancellationToken?.Dispose();
            _publishingCancellationToken = null;
        }
        private void StopMaintainingConnection()
        {
            _connectionCancellationToken?.Cancel(false);
            _connectionCancellationToken?.Dispose();
            _connectionCancellationToken = null;
        }
    }
 }
@@ -1,39 +0,0 @@
 using System;
 using System.Threading.Tasks;
 using MQTTnet.Protocol;
 namespace MQTTnet.ManagedClient
 {
    public static class ManagedMqttClientExtensions
    {
        public static Task SubscribeAsync(this IManagedMqttClient managedClient, params TopicFilter[] topicFilters)
        {
            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
            return managedClient.SubscribeAsync(topicFilters);
        }
        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
        {
            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
            if (topic == null) throw new ArgumentNullException(nameof(topic));
            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
        }
        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic)
        {
            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
            if (topic == null) throw new ArgumentNullException(nameof(topic));
            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build());
        }
        public static Task UnsubscribeAsync(this IManagedMqttClient managedClient, params string[] topicFilters)
        {
            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
            return managedClient.UnsubscribeAsync(topicFilters);
        }
    }
 }
@@ -1,14 +0,0 @@
 using System;
 using MQTTnet.Client;
 namespace MQTTnet.ManagedClient
 {
    public class ManagedMqttClientOptions : IManagedMqttClientOptions
    {
        public IMqttClientOptions ClientOptions { get; set; }
        public TimeSpan AutoReconnectDelay { get; set; } = TimeSpan.FromSeconds(5);
        public IManagedMqttClientStorage Storage { get; set; }
    }
 }
@@ -1,67 +0,0 @@
 using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 namespace MQTTnet.ManagedClient
 {
    public class ManagedMqttClientStorageManager
    {
        private readonly List<MqttApplicationMessage> _applicationMessages = new List<MqttApplicationMessage>();
        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
        private readonly IManagedMqttClientStorage _storage;
        public ManagedMqttClientStorageManager(IManagedMqttClientStorage storage)
        {
            _storage = storage ?? throw new ArgumentNullException(nameof(storage));
        }
        public async Task LoadQueuedMessagesAsync()
        {
            var loadedMessages = await _storage.LoadQueuedMessagesAsync().ConfigureAwait(false);
            foreach (var loadedMessage in loadedMessages)
            {
                _applicationMessages.Add(loadedMessage);
            }
        }
        public async Task AddAsync(MqttApplicationMessage applicationMessage)
        {
            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                _applicationMessages.Add(applicationMessage);
                await SaveAsync().ConfigureAwait(false);
            }
            finally
            {
                _semaphore.Release();
            }
        }
        public async Task RemoveAsync(MqttApplicationMessage applicationMessage)
        {
            await _semaphore.WaitAsync().ConfigureAwait(false);
            try
            {
                var index = _applicationMessages.IndexOf(applicationMessage);
                if (index == -1)
                {
                    return;
                }
                _applicationMessages.RemoveAt(index);
                await SaveAsync().ConfigureAwait(false);
            }
            finally
            {
                _semaphore.Release();
            }
        }
        private Task SaveAsync()
        {
            return _storage.SaveQueuedMessagesAsync(_applicationMessages);
        }
    }
 }
@@ -1,9 +0,0 @@
 namespace MQTTnet.ManagedClient
 {
    public enum ReconnectionResult
    {
        StillConnected,
        Reconnected,
        NotConnected
    }
 }
@@ -1,29 +0,0 @@
 using System;
 using MQTTnet.Protocol;
 namespace MQTTnet
 {
    public sealed class MqttApplicationMessage
    {
        public MqttApplicationMessage()
        {
        }
        [Obsolete("Use object initializer or _MqttApplicationMessageBuilder_ instead.")]
        public MqttApplicationMessage(string topic, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, bool retain)
        {
            Topic = topic ?? throw new ArgumentNullException(nameof(topic));
            Payload = payload ?? throw new ArgumentNullException(nameof(payload));
            QualityOfServiceLevel = qualityOfServiceLevel;
            Retain = retain;
        }
        public string Topic { get; set; }
        public byte[] Payload { get; set; }
        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
        public bool Retain { get; set; }
    }
 }
@@ -1,114 +0,0 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
 using MQTTnet.Exceptions;
 using MQTTnet.Protocol;
 namespace MQTTnet
 {
    public class MqttApplicationMessageBuilder
    {
        private MqttQualityOfServiceLevel _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce;
        private string _topic;
        private byte[] _payload;
        private bool _retain;
        public MqttApplicationMessageBuilder WithTopic(string topic)
        {
            _topic = topic;
            return this;
        }
        public MqttApplicationMessageBuilder WithPayload(IEnumerable<byte> payload)
        {
            if (payload == null)
            {
                _payload = null;
                return this;
            }
            _payload = payload.ToArray();
            return this;
        }
        public MqttApplicationMessageBuilder WithPayload(MemoryStream payload)
        {
            if (payload == null)
            {
                _payload = null;
                return this;
            }
            if (payload.Length == 0)
            {
                _payload = new byte[0];
            }
            else
            {
                _payload = new byte[payload.Length - payload.Position];
                payload.Read(_payload, 0, _payload.Length);
            }
            return this;
        }
        public MqttApplicationMessageBuilder WithPayload(string payload)
        {
            if (payload == null)
            {
                _payload = null;
                return this;
            }
            _payload = string.IsNullOrEmpty(payload) ? new byte[0] : Encoding.UTF8.GetBytes(payload);
            return this;
        }
        public MqttApplicationMessageBuilder WithQualityOfServiceLevel(MqttQualityOfServiceLevel qualityOfServiceLevel)
        {
            _qualityOfServiceLevel = qualityOfServiceLevel;
            return this;
        }
        public MqttApplicationMessageBuilder WithRetainFlag(bool value = true)
        {
            _retain = value;
            return this;
        }
        public MqttApplicationMessageBuilder WithAtLeastOnceQoS()
        {
            _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce;
            return this;
        }
        public MqttApplicationMessageBuilder WithAtMostOnceQoS()
        {
            _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce;
            return this;
        }
        public MqttApplicationMessageBuilder WithExactlyOnceQoS()
        {
            _qualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce;
            return this;
        }
        public MqttApplicationMessage Build()
        {
            if (string.IsNullOrEmpty(_topic))
            {
                throw new MqttProtocolViolationException("Topic is not set.");
            }
            return new MqttApplicationMessage
            {
                Topic = _topic,
                Payload = _payload ?? new byte[0],
                QualityOfServiceLevel = _qualityOfServiceLevel,
                Retain = _retain
            };
        }
    }
 }
@@ -1,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; }
    }
 }
@@ -1,59 +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(logger);
        }
        public IMqttServer CreateMqttServer(IMqttNetLogger logger)
        {
            if (logger == null) throw new ArgumentNullException(nameof(logger));
            return CreateMqttServer(new List<IMqttServerAdapter> { new MqttTcpServerAdapter(logger) }, logger);
        }
        public IMqttServer CreateMqttServer(IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
        {
            if (adapters == null) throw new ArgumentNullException(nameof(adapters));
            if (logger == null) throw new ArgumentNullException(nameof(logger));
            return new MqttServer(adapters, logger);
        }
    }
 }
@@ -1,7 +0,0 @@
 namespace MQTTnet.Packets
 {
    public interface IMqttPacketWithIdentifier
    {
        ushort? PacketIdentifier { get; set; }
    }
 }
@@ -1,6 +0,0 @@
 namespace MQTTnet.Packets
 {
    public abstract class MqttBasePacket
    {
    }
 }
@@ -1,7 +0,0 @@
 namespace MQTTnet.Packets
 {
    public class MqttBasePublishPacket : MqttBasePacket, IMqttPacketWithIdentifier
    {
        public ushort? PacketIdentifier { get; set; }
    }
 }
@@ -1,16 +0,0 @@
 using MQTTnet.Protocol;
 namespace MQTTnet.Packets
 {
    public sealed class MqttConnAckPacket : MqttBasePacket
    {
        public bool IsSessionPresent { get; set; }
        public MqttConnectReturnCode ConnectReturnCode { get; set; }
        public override string ToString()
        {
            return "ConnAck: [ConnectReturnCode=" + ConnectReturnCode + "] [IsSessionPresent=" + IsSessionPresent + "]";
        }
    }
 }
@@ -1,26 +0,0 @@
 using MQTTnet.Serializer;
 namespace MQTTnet.Packets
 {
    public sealed class MqttConnectPacket : MqttBasePacket
    {
        public MqttProtocolVersion ProtocolVersion { get; set; }
        public string ClientId { get; set; }
        public string Username { get; set; }
        public string Password { get; set; }
        public ushort KeepAlivePeriod { get; set; }
        public bool CleanSession { get; set; }
        public MqttApplicationMessage WillMessage { get; set; }
        public override string ToString()
        {
            return "Connect: [ClientId=" + ClientId + "] [Username=" + Username + "] [Password=" + Password + "] [KeepAlivePeriod=" + KeepAlivePeriod + "] [CleanSession=" + CleanSession + "]";
        }
    }
 }
@@ -1,10 +0,0 @@
 namespace MQTTnet.Packets
 {
    public sealed class MqttDisconnectPacket : MqttBasePacket
    {
        public override string ToString()
        {
            return "Disconnect";
        }
    }
 }
@@ -1,13 +0,0 @@
 using MQTTnet.Protocol;
 namespace MQTTnet.Packets
 {
    public class MqttPacketHeader
    {
        public MqttControlPacketType ControlPacketType { get; set; }
        public byte FixedHeader { get; set; }
        public int BodyLength { get; set; }
    }
 }
@@ -1,10 +0,0 @@
 namespace MQTTnet.Packets
 {
    public sealed class MqttPingReqPacket : MqttBasePacket
    {
        public override string ToString()
        {
            return "PingReq";
        }
    }
 }
@@ -1,10 +0,0 @@
 namespace MQTTnet.Packets
 {
    public sealed class MqttPingRespPacket : MqttBasePacket
    {
        public override string ToString()
        {
            return "PingResp";
        }
    }
 }
@@ -1,10 +0,0 @@
 namespace MQTTnet.Packets
 {
    public sealed class MqttPubAckPacket : MqttBasePublishPacket
    {
        public override string ToString()
        {
            return "PubAck";
        }
    }
 }
@@ -1,10 +0,0 @@
 namespace MQTTnet.Packets
 {
    public sealed class MqttPubCompPacket : MqttBasePublishPacket
    {
        public override string ToString()
        {
            return "PubComp";
        }
    }
 }
@@ -1,10 +0,0 @@
 namespace MQTTnet.Packets
 {
    public sealed class MqttPubRecPacket : MqttBasePublishPacket
    {
        public override string ToString()
        {
            return "PubRec";
        }
    }
 }
--- a/Show More
+++ b/Show More