Update documents

Bug fixes v3

.bettercodehub.yml

@@ -0,0 +1,8 @@
+exclude:
+- /Frameworks/.*
+- /MQTTnet.TestApp.NetCore/Program.cs
+- /Tests/MQTTnet.TestApp.NetFramework/.*
+- /Tests/MQTTnet.TestApp.UniversalWindows/.*
+component_depth: 1
+languages:
+- csharp

.gitignore

@@ -1,5 +1,7 @@
 ## Ignore Visual Studio temporary files, build results, and
 ## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
 
 # User-specific files
 *.suo
@@ -15,12 +17,12 @@
 [Dd]ebugPublic/
 [Rr]elease/
 [Rr]eleases/
-[Xx]64/
-[Xx]86/
-[Bb]uild/
+x64/
+x86/
 bld/
 [Bb]in/
 [Oo]bj/
+[Ll]og/
 
 # Visual Studio 2015 cache/options directory
 .vs/
@@ -40,9 +42,11 @@ TestResult.xml
 [Rr]eleasePS/
 dlldata.c
 
-# DNX
+# .NET Core
 project.lock.json
+project.fragment.lock.json
 artifacts/
+**/Properties/launchSettings.json
 
 *_i.c
 *_p.c
@@ -81,6 +85,7 @@ ipch/
 *.sdf
 *.cachefile
 *.VC.db
+*.VC.VC.opendb
 
 # Visual Studio profiler
 *.psess
@@ -108,6 +113,10 @@ _TeamCity*
 # DotCover is a Code Coverage Tool
 *.dotCover
 
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
 # NCrunch
 _NCrunch_*
 .*crunch*.local.xml
@@ -139,13 +148,16 @@ publish/
 # Publish Web Output
 *.[Pp]ublish.xml
 *.azurePubxml
-
-# TODO: Un-comment the next line if you do not want to checkin 
-# your web deploy settings because they may include unencrypted
-# passwords
-#*.pubxml
+# TODO: Comment the next line if you want to checkin your web deploy settings
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
 *.publishproj
 
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
 # NuGet Packages
 *.nupkg
 # The packages folder can be ignored because of Package Restore
@@ -154,7 +166,7 @@ publish/
 !**/packages/build/
 # Uncomment if necessary however generally it will be regenerated when needed
 #!**/packages/repositories.config
-# NuGet v3's project.json files produces more ignoreable files
+# NuGet v3's project.json files produces more ignorable files
 *.nuget.props
 *.nuget.targets
 
@@ -166,12 +178,11 @@ csx/
 ecf/
 rcf/
 
-# Microsoft Azure ApplicationInsights config file
-ApplicationInsights.config
-
-# Windows Store app package directory
+# Windows Store app package directories and files
 AppPackages/
 BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
 
 # Visual Studio cache files
 # files ending in .cache can be ignored
@@ -181,16 +192,19 @@ BundleArtifacts/
 
 # Others
 ClientBin/
-[Ss]tyle[Cc]op.*
 ~$*
 *~
 *.dbmdl
 *.dbproj.schemaview
+*.jfm
 *.pfx
 *.publishsettings
-node_modules/
 orleans.codegen.cs
 
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
 # RIA/Silverlight projects
 Generated_Code/
 
@@ -205,6 +219,7 @@ UpgradeLog*.htm
 # SQL Server files
 *.mdf
 *.ldf
+*.ndf
 
 # Business Intelligence projects
 *.rdl.data
@@ -219,6 +234,10 @@ FakesAssemblies/
 
 # Node.js Tools for Visual Studio
 .ntvs_analysis.dat
+node_modules/
+
+# Typescript v1 declaration files
+typings/
 
 # Visual Studio 6 build log
 *.plg
@@ -226,6 +245,9 @@ FakesAssemblies/
 # Visual Studio 6 workspace options file
 *.opt
 
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
 # Visual Studio LightSwitch build output
 **/*.HTMLClient/GeneratedArtifacts
 **/*.DesktopClient/GeneratedArtifacts
@@ -234,13 +256,36 @@ FakesAssemblies/
 **/*.Server/ModelManifest.xml
 _Pvt_Extensions
 
-# LightSwitch generated files
-GeneratedArtifacts/
-ModelManifest.xml
-
 # Paket dependency manager
 .paket/paket.exe
+paket-files/
 
 # FAKE - F# Make
 .fake/
-nuget.exe
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+
+Build/nuget.exe

.travis.yml

@@ -0,0 +1,10 @@
+language: csharp
+solution: MQTTnet.sln
+
+matrix:
+  include:
+    - dotnet: 2.0.0
+      mono: none
+      dist: trusty
+      env: DOTNETCORE=1  # optional, can be used to take different code paths in your script
+    - mono: latest

Build/MQTTnet.nuspec

@@ -0,0 +1,48 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>MQTTnet</id>
+    <version>2.3.1</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 .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker).</description>
+    <releaseNotes>* [Server] Fixed an issue when accepting a new connection (UWP only) (Thanks to haeberle)
+[Core] Fixed a dead lock while sending messages (Thanks to 1liveowl, JanEggers)
+[Client] The client is no longer sending packets before receiving has started
+[Core] Minor changes and improvements
+    </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</tags> 
+    <dependencies>
+
+      <group targetFramework="netstandard1.3">
+        <dependency id="NETStandard.Library" version="1.6.1" />
+        <dependency id="System.Net.Security" version="4.3.2" />
+      </group>
+      
+      <group targetFramework="uap10.0">
+        <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="5.4.0" />
+      </group>
+
+    </dependencies>
+  </metadata>
+
+  <files>
+    <!-- .NET Standard 1.3 -->
+    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\netstandard1.3\MQTTnet.Core.*" target="lib\netstandard1.3\"/>
+    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\netstandard1.3\MQTTnet.*" target="lib\netstandard1.3\"/>
+
+    <!-- Universal Windows -->
+    <file src="..\Frameworks\MQTTnet.UniversalWindows\bin\Release\MQTTnet.Core.*" target="lib\uap10.0\"/>
+    <file src="..\Frameworks\MQTTnet.UniversalWindows\bin\Release\MQTTnet.*" target="lib\uap10.0\"/>
+
+    <!-- .NET Framework -->
+    <file src="..\Frameworks\MQTTnet.NetFramework\bin\Release\MQTTnet.Core.*" target="lib\net45\"/>
+    <file src="..\Frameworks\MQTTnet.NetFramework\bin\Release\MQTTnet.*" target="lib\net45\"/>
+    
+  </files>
+</package>

Build/build.ps1

@@ -0,0 +1,12 @@
+param([string]$version)
+
+if ([string]::IsNullOrEmpty($version)) {$version = "0.0.1"}
+
+$msbuild = "MSBuild.exe"
+&$msbuild ..\Frameworks\MQTTnet.NetFramework\MQTTnet.NetFramework.csproj /t:Build /p:Configuration="Release"
+&$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release"
+&$msbuild ..\Frameworks\MQTTnet.UniversalWindows\MQTTnet.UniversalWindows.csproj /t:Build /p:Configuration="Release"
+
+Remove-Item .\NuGet -Force -Recurse
+New-Item -ItemType Directory -Force -Path .\NuGet
+.\NuGet.exe pack MQTTnet.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $version

Frameworks/MQTTnet.NetCoreApp/MQTTnet.NetCoreApp.csproj

@@ -1,34 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <TargetFramework>netcoreapp1.1</TargetFramework>
-    <Authors>Christian Kratky</Authors>
-    <Company>Christian Kratky</Company>
-    <Product>MQTTnet</Product>
-    <Description>MQTTnet is a .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker).</Description>
-    <Copyright>Copyright © Christian Kratky 2016-2017</Copyright>
-    <Version>2.1.1.0</Version>
-    <AssemblyVersion>2.1.1.0</AssemblyVersion>
-    <FileVersion>2.1.1.0</FileVersion>
-    <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
-    <AssemblyName>MQTTnet</AssemblyName>
-    <RootNamespace>MQTTnet</RootNamespace>
-    <PackageId>MQTTnet.NetCore</PackageId>
-    <PackageProjectUrl>https://github.com/chkr1011/MQTTnet</PackageProjectUrl>
-    <RepositoryUrl>https://github.com/chkr1011/MQTTnet</RepositoryUrl>
-    <PackageTags>MQTT MQTTClient MQTTServer MQTTBroker Broker</PackageTags>
-    <PackageIconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</PackageIconUrl>
-    <PackageLicenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</PackageLicenseUrl>
-  </PropertyGroup>
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Any CPU|AnyCPU'" />
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Any CPU|x64'" />
-
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Any CPU|x86'" />
-
-  <ItemGroup>
-    <ProjectReference Include="..\..\MQTTnet.Core\MQTTnet.Core.csproj" />
-  </ItemGroup>
-
-</Project>

Frameworks/MQTTnet.NetCoreApp/MqttClientFactory.cs

@@ -1,17 +0,0 @@
-using System;
-using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Client;
-using MQTTnet.Core.Serializer;
-
-namespace MQTTnet
-{
-    public class MqttClientFactory
-    {
-        public MqttClient CreateMqttClient(MqttClientOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            return new MqttClient(options, new MqttChannelCommunicationAdapter(new MqttTcpChannel(), new DefaultMqttV311PacketSerializer()));
-        }
-    }
-}

Frameworks/MQTTnet.NetCoreApp/MqttServerAdapter.cs

@@ -1,56 +0,0 @@
-using System;
-using System.Net;
-using System.Net.Sockets;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Serializer;
-using MQTTnet.Core.Server;
-
-namespace MQTTnet
-{
-    public sealed class MqttServerAdapter : IMqttServerAdapter, IDisposable
-    {
-        private CancellationTokenSource _cancellationTokenSource;
-        private Socket _socket;
-
-        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
-
-        public void Start(MqttServerOptions options)
-        {
-            if (_socket != null) throw new InvalidOperationException("Server is already started.");
-
-            _cancellationTokenSource = new CancellationTokenSource();
-
-            _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-            _socket.Bind(new IPEndPoint(IPAddress.Any, options.Port));
-            _socket.Listen(options.ConnectionBacklog);
-            
-            Task.Run(async () => await AcceptConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
-        }
-
-        public void Stop()
-        {
-            _cancellationTokenSource?.Dispose();
-            _cancellationTokenSource = null;
-
-            _socket?.Dispose();
-            _socket = null;
-        }
-
-        public void Dispose()
-        {
-            Stop();
-        }
-
-        private async Task AcceptConnectionsAsync(CancellationToken cancellationToken)
-        {
-            while (!cancellationToken.IsCancellationRequested)
-            {
-                var clientSocket = await _socket.AcceptAsync();
-                var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(clientSocket), new DefaultMqttV311PacketSerializer());    
-                ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
-            }
-        }
-    }
-}

Frameworks/MQTTnet.NetCoreApp/MqttServerFactory.cs

@@ -1,15 +0,0 @@
-using System;
-using MQTTnet.Core.Server;
-
-namespace MQTTnet
-{
-    public class MqttServerFactory
-    {
-        public MqttServer CreateMqttServer(MqttServerOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            return new MqttServer(options, new MqttServerAdapter());
-        }
-    }
-}

Frameworks/MQTTnet.NetCoreApp/MqttTcpChannel.cs

@@ -1,81 +0,0 @@
-using System;
-using System.Net.Sockets;
-using System.Threading.Tasks;
-using MQTTnet.Core.Channel;
-using MQTTnet.Core.Client;
-using MQTTnet.Core.Exceptions;
-
-namespace MQTTnet
-{
-    public class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
-    {
-        private readonly Socket _socket;
-
-        public MqttTcpChannel()
-        {
-            _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-        }
-
-        public MqttTcpChannel(Socket socket)
-        {
-            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
-        }
-
-        public async Task ConnectAsync(MqttClientOptions options)
-        {
-            try
-            {
-                await _socket.ConnectAsync(options.Server, options.Port);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public async Task DisconnectAsync()
-        {
-            try
-            {
-                _socket.Dispose();
-                await Task.FromResult(0);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public async Task WriteAsync(byte[] buffer)
-        {
-            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
-
-            try
-            {
-                await _socket.SendAsync(new ArraySegment<byte>(buffer), SocketFlags.None);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public async Task ReadAsync(byte[] buffer)
-        {
-            try
-            {
-                var buffer2 = new ArraySegment<byte>(buffer);
-                await _socket.ReceiveAsync(buffer2, SocketFlags.None);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public void Dispose()
-        {
-            _socket?.Dispose();
-        }
-    }
-}

Frameworks/MQTTnet.NetFramework/Implementations/MqttServerAdapter.cs

@@ -0,0 +1,129 @@
+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.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
+using MQTTnet.Core.Server;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
+    {
+        private CancellationTokenSource _cancellationTokenSource;
+        private Socket _defaultEndpointSocket;
+        private Socket _tlsEndpointSocket;
+        private X509Certificate2 _tlsCertificate;
+
+        private bool _isRunning;
+
+        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
+
+        public void Start(MqttServerOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            if (_isRunning) throw new InvalidOperationException("Server is already started.");
+            _isRunning = true;
+
+            _cancellationTokenSource = new CancellationTokenSource();
+
+            if (options.DefaultEndpointOptions.IsEnabled)
+            {
+                _defaultEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+                _defaultEndpointSocket.Bind(new IPEndPoint(IPAddress.Any, options.GetDefaultEndpointPort()));
+                _defaultEndpointSocket.Listen(options.ConnectionBacklog);
+
+                Task.Run(() => AcceptDefaultEndpointConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
+            }
+
+            if (options.TlsEndpointOptions.IsEnabled)
+            {
+                if (options.TlsEndpointOptions.Certificate == null)
+                {
+                    throw new ArgumentException("TLS certificate is not set.");
+                }
+
+                _tlsCertificate = new X509Certificate2(options.TlsEndpointOptions.Certificate);
+
+                _tlsEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+                _tlsEndpointSocket.Bind(new IPEndPoint(IPAddress.Any, options.GetTlsEndpointPort()));
+                _tlsEndpointSocket.Listen(options.ConnectionBacklog);
+
+                Task.Run(() => AcceptTlsEndpointConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
+            }
+        }
+
+        public void Stop()
+        {
+            _isRunning = false;
+
+            _cancellationTokenSource?.Cancel(false);
+            _cancellationTokenSource?.Dispose();
+            _cancellationTokenSource = null;
+
+            _defaultEndpointSocket?.Dispose();
+            _defaultEndpointSocket = null;
+
+            _tlsEndpointSocket?.Dispose();
+            _tlsEndpointSocket = null;
+        }
+
+        public void Dispose()
+        {
+            Stop();
+        }
+
+        private async Task AcceptDefaultEndpointConnectionsAsync(CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+                    var clientSocket = await Task.Factory.FromAsync(_defaultEndpointSocket.BeginAccept, _defaultEndpointSocket.EndAccept, null).ConfigureAwait(false);
+
+                    var tcpChannel = new MqttTcpChannel(clientSocket, null);
+                    var clientAdapter = new MqttChannelCommunicationAdapter(tcpChannel, new MqttPacketSerializer());
+                    ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
+                }
+                catch (Exception exception) when (!(exception is ObjectDisposedException))
+                {
+                    MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while accepting connection at default endpoint.");
+
+                    //excessive CPU consumed if in endless loop of socket errors
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private async Task AcceptTlsEndpointConnectionsAsync(CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+                    var clientSocket = await Task.Factory.FromAsync(_tlsEndpointSocket.BeginAccept, _tlsEndpointSocket.EndAccept, null).ConfigureAwait(false);
+
+                    var sslStream = new SslStream(new NetworkStream(clientSocket));
+                    await sslStream.AuthenticateAsServerAsync(_tlsCertificate, false, SslProtocols.Tls12, false).ConfigureAwait(false);
+
+                    var tcpChannel = new MqttTcpChannel(clientSocket, sslStream);
+                    var clientAdapter = new MqttChannelCommunicationAdapter(tcpChannel, new MqttPacketSerializer());
+                    ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
+                }
+                catch (Exception exception)
+                {
+                    MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while accepting connection at TLS endpoint.");
+
+                    //excessive CPU consumed if in endless loop of socket errors
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+    }
+}

Frameworks/MQTTnet.NetFramework/Implementations/MqttTcpChannel.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading.Tasks;
+using MQTTnet.Core.Channel;
+using MQTTnet.Core.Client;
+using System.IO;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
+    {
+        // ReSharper disable once MemberCanBePrivate.Global
+        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
+        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
+
+        private Socket _socket;
+        private SslStream _sslStream;
+
+        /// <summary>
+        /// called on client sockets are created in connect
+        /// </summary>
+        public MqttTcpChannel()
+        {
+
+        }
+
+        /// <summary>
+        /// called on server, sockets are passed in
+        /// connect will not be called
+        /// </summary>
+        public MqttTcpChannel(Socket socket, SslStream sslStream)
+        {
+            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
+            _sslStream = sslStream;
+            CreateStreams(socket, sslStream);
+        }
+
+        public Stream SendStream { get; private set; }
+        public Stream ReceiveStream { get; private set; }
+        public Stream RawReceiveStream { get; private set; }
+
+        public async Task ConnectAsync(MqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            if (_socket == null)
+            {
+                _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+            }
+
+            await Task.Factory.FromAsync(_socket.BeginConnect, _socket.EndConnect, options.Server, options.GetPort(), null).ConfigureAwait(false);
+
+            if (options.TlsOptions.UseTls)
+            {
+                _sslStream = new SslStream(new NetworkStream(_socket, true));
+
+                await _sslStream.AuthenticateAsClientAsync(options.Server, LoadCertificates(options), SslProtocols.Tls12, options.TlsOptions.CheckCertificateRevocation).ConfigureAwait(false);
+            }
+
+            CreateStreams(_socket, _sslStream);
+        }
+
+        public Task DisconnectAsync()
+        {
+            Dispose();
+            return Task.FromResult(0);
+        }
+
+        public void Dispose()
+        {
+            RawReceiveStream?.Dispose();
+            RawReceiveStream = null;
+
+            ReceiveStream?.Dispose();
+            ReceiveStream = null;
+
+            SendStream?.Dispose();
+            SendStream = null;
+
+            _socket?.Dispose();
+            _socket = null;
+
+            _sslStream?.Dispose();
+            _sslStream = null;
+        }
+
+        private void CreateStreams(Socket socket, Stream sslStream)
+        {
+            RawReceiveStream = sslStream ?? new NetworkStream(socket);
+
+            //cannot use this as default buffering prevents from receiving the first connect message
+            //need two streams otherwise read and write have to be synchronized
+            SendStream = new BufferedStream(RawReceiveStream, BufferSize);
+            ReceiveStream = new BufferedStream(RawReceiveStream, BufferSize);
+        }
+
+        private static X509CertificateCollection LoadCertificates(MqttClientOptions options)
+        {
+            var certificates = new X509CertificateCollection();
+            if (options.TlsOptions.Certificates == null)
+            {
+                return certificates;
+            }
+
+            foreach (var certificate in options.TlsOptions.Certificates)
+            {
+                certificates.Add(new X509Certificate(certificate));
+            }
+
+            return certificates;
+        }
+    }
+}

Frameworks/MQTTnet.NetFramework/Implementations/MqttWebSocketChannel.cs

@@ -0,0 +1,55 @@
+using MQTTnet.Core.Channel;
+using MQTTnet.Core.Client;
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class MqttWebSocketChannel : IMqttCommunicationChannel, IDisposable
+    {
+        private ClientWebSocket _webSocket;
+
+        public Stream RawReceiveStream { get; private set; }
+        public Stream SendStream => RawReceiveStream;
+        public Stream ReceiveStream => RawReceiveStream;
+
+        public async Task ConnectAsync(MqttClientOptions options)
+        {
+            var uri = options.Server;
+            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase))
+            {
+                uri = "ws://" + uri;
+            }
+
+            if (options.Port.HasValue)
+            {
+                uri += ":" + options.Port;
+            }
+            
+            _webSocket = new ClientWebSocket();
+            _webSocket.Options.KeepAliveInterval = options.KeepAlivePeriod;
+            await _webSocket.ConnectAsync(new Uri(uri), CancellationToken.None).ConfigureAwait(false);
+            RawReceiveStream = new WebSocketStream(_webSocket);
+        }
+
+        public async Task DisconnectAsync()
+        {
+            RawReceiveStream = null;
+
+            if (_webSocket == null)
+            {
+                return;
+            }
+
+            await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        public void Dispose()
+        {
+            _webSocket?.Dispose();
+        }
+    }
+}

Frameworks/MQTTnet.NetFramework/Implementations/WebSocketStream.cs

@@ -0,0 +1,77 @@
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public class WebSocketStream : Stream
+    {
+        private readonly ClientWebSocket _webSocket;
+
+        public WebSocketStream(ClientWebSocket webSocket)
+        {
+            _webSocket = webSocket;
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var currentOffset = offset;
+            var targetOffset = offset + count;
+            while (_webSocket.State == WebSocketState.Open && currentOffset < targetOffset)
+            {
+                var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer, currentOffset, count), cancellationToken).ConfigureAwait(false);
+                currentOffset += response.Count;
+
+                if (response.MessageType == WebSocketMessageType.Close)
+                {
+                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            return currentOffset - offset;
+        }
+
+        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 int Read(byte[] buffer, int offset, int count)
+        {
+            return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        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 long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}

Frameworks/MQTTnet.NetFramework/MQTTnet.NetFramework.csproj

@@ -100,11 +100,13 @@
     <Reference Include="System.Core" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Implementations\MqttWebSocketChannel.cs" />
+    <Compile Include="Implementations\WebSocketStream.cs" />
     <Compile Include="MqttClientFactory.cs" />
-    <Compile Include="MqttServerAdapter.cs" />
     <Compile Include="MqttServerFactory.cs" />
+    <Compile Include="Implementations\MqttServerAdapter.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="MqttTcpChannel.cs" />
+    <Compile Include="Implementations\MqttTcpChannel.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\MQTTnet.Core\MQTTnet.Core.csproj">

Frameworks/MQTTnet.NetFramework/MqttClientFactory.cs

@@ -1,17 +1,33 @@
 using System;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Channel;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Serializer;
+using MQTTnet.Implementations;
 
 namespace MQTTnet
 {
-    public class MqttClientFactory
+    public class MqttClientFactory : IMqttClientFactory
     {
-        public MqttClient CreateMqttClient(MqttClientOptions options)
+        public IMqttClient CreateMqttClient(MqttClientOptions options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
-            return new MqttClient(options, new MqttChannelCommunicationAdapter(new MqttTcpChannel(), new DefaultMqttV311PacketSerializer()));
+            return new MqttClient(options, new MqttChannelCommunicationAdapter(GetMqttCommunicationChannel(options), new MqttPacketSerializer()));
+        }
+
+        private static IMqttCommunicationChannel GetMqttCommunicationChannel(MqttClientOptions options)
+        {
+            switch (options.ConnectionType)
+            {
+                case MqttConnectionType.Tcp:
+                    return new MqttTcpChannel();
+                case MqttConnectionType.Ws:
+                    return new MqttWebSocketChannel();
+
+                default:
+                    throw new NotSupportedException();
+            }
         }
     }
-}
+}

Frameworks/MQTTnet.NetFramework/MqttServerAdapter.cs

@@ -1,56 +0,0 @@
-using System;
-using System.Net;
-using System.Net.Sockets;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Serializer;
-using MQTTnet.Core.Server;
-
-namespace MQTTnet
-{
-    public sealed class MqttServerAdapter : IMqttServerAdapter, IDisposable
-    {
-        private CancellationTokenSource _cancellationTokenSource;
-        private Socket _socket;
-
-        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
-
-        public void Start(MqttServerOptions options)
-        {
-            if (_socket != null) throw new InvalidOperationException("Server is already started.");
-
-            _cancellationTokenSource = new CancellationTokenSource();
-
-            _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-            _socket.Bind(new IPEndPoint(IPAddress.Any, options.Port));
-            _socket.Listen(options.ConnectionBacklog);
-            
-            Task.Run(async () => await AcceptConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
-        }
-
-        public void Stop()
-        {
-            _cancellationTokenSource?.Dispose();
-            _cancellationTokenSource = null;
-
-            _socket?.Dispose();
-            _socket = null;
-        }
-
-        public void Dispose()
-        {
-            Stop();
-        }
-
-        private async Task AcceptConnectionsAsync(CancellationToken cancellationToken)
-        {
-            while (!cancellationToken.IsCancellationRequested)
-            {
-                var clientSocket = await Task.Factory.FromAsync(_socket.BeginAccept, _socket.EndAccept, null);
-                var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(clientSocket), new DefaultMqttV311PacketSerializer());    
-                ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
-            }
-        }
-    }
-}

Frameworks/MQTTnet.NetFramework/MqttServerFactory.cs

@@ -1,15 +1,18 @@
 using System;
+using System.Collections.Generic;
+using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Server;
+using MQTTnet.Implementations;
 
 namespace MQTTnet
 {
-    public class MqttServerFactory
+    public class MqttServerFactory : IMqttServerFactory
     {
-        public MqttServer CreateMqttServer(MqttServerOptions options)
+        public IMqttServer CreateMqttServer(MqttServerOptions options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
-            return new MqttServer(options, new MqttServerAdapter());
+            return new MqttServer(options, new List<IMqttServerAdapter> { new MqttServerAdapter() });
         }
     }
 }

Frameworks/MQTTnet.NetFramework/MqttTcpChannel.cs

@@ -1,85 +0,0 @@
-using System;
-using System.Net.Sockets;
-using System.Threading.Tasks;
-using MQTTnet.Core.Channel;
-using MQTTnet.Core.Client;
-using MQTTnet.Core.Exceptions;
-
-namespace MQTTnet
-{
-    public class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
-    {
-        private readonly Socket _socket;
-
-        public MqttTcpChannel()
-        {
-            _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-        }
-
-        public MqttTcpChannel(Socket socket)
-        {
-            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
-        }
-
-        public async Task ConnectAsync(MqttClientOptions options)
-        {
-            try
-            {
-                await Task.Factory.FromAsync(_socket.BeginConnect, _socket.EndConnect, options.Server, options.Port, null);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public async Task DisconnectAsync()
-        {
-            try
-            {
-                await Task.Factory.FromAsync(_socket.BeginDisconnect, _socket.EndDisconnect, true, null);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public async Task WriteAsync(byte[] buffer)
-        {
-            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
-
-            try
-            {
-                await Task.Factory.FromAsync(
-                    // ReSharper disable once AssignNullToNotNullAttribute
-                    _socket.BeginSend(buffer, 0, buffer.Length, SocketFlags.None, null, null),
-                    _socket.EndSend);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public async Task ReadAsync(byte[] buffer)
-        {
-            try
-            {
-                await Task.Factory.FromAsync(
-                    // ReSharper disable once AssignNullToNotNullAttribute
-                    _socket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, null, null),
-                    _socket.EndReceive);
-            }
-            catch (SocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public void Dispose()
-        {
-            _socket?.Dispose();
-        }
-    }
-}

Frameworks/MQTTnet.NetFramework/Properties/AssemblyInfo.cs

@@ -11,5 +11,5 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCulture("")]
 [assembly: ComVisible(false)]
 [assembly: Guid("a480ef90-0eaa-4d9a-b271-47a9c47f6f7d")]
-[assembly: AssemblyVersion("2.1.1.0")]
-[assembly: AssemblyFileVersion("2.1.1.0")]
+[assembly: AssemblyVersion("2.3.1.0")]
+[assembly: AssemblyFileVersion("2.3.1.0")]

Frameworks/MQTTnet.NetStandard/Implementations/MqttServerAdapter.cs

@@ -0,0 +1,125 @@
+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.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
+using MQTTnet.Core.Server;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
+    {
+        private CancellationTokenSource _cancellationTokenSource;
+        private Socket _defaultEndpointSocket;
+        private Socket _tlsEndpointSocket;
+        private X509Certificate2 _tlsCertificate;
+
+        private bool _isRunning;
+
+        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
+
+        public void Start(MqttServerOptions options)
+        {
+            if (_isRunning) throw new InvalidOperationException("Server is already started.");
+
+            _isRunning = true;
+
+            _cancellationTokenSource = new CancellationTokenSource();
+
+            if (options.DefaultEndpointOptions.IsEnabled)
+            {
+                _defaultEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+                _defaultEndpointSocket.Bind(new IPEndPoint(IPAddress.Any, options.GetDefaultEndpointPort()));
+                _defaultEndpointSocket.Listen(options.ConnectionBacklog);
+
+                Task.Run(() => AcceptDefaultEndpointConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
+            }
+
+            if (options.TlsEndpointOptions.IsEnabled)
+            {
+                if (options.TlsEndpointOptions.Certificate == null)
+                {
+                    throw new ArgumentException("TLS certificate is not set.");
+                }
+
+                _tlsCertificate = new X509Certificate2(options.TlsEndpointOptions.Certificate);
+
+                _tlsEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+                _tlsEndpointSocket.Bind(new IPEndPoint(IPAddress.Any, options.GetTlsEndpointPort()));
+                _tlsEndpointSocket.Listen(options.ConnectionBacklog);
+
+                Task.Run(() => AcceptTlsEndpointConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
+            }
+        }
+
+        public void Stop()
+        {
+            _isRunning = false;
+
+            _cancellationTokenSource?.Cancel(false);
+            _cancellationTokenSource?.Dispose();
+            _cancellationTokenSource = null;
+
+            _defaultEndpointSocket?.Dispose();
+            _defaultEndpointSocket = null;
+
+            _tlsEndpointSocket?.Dispose();
+            _tlsEndpointSocket = null;
+        }
+
+        public void Dispose()
+        {
+            Stop();
+        }
+
+        private async Task AcceptDefaultEndpointConnectionsAsync(CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+                    var clientSocket = await _defaultEndpointSocket.AcceptAsync().ConfigureAwait(false);
+                    var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(clientSocket, null), new MqttPacketSerializer());
+                    ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
+                }
+                catch (Exception exception)
+                {
+                    MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while accepting connection at default endpoint.");
+
+                    //excessive CPU consumed if in endless loop of socket errors
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+
+        private async Task AcceptTlsEndpointConnectionsAsync(CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+                    var clientSocket = await _tlsEndpointSocket.AcceptAsync().ConfigureAwait(false);
+
+                    var sslStream = new SslStream(new NetworkStream(clientSocket));
+                    await sslStream.AuthenticateAsServerAsync(_tlsCertificate, false, SslProtocols.Tls12, false).ConfigureAwait(false);
+
+                    var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(clientSocket, sslStream), new MqttPacketSerializer());
+                    ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
+                }
+                catch (Exception exception)
+                {
+                    MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while accepting connection at TLS endpoint.");
+
+                    //excessive CPU consumed if in endless loop of socket errors
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+    }
+}

Frameworks/MQTTnet.NetStandard/Implementations/MqttTcpChannel.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading.Tasks;
+using MQTTnet.Core.Channel;
+using MQTTnet.Core.Client;
+using System.IO;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
+    {
+        private Socket _socket;
+        private SslStream _sslStream;
+        
+        /// <summary>
+        /// called on client sockets are created in connect
+        /// </summary>
+        public MqttTcpChannel()
+        {
+        }
+
+        /// <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;
+            ReceiveStream = (Stream)sslStream ?? new NetworkStream(socket);
+        }
+
+        public Stream SendStream => ReceiveStream;
+        public Stream ReceiveStream { get; private set; }
+        public Stream RawReceiveStream => ReceiveStream;
+        
+        public async Task ConnectAsync(MqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            if (_socket == null)
+            {
+                _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
+            }
+
+            await _socket.ConnectAsync(options.Server, options.GetPort()).ConfigureAwait(false);
+
+            if (options.TlsOptions.UseTls)
+            {
+                _sslStream = new SslStream(new NetworkStream(_socket, true));
+                ReceiveStream = _sslStream;
+                await _sslStream.AuthenticateAsClientAsync(options.Server, LoadCertificates(options), SslProtocols.Tls12, options.TlsOptions.CheckCertificateRevocation).ConfigureAwait(false);
+            }
+            else
+            {
+                ReceiveStream = new NetworkStream(_socket);
+            }
+        }
+
+        public Task DisconnectAsync()
+        {
+            Dispose();
+            return Task.FromResult(0);
+        }
+
+        public void Dispose()
+        {
+            _socket?.Dispose();
+            _socket = null;
+
+            _sslStream?.Dispose();
+            _sslStream = null;
+        }
+
+        private static X509CertificateCollection LoadCertificates(MqttClientOptions options)
+        {
+            var certificates = new X509CertificateCollection();
+            if (options.TlsOptions.Certificates == null)
+            {
+                return certificates;
+            }
+
+            foreach (var certificate in options.TlsOptions.Certificates)
+            {
+                certificates.Add(new X509Certificate(certificate));
+            }
+
+            return certificates;
+        }
+    }
+}

Frameworks/MQTTnet.NetStandard/Implementations/MqttWebSocketChannel.cs

@@ -0,0 +1,55 @@
+using MQTTnet.Core.Channel;
+using MQTTnet.Core.Client;
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class MqttWebSocketChannel : IMqttCommunicationChannel, IDisposable
+    {
+        private ClientWebSocket _webSocket;
+
+        public Stream SendStream => RawReceiveStream;
+        public Stream ReceiveStream => RawReceiveStream;
+        public Stream RawReceiveStream { get; private set; }
+
+        public async Task ConnectAsync(MqttClientOptions options)
+        {
+            var uri = options.Server;
+            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase))
+            {
+                uri = "ws://" + uri;
+            }
+
+            if (options.Port.HasValue)
+            {
+                uri += ":" + options.Port;
+            }
+            
+            _webSocket = new ClientWebSocket();
+            _webSocket.Options.KeepAliveInterval = options.KeepAlivePeriod;
+            await _webSocket.ConnectAsync(new Uri(uri), CancellationToken.None);
+            RawReceiveStream = new WebSocketStream(_webSocket);
+        }
+
+        public async Task DisconnectAsync()
+        {
+            RawReceiveStream = null;
+
+            if (_webSocket == null)
+            {
+                return;
+            }
+
+            await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        public void Dispose()
+        {
+            _webSocket?.Dispose();
+        }
+    }
+}

Frameworks/MQTTnet.NetStandard/Implementations/WebSocketStream.cs

@@ -0,0 +1,79 @@
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public class WebSocketStream : Stream
+    {
+        private readonly ClientWebSocket _webSocket;
+        
+        public WebSocketStream(ClientWebSocket webSocket)
+        {
+            _webSocket = 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 async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var currentOffset = offset;
+            var targetOffset = offset + count;
+            while (_webSocket.State == WebSocketState.Open && currentOffset < targetOffset)
+            {
+                var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer, currentOffset, count), cancellationToken).ConfigureAwait(false);
+                currentOffset += response.Count;
+
+                if (response.MessageType == WebSocketMessageType.Close)
+                {
+                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            return currentOffset - offset;
+        }
+
+        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 int Read(byte[] buffer, int offset, int count)
+        {
+            return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}

Frameworks/MQTTnet.NetStandard/MQTTnet.Netstandard.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard1.3</TargetFramework>
+    <AssemblyName>MQTTnet</AssemblyName>
+    <RootNamespace>MQTTnet</RootNamespace>
+    <AssemblyVersion>2.3.1.0</AssemblyVersion>
+    <FileVersion>2.3.1.0</FileVersion>
+    <Version>0.0.0.0</Version>
+    <Company />
+    <Product />
+    <Description />
+    <Authors />
+    <PackageId />
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'" />
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\MQTTnet.Core\MQTTnet.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <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" />
+    <PackageReference Include="System.Threading.Thread" Version="4.3.0" />
+  </ItemGroup>
+
+</Project>

Frameworks/MQTTnet.NetStandard/MqttClientFactory.cs

@@ -0,0 +1,33 @@
+using System;
+using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Channel;
+using MQTTnet.Core.Client;
+using MQTTnet.Core.Serializer;
+using MQTTnet.Implementations;
+
+namespace MQTTnet
+{
+    public class MqttClientFactory : IMqttClientFactory
+    {
+        public IMqttClient CreateMqttClient(MqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            return new MqttClient(options, new MqttChannelCommunicationAdapter(GetMqttCommunicationChannel(options), new MqttPacketSerializer()));
+        }
+
+        private static IMqttCommunicationChannel GetMqttCommunicationChannel(MqttClientOptions options)
+        {
+            switch (options.ConnectionType)
+            {
+                case MqttConnectionType.Tcp:
+                    return new MqttTcpChannel();
+                case MqttConnectionType.Ws:
+                    return new MqttWebSocketChannel();
+
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+    }
+}

Frameworks/MQTTnet.NetStandard/MqttServerFactory.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Server;
+using MQTTnet.Implementations;
+
+namespace MQTTnet
+{
+    public class MqttServerFactory : IMqttServerFactory
+    {
+        public IMqttServer CreateMqttServer(MqttServerOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            return new MqttServer(options, new List<IMqttServerAdapter> { new MqttServerAdapter() });
+        }
+    }
+}

Frameworks/MQTTnet.UniversalWindows/Implementations/MqttServerAdapter.cs

@@ -0,0 +1,65 @@
+using System;
+using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
+using MQTTnet.Core.Server;
+using Windows.Networking.Sockets;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
+    {
+        private StreamSocketListener _defaultEndpointSocket;
+
+        private bool _isRunning;
+
+        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
+
+        public void Start(MqttServerOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            if (_isRunning) throw new InvalidOperationException("Server is already started.");
+
+            _isRunning = true;
+
+            if (options.DefaultEndpointOptions.IsEnabled)
+            {
+                _defaultEndpointSocket = new StreamSocketListener();
+                _defaultEndpointSocket.BindServiceNameAsync(options.GetDefaultEndpointPort().ToString(), SocketProtectionLevel.PlainSocket).GetAwaiter().GetResult();
+                _defaultEndpointSocket.ConnectionReceived += AcceptDefaultEndpointConnectionsAsync;
+            }
+
+            if (options.TlsEndpointOptions.IsEnabled)
+            {
+                throw new NotSupportedException("TLS servers are not supported for UWP apps.");
+            }
+        }
+
+        public void Stop()
+        {
+            _isRunning = false;
+
+            _defaultEndpointSocket?.Dispose();
+            _defaultEndpointSocket = null;
+        }
+
+        public void Dispose()
+        {
+            Stop();
+        }
+
+        private void AcceptDefaultEndpointConnectionsAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
+        {
+            try
+            {
+                var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(args.Socket), new MqttPacketSerializer());
+                ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(args.Socket.Information.RemoteAddress.ToString(), clientAdapter));
+            }
+            catch (Exception exception)
+            {
+                MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while accepting connection at default endpoint.");
+            }
+        }
+    }
+}

Frameworks/MQTTnet.UniversalWindows/Implementations/MqttTcpChannel.cs

@@ -0,0 +1,104 @@
+using System;
+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.Core.Channel;
+using MQTTnet.Core.Client;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
+    {
+        private StreamSocket _socket;
+
+        public MqttTcpChannel()
+        {
+        }
+
+        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 Stream RawReceiveStream { get; private set; }
+
+        public async Task ConnectAsync(MqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            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);
+
+                if (!options.TlsOptions.CheckCertificateRevocation)
+                {
+                    _socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.IncompleteChain);
+                    _socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.RevocationInformationMissing);
+                }
+
+                await _socket.ConnectAsync(new HostName(options.Server), options.GetPort().ToString(), SocketProtectionLevel.Tls12);
+            }
+
+            CreateStreams();
+        }
+
+        public Task DisconnectAsync()
+        {
+            Dispose();
+            return Task.FromResult(0);
+        }
+
+        public void Dispose()
+        {
+            RawReceiveStream?.Dispose();
+            RawReceiveStream = null;
+
+            SendStream?.Dispose();
+            SendStream = null;
+
+            ReceiveStream?.Dispose();
+            ReceiveStream = null;
+
+            _socket?.Dispose();
+            _socket = null;
+        }
+
+        private void CreateStreams()
+        {
+            SendStream = _socket.OutputStream.AsStreamForWrite();
+            ReceiveStream = _socket.InputStream.AsStreamForRead();
+            RawReceiveStream = ReceiveStream;
+        }
+
+        private static Certificate LoadCertificate(MqttClientOptions 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());
+        }
+    }
+}

Frameworks/MQTTnet.UniversalWindows/Implementations/MqttWebSocketChannel.cs

@@ -0,0 +1,56 @@
+using MQTTnet.Core.Channel;
+using MQTTnet.Core.Client;
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class MqttWebSocketChannel : IMqttCommunicationChannel, IDisposable
+    {
+        private ClientWebSocket _webSocket = new ClientWebSocket();
+
+        public Stream RawReceiveStream { get; private set; }
+        public Stream SendStream => RawReceiveStream;
+        public Stream ReceiveStream => RawReceiveStream;
+
+        public async Task ConnectAsync(MqttClientOptions options)
+        {
+            var uri = options.Server;
+            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase))
+            {
+                uri = "ws://" + uri;
+            }
+
+            if (options.Port.HasValue)
+            {
+                uri += ":" + options.Port;
+            }
+            
+            _webSocket = new ClientWebSocket();
+            _webSocket.Options.KeepAliveInterval = options.KeepAlivePeriod;
+            await _webSocket.ConnectAsync(new Uri(uri), CancellationToken.None).ConfigureAwait(false);
+
+            RawReceiveStream = new WebSocketStream(_webSocket);
+        }
+
+        public async Task DisconnectAsync()
+        {
+            RawReceiveStream = null;
+
+            if (_webSocket == null)
+            {
+                return;
+            }
+
+            await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        public void Dispose()
+        {
+            _webSocket?.Dispose();
+        }
+    }
+}

Frameworks/MQTTnet.UniversalWindows/Implementations/WebSocketStream.cs

@@ -0,0 +1,77 @@
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public class WebSocketStream : Stream
+    {
+        private readonly ClientWebSocket _webSocket;
+
+        public WebSocketStream(ClientWebSocket webSocket)
+        {
+            _webSocket = webSocket;
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var currentOffset = offset;
+            var targetOffset = offset + count;
+            while (_webSocket.State == WebSocketState.Open && currentOffset < targetOffset)
+            {
+                var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer, currentOffset, count), cancellationToken).ConfigureAwait(false);
+                currentOffset += response.Count;
+                
+                if (response.MessageType == WebSocketMessageType.Close)
+                {
+                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            return currentOffset - offset;
+        }
+
+        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 int Read(byte[] buffer, int offset, int count)
+        {
+            return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        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 long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}

Frameworks/MQTTnet.UniversalWindows/MQTTnet.UniversalWindows.csproj

@@ -11,11 +11,12 @@
     <AssemblyName>MQTTnet</AssemblyName>
     <DefaultLanguage>en-US</DefaultLanguage>
     <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
-    <TargetPlatformVersion>10.0.14393.0</TargetPlatformVersion>
+    <TargetPlatformVersion>10.0.15063.0</TargetPlatformVersion>
     <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
     <MinimumVisualStudioVersion>14</MinimumVisualStudioVersion>
     <FileAlignment>512</FileAlignment>
     <ProjectTypeGuids>{A5A43C5B-DE2A-4C0C-9213-0A381AF9435A};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <RuntimeIdentifiers>win10-arm;win10-arm-aot;win10-x86;win10-x86-aot;win10-x64;win10-x64-aot</RuntimeIdentifiers>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -26,6 +27,7 @@
     <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <NoWarn>CS1591</NoWarn>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -35,13 +37,14 @@
     <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <NoWarn>CS1591</NoWarn>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
     <PlatformTarget>x86</PlatformTarget>
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\x86\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
+    <NoWarn>;2008,CS1591</NoWarn>
     <DebugType>full</DebugType>
     <PlatformTarget>x86</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
@@ -52,7 +55,7 @@
     <OutputPath>bin\x86\Release\</OutputPath>
     <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
     <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
+    <NoWarn>;2008,CS1591</NoWarn>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x86</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
@@ -64,7 +67,7 @@
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\ARM\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
+    <NoWarn>;2008,CS1591</NoWarn>
     <DebugType>full</DebugType>
     <PlatformTarget>ARM</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
@@ -75,7 +78,7 @@
     <OutputPath>bin\ARM\Release\</OutputPath>
     <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
     <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
+    <NoWarn>;2008,CS1591</NoWarn>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>ARM</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
@@ -87,7 +90,7 @@
     <DebugSymbols>true</DebugSymbols>
     <OutputPath>bin\x64\Debug\</OutputPath>
     <DefineConstants>DEBUG;TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
-    <NoWarn>;2008</NoWarn>
+    <NoWarn>;2008,CS1591</NoWarn>
     <DebugType>full</DebugType>
     <PlatformTarget>x64</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
@@ -98,7 +101,7 @@
     <OutputPath>bin\x64\Release\</OutputPath>
     <DefineConstants>TRACE;NETFX_CORE;WINDOWS_UWP</DefineConstants>
     <Optimize>true</Optimize>
-    <NoWarn>;2008</NoWarn>
+    <NoWarn>;2008,CS1591</NoWarn>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x64</PlatformTarget>
     <UseVSHostingProcess>false</UseVSHostingProcess>
@@ -107,15 +110,13 @@
     <DocumentationFile>bin\x64\Release\MQTTnet.XML</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
-    <!-- A reference to the entire .Net Framework and Windows SDK are automatically included -->
-    <None Include="project.json" />
-  </ItemGroup>
-  <ItemGroup>
+    <Compile Include="Implementations\MqttWebSocketChannel.cs" />
     <Compile Include="MqttClientFactory.cs" />
-    <Compile Include="MqttServerAdapter.cs" />
+    <Compile Include="Implementations\MqttServerAdapter.cs" />
+    <Compile Include="Implementations\MqttTcpChannel.cs" />
     <Compile Include="MqttServerFactory.cs" />
-    <Compile Include="MqttTcpChannel.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Implementations\WebSocketStream.cs" />
     <EmbeddedResource Include="Properties\MQTTnet.Universal.rd.xml" />
   </ItemGroup>
   <ItemGroup>
@@ -124,6 +125,11 @@
       <Name>MQTTnet.Core</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
+      <Version>5.4.0</Version>
+    </PackageReference>
+  </ItemGroup>
   <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '14.0' ">
     <VisualStudioVersion>14.0</VisualStudioVersion>
   </PropertyGroup>

Frameworks/MQTTnet.UniversalWindows/MqttClientFactory.cs

@@ -1,17 +1,33 @@
 using System;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Channel;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Serializer;
+using MQTTnet.Implementations;
 
 namespace MQTTnet
 {
-    public class MqttClientFactory
+    public class MqttClientFactory : IMqttClientFactory
     {
-        public MqttClient CreateMqttClient(MqttClientOptions options)
+        public IMqttClient CreateMqttClient(MqttClientOptions options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
-            return new MqttClient(options, new MqttChannelCommunicationAdapter(new MqttTcpChannel(), new DefaultMqttV311PacketSerializer()));
+            return new MqttClient(options, new MqttChannelCommunicationAdapter(GetMqttCommunicationChannel(options), new MqttPacketSerializer()));
+        }
+
+        private static IMqttCommunicationChannel GetMqttCommunicationChannel(MqttClientOptions options)
+        {
+            switch (options.ConnectionType)
+            {
+                case MqttConnectionType.Tcp:
+                    return new MqttTcpChannel();
+                case MqttConnectionType.Ws:
+                    return new MqttWebSocketChannel();
+
+                default:
+                    throw new NotSupportedException();
+            }
         }
     }
-}
+}

Frameworks/MQTTnet.UniversalWindows/MqttServerAdapter.cs

@@ -1,54 +0,0 @@
-using System;
-using System.Threading;
-using Windows.Networking.Sockets;
-using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Serializer;
-using MQTTnet.Core.Server;
-
-namespace MQTTnet
-{
-    public sealed class MqttServerAdapter : IMqttServerAdapter, IDisposable
-    {
-        private CancellationTokenSource _cancellationTokenSource;
-        private StreamSocketListener _socket;
-
-        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
-
-        public void Start(MqttServerOptions options)
-        {
-            if (_socket != null) throw new InvalidOperationException("Server is already started.");
-
-            _cancellationTokenSource = new CancellationTokenSource();
-
-            _socket = new StreamSocketListener();
-            _socket.BindServiceNameAsync(options.Port.ToString()).AsTask().Wait();
-            _socket.ConnectionReceived += ConnectionReceived;
-        }
-
-        private void ConnectionReceived(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
-        {
-            var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(args.Socket), new DefaultMqttV311PacketSerializer());
-
-            var identifier = $"{args.Socket.Information.RemoteAddress}:{args.Socket.Information.RemotePort}";
-            ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(identifier, clientAdapter));
-        }
-
-        public void Stop()
-        {
-            _cancellationTokenSource?.Dispose();
-
-            if (_socket != null)
-            {
-                _socket.ConnectionReceived -= ConnectionReceived;
-            }
-
-            _socket?.Dispose();
-            _socket = null;
-        }
-
-        public void Dispose()
-        {
-            Stop();
-        }
-    }
-}

Frameworks/MQTTnet.UniversalWindows/MqttServerFactory.cs

@@ -1,15 +1,18 @@
 using System;
+using System.Collections.Generic;
+using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Server;
+using MQTTnet.Implementations;
 
 namespace MQTTnet
 {
-    public class MqttServerFactory
+    public class MqttServerFactory : IMqttServerFactory
     {
-        public MqttServer CreateMqttServer(MqttServerOptions options)
+        public IMqttServer CreateMqttServer(MqttServerOptions options)
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
-            return new MqttServer(options, new MqttServerAdapter());
+            return new MqttServer(options, new List<IMqttServerAdapter> { new MqttServerAdapter() });
         }
     }
 }

Frameworks/MQTTnet.UniversalWindows/MqttTcpChannel.cs

@@ -1,62 +0,0 @@
-using System;
-using System.Runtime.InteropServices.WindowsRuntime;
-using System.Threading.Tasks;
-using Windows.Networking;
-using Windows.Networking.Sockets;
-using Windows.Storage.Streams;
-using MQTTnet.Core.Channel;
-using MQTTnet.Core.Client;
-using Buffer = Windows.Storage.Streams.Buffer;
-
-namespace MQTTnet
-{
-    public sealed class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
-    {
-        private readonly StreamSocket _socket;
-
-        public MqttTcpChannel()
-        {
-            _socket = new StreamSocket();
-        }
-
-        public MqttTcpChannel(StreamSocket socket)
-        {
-            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
-        }
-
-        public async Task ConnectAsync(MqttClientOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            await _socket.ConnectAsync(new HostName(options.Server), options.Port.ToString());
-        }
-
-        public async Task DisconnectAsync()
-        {
-            await _socket.CancelIOAsync();
-            _socket.Dispose();
-        }
-
-        public async Task WriteAsync(byte[] buffer)
-        {
-            if (buffer == null) throw new ArgumentNullException(nameof(buffer));
-
-            await _socket.OutputStream.WriteAsync(buffer.AsBuffer());
-            await _socket.OutputStream.FlushAsync();
-        }
-
-        public async Task ReadAsync(byte[] buffer)
-        {
-            var buffer2 = new Buffer((uint)buffer.Length);
-            await _socket.InputStream.ReadAsync(buffer2, (uint)buffer.Length, InputStreamOptions.None);
-
-            var array2 = buffer2.ToArray();
-            Array.Copy(array2, buffer, array2.Length);
-        }
-
-        public void Dispose()
-        {
-            _socket?.Dispose();
-        }
-    }
-}

Frameworks/MQTTnet.UniversalWindows/Properties/AssemblyInfo.cs

@@ -10,5 +10,5 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyTrademark("")]
 [assembly: AssemblyCulture("")]
 [assembly: ComVisible(false)]
-[assembly: AssemblyVersion("2.1.1.0")]
-[assembly: AssemblyFileVersion("2.1.1.0")]
+[assembly: AssemblyVersion("2.3.1.0")]
+[assembly: AssemblyFileVersion("2.3.1.0")]

Frameworks/MQTTnet.UniversalWindows/project.json

@@ -1,17 +0,0 @@
-{
-  "dependencies": {
-    "Microsoft.NETCore.UniversalWindowsPlatform": "5.1.0"
-  },
-  "frameworks": {
-    "uap10.0": {},
-    "netstandard1.1": {}
-  },
-  "runtimes": {
-    "win10-arm": {},
-    "win10-arm-aot": {},
-    "win10-x86": {},
-    "win10-x86-aot": {},
-    "win10-x64": {},
-    "win10-x64-aot": {}
-  }
-}

MQTTnet.Core/Adapter/IMqttCommunicationAdapter.cs

@@ -1,18 +1,23 @@
 using System;
+using System.Collections.Generic;
+using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Packets;
+using MQTTnet.Core.Serializer;
 
 namespace MQTTnet.Core.Adapter
 {
     public interface IMqttCommunicationAdapter
     {
-        Task ConnectAsync(MqttClientOptions options, TimeSpan timeout);
+        IMqttPacketSerializer PacketSerializer { get; }
 
-        Task DisconnectAsync();
+        Task ConnectAsync(TimeSpan timeout, MqttClientOptions options);
 
-        Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout);
+        Task DisconnectAsync(TimeSpan timeout);
 
-        Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout);
+        Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets);
+
+        Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken);
     }
 }

MQTTnet.Core/Adapter/MqttChannelCommunicationAdapter.cs

@@ -1,9 +1,13 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Channel;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
+using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Serializer;
 
@@ -11,78 +15,180 @@ namespace MQTTnet.Core.Adapter
 {
     public class MqttChannelCommunicationAdapter : IMqttCommunicationAdapter
     {
-        private readonly IMqttPacketSerializer _serializer;
         private readonly IMqttCommunicationChannel _channel;
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
 
         public MqttChannelCommunicationAdapter(IMqttCommunicationChannel channel, IMqttPacketSerializer serializer)
         {
             _channel = channel ?? throw new ArgumentNullException(nameof(channel));
-            _serializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
+            PacketSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
         }
 
-        public async Task ConnectAsync(MqttClientOptions options, TimeSpan timeout)
-        {
-            var task = _channel.ConnectAsync(options);
-            if (await Task.WhenAny(Task.Delay(timeout), task) != task)
-            {
-                throw new MqttCommunicationTimedOutException();
-            }
-        }
+        public IMqttPacketSerializer PacketSerializer { get; }
 
-        public async Task DisconnectAsync()
+        public async Task ConnectAsync(TimeSpan timeout, MqttClientOptions options)
         {
-            await _channel.DisconnectAsync();
-        }
-
-        public async Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout)
-        {
-            MqttTrace.Information(nameof(MqttChannelCommunicationAdapter), $"TX >>> {packet} [Timeout={timeout}]");
-
-            bool hasTimeout;
             try
             {
-                var task = _serializer.SerializeAsync(packet, _channel);
-                hasTimeout = await Task.WhenAny(Task.Delay(timeout), task) != task;
+                await _channel.ConnectAsync(options).TimeoutAfter(timeout).ConfigureAwait(false);
+            }
+            catch (TaskCanceledException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationTimedOutException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationException)
+            {
+                throw;
             }
             catch (Exception exception)
             {
                 throw new MqttCommunicationException(exception);
             }
+        }
 
-            if (hasTimeout)
+        public async Task DisconnectAsync(TimeSpan timeout)
+        {
+            try
             {
-                throw new MqttCommunicationTimedOutException();
+                await _channel.DisconnectAsync().TimeoutAfter(timeout).ConfigureAwait(false);
+            }
+            catch (TaskCanceledException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationTimedOutException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationException)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                throw new MqttCommunicationException(exception);
             }
         }
 
-        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout)
+        public async Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets)
         {
-            MqttBasePacket packet;
-            if (timeout > TimeSpan.Zero)
-            {
-                var workerTask = _serializer.DeserializeAsync(_channel);
-                var timeoutTask = Task.Delay(timeout);
-                var hasTimeout = Task.WhenAny(timeoutTask, workerTask) == timeoutTask;
+            await _semaphore.WaitAsync(cancellationToken);
 
-                if (hasTimeout)
+            try
+            {
+                foreach (var packet in packets)
                 {
-                    throw new MqttCommunicationTimedOutException();
+                    if (packet == null)
+                    {
+                        continue;
+                    }
+
+                    MqttTrace.Information(nameof(MqttChannelCommunicationAdapter), $"TX >>> {0} [Timeout={1}]", packet, timeout);
+
+                    var writeBuffer = PacketSerializer.Serialize(packet);
+                    await _channel.SendStream.WriteAsync(writeBuffer, 0, writeBuffer.Length, cancellationToken).ConfigureAwait(false);
                 }
 
-                packet = workerTask.Result;
+                if (timeout > TimeSpan.Zero)
+                {
+                    await _channel.SendStream.FlushAsync(cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
+                }
+                else
+                {
+                    await _channel.SendStream.FlushAsync(cancellationToken).ConfigureAwait(false);
+                }
             }
-            else
+            catch (TaskCanceledException)
             {
-                packet = await _serializer.DeserializeAsync(_channel);
+                throw;
+            }
+            catch (MqttCommunicationTimedOutException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationException)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                throw new MqttCommunicationException(exception);
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            try
+            {
+                ReceivedMqttPacket receivedMqttPacket;
+                if (timeout > TimeSpan.Zero)
+                {
+                    receivedMqttPacket = await ReceiveAsync(_channel.RawReceiveStream, cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
+                }
+                else
+                {
+                    receivedMqttPacket = await ReceiveAsync(_channel.ReceiveStream, cancellationToken).ConfigureAwait(false);
+                }
+
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    throw new TaskCanceledException();
+                }
+
+                var packet = PacketSerializer.Deserialize(receivedMqttPacket);
+                if (packet == null)
+                {
+                    throw new MqttProtocolViolationException("Received malformed packet.");
+                }
+
+                MqttTrace.Information(nameof(MqttChannelCommunicationAdapter), "RX <<< {0}", packet);
+                return packet;
+            }
+            catch (TaskCanceledException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationTimedOutException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationException)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                throw new MqttCommunicationException(exception);
+            }
+        }
+
+        private static async Task<ReceivedMqttPacket> ReceiveAsync(Stream stream, CancellationToken cancellationToken)
+        {
+            var header = MqttPacketReader.ReadHeaderFromSource(stream, cancellationToken);
+
+            if (header.BodyLength == 0)
+            {
+                return new ReceivedMqttPacket(header, new MemoryStream(0));
             }
 
-            if (packet == null)
-            {
-                throw new MqttProtocolViolationException("Received malformed packet.");
-            }
+            var body = new byte[header.BodyLength];
 
-            MqttTrace.Information(nameof(MqttChannelCommunicationAdapter), $"RX <<< {packet}");
-            return packet;
+            var offset = 0;
+            do
+            {
+                var readBytesCount = await stream.ReadAsync(body, offset, body.Length - offset, cancellationToken).ConfigureAwait(false);
+                offset += readBytesCount;
+            } while (offset < header.BodyLength);
+
+            return new ReceivedMqttPacket(header, new MemoryStream(body, 0, body.Length));
         }
     }
-}
+}

MQTTnet.Core/Adapter/MqttCommunicationAdapterExtensions.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Core.Packets;
+
+namespace MQTTnet.Core.Adapter
+{
+    public static class MqttCommunicationAdapterExtensions
+    {
+        public static Task SendPacketsAsync(this IMqttCommunicationAdapter adapter, TimeSpan timeout, CancellationToken cancellationToken, params MqttBasePacket[] packets)
+        {
+            return adapter.SendPacketsAsync(timeout, cancellationToken, packets);
+        }
+    }
+}

MQTTnet.Core/Adapter/MqttConnectingFailedException.cs

@@ -5,7 +5,7 @@ namespace MQTTnet.Core.Adapter
 {
     public class MqttConnectingFailedException : MqttCommunicationException
     {
-        public MqttConnectingFailedException(MqttConnectReturnCode returnCode) 
+        public MqttConnectingFailedException(MqttConnectReturnCode returnCode)
             : base($"Connecting with MQTT server failed ({returnCode}).")
         {
             ReturnCode = returnCode;

MQTTnet.Core/Adapter/ReceivedMqttPacket.cs

@@ -0,0 +1,19 @@
+using System;
+using System.IO;
+using MQTTnet.Core.Packets;
+
+namespace MQTTnet.Core.Adapter
+{
+    public class ReceivedMqttPacket
+    {
+        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; }
+    }
+}

MQTTnet.Core/Channel/IMqttCommunicationChannel.cs

@@ -1,16 +1,16 @@
 using System.Threading.Tasks;
 using MQTTnet.Core.Client;
+using System.IO;
 
 namespace MQTTnet.Core.Channel
 {
     public interface IMqttCommunicationChannel
     {
+        Stream SendStream { get; }
+        Stream ReceiveStream { get; }
+        Stream RawReceiveStream { get; }
+
         Task ConnectAsync(MqttClientOptions options);
-
         Task DisconnectAsync();
-
-        Task WriteAsync(byte[] buffer);
-
-        Task ReadAsync(byte[] buffer);
     }
 }

MQTTnet.Core/Client/IMqttClient.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using MQTTnet.Core.Packets;
+
+namespace MQTTnet.Core.Client
+{
+    public interface IMqttClient
+    {
+        bool IsConnected { get; }
+
+        event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+        event EventHandler Connected;
+        event EventHandler Disconnected;
+
+        Task ConnectAsync(MqttApplicationMessage willApplicationMessage = null);
+        Task DisconnectAsync();
+
+        Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
+        Task UnsubscribeAsync(IEnumerable<string> topicFilters);
+
+        Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages);
+    }
+}

MQTTnet.Core/Client/IMqttClientFactory.cs

@@ -0,0 +1,7 @@
+namespace MQTTnet.Core.Client
+{
+    public interface IMqttClientFactory
+    {
+        IMqttClient CreateMqttClient(MqttClientOptions options);
+    }
+}

MQTTnet.Core/Client/MqttApplicationMessageReceivedEventArgs.cs

@@ -1,8 +1,8 @@
 using System;
 
-namespace MQTTnet.Core
+namespace MQTTnet.Core.Client
 {
-    public class MqttApplicationMessageReceivedEventArgs : EventArgs
+    public sealed class MqttApplicationMessageReceivedEventArgs : EventArgs
     {
         public MqttApplicationMessageReceivedEventArgs(MqttApplicationMessage applicationMessage)
         {

MQTTnet.Core/Client/MqttClient.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -13,15 +12,14 @@ using MQTTnet.Core.Protocol;
 
 namespace MQTTnet.Core.Client
 {
-    public class MqttClient
+    public class MqttClient : IMqttClient
     {
-        private readonly ConcurrentDictionary<ushort, MqttPublishPacket> _pendingExactlyOncePublishPackets = new ConcurrentDictionary<ushort, MqttPublishPacket>();
-        private readonly HashSet<ushort> _processedPublishPackets = new HashSet<ushort>();
-
+        private readonly HashSet<ushort> _unacknowledgedPublishPackets = new HashSet<ushort>();
         private readonly MqttPacketDispatcher _packetDispatcher = new MqttPacketDispatcher();
         private readonly MqttClientOptions _options;
         private readonly IMqttCommunicationAdapter _adapter;
 
+        private bool _isReceivingPackets;
         private int _latestPacketIdentifier;
         private CancellationTokenSource _cancellationTokenSource;
 
@@ -29,137 +27,183 @@ namespace MQTTnet.Core.Client
         {
             _options = options ?? throw new ArgumentNullException(nameof(options));
             _adapter = adapter ?? throw new ArgumentNullException(nameof(adapter));
+
+            _adapter.PacketSerializer.ProtocolVersion = options.ProtocolVersion;
         }
 
         public event EventHandler Connected;
-
         public event EventHandler Disconnected;
-
         public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
 
-        public bool IsConnected { get; private set; }
+        public bool IsConnected => _cancellationTokenSource != null && !_cancellationTokenSource.IsCancellationRequested;
 
         public async Task ConnectAsync(MqttApplicationMessage willApplicationMessage = null)
         {
-            MqttTrace.Verbose(nameof(MqttClient), "Trying to connect.");
+            ThrowIfConnected("It is not allowed to connect with a server after the connection is established.");
 
-            if (IsConnected)
+            try
             {
-                throw new MqttProtocolViolationException("It is not allowed to connect with a server after the connection is established.");
+                _cancellationTokenSource = new CancellationTokenSource();
+                _latestPacketIdentifier = 0;
+                _packetDispatcher.Reset();
+
+                MqttTrace.Verbose(nameof(MqttClient), "Trying to connect with server.");
+                await _adapter.ConnectAsync(_options.DefaultCommunicationTimeout, _options).ConfigureAwait(false);
+                MqttTrace.Verbose(nameof(MqttClient), "Connection with server established.");
+
+                await SetupIncomingPacketProcessingAsync();
+                await AuthenticateAsync(willApplicationMessage);
+
+                MqttTrace.Verbose(nameof(MqttClient), "MQTT connection with server established.");
+
+                if (_options.KeepAlivePeriod != TimeSpan.Zero)
+                {
+                    StartSendKeepAliveMessages(_cancellationTokenSource.Token);
+                }
+
+                Connected?.Invoke(this, EventArgs.Empty);
             }
-
-            var connectPacket = new MqttConnectPacket
+            catch (Exception)
             {
-                ClientId = _options.ClientId,
-                Username = _options.UserName,
-                Password = _options.Password,
-                KeepAlivePeriod = (ushort)_options.KeepAlivePeriod.TotalSeconds,
-                WillMessage = willApplicationMessage
-            };
-
-            await _adapter.ConnectAsync(_options, _options.DefaultCommunicationTimeout);
-            MqttTrace.Verbose(nameof(MqttClient), "Connection with server established.");
-
-            _cancellationTokenSource = new CancellationTokenSource();
-            _latestPacketIdentifier = 0;
-            _processedPublishPackets.Clear();
-            _packetDispatcher.Reset();
-            IsConnected = true;
-
-            Task.Run(() => ReceivePackets(_cancellationTokenSource.Token), _cancellationTokenSource.Token).Forget();
-
-            var response = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket);
-            if (response.ConnectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
-            {
-                throw new MqttConnectingFailedException(response.ConnectReturnCode);
+                await DisconnectInternalAsync().ConfigureAwait(false);
+                throw;
             }
-
-            if (_options.KeepAlivePeriod != TimeSpan.Zero)
-            {
-                Task.Run(() => SendKeepAliveMessagesAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token).Forget();
-            }
-
-            Connected?.Invoke(this, EventArgs.Empty);
         }
 
         public async Task DisconnectAsync()
         {
-            await SendAsync(new MqttDisconnectPacket());
-            await DisconnectInternalAsync();
+            if (!IsConnected)
+            {
+                return;
+            }
+
+            try
+            {
+                await SendAsync(new MqttDisconnectPacket()).ConfigureAwait(false);
+            }
+            finally
+            {
+                await DisconnectInternalAsync().ConfigureAwait(false);
+            }
         }
 
-        public Task<IList<MqttSubscribeResult>> SubscribeAsync(params TopicFilter[] topicFilters)
+        public async Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
         {
             if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
 
-            return SubscribeAsync(topicFilters.ToList());
-        }
-
-        public async Task<IList<MqttSubscribeResult>> SubscribeAsync(IList<TopicFilter> topicFilters)
-        {
-            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
-            if (!topicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.8.3-3].");
             ThrowIfNotConnected();
 
             var subscribePacket = new MqttSubscribePacket
             {
                 PacketIdentifier = GetNewPacketIdentifier(),
-                TopicFilters = topicFilters
+                TopicFilters = topicFilters.ToList()
             };
 
-            var response = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket);
+            var response = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket).ConfigureAwait(false);
 
-            if (response.SubscribeReturnCodes.Count != topicFilters.Count)
+            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 topicFilters.Select((t, i) => new MqttSubscribeResult(t, response.SubscribeReturnCodes[i])).ToList();
+            return subscribePacket.TopicFilters.Select((t, i) => new MqttSubscribeResult(t, response.SubscribeReturnCodes[i])).ToList();
         }
 
-        public Task Unsubscribe(params string[] topicFilters)
+        public async Task UnsubscribeAsync(IEnumerable<string> topicFilters)
         {
             if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
 
-            return Unsubscribe(topicFilters.ToList());
-        }
-
-        public async Task Unsubscribe(IList<string> topicFilters)
-        {
-            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
-            if (!topicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.10.3-2].");
             ThrowIfNotConnected();
 
             var unsubscribePacket = new MqttUnsubscribePacket
             {
                 PacketIdentifier = GetNewPacketIdentifier(),
-                TopicFilters = topicFilters
+                TopicFilters = topicFilters.ToList()
             };
 
             await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket);
         }
 
-        public async Task PublishAsync(MqttApplicationMessage applicationMessage)
+        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
         {
-            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
             ThrowIfNotConnected();
 
-            var publishPacket = applicationMessage.ToPublishPacket();
+            var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
 
-            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
+            foreach (var qosGroup in publishPackets.GroupBy(p => p.QualityOfServiceLevel))
             {
-                await SendAsync(publishPacket);
+                var qosPackets = qosGroup.ToArray();
+                switch (qosGroup.Key)
+                {
+                    case MqttQualityOfServiceLevel.AtMostOnce:
+                        {
+                            // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
+                            await _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, _cancellationTokenSource.Token, qosPackets);
+                            break;
+                        }
+                    case MqttQualityOfServiceLevel.AtLeastOnce:
+                        {
+                            foreach (var publishPacket in qosPackets)
+                            {
+                                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
+                                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket);
+                            }
+
+                            break;
+                        }
+                    case MqttQualityOfServiceLevel.ExactlyOnce:
+                        {
+                            foreach (var publishPacket in qosPackets)
+                            {
+                                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
+                                var pubRecPacket = await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket).ConfigureAwait(false);
+                                await SendAndReceiveAsync<MqttPubCompPacket>(pubRecPacket.CreateResponse<MqttPubRelPacket>()).ConfigureAwait(false);
+                            }
+
+                            break;
+                        }
+                    default:
+                        {
+                            throw new InvalidOperationException();
+                        }
+                }
             }
-            else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
+        }
+
+        private async Task AuthenticateAsync(MqttApplicationMessage willApplicationMessage)
+        {
+            var connectPacket = new MqttConnectPacket
             {
-                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
-                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket);
+                ClientId = _options.ClientId,
+                Username = _options.UserName,
+                Password = _options.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);
             }
-            else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
+        }
+
+        private async Task SetupIncomingPacketProcessingAsync()
+        {
+            _isReceivingPackets = false;
+
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Task.Factory.StartNew(
+                () => ReceivePackets(_cancellationTokenSource.Token),
+                _cancellationTokenSource.Token,
+                TaskCreationOptions.LongRunning,
+                TaskScheduler.Default).ConfigureAwait(false);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+            while (!_isReceivingPackets && _cancellationTokenSource != null && !_cancellationTokenSource.IsCancellationRequested)
             {
-                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
-                await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket);
-                await SendAsync(publishPacket.CreateResponse<MqttPubCompPacket>());
+                await Task.Delay(TimeSpan.FromMilliseconds(100));
             }
         }
 
@@ -168,76 +212,87 @@ namespace MQTTnet.Core.Client
             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()
         {
+            var cts = _cancellationTokenSource;
+            if (cts == null || cts.IsCancellationRequested)
+            {
+                return;
+            }
+
+            cts.Cancel(false);
+            cts.Dispose();
+            _cancellationTokenSource = null;
+
             try
             {
-                await _adapter.DisconnectAsync();
+                await _adapter.DisconnectAsync(_options.DefaultCommunicationTimeout).ConfigureAwait(false);
+                MqttTrace.Information(nameof(MqttClient), "Disconnected from adapter.");
             }
-            catch
+            catch (Exception exception)
             {
+                MqttTrace.Warning(nameof(MqttClient), exception, "Error while disconnecting from adapter.");
             }
             finally
             {
-                _cancellationTokenSource?.Cancel();
-                IsConnected = false;
                 Disconnected?.Invoke(this, EventArgs.Empty);
             }
         }
 
-        private async void ProcessReceivedPacket(MqttBasePacket mqttPacket)
+        private async Task ProcessReceivedPacketAsync(MqttBasePacket packet)
         {
             try
             {
-                if (mqttPacket is MqttPingReqPacket)
+                MqttTrace.Information(nameof(MqttClient), "Received <<< {0}", packet);
+
+                if (packet is MqttPingReqPacket)
                 {
                     await SendAsync(new MqttPingRespPacket());
                     return;
                 }
 
-                if (mqttPacket is MqttDisconnectPacket)
+                if (packet is MqttDisconnectPacket)
                 {
                     await DisconnectAsync();
                     return;
                 }
 
-                var publishPacket = mqttPacket as MqttPublishPacket;
-                if (publishPacket != null)
+                if (packet is MqttPublishPacket publishPacket)
                 {
                     await ProcessReceivedPublishPacket(publishPacket);
                     return;
                 }
 
-                var pubRelPacket = mqttPacket as MqttPubRelPacket;
-                if (pubRelPacket != null)
+                if (packet is MqttPubRelPacket pubRelPacket)
                 {
                     await ProcessReceivedPubRelPacket(pubRelPacket);
                     return;
                 }
 
-                _packetDispatcher.Dispatch(mqttPacket);
+                _packetDispatcher.Dispatch(packet);
             }
             catch (Exception exception)
             {
-                MqttTrace.Error(nameof(MqttClient), exception, "Error while processing received packet.");
+                MqttTrace.Error(nameof(MqttClient), exception, "Unhandled exception while processing received packet.");
             }
         }
 
         private void FireApplicationMessageReceivedEvent(MqttPublishPacket publishPacket)
         {
-            if (publishPacket.QualityOfServiceLevel != MqttQualityOfServiceLevel.AtMostOnce)
+            try
             {
-                _processedPublishPackets.Add(publishPacket.PacketIdentifier);
+                var applicationMessage = publishPacket.ToApplicationMessage();
+                ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(applicationMessage));
+            }
+            catch (Exception exception)
+            {
+                MqttTrace.Error(nameof(MqttClient), exception, "Unhandled exception while handling application message.");
             }
-
-            var applicationMessage = new MqttApplicationMessage(
-                publishPacket.Topic,
-                publishPacket.Payload,
-                publishPacket.QualityOfServiceLevel,
-                publishPacket.Retain
-            );
-
-            ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(applicationMessage));
         }
 
         private async Task ProcessReceivedPublishPacket(MqttPublishPacket publishPacket)
@@ -245,66 +300,52 @@ namespace MQTTnet.Core.Client
             if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
             {
                 FireApplicationMessageReceivedEvent(publishPacket);
+                return;
             }
-            else
+
+            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
             {
-                if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
-                {
-                    FireApplicationMessageReceivedEvent(publishPacket);
-                    await SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier });
-                }
-                else if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
-                {
-                    _pendingExactlyOncePublishPackets[publishPacket.PacketIdentifier] = publishPacket;
-                    await SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier });
-                }
+                FireApplicationMessageReceivedEvent(publishPacket);
+                await SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier });
+                return;
             }
+
+            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
+            {
+                // QoS 2 is implement as method "B" [4.3.3 QoS 2: Exactly once delivery]
+                lock (_unacknowledgedPublishPackets)
+                {
+                    _unacknowledgedPublishPackets.Add(publishPacket.PacketIdentifier);
+                }
+
+                FireApplicationMessageReceivedEvent(publishPacket);
+                await SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier });
+                return;
+            }
+
+            throw new MqttCommunicationException("Received a not supported QoS level.");
         }
 
-        private async Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
+        private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
         {
-            MqttPublishPacket originalPublishPacket;
-            if (!_pendingExactlyOncePublishPackets.TryRemove(pubRelPacket.PacketIdentifier, out originalPublishPacket))
+            lock (_unacknowledgedPublishPackets)
             {
-                throw new MqttCommunicationException();
+                _unacknowledgedPublishPackets.Remove(pubRelPacket.PacketIdentifier);
             }
 
-            await SendAsync(originalPublishPacket.CreateResponse<MqttPubCompPacket>());
-
-            FireApplicationMessageReceivedEvent(originalPublishPacket);
+            return SendAsync(pubRelPacket.CreateResponse<MqttPubCompPacket>());
         }
 
         private Task SendAsync(MqttBasePacket packet)
         {
-            return _adapter.SendPacketAsync(packet, _options.DefaultCommunicationTimeout);
+            return _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, _cancellationTokenSource.Token, packet);
         }
 
         private async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket) where TResponsePacket : MqttBasePacket
         {
-            bool ResponsePacketSelector(MqttBasePacket p)
-            {
-                var p1 = p as TResponsePacket;
-                if (p1 == null)
-                {
-                    return false;
-                }
-
-                var pi1 = requestPacket as IPacketWithIdentifier;
-                var pi2 = p as IPacketWithIdentifier;
-
-                if (pi1 != null && pi2 != null)
-                {
-                    if (pi1.PacketIdentifier != pi2.PacketIdentifier)
-                    {
-                        return false;
-                    }
-                }
-
-                return true;
-            }
-
-            await _adapter.SendPacketAsync(requestPacket, _options.DefaultCommunicationTimeout);
-            return (TResponsePacket)await _packetDispatcher.WaitForPacketAsync(ResponsePacketSelector, _options.DefaultCommunicationTimeout);
+            var packetAwaiter = _packetDispatcher.WaitForPacketAsync(requestPacket, typeof(TResponsePacket), _options.DefaultCommunicationTimeout);
+            await _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, _cancellationTokenSource.Token, requestPacket).ConfigureAwait(false);
+            return (TResponsePacket)await packetAwaiter.ConfigureAwait(false);
         }
 
         private ushort GetNewPacketIdentifier()
@@ -320,51 +361,94 @@ namespace MQTTnet.Core.Client
             {
                 while (!cancellationToken.IsCancellationRequested)
                 {
-                    await Task.Delay(_options.KeepAlivePeriod, cancellationToken);
-                    await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket());
+                    await Task.Delay(_options.KeepAlivePeriod, cancellationToken).ConfigureAwait(false);
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        return;
+                    }
+
+                    await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket()).ConfigureAwait(false);
                 }
             }
+            catch (TaskCanceledException)
+            {
+            }
             catch (MqttCommunicationException exception)
             {
-                MqttTrace.Warning(nameof(MqttClient), exception, "MQTT communication error while receiving packets.");
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                MqttTrace.Warning(nameof(MqttClient), exception, "MQTT communication exception while sending/receiving keep alive packets.");
+                await DisconnectInternalAsync().ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                MqttTrace.Warning(nameof(MqttClient), exception, "Error while sending/receiving keep alive packets.");
+                MqttTrace.Warning(nameof(MqttClient), exception, "Unhandled exception while sending/receiving keep alive packets.");
+                await DisconnectInternalAsync().ConfigureAwait(false);
             }
             finally
             {
                 MqttTrace.Information(nameof(MqttClient), "Stopped sending keep alive packets.");
-                await DisconnectInternalAsync();
             }
         }
 
         private async Task ReceivePackets(CancellationToken cancellationToken)
         {
             MqttTrace.Information(nameof(MqttClient), "Start receiving packets.");
+
             try
             {
                 while (!cancellationToken.IsCancellationRequested)
                 {
-                    var mqttPacket = await _adapter.ReceivePacketAsync(TimeSpan.Zero);
-                    MqttTrace.Information(nameof(MqttClient), $"Received <<< {mqttPacket}");
+                    _isReceivingPackets = true;
 
-                    Task.Run(() => ProcessReceivedPacket(mqttPacket), cancellationToken).Forget();
+                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        return;
+                    }
+
+                    StartProcessReceivedPacket(packet, cancellationToken);
                 }
             }
+            catch (TaskCanceledException)
+            {
+            }
             catch (MqttCommunicationException exception)
             {
-                MqttTrace.Warning(nameof(MqttClient), exception, "MQTT communication error while receiving packets.");
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                MqttTrace.Warning(nameof(MqttClient), exception, "MQTT communication exception while receiving packets.");
+                await DisconnectInternalAsync().ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                MqttTrace.Error(nameof(MqttClient), exception, "Error while receiving packets.");
+                MqttTrace.Error(nameof(MqttClient), exception, "Unhandled exception while receiving packets.");
+                await DisconnectInternalAsync().ConfigureAwait(false);
             }
             finally
             {
                 MqttTrace.Information(nameof(MqttClient), "Stopped receiving packets.");
-                await DisconnectInternalAsync();
             }
         }
+
+        private void StartProcessReceivedPacket(MqttBasePacket packet, CancellationToken cancellationToken)
+        {
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Task.Run(() => ProcessReceivedPacketAsync(packet), cancellationToken).ConfigureAwait(false);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+        }
+
+        private void StartSendKeepAliveMessages(CancellationToken cancellationToken)
+        {
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Task.Factory.StartNew(() => SendKeepAliveMessagesAsync(cancellationToken), cancellationToken, TaskCreationOptions.LongRunning, TaskScheduler.Default).ConfigureAwait(false);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+        }
     }
 }

MQTTnet.Core/Client/MqttClientExtensions.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using MQTTnet.Core.Packets;
+
+namespace MQTTnet.Core.Client
+{
+    public static class MqttClientExtensions
+    {
+        public static Task PublishAsync(this IMqttClient client, params MqttApplicationMessage[] applicationMessages)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
+
+            return client.PublishAsync(applicationMessages);
+        }
+
+        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 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());
+        }
+    }
+}

MQTTnet.Core/Client/MqttClientOptions.cs

@@ -1,12 +1,15 @@
 using System;
+using MQTTnet.Core.Serializer;
 
 namespace MQTTnet.Core.Client
 {
-    public class MqttClientOptions
+    public sealed class MqttClientOptions
     {
         public string Server { get; set; }
 
-        public int Port { get; set; } = 1883;
+        public int? Port { get; set; }
+
+        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
 
         public string UserName { get; set; }
 
@@ -14,8 +17,14 @@ namespace MQTTnet.Core.Client
 
         public string ClientId { get; set; } = Guid.NewGuid().ToString().Replace("-", string.Empty);
 
+        public bool CleanSession { get; set; } = true;
+
         public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(5);
 
         public TimeSpan DefaultCommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
+        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
+
+        public MqttConnectionType ConnectionType { get; set; } = MqttConnectionType.Tcp;
     }
 }

MQTTnet.Core/Client/MqttClientOptionsExtensions.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace MQTTnet.Core.Client
+{
+    public static class MqttClientOptionsExtensions
+    {
+        public static int GetPort(this MqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            if (options.Port.HasValue)
+            {
+                return options.Port.Value;
+            }
+
+            return !options.TlsOptions.UseTls ? 1883 : 8883;
+        }
+    }
+}

MQTTnet.Core/Client/MqttClientTlsOptions.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace MQTTnet.Core.Client
+{
+    public sealed class MqttClientTlsOptions
+    {
+        public bool UseTls { get; set; }
+
+        public bool CheckCertificateRevocation { get; set; }
+
+        public List<byte[]> Certificates { get; set; }
+    }
+}

MQTTnet.Core/Client/MqttConnectionType.cs

@@ -0,0 +1,8 @@
+namespace MQTTnet.Core.Client
+{
+    public enum MqttConnectionType
+    {
+        Tcp,
+        Ws
+    }
+}

MQTTnet.Core/Client/MqttPacketAwaiter.cs

@@ -1,16 +0,0 @@
-using System;
-using System.Threading.Tasks;
-using MQTTnet.Core.Packets;
-
-namespace MQTTnet.Core.Client
-{
-    public class MqttPacketAwaiter : TaskCompletionSource<MqttBasePacket>
-    {
-        public MqttPacketAwaiter(Func<MqttBasePacket, bool> packetSelector)
-        {
-            PacketSelector = packetSelector ?? throw new ArgumentNullException(nameof(packetSelector));
-        }
-
-        public Func<MqttBasePacket, bool> PacketSelector { get; }
-    }
-}

MQTTnet.Core/Client/MqttPacketDispatcher.cs

@@ -1,111 +1,96 @@
 using System;
-using System.Collections.Generic;
 using System.Threading.Tasks;
 using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
+using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
+using System.Collections.Concurrent;
 
 namespace MQTTnet.Core.Client
 {
     public class MqttPacketDispatcher
     {
-        private readonly object _syncRoot = new object();
-        private readonly List<MqttBasePacket> _receivedPackets = new List<MqttBasePacket>();
-        private readonly List<MqttPacketAwaiter> _packetAwaiters = new List<MqttPacketAwaiter>();
+        private readonly ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>> _packetByResponseType = new ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>>();
+        private readonly ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>> _packetByResponseTypeAndIdentifier = new ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>>();
 
-        public async Task<MqttBasePacket> WaitForPacketAsync(Func<MqttBasePacket, bool> selector, TimeSpan timeout)
+        public async Task<MqttBasePacket> WaitForPacketAsync(MqttBasePacket request, Type responseType, TimeSpan timeout)
         {
-            if (selector == null) throw new ArgumentNullException(nameof(selector));
+            if (request == null) throw new ArgumentNullException(nameof(request));
 
-            var packetAwaiter = AddPacketAwaiter(selector);
-            DispatchPendingPackets();
-
-            var hasTimeout = await Task.WhenAny(Task.Delay(timeout), packetAwaiter.Task) != packetAwaiter.Task;
-            RemovePacketAwaiter(packetAwaiter);
-
-            if (hasTimeout)
+            var packetAwaiter = AddPacketAwaiter(request, responseType);
+            try
             {
-                MqttTrace.Warning(nameof(MqttPacketDispatcher), "Timeout while waiting for packet.");
-                throw new MqttCommunicationTimedOutException();
+                return await packetAwaiter.Task.TimeoutAfter(timeout).ConfigureAwait(false);
+            }
+            catch (MqttCommunicationTimedOutException)
+            {
+                MqttTrace.Warning(nameof(MqttPacketDispatcher), "Timeout while waiting for packet of type '{0}'.", responseType.Name);
+                throw;
+            }
+            finally
+            {
+                RemovePacketAwaiter(request, responseType);
             }
-
-            return packetAwaiter.Task.Result;
         }
 
         public void Dispatch(MqttBasePacket packet)
         {
             if (packet == null) throw new ArgumentNullException(nameof(packet));
 
-            var packetDispatched = false;
-            foreach (var packetAwaiter in GetPacketAwaiters())
+            var type = packet.GetType();
+            if (packet is IMqttPacketWithIdentifier withIdentifier)
             {
-                if (packetAwaiter.PacketSelector(packet))
+                if (_packetByResponseTypeAndIdentifier.TryGetValue(type, out var byid))
                 {
-                    packetAwaiter.SetResult(packet);
-                    packetDispatched = true;
-                    break;
+                    if (byid.TryRemove(withIdentifier.PacketIdentifier, out var tcs))
+                    {
+                        tcs.TrySetResult(packet);
+                        return;
+                    }
                 }
             }
+            else if (_packetByResponseType.TryRemove(type, out var tcs))
+            {
+                tcs.TrySetResult(packet);
+                return;
+            }
 
-            lock (_syncRoot)
-            {
-                if (!packetDispatched)
-                {
-                    _receivedPackets.Add(packet);
-                }
-                else
-                {
-                    _receivedPackets.Remove(packet);
-                }
-            }
+            throw new InvalidOperationException($"Packet of type '{type.Name}' not handled or dispatched.");
         }
 
         public void Reset()
         {
-            lock (_syncRoot)
-            {
-                _packetAwaiters.Clear();
-                _receivedPackets.Clear();
-            }
+            _packetByResponseTypeAndIdentifier.Clear();
+            _packetByResponseType.Clear();
         }
 
-        private List<MqttPacketAwaiter> GetPacketAwaiters()
+        private TaskCompletionSource<MqttBasePacket> AddPacketAwaiter(MqttBasePacket request, Type responseType)
         {
-            lock (_packetAwaiters)
+            var tcs = new TaskCompletionSource<MqttBasePacket>();
+
+            if (request is IMqttPacketWithIdentifier requestWithIdentifier)
             {
-                return new List<MqttPacketAwaiter>(_packetAwaiters);
+                var byId = _packetByResponseTypeAndIdentifier.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
+                byId[requestWithIdentifier.PacketIdentifier] = tcs;
             }
+            else
+            {
+                _packetByResponseType[responseType] = tcs;
+            }
+
+            return tcs;
         }
 
-        private MqttPacketAwaiter AddPacketAwaiter(Func<MqttBasePacket, bool> selector)
+        private void RemovePacketAwaiter(MqttBasePacket request, Type responseType)
         {
-            lock (_syncRoot)
+            if (request is IMqttPacketWithIdentifier requestWithIdentifier)
             {
-                var packetAwaiter = new MqttPacketAwaiter(selector);
-                _packetAwaiters.Add(packetAwaiter);
-                return packetAwaiter;
+                var byId = _packetByResponseTypeAndIdentifier.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
+                byId.TryRemove(requestWithIdentifier.PacketIdentifier, out var _);
             }
-        }
-
-        private void RemovePacketAwaiter(MqttPacketAwaiter packetAwaiter)
-        {
-            lock (_syncRoot)
+            else
             {
-                _packetAwaiters.Remove(packetAwaiter);
-            }
-        }
-
-        private void DispatchPendingPackets()
-        {
-            List<MqttBasePacket> receivedPackets;
-            lock (_syncRoot)
-            {
-                receivedPackets = new List<MqttBasePacket>(_receivedPackets);
-            }
-
-            foreach (var pendingPacket in receivedPackets)
-            {
-                Dispatch(pendingPacket);
+                _packetByResponseType.TryRemove(responseType, out var _);
             }
         }
     }

MQTTnet.Core/Diagnostics/MqttTrace.cs

@@ -6,39 +6,58 @@ namespace MQTTnet.Core.Diagnostics
     {
         public static event EventHandler<MqttTraceMessagePublishedEventArgs> TraceMessagePublished;
 
-        public static void Verbose(string source, string message)
+        public static void Verbose(string source, string message, params object[] parameters)
         {
-            Publish(source, MqttTraceLevel.Verbose, null, message);
+            Publish(source, MqttTraceLevel.Verbose, null, message, parameters);
         }
 
-        public static void Information(string source, string message)
+        public static void Information(string source, string message, params object[] parameters)
         {
-            Publish(source, MqttTraceLevel.Information, null, message);
+            Publish(source, MqttTraceLevel.Information, null, message, parameters);
         }
 
-        public static void Warning(string source, string message)
+        public static void Warning(string source, string message, params object[] parameters)
         {
-            Publish(source, MqttTraceLevel.Warning, null, message);
+            Publish(source, MqttTraceLevel.Warning, null, message, parameters);
         }
 
-        public static void Warning(string source, Exception exception, string message)
+        public static void Warning(string source, Exception exception, string message, params object[] parameters)
         {
-            Publish(source, MqttTraceLevel.Warning, exception, message);
+            Publish(source, MqttTraceLevel.Warning, exception, message, parameters);
         }
 
-        public static void Error(string source, string message)
+        public static void Error(string source, string message, params object[] parameters)
         {
-            Publish(source, MqttTraceLevel.Error, null, message);
+            Publish(source, MqttTraceLevel.Error, null, message, parameters);
         }
 
-        public static void Error(string source, Exception exception, string message)
+        public static void Error(string source, Exception exception, string message, params object[] parameters)
         {
-            Publish(source, MqttTraceLevel.Error, exception, message);
+            Publish(source, MqttTraceLevel.Error, exception, message, parameters);
         }
 
-        private static void Publish(string source, MqttTraceLevel traceLevel, Exception exception, string message)
+        private static void Publish(string source, MqttTraceLevel traceLevel, Exception exception, string message, params object[] parameters)
         {
-            TraceMessagePublished?.Invoke(null, new MqttTraceMessagePublishedEventArgs(Environment.CurrentManagedThreadId, source, traceLevel, message, exception));
+            var handler = TraceMessagePublished;
+            if (handler == null)
+            {
+                return;
+            }
+
+            if (parameters?.Length > 0)
+            {
+                try
+                {
+                    message = string.Format(message, parameters);
+                }
+                catch (Exception formatException)
+                {
+                    Error(nameof(MqttTrace), formatException, "Error while tracing message: " + message);
+                    return;
+                }
+            }
+
+            handler.Invoke(null, new MqttTraceMessagePublishedEventArgs(Environment.CurrentManagedThreadId, source, traceLevel, message, exception));
         }
     }
 }

MQTTnet.Core/Diagnostics/MqttTraceLevel.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Diagnostics
 {
-    public enum  MqttTraceLevel
+    public enum MqttTraceLevel
     {
         Verbose,
         Information,

MQTTnet.Core/Diagnostics/MqttTraceMessagePublishedEventArgs.cs

@@ -2,7 +2,7 @@
 
 namespace MQTTnet.Core.Diagnostics
 {
-    public class MqttTraceMessagePublishedEventArgs : EventArgs
+    public sealed class MqttTraceMessagePublishedEventArgs : EventArgs
     {
         public MqttTraceMessagePublishedEventArgs(int threadId, string source, MqttTraceLevel level, string message, Exception exception)
         {

MQTTnet.Core/Exceptions/MqttCommunicationException.cs

@@ -4,7 +4,7 @@ namespace MQTTnet.Core.Exceptions
 {
     public class MqttCommunicationException : Exception
     {
-        public MqttCommunicationException()
+        protected MqttCommunicationException()
         {
         }
 
@@ -17,5 +17,10 @@ namespace MQTTnet.Core.Exceptions
             : base(message)
         {
         }
+
+        public MqttCommunicationException(string message, Exception innerException)
+            : base(message, innerException)
+        {
+        }
     }
 }

MQTTnet.Core/Exceptions/MqttCommunicationTimedOutException.cs

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

MQTTnet.Core/Exceptions/MqttProtocolViolationException.cs

@@ -2,9 +2,9 @@
 
 namespace MQTTnet.Core.Exceptions
 {
-    public class MqttProtocolViolationException : Exception
+    public sealed class MqttProtocolViolationException : Exception
     {
-        public MqttProtocolViolationException(string message) 
+        public MqttProtocolViolationException(string message)
             : base(message)
         {
         }

MQTTnet.Core/Internal/AsyncAutoResetEvent.cs

@@ -1,32 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-
-namespace MQTTnet.Core.Internal
-{
-    public class AsyncGate
-    {
-        private readonly Queue<TaskCompletionSource<bool>> _waitingTasks = new Queue<TaskCompletionSource<bool>>();
-
-        public Task WaitOneAsync()
-        {
-            var tcs = new TaskCompletionSource<bool>();
-            lock (_waitingTasks)
-            {
-                _waitingTasks.Enqueue(tcs);
-            }
-
-            return tcs.Task;
-        }
-
-        public void Set()
-        {
-            lock (_waitingTasks)
-            {
-                if (_waitingTasks.Count > 0)
-                {
-                    _waitingTasks.Dequeue().SetResult(true);
-                }
-            }
-        }
-    }
-}

MQTTnet.Core/Internal/MqttApplicationMessageExtensions.cs

@@ -4,6 +4,16 @@ namespace MQTTnet.Core.Internal
 {
     internal static class MqttApplicationMessageExtensions
     {
+        public static MqttApplicationMessage ToApplicationMessage(this MqttPublishPacket publishPacket)
+        {
+            return new MqttApplicationMessage(
+                publishPacket.Topic,
+                publishPacket.Payload,
+                publishPacket.QualityOfServiceLevel,
+                publishPacket.Retain
+            );
+        }
+
         public static MqttPublishPacket ToPublishPacket(this MqttApplicationMessage applicationMessage)
         {
             if (applicationMessage == null)

MQTTnet.Core/Internal/TaskExtensions.cs

@@ -1,11 +1,74 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Core.Exceptions;
 
 namespace MQTTnet.Core.Internal
 {
-    internal static class TaskExtensions
+    public static class TaskExtensions
     {
-        public static void Forget(this Task task)
+        public static async Task TimeoutAfter(this Task task, TimeSpan timeout)
         {
+            using (var cancellationTokenSource = new CancellationTokenSource())
+            {
+                try
+                {
+                    var timeoutTask = Task.Delay(timeout, cancellationTokenSource.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
+                {
+                    cancellationTokenSource.Cancel();
+                }
+            }
+        }
+
+        public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout)
+        {
+            using (var cancellationTokenSource = new CancellationTokenSource())
+            {
+                try
+                {
+                    var timeoutTask = Task.Delay(timeout, cancellationTokenSource.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
+                {
+                    cancellationTokenSource.Cancel();
+                }
+            }
         }
     }
 }

MQTTnet.Core/MQTTnet.Core.csproj

@@ -5,20 +5,21 @@
     <AssemblyName>MQTTnet.Core</AssemblyName>
     <RootNamespace>MQTTnet.Core</RootNamespace>
     <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
-    <Description>MQTTnet is a .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker).</Description>
-    <Product>MQTTnet</Product>
-    <Company>Christian Kratky</Company>
-    <Authors>Christian Kratky</Authors>
-    <Version>2.1.1.0</Version>
-    <PackageId>MQTTnet.Core</PackageId>
-    <Copyright>Copyright © Christian Kratky 2016-2017</Copyright>
-    <PackageProjectUrl>https://github.com/chkr1011/MQTTnet</PackageProjectUrl>
-    <PackageIconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</PackageIconUrl>
-    <RepositoryUrl>https://github.com/chkr1011/MQTTnet</RepositoryUrl>
-    <PackageTags>MQTT MQTTClient MQTTServer MQTTBroker Broker</PackageTags>
-    <FileVersion>2.1.1.0</FileVersion>
-    <AssemblyVersion>2.1.1.0</AssemblyVersion>
-    <PackageLicenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</PackageLicenseUrl>
+    <DebugType>Full</DebugType>
+    <Description></Description>
+    <Product></Product>
+    <Company></Company>
+    <Authors></Authors>
+    <Version>0.0.0.0</Version>
+    <PackageId></PackageId>
+    <Copyright></Copyright>
+    <PackageProjectUrl></PackageProjectUrl>
+    <PackageIconUrl></PackageIconUrl>
+    <RepositoryUrl></RepositoryUrl>
+    <PackageTags></PackageTags>
+    <FileVersion>2.3.1.0</FileVersion>
+    <AssemblyVersion>2.3.1.0</AssemblyVersion>
+    <PackageLicenseUrl></PackageLicenseUrl>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Any CPU|AnyCPU'" />

MQTTnet.Core/MqttApplicationMessage.cs

@@ -3,7 +3,7 @@ using MQTTnet.Core.Protocol;
 
 namespace MQTTnet.Core
 {
-    public class MqttApplicationMessage
+    public sealed class MqttApplicationMessage
     {
         public MqttApplicationMessage(string topic, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, bool retain)
         {

MQTTnet.Core/MqttApplicationMessageFactory.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Globalization;
+using System.IO;
+using System.Text;
+using MQTTnet.Core.Protocol;
+
+namespace MQTTnet.Core
+{
+    public class MqttApplicationMessageFactory
+    {
+        public MqttApplicationMessage CreateApplicationMessage(string topic, MqttQualityOfServiceLevel qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce, bool retain = false)
+        {
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return CreateApplicationMessage(topic, new byte[0], qualityOfServiceLevel, retain);
+        }
+
+        public MqttApplicationMessage CreateApplicationMessage(string topic, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce, bool retain = false)
+        {
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            if (payload == null)
+            {
+                payload = new byte[0];
+            }
+
+            return new MqttApplicationMessage(topic, payload, qualityOfServiceLevel, retain);
+        }
+
+        public MqttApplicationMessage CreateApplicationMessage<TPayload>(string topic, TPayload payload, MqttQualityOfServiceLevel qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce, bool retain = false)
+        {
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            var payloadString = Convert.ToString(payload, CultureInfo.InvariantCulture);
+            var payloadBuffer = string.IsNullOrEmpty(payloadString) ? new byte[0] : Encoding.UTF8.GetBytes(payloadString);
+
+            return CreateApplicationMessage(topic, payloadBuffer, qualityOfServiceLevel, retain);
+        }
+
+        public MqttApplicationMessage CreateApplicationMessage(string topic, Stream payload, MqttQualityOfServiceLevel qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce, bool retain = false)
+        {
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            byte[] payloadBuffer;
+            if (payload == null || payload.Length == 0)
+            {
+                payloadBuffer = new byte[0];
+            }
+            else
+            {
+                payloadBuffer = new byte[payload.Length - payload.Position];
+                payload.Read(payloadBuffer, 0, payloadBuffer.Length);
+            }
+
+            return CreateApplicationMessage(topic, payloadBuffer, qualityOfServiceLevel, retain);
+        }
+    }
+}

MQTTnet.Core/Packets/IMqttPacketWithIdentifier.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public interface IPacketWithIdentifier
+    public interface IMqttPacketWithIdentifier
     {
         ushort PacketIdentifier { get; set; }
     }

MQTTnet.Core/Packets/MqttBasePacket.cs

@@ -1,25 +1,6 @@
-using System;
-
-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Core.Packets
 {
     public abstract class MqttBasePacket
     {
-        public TResponsePacket CreateResponse<TResponsePacket>()
-        {
-            var responsePacket = Activator.CreateInstance<TResponsePacket>();
-            var responsePacketWithIdentifier = responsePacket as IPacketWithIdentifier;
-            if (responsePacketWithIdentifier != null)
-            {
-                var requestPacketWithIdentifier = this as IPacketWithIdentifier;
-                if (requestPacketWithIdentifier == null)
-                {
-                    throw new InvalidOperationException("Response packet has PacketIdentifier but request packet does not.");
-                }
-
-                responsePacketWithIdentifier.PacketIdentifier = requestPacketWithIdentifier.PacketIdentifier;
-            }
-
-            return responsePacket;
-        }
     }
 }

MQTTnet.Core/Packets/MqttBasePublishPacket.cs

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

MQTTnet.Core/Packets/MqttConnAckPacket.cs

@@ -2,7 +2,7 @@
 
 namespace MQTTnet.Core.Packets
 {
-    public class MqttConnAckPacket : MqttBasePacket
+    public sealed class MqttConnAckPacket : MqttBasePacket
     {
         public bool IsSessionPresent { get; set; }
 
@@ -10,7 +10,7 @@ namespace MQTTnet.Core.Packets
 
         public override string ToString()
         {
-            return $"{nameof(MqttConnAckPacket)}: [ConnectReturnCode={ConnectReturnCode}] [IsSessionPresent={IsSessionPresent}]";
+            return nameof(MqttConnAckPacket) + ": [ConnectReturnCode=" + ConnectReturnCode + "] [IsSessionPresent=" + IsSessionPresent + "]";
         }
     }
 }

MQTTnet.Core/Packets/MqttConnectPacket.cs

@@ -1,7 +1,11 @@
-namespace MQTTnet.Core.Packets
+using MQTTnet.Core.Serializer;
+
+namespace MQTTnet.Core.Packets
 {
-    public class MqttConnectPacket: MqttBasePacket
+    public sealed class MqttConnectPacket : MqttBasePacket
     {
+        public MqttProtocolVersion ProtocolVersion { get; set; }
+
         public string ClientId { get; set; }
 
         public string Username { get; set; }
@@ -16,7 +20,7 @@
 
         public override string ToString()
         {
-            return $"{nameof(MqttConnectPacket)} [ClientId={ClientId}] [Username={Username}] [Password={Password}] [KeepAlivePeriod={KeepAlivePeriod}] [CleanSession={CleanSession}]";
+            return nameof(MqttConnectPacket) + ": [ClientId=" + ClientId + "] [Username=" + Username + "] [Password=" + Password + "] [KeepAlivePeriod=" + KeepAlivePeriod + "] [CleanSession=" + CleanSession + "]";
         }
     }
 }

MQTTnet.Core/Packets/MqttDisconnectPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttDisconnectPacket : MqttBasePacket
+    public sealed class MqttDisconnectPacket : MqttBasePacket
     {
     }
 }

MQTTnet.Core/Packets/MqttPacketExtensions.cs

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

MQTTnet.Core/Packets/MqttPacketHeader.cs

@@ -0,0 +1,13 @@
+using MQTTnet.Core.Protocol;
+
+namespace MQTTnet.Core.Packets
+{
+    public class MqttPacketHeader
+    {
+        public MqttControlPacketType ControlPacketType { get; set; }
+
+        public byte FixedHeader { get; set; }
+
+        public int BodyLength { get; set; }
+    }
+}

MQTTnet.Core/Packets/MqttPingReqPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttPingReqPacket : MqttBasePacket
+    public sealed class MqttPingReqPacket : MqttBasePacket
     {
         public override string ToString()
         {

MQTTnet.Core/Packets/MqttPingRespPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttPingRespPacket : MqttBasePacket
+    public sealed class MqttPingRespPacket : MqttBasePacket
     {
         public override string ToString()
         {

MQTTnet.Core/Packets/MqttPubAckPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttPubAckPacket : MqttBasePublishPacket
+    public sealed class MqttPubAckPacket : MqttBasePublishPacket
     {
     }
 }

MQTTnet.Core/Packets/MqttPubCompPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttPubCompPacket : MqttBasePublishPacket
+    public sealed class MqttPubCompPacket : MqttBasePublishPacket
     {
     }
 }

MQTTnet.Core/Packets/MqttPubRecPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttPubRecPacket : MqttBasePublishPacket
+    public sealed class MqttPubRecPacket : MqttBasePublishPacket
     {
     }
 }

MQTTnet.Core/Packets/MqttPubRelPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttPubRelPacket : MqttBasePublishPacket
+    public sealed class MqttPubRelPacket : MqttBasePublishPacket
     {
     }
 }

MQTTnet.Core/Packets/MqttPublishPacket.cs

@@ -1,9 +1,9 @@
-using System.Text;
+using System;
 using MQTTnet.Core.Protocol;
 
 namespace MQTTnet.Core.Packets
 {
-    public class MqttPublishPacket : MqttBasePublishPacket
+    public sealed class MqttPublishPacket : MqttBasePublishPacket
     {
         public bool Retain { get; set; }
 
@@ -17,8 +17,13 @@ namespace MQTTnet.Core.Packets
 
         public override string ToString()
         {
-            return
-                $"{nameof(MqttPublishPacket)} [Topic={Topic}] [Payload={Encoding.UTF8.GetString(Payload, 0, Payload.Length)}] [QoSLevel={QualityOfServiceLevel}] [Dup={Dup}] [Retain={Retain}] [PacketIdentifier={PacketIdentifier}]";
+            return nameof(MqttPublishPacket) +
+                ": [Topic=" + Topic + "]" +
+                " [Payload=" + Convert.ToBase64String(Payload) + "]" +
+                " [QoSLevel=" + QualityOfServiceLevel + "]" +
+                " [Dup=" + Dup + "]" +
+                " [Retain=" + Retain + "]" +
+                " [PacketIdentifier=" + PacketIdentifier + "]";
         }
     }
 }

MQTTnet.Core/Packets/MqttSubAckPacket.cs

@@ -4,7 +4,7 @@ using MQTTnet.Core.Protocol;
 
 namespace MQTTnet.Core.Packets
 {
-    public class MqttSubAckPacket : MqttBasePacket, IPacketWithIdentifier
+    public sealed class MqttSubAckPacket : MqttBasePacket, IMqttPacketWithIdentifier
     {
         public ushort PacketIdentifier { get; set; }
 
@@ -13,8 +13,7 @@ namespace MQTTnet.Core.Packets
         public override string ToString()
         {
             var subscribeReturnCodesText = string.Join(",", SubscribeReturnCodes.Select(f => f.ToString()));
-            return
-                $"{nameof(MqttSubAckPacket)} [PacketIdentifier={PacketIdentifier}] [SubscribeReturnCodes={subscribeReturnCodesText}]";
+            return nameof(MqttSubAckPacket) + ": [PacketIdentifier=" + PacketIdentifier + "] [SubscribeReturnCodes=" + subscribeReturnCodesText + "]";
         }
     }
 }

MQTTnet.Core/Packets/MqttSubscribePacket.cs

@@ -3,17 +3,16 @@ using System.Linq;
 
 namespace MQTTnet.Core.Packets
 {
-    public class MqttSubscribePacket : MqttBasePacket, IPacketWithIdentifier
+    public sealed class MqttSubscribePacket : MqttBasePacket, IMqttPacketWithIdentifier
     {
         public ushort PacketIdentifier { get; set; }
-        
+
         public IList<TopicFilter> TopicFilters { get; set; } = new List<TopicFilter>();
 
         public override string ToString()
         {
             var topicFiltersText = string.Join(",", TopicFilters.Select(f => $"{f.Topic}@{f.QualityOfServiceLevel}"));
-            return
-                $"{nameof(MqttSubscribePacket)} [PacketIdentifier={PacketIdentifier}] [TopicFilters={topicFiltersText}]";
+            return nameof(MqttSubscribePacket) + ": [PacketIdentifier=" + PacketIdentifier + "] [TopicFilters=" + topicFiltersText + "]";
         }
     }
 }

MQTTnet.Core/Packets/MqttUnsubAckPacket.cs

@@ -1,6 +1,6 @@
 namespace MQTTnet.Core.Packets
 {
-    public class MqttUnsubAckPacket : MqttBasePacket, IPacketWithIdentifier
+    public sealed class MqttUnsubAckPacket : MqttBasePacket, IMqttPacketWithIdentifier
     {
         public ushort PacketIdentifier { get; set; }
     }

MQTTnet.Core/Packets/MqttUnsubscribe.cs

@@ -2,10 +2,10 @@
 
 namespace MQTTnet.Core.Packets
 {
-    public class MqttUnsubscribePacket : MqttBasePacket, IPacketWithIdentifier
+    public sealed class MqttUnsubscribePacket : MqttBasePacket, IMqttPacketWithIdentifier
     {
         public ushort PacketIdentifier { get; set; }
-        
+
         public IList<string> TopicFilters { get; set; } = new List<string>();
     }
 }

MQTTnet.Core/Packets/TopicFilter.cs

@@ -2,7 +2,7 @@
 
 namespace MQTTnet.Core.Packets
 {
-    public class TopicFilter
+    public sealed class TopicFilter
     {
         public TopicFilter(string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
         {

MQTTnet.Core/Serializer/ByteReader.cs

@@ -2,7 +2,7 @@
 
 namespace MQTTnet.Core.Serializer
 {
-    public class ByteReader
+    public sealed class ByteReader
     {
         private readonly int _source;
         private int _index;
@@ -24,7 +24,7 @@ namespace MQTTnet.Core.Serializer
             return result;
         }
 
-        public byte Read(int count)
+        public int Read(int count)
         {
             if (_index + count > 8)
             {
@@ -42,7 +42,7 @@ namespace MQTTnet.Core.Serializer
                 _index++;
             }
 
-            return (byte)result;
+            return result;
         }
     }
 }

MQTTnet.Core/Serializer/ByteWriter.cs

@@ -2,7 +2,7 @@
 
 namespace MQTTnet.Core.Serializer
 {
-    public class ByteWriter
+    public sealed class ByteWriter
     {
         private int _index;
         private int _byte;

MQTTnet.Core/Serializer/DefaultMqttV311PacketSerializer.cs

@@ -1,616 +0,0 @@
-using System;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using MQTTnet.Core.Channel;
-using MQTTnet.Core.Exceptions;
-using MQTTnet.Core.Packets;
-using MQTTnet.Core.Protocol;
-
-namespace MQTTnet.Core.Serializer
-{
-    public class DefaultMqttV311PacketSerializer : IMqttPacketSerializer
-    {
-        public Task SerializeAsync(MqttBasePacket packet, IMqttCommunicationChannel destination)
-        {
-            if (packet == null) throw new ArgumentNullException(nameof(packet));
-            if (destination == null) throw new ArgumentNullException(nameof(destination));
-
-            var connectPacket = packet as MqttConnectPacket;
-            if (connectPacket != null)
-            {
-                return SerializeAsync(connectPacket, destination);
-            }
-
-            var connAckPacket = packet as MqttConnAckPacket;
-            if (connAckPacket != null)
-            {
-                return SerializeAsync(connAckPacket, destination);
-            }
-
-            var disconnectPacket = packet as MqttDisconnectPacket;
-            if (disconnectPacket != null)
-            {
-                return SerializeAsync(disconnectPacket, destination);
-            }
-
-            var pingReqPacket = packet as MqttPingReqPacket;
-            if (pingReqPacket != null)
-            {
-                return SerializeAsync(pingReqPacket, destination);
-            }
-
-            var pingRespPacket = packet as MqttPingRespPacket;
-            if (pingRespPacket != null)
-            {
-                return SerializeAsync(pingRespPacket, destination);
-            }
-
-            var publishPacket = packet as MqttPublishPacket;
-            if (publishPacket != null)
-            {
-                return SerializeAsync(publishPacket, destination);
-            }
-
-            var pubAckPacket = packet as MqttPubAckPacket;
-            if (pubAckPacket != null)
-            {
-                return SerializeAsync(pubAckPacket, destination);
-            }
-
-            var pubRecPacket = packet as MqttPubRecPacket;
-            if (pubRecPacket != null)
-            {
-                return SerializeAsync(pubRecPacket, destination);
-            }
-
-            var pubRelPacket = packet as MqttPubRelPacket;
-            if (pubRelPacket != null)
-            {
-                return SerializeAsync(pubRelPacket, destination);
-            }
-
-            var pubCompPacket = packet as MqttPubCompPacket;
-            if (pubCompPacket != null)
-            {
-                return SerializeAsync(pubCompPacket, destination);
-            }
-
-            var subscribePacket = packet as MqttSubscribePacket;
-            if (subscribePacket != null)
-            {
-                return SerializeAsync(subscribePacket, destination);
-            }
-
-            var subAckPacket = packet as MqttSubAckPacket;
-            if (subAckPacket != null)
-            {
-                return SerializeAsync(subAckPacket, destination);
-            }
-
-            var unsubscribePacket = packet as MqttUnsubscribePacket;
-            if (unsubscribePacket != null)
-            {
-                return SerializeAsync(unsubscribePacket, destination);
-            }
-
-            var unsubAckPacket = packet as MqttUnsubAckPacket;
-            if (unsubAckPacket != null)
-            {
-                return SerializeAsync(unsubAckPacket, destination);
-            }
-
-            throw new MqttProtocolViolationException("Packet type invalid.");
-        }
-
-        public async Task<MqttBasePacket> DeserializeAsync(IMqttCommunicationChannel source)
-        {
-            if (source == null) throw new ArgumentNullException(nameof(source));
-
-            using (var mqttPacketReader = new MqttPacketReader(source))
-            {
-                await mqttPacketReader.ReadToEndAsync();
-
-                switch (mqttPacketReader.ControlPacketType)
-                {
-                    case MqttControlPacketType.Connect:
-                        {
-                            return await DeserializeConnectAsync(mqttPacketReader);
-                        }
-
-                    case MqttControlPacketType.ConnAck:
-                        {
-                            return await DeserializeConnAck(mqttPacketReader);
-                        }
-
-                    case MqttControlPacketType.Disconnect:
-                        {
-                            return new MqttDisconnectPacket();
-                        }
-
-                    case MqttControlPacketType.Publish:
-                        {
-                            return await DeserializePublishAsync(mqttPacketReader);
-                        }
-
-                    case MqttControlPacketType.PubAck:
-                        {
-                            return new MqttPubAckPacket
-                            {
-                                PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
-                            };
-                        }
-
-                    case MqttControlPacketType.PubRec:
-                        {
-                            return new MqttPubRecPacket
-                            {
-                                PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
-                            };
-                        }
-
-                    case MqttControlPacketType.PubRel:
-                        {
-                            return new MqttPubRelPacket
-                            {
-                                PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
-                            };
-                        }
-
-                    case MqttControlPacketType.PubComp:
-                        {
-                            return new MqttPubCompPacket
-                            {
-                                PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
-                            };
-                        }
-
-                    case MqttControlPacketType.PingReq:
-                        {
-                            return new MqttPingReqPacket();
-                        }
-
-                    case MqttControlPacketType.PingResp:
-                        {
-                            return new MqttPingRespPacket();
-                        }
-
-                    case MqttControlPacketType.Subscribe:
-                        {
-                            return await DeserializeSubscribeAsync(mqttPacketReader);
-                        }
-
-                    case MqttControlPacketType.SubAck:
-                        {
-                            return await DeserializeSubAck(mqttPacketReader);
-                        }
-
-                    case MqttControlPacketType.Unsubscibe:
-                        {
-                            return await DeserializeUnsubscribeAsync(mqttPacketReader);
-                        }
-
-                    case MqttControlPacketType.UnsubAck:
-                        {
-                            return new MqttUnsubAckPacket
-                            {
-                                PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
-                            };
-                        }
-
-                    default:
-                        {
-                            throw new MqttProtocolViolationException("Packet type not supported.");
-                        }
-                }
-            }
-        }
-
-        private async Task<MqttBasePacket> DeserializeUnsubscribeAsync(MqttPacketReader reader)
-        {
-            var packet = new MqttUnsubscribePacket
-            {
-                PacketIdentifier = await reader.ReadRemainingDataUShortAsync(),
-            };
-
-            while (!reader.EndOfRemainingData)
-            {
-                packet.TopicFilters.Add(await reader.ReadRemainingDataStringWithLengthPrefixAsync());
-            }
-
-            return packet;
-        }
-
-        private async Task<MqttBasePacket> DeserializeSubscribeAsync(MqttPacketReader reader)
-        {
-            var packet = new MqttSubscribePacket
-            {
-                PacketIdentifier = await reader.ReadRemainingDataUShortAsync(),
-            };
-
-            while (!reader.EndOfRemainingData)
-            {
-                packet.TopicFilters.Add(new TopicFilter(
-                    await reader.ReadRemainingDataStringWithLengthPrefixAsync(),
-                    (MqttQualityOfServiceLevel)await reader.ReadRemainingDataByteAsync()));
-            }
-
-            return packet;
-        }
-
-        private async Task<MqttBasePacket> DeserializePublishAsync(MqttPacketReader reader)
-        {
-            var fixedHeader = new ByteReader(reader.FixedHeader);
-            var retain = fixedHeader.Read();
-            var qualityOfServiceLevel = (MqttQualityOfServiceLevel)fixedHeader.Read(2);
-            var dup = fixedHeader.Read();
-
-            var topic = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
-
-            ushort packetIdentifier = 0;
-            if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
-            {
-                packetIdentifier = await reader.ReadRemainingDataUShortAsync();
-            }
-
-            var packet = new MqttPublishPacket
-            {
-                Retain = retain,
-                QualityOfServiceLevel = qualityOfServiceLevel,
-                Dup = dup,
-                Topic = topic,
-                Payload = await reader.ReadRemainingDataAsync(),
-                PacketIdentifier = packetIdentifier
-            };
-
-            return packet;
-        }
-
-        private async Task<MqttBasePacket> DeserializeConnectAsync(MqttPacketReader reader)
-        {
-            var packet = new MqttConnectPacket();
-
-            await reader.ReadRemainingDataByteAsync();
-            await reader.ReadRemainingDataByteAsync();
-
-            var protocolName = await reader.ReadRemainingDataAsync(4);
-
-            if (Encoding.UTF8.GetString(protocolName, 0, protocolName.Length) != "MQTT")
-            {
-                throw new MqttProtocolViolationException("Protocol name is not 'MQTT'.");
-            }
-
-            var protocolLevel = await reader.ReadRemainingDataByteAsync();
-            var connectFlags = await reader.ReadRemainingDataByteAsync();
-
-            var connectFlagsReader = new ByteReader(connectFlags);
-            connectFlagsReader.Read(); // Reserved.
-            packet.CleanSession = connectFlagsReader.Read();
-            var willFlag = connectFlagsReader.Read();
-            var willQoS = connectFlagsReader.Read(2);
-            var willRetain = connectFlagsReader.Read();
-            var passwordFlag = connectFlagsReader.Read();
-            var usernameFlag = connectFlagsReader.Read();
-
-            packet.KeepAlivePeriod = await reader.ReadRemainingDataUShortAsync();
-            packet.ClientId = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
-
-            if (willFlag)
-            {
-                packet.WillMessage = new MqttApplicationMessage(
-                    await reader.ReadRemainingDataStringWithLengthPrefixAsync(),
-                    await reader.ReadRemainingDataWithLengthPrefixAsync(),
-                    (MqttQualityOfServiceLevel)willQoS,
-                    willRetain);
-            }
-
-            if (usernameFlag)
-            {
-                packet.Username = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
-            }
-
-            if (passwordFlag)
-            {
-                packet.Password = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
-            }
-
-            ValidateConnectPacket(packet);
-            return packet;
-        }
-
-        private async Task<MqttBasePacket> DeserializeSubAck(MqttPacketReader reader)
-        {
-            var packet = new MqttSubAckPacket
-            {
-                PacketIdentifier = await reader.ReadRemainingDataUShortAsync()
-            };
-
-            while (!reader.EndOfRemainingData)
-            {
-                packet.SubscribeReturnCodes.Add((MqttSubscribeReturnCode)await reader.ReadRemainingDataByteAsync());
-            }
-
-            return packet;
-        }
-
-        private async Task<MqttBasePacket> DeserializeConnAck(MqttPacketReader reader)
-        {
-            var variableHeader1 = await reader.ReadRemainingDataByteAsync();
-            var variableHeader2 = await reader.ReadRemainingDataByteAsync();
-
-            var packet = new MqttConnAckPacket
-            {
-                IsSessionPresent = new ByteReader(variableHeader1).Read(),
-                ConnectReturnCode = (MqttConnectReturnCode)variableHeader2
-            };
-
-            return packet;
-        }
-
-        private void ValidateConnectPacket(MqttConnectPacket packet)
-        {
-            if (string.IsNullOrEmpty(packet.ClientId) && !packet.CleanSession)
-            {
-                throw new MqttProtocolViolationException("CleanSession must be set if ClientId is empty [MQTT-3.1.3-7].");
-            }
-
-            if (!string.IsNullOrEmpty(packet.ClientId) && !Regex.IsMatch(packet.ClientId, "^[a-zA-Z0-9]*$"))
-            {
-                throw new MqttProtocolViolationException("ClientId contains invalid characters [MQTT-3.1.3-5].");
-            }
-        }
-
-        private void ValidatePublishPacket(MqttPublishPacket packet)
-        {
-            if (packet.QualityOfServiceLevel == 0 && packet.Dup)
-            {
-                throw new MqttProtocolViolationException("Dup flag must be false for QoS 0 packets [MQTT-3.3.1-2].");
-            }
-        }
-
-        private static readonly byte[] MqttPrefix = Encoding.UTF8.GetBytes("MQTT");
-
-        private Task SerializeAsync(MqttConnectPacket packet, IMqttCommunicationChannel destination)
-        {
-            ValidateConnectPacket(packet);
-
-            using (var output = new MqttPacketWriter())
-            {
-                // Write variable header
-                output.Write(0x00, 0x04); // 3.1.2.1 Protocol Name
-                output.Write(MqttPrefix);
-                output.Write(0x04); // 3.1.2.2 Protocol Level
-
-                var connectFlags = new ByteWriter(); // 3.1.2.3 Connect Flags
-                connectFlags.Write(false); // Reserved
-                connectFlags.Write(packet.CleanSession);
-                connectFlags.Write(packet.WillMessage != null);
-
-                if (packet.WillMessage != null)
-                {
-                    connectFlags.Write((int)packet.WillMessage.QualityOfServiceLevel, 2);
-                    connectFlags.Write(packet.WillMessage.Retain);
-                }
-                else
-                {
-                    connectFlags.Write(0, 2);
-                    connectFlags.Write(false);
-                }
-                
-                connectFlags.Write(packet.Password != null);
-                connectFlags.Write(packet.Username != null);
-
-                output.Write(connectFlags);
-                output.Write(packet.KeepAlivePeriod);
-                output.WriteWithLengthPrefix(packet.ClientId);
-
-                if (packet.WillMessage != null)
-                {
-                    output.WriteWithLengthPrefix(packet.WillMessage.Topic);
-                    output.WriteWithLengthPrefix(packet.WillMessage.Payload);
-                }
-
-                if (packet.Username != null)
-                {
-                    output.WriteWithLengthPrefix(packet.Username);
-                }
-
-                if (packet.Password != null)
-                {
-                    output.WriteWithLengthPrefix(packet.Password);
-                }
-
-                output.InjectFixedHeader(MqttControlPacketType.Connect);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttConnAckPacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                var connectAcknowledgeFlags = new ByteWriter();
-                connectAcknowledgeFlags.Write(packet.IsSessionPresent);
-
-                output.Write(connectAcknowledgeFlags);
-                output.Write((byte)packet.ConnectReturnCode);
-
-                output.InjectFixedHeader(MqttControlPacketType.ConnAck);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttDisconnectPacket packet, IMqttCommunicationChannel destination)
-        {
-            return SerializeEmptyPacketAsync(MqttControlPacketType.Disconnect, destination);
-        }
-
-        private Task SerializeAsync(MqttPingReqPacket packet, IMqttCommunicationChannel destination)
-        {
-            return SerializeEmptyPacketAsync(MqttControlPacketType.PingReq, destination);
-        }
-
-        private Task SerializeAsync(MqttPingRespPacket packet, IMqttCommunicationChannel destination)
-        {
-            return SerializeEmptyPacketAsync(MqttControlPacketType.PingResp, destination);
-        }
-
-        private Task SerializeAsync(MqttPublishPacket packet, IMqttCommunicationChannel destination)
-        {
-            ValidatePublishPacket(packet);
-
-            using (var output = new MqttPacketWriter())
-            {
-                output.WriteWithLengthPrefix(packet.Topic);
-
-                if (packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
-                {
-                    output.Write(packet.PacketIdentifier);
-                }
-                else
-                {
-                    if (packet.PacketIdentifier > 0)
-                    {
-                        throw new MqttProtocolViolationException("Packet identifier must be empty if QoS == 0 [MQTT-2.3.1-5].");
-                    }
-                }
-
-                if (packet.Payload?.Length > 0)
-                {
-                    output.Write(packet.Payload);
-                }
-
-                var fixedHeader = new ByteWriter();
-                fixedHeader.Write(packet.Retain);
-                fixedHeader.Write((byte)packet.QualityOfServiceLevel, 2);
-                fixedHeader.Write(packet.Dup);
-
-                output.InjectFixedHeader(MqttControlPacketType.Publish, fixedHeader.Value);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttPubAckPacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                output.InjectFixedHeader(MqttControlPacketType.PubAck);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttPubRecPacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                output.InjectFixedHeader(MqttControlPacketType.PubRec);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private async Task SerializeAsync(MqttPubRelPacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                output.InjectFixedHeader(MqttControlPacketType.PubRel, 0x02);
-                await output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttPubCompPacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                output.InjectFixedHeader(MqttControlPacketType.PubComp);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttSubscribePacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                if (packet.TopicFilters?.Count > 0)
-                {
-                    foreach (var topicFilter in packet.TopicFilters)
-                    {
-                        output.WriteWithLengthPrefix(topicFilter.Topic);
-                        output.Write((byte)topicFilter.QualityOfServiceLevel);
-                    }
-                }
-
-                output.InjectFixedHeader(MqttControlPacketType.Subscribe, 0x02);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttSubAckPacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                if (packet.SubscribeReturnCodes?.Any() == true)
-                {
-                    foreach (var packetSubscribeReturnCode in packet.SubscribeReturnCodes)
-                    {
-                        output.Write((byte)packetSubscribeReturnCode);
-                    }
-                }
-
-                output.InjectFixedHeader(MqttControlPacketType.SubAck);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttUnsubscribePacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                if (packet.TopicFilters?.Any() == true)
-                {
-                    foreach (var topicFilter in packet.TopicFilters)
-                    {
-                        output.WriteWithLengthPrefix(topicFilter);
-                    }
-                }
-
-                output.InjectFixedHeader(MqttControlPacketType.Unsubscibe, 0x02);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeAsync(MqttUnsubAckPacket packet, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.Write(packet.PacketIdentifier);
-
-                output.InjectFixedHeader(MqttControlPacketType.UnsubAck);
-                return output.WriteToAsync(destination);
-            }
-        }
-
-        private Task SerializeEmptyPacketAsync(MqttControlPacketType type, IMqttCommunicationChannel destination)
-        {
-            using (var output = new MqttPacketWriter())
-            {
-                output.InjectFixedHeader(type);
-                return output.WriteToAsync(destination);
-            }
-        }
-    }
-}

MQTTnet.Core/Serializer/IMqttPacketSerializer.cs

@@ -1,13 +1,14 @@
-using System.Threading.Tasks;
-using MQTTnet.Core.Channel;
+using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Packets;
 
 namespace MQTTnet.Core.Serializer
 {
     public interface IMqttPacketSerializer
     {
-        Task SerializeAsync(MqttBasePacket mqttPacket, IMqttCommunicationChannel destination);
+        MqttProtocolVersion ProtocolVersion { get; set; }
 
-        Task<MqttBasePacket> DeserializeAsync(IMqttCommunicationChannel source);
+        byte[] Serialize(MqttBasePacket mqttPacket);
+
+        MqttBasePacket Deserialize(ReceivedMqttPacket receivedMqttPacket);
     }
 }

MQTTnet.Core/Serializer/MqttPacketReader.cs

@@ -1,92 +1,44 @@
 using System;
 using System.IO;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Core.Channel;
+using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Protocol;
+using MQTTnet.Core.Packets;
 
 namespace MQTTnet.Core.Serializer
 {
-    public sealed class MqttPacketReader : IDisposable
+    public sealed class MqttPacketReader : BinaryReader
     {
-        private readonly MemoryStream _remainingData = new MemoryStream();
-        private readonly IMqttCommunicationChannel _source;
-
-        public MqttPacketReader(IMqttCommunicationChannel source)
+        private readonly ReceivedMqttPacket _receivedMqttPacket;
+        
+        public MqttPacketReader(ReceivedMqttPacket receivedMqttPacket)
+            : base(receivedMqttPacket.Body, Encoding.UTF8, true)
         {
-            _source = source ?? throw new ArgumentNullException(nameof(source));
+            _receivedMqttPacket = receivedMqttPacket;
         }
 
-        public MqttControlPacketType ControlPacketType { get; private set; }
+        public bool EndOfRemainingData => BaseStream.Position == _receivedMqttPacket.Header.BodyLength;
 
-        public byte FixedHeader { get; private set; }
-
-        public int RemainingLength { get; private set; }
-
-        public bool EndOfRemainingData => _remainingData.Position == _remainingData.Length;
-
-        public async Task ReadToEndAsync()
+        public static MqttPacketHeader ReadHeaderFromSource(Stream stream, CancellationToken cancellationToken)
         {
-            await ReadFixedHeaderAsync();
-            await ReadRemainingLengthAsync();
+            var fixedHeader = (byte)stream.ReadByte();
+            var controlPacketType = (MqttControlPacketType)(fixedHeader >> 4);
+            var bodyLength = ReadBodyLengthFromSource(stream, cancellationToken);
 
-            if (RemainingLength == 0)
+            return new MqttPacketHeader
             {
-                return;
-            }
-
-            var buffer = new byte[RemainingLength];
-            await _source.ReadAsync(buffer);
-
-            _remainingData.Write(buffer, 0, buffer.Length);
-            _remainingData.Position = 0;
+                FixedHeader = fixedHeader,
+                ControlPacketType = controlPacketType,
+                BodyLength = bodyLength
+            };
         }
 
-        private async Task ReadFixedHeaderAsync()
+        public override ushort ReadUInt16()
         {
-            FixedHeader = await ReadStreamByteAsync();
-
-            var byteReader = new ByteReader(FixedHeader);
-            byteReader.Read(4);
-            ControlPacketType = (MqttControlPacketType)byteReader.Read(4);
-        }
-
-        private async Task<byte> ReadStreamByteAsync()
-        {
-            var buffer = new byte[1];
-            await _source.ReadAsync(buffer);
-            return buffer[0];
-        }
-
-        private async Task ReadRemainingLengthAsync()
-        {
-            // Alorithm taken from http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html.
-            var multiplier = 1;
-            var value = 0;
-            byte encodedByte;
-            do
-            {
-                encodedByte = await ReadStreamByteAsync();
-                value += (encodedByte & 127) * multiplier;
-                multiplier *= 128;
-                if (multiplier > 128 * 128 * 128)
-                {
-                    throw new MqttProtocolViolationException("Remaining length is ivalid.");
-                }
-            } while ((encodedByte & 128) != 0);
-
-            RemainingLength = value;
-        }
-
-        public async Task<byte> ReadRemainingDataByteAsync()
-        {
-            return (await ReadRemainingDataAsync(1))[0];
-        }
-
-        public async Task<ushort> ReadRemainingDataUShortAsync()
-        {
-            var buffer = await ReadRemainingDataAsync(2);
+            var buffer = ReadBytes(2);
 
             var temp = buffer[0];
             buffer[0] = buffer[1];
@@ -95,34 +47,45 @@ namespace MQTTnet.Core.Serializer
             return BitConverter.ToUInt16(buffer, 0);
         }
 
-        public async Task<string> ReadRemainingDataStringWithLengthPrefixAsync()
+        public string ReadStringWithLengthPrefix()
         {
-            var buffer = await ReadRemainingDataWithLengthPrefixAsync();
+            var buffer = ReadWithLengthPrefix();
             return Encoding.UTF8.GetString(buffer, 0, buffer.Length);
         }
 
-        public async Task<byte[]> ReadRemainingDataWithLengthPrefixAsync()
+        public byte[] ReadWithLengthPrefix()
         {
-            var length = await ReadRemainingDataUShortAsync();
-            return await ReadRemainingDataAsync(length);
+            var length = ReadUInt16();
+            return ReadBytes(length);
         }
 
-        public Task<byte[]> ReadRemainingDataAsync()
+        public byte[] ReadRemainingData()
         {
-            return ReadRemainingDataAsync(RemainingLength - (int)_remainingData.Position);
+            return ReadBytes(_receivedMqttPacket.Header.BodyLength - (int)BaseStream.Position);
         }
 
-        public async Task<byte[]> ReadRemainingDataAsync(int length)
+        private static int ReadBodyLengthFromSource(Stream stream, CancellationToken cancellationToken)
         {
-            var buffer = new byte[length];
-            await _remainingData.ReadAsync(buffer, 0, buffer.Length);
+            // Alorithm taken from http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html.
+            var multiplier = 1;
+            var value = 0;
+            byte encodedByte;
+            do
+            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    throw new TaskCanceledException();
+                }
 
-            return buffer;
-        }
-
-        public void Dispose()
-        {
-            _remainingData?.Dispose();
+                encodedByte = (byte)stream.ReadByte();
+                value += (encodedByte & 127) * multiplier;
+                multiplier *= 128;
+                if (multiplier > 128 * 128 * 128)
+                {
+                    throw new MqttProtocolViolationException("Remaining length is invalid.");
+                }
+            } while ((encodedByte & 128) != 0);
+            return value;
         }
     }
 }

MQTTnet.Core/Serializer/MqttPacketSerializer.cs

@@ -0,0 +1,609 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Exceptions;
+using MQTTnet.Core.Packets;
+using MQTTnet.Core.Protocol;
+
+namespace MQTTnet.Core.Serializer
+{
+    public sealed class MqttPacketSerializer : IMqttPacketSerializer
+    {
+        private static byte[] ProtocolVersionV311Name { get; } = Encoding.UTF8.GetBytes("MQTT");
+        private static byte[] ProtocolVersionV310Name { get; } = Encoding.UTF8.GetBytes("MQIs");
+
+        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
+
+        public byte[] Serialize(MqttBasePacket packet)
+        {
+            if (packet == null) throw new ArgumentNullException(nameof(packet));
+
+            using (var stream = new MemoryStream())
+            using (var writer = new MqttPacketWriter(stream))
+            {
+                var header = new List<byte> { SerializePacket(packet, writer) };
+                var body = stream.ToArray();
+                MqttPacketWriter.BuildLengthHeader(body.Length, header);
+                var headerArray = header.ToArray();
+                var writeBuffer = new byte[header.Count + body.Length];
+                Buffer.BlockCopy(headerArray, 0, writeBuffer, 0, headerArray.Length);
+                Buffer.BlockCopy(body, 0, writeBuffer, headerArray.Length, body.Length);
+
+                return writeBuffer;
+            }
+        }
+
+        private byte SerializePacket(MqttBasePacket packet, MqttPacketWriter writer)
+        {
+            if (packet is MqttConnectPacket connectPacket)
+            {
+                return Serialize(connectPacket, writer);
+            }
+
+            if (packet is MqttConnAckPacket connAckPacket)
+            {
+                return Serialize(connAckPacket, writer);
+            }
+
+            if (packet is MqttDisconnectPacket disconnectPacket)
+            {
+                return Serialize(disconnectPacket, writer);
+            }
+
+            if (packet is MqttPingReqPacket pingReqPacket)
+            {
+                return Serialize(pingReqPacket, writer);
+            }
+
+            if (packet is MqttPingRespPacket pingRespPacket)
+            {
+                return Serialize(pingRespPacket, writer);
+            }
+
+            if (packet is MqttPublishPacket publishPacket)
+            {
+                return Serialize(publishPacket, writer);
+            }
+
+            if (packet is MqttPubAckPacket pubAckPacket)
+            {
+                return Serialize(pubAckPacket, writer);
+            }
+
+            if (packet is MqttPubRecPacket pubRecPacket)
+            {
+                return Serialize(pubRecPacket, writer);
+            }
+
+            if (packet is MqttPubRelPacket pubRelPacket)
+            {
+                return Serialize(pubRelPacket, writer);
+            }
+
+            if (packet is MqttPubCompPacket pubCompPacket)
+            {
+                return Serialize(pubCompPacket, writer);
+            }
+
+            if (packet is MqttSubscribePacket subscribePacket)
+            {
+                return Serialize(subscribePacket, writer);
+            }
+
+            if (packet is MqttSubAckPacket subAckPacket)
+            {
+                return Serialize(subAckPacket, writer);
+            }
+
+            if (packet is MqttUnsubscribePacket unsubscribePacket)
+            {
+                return Serialize(unsubscribePacket, writer);
+            }
+
+            if (packet is MqttUnsubAckPacket unsubAckPacket)
+            {
+                return Serialize(unsubAckPacket, writer);
+            }
+
+            throw new MqttProtocolViolationException("Packet type invalid.");
+        }
+
+        public MqttBasePacket Deserialize(ReceivedMqttPacket receivedMqttPacket)
+        {
+            if (receivedMqttPacket == null) throw new ArgumentNullException(nameof(receivedMqttPacket));
+
+            using (var reader = new MqttPacketReader(receivedMqttPacket))
+            {
+                return Deserialize(receivedMqttPacket.Header, reader);
+            }
+        }
+
+        private static MqttBasePacket Deserialize(MqttPacketHeader header, MqttPacketReader reader)
+        {
+            switch (header.ControlPacketType)
+            {
+                case MqttControlPacketType.Connect:
+                    {
+                        return DeserializeConnect(reader);
+                    }
+
+                case MqttControlPacketType.ConnAck:
+                    {
+                        return DeserializeConnAck(reader);
+                    }
+
+                case MqttControlPacketType.Disconnect:
+                    {
+                        return new MqttDisconnectPacket();
+                    }
+
+                case MqttControlPacketType.Publish:
+                    {
+                        return DeserializePublish(reader, header);
+                    }
+
+                case MqttControlPacketType.PubAck:
+                    {
+                        return new MqttPubAckPacket
+                        {
+                            PacketIdentifier = reader.ReadUInt16()
+                        };
+                    }
+
+                case MqttControlPacketType.PubRec:
+                    {
+                        return new MqttPubRecPacket
+                        {
+                            PacketIdentifier = reader.ReadUInt16()
+                        };
+                    }
+
+                case MqttControlPacketType.PubRel:
+                    {
+                        return new MqttPubRelPacket
+                        {
+                            PacketIdentifier = reader.ReadUInt16()
+                        };
+                    }
+
+                case MqttControlPacketType.PubComp:
+                    {
+                        return new MqttPubCompPacket
+                        {
+                            PacketIdentifier = reader.ReadUInt16()
+                        };
+                    }
+
+                case MqttControlPacketType.PingReq:
+                    {
+                        return new MqttPingReqPacket();
+                    }
+
+                case MqttControlPacketType.PingResp:
+                    {
+                        return new MqttPingRespPacket();
+                    }
+
+                case MqttControlPacketType.Subscribe:
+                    {
+                        return DeserializeSubscribe(reader);
+                    }
+
+                case MqttControlPacketType.SubAck:
+                    {
+                        return DeserializeSubAck(reader);
+                    }
+
+                case MqttControlPacketType.Unsubscibe:
+                    {
+                        return DeserializeUnsubscribe(reader);
+                    }
+
+                case MqttControlPacketType.UnsubAck:
+                    {
+                        return new MqttUnsubAckPacket
+                        {
+                            PacketIdentifier = reader.ReadUInt16()
+                        };
+                    }
+
+                default:
+                    {
+                        throw new MqttProtocolViolationException(
+                            $"Packet type ({(int)header.ControlPacketType}) not supported.");
+                    }
+            }
+        }
+
+        private static MqttBasePacket DeserializeUnsubscribe(MqttPacketReader reader)
+        {
+            var packet = new MqttUnsubscribePacket
+            {
+                PacketIdentifier = reader.ReadUInt16(),
+            };
+
+            while (!reader.EndOfRemainingData)
+            {
+                packet.TopicFilters.Add(reader.ReadStringWithLengthPrefix());
+            }
+
+            return packet;
+        }
+
+        private static MqttBasePacket DeserializeSubscribe(MqttPacketReader reader)
+        {
+            var packet = new MqttSubscribePacket
+            {
+                PacketIdentifier = reader.ReadUInt16()
+            };
+
+            while (!reader.EndOfRemainingData)
+            {
+                packet.TopicFilters.Add(new TopicFilter(
+                    reader.ReadStringWithLengthPrefix(),
+                    (MqttQualityOfServiceLevel)reader.ReadByte()));
+            }
+
+            return packet;
+        }
+
+        private static MqttBasePacket DeserializePublish(MqttPacketReader reader, MqttPacketHeader mqttPacketHeader)
+        {
+            var fixedHeader = new ByteReader(mqttPacketHeader.FixedHeader);
+            var retain = fixedHeader.Read();
+            var qualityOfServiceLevel = (MqttQualityOfServiceLevel)fixedHeader.Read(2);
+            var dup = fixedHeader.Read();
+
+            var topic = reader.ReadStringWithLengthPrefix();
+
+            ushort packetIdentifier = 0;
+            if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
+            {
+                packetIdentifier = reader.ReadUInt16();
+            }
+
+            var packet = new MqttPublishPacket
+            {
+                Retain = retain,
+                QualityOfServiceLevel = qualityOfServiceLevel,
+                Dup = dup,
+                Topic = topic,
+                Payload = reader.ReadRemainingData(),
+                PacketIdentifier = packetIdentifier
+            };
+
+            return packet;
+        }
+
+        private static MqttBasePacket DeserializeConnect(MqttPacketReader reader)
+        {
+            reader.ReadBytes(2); // Skip 2 bytes
+
+            MqttProtocolVersion protocolVersion;
+            var protocolName = reader.ReadBytes(4);
+            if (protocolName.SequenceEqual(ProtocolVersionV310Name))
+            {
+                reader.ReadBytes(2);
+                protocolVersion = MqttProtocolVersion.V310;
+            }
+            else if (protocolName.SequenceEqual(ProtocolVersionV311Name))
+            {
+                protocolVersion = MqttProtocolVersion.V311;
+            }
+            else
+            {
+                throw new MqttProtocolViolationException("Protocol name is not supported.");
+            }
+
+            var protocolLevel = reader.ReadByte();
+            var connectFlags = reader.ReadByte();
+
+            var connectFlagsReader = new ByteReader(connectFlags);
+            connectFlagsReader.Read(); // Reserved.
+
+            var packet = new MqttConnectPacket
+            {
+                ProtocolVersion = protocolVersion,
+                CleanSession = connectFlagsReader.Read()
+            };
+
+            var willFlag = connectFlagsReader.Read();
+            var willQoS = connectFlagsReader.Read(2);
+            var willRetain = connectFlagsReader.Read();
+            var passwordFlag = connectFlagsReader.Read();
+            var usernameFlag = connectFlagsReader.Read();
+
+            packet.KeepAlivePeriod = reader.ReadUInt16();
+            packet.ClientId = reader.ReadStringWithLengthPrefix();
+
+            if (willFlag)
+            {
+                packet.WillMessage = new MqttApplicationMessage(
+                    reader.ReadStringWithLengthPrefix(),
+                    reader.ReadWithLengthPrefix(),
+                    (MqttQualityOfServiceLevel)willQoS,
+                    willRetain);
+            }
+
+            if (usernameFlag)
+            {
+                packet.Username = reader.ReadStringWithLengthPrefix();
+            }
+
+            if (passwordFlag)
+            {
+                packet.Password = reader.ReadStringWithLengthPrefix();
+            }
+
+            ValidateConnectPacket(packet);
+            return packet;
+        }
+
+        private static MqttBasePacket DeserializeSubAck(MqttPacketReader reader)
+        {
+            var packet = new MqttSubAckPacket
+            {
+                PacketIdentifier = reader.ReadUInt16()
+            };
+
+            while (!reader.EndOfRemainingData)
+            {
+                packet.SubscribeReturnCodes.Add((MqttSubscribeReturnCode)reader.ReadByte());
+            }
+
+            return packet;
+        }
+
+        private static MqttBasePacket DeserializeConnAck(MqttPacketReader reader)
+        {
+            var variableHeader1 = reader.ReadByte();
+            var variableHeader2 = reader.ReadByte();
+
+            var packet = new MqttConnAckPacket
+            {
+                IsSessionPresent = new ByteReader(variableHeader1).Read(),
+                ConnectReturnCode = (MqttConnectReturnCode)variableHeader2
+            };
+
+            return packet;
+        }
+
+        private static void ValidateConnectPacket(MqttConnectPacket packet)
+        {
+            if (string.IsNullOrEmpty(packet.ClientId) && !packet.CleanSession)
+            {
+                throw new MqttProtocolViolationException("CleanSession must be set if ClientId is empty [MQTT-3.1.3-7].");
+            }
+        }
+
+        private static void ValidatePublishPacket(MqttPublishPacket packet)
+        {
+            if (packet.QualityOfServiceLevel == 0 && packet.Dup)
+            {
+                throw new MqttProtocolViolationException("Dup flag must be false for QoS 0 packets [MQTT-3.3.1-2].");
+            }
+        }
+
+        private byte Serialize(MqttConnectPacket packet, MqttPacketWriter writer)
+        {
+            ValidateConnectPacket(packet);
+
+            // Write variable header
+            writer.Write(0x00, 0x04); // 3.1.2.1 Protocol Name
+            if (ProtocolVersion == MqttProtocolVersion.V311)
+            {
+                writer.Write(ProtocolVersionV311Name);
+                writer.Write(0x04); // 3.1.2.2 Protocol Level (4)
+            }
+            else
+            {
+                writer.Write(ProtocolVersionV310Name);
+                writer.Write(0x64, 0x70, 0x03); // Protocol Level (0x03)
+            }
+
+            var connectFlags = new ByteWriter(); // 3.1.2.3 Connect Flags
+            connectFlags.Write(false); // Reserved
+            connectFlags.Write(packet.CleanSession);
+            connectFlags.Write(packet.WillMessage != null);
+
+            if (packet.WillMessage != null)
+            {
+                connectFlags.Write((int)packet.WillMessage.QualityOfServiceLevel, 2);
+                connectFlags.Write(packet.WillMessage.Retain);
+            }
+            else
+            {
+                connectFlags.Write(0, 2);
+                connectFlags.Write(false);
+            }
+
+            connectFlags.Write(packet.Password != null);
+            connectFlags.Write(packet.Username != null);
+
+            writer.Write(connectFlags);
+            writer.Write(packet.KeepAlivePeriod);
+            writer.WriteWithLengthPrefix(packet.ClientId);
+
+            if (packet.WillMessage != null)
+            {
+                writer.WriteWithLengthPrefix(packet.WillMessage.Topic);
+                writer.WriteWithLengthPrefix(packet.WillMessage.Payload);
+            }
+
+            if (packet.Username != null)
+            {
+                writer.WriteWithLengthPrefix(packet.Username);
+            }
+
+            if (packet.Password != null)
+            {
+                writer.WriteWithLengthPrefix(packet.Password);
+            }
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Connect);
+        }
+
+        private byte Serialize(MqttConnAckPacket packet, MqttPacketWriter writer)
+        {
+            var connectAcknowledgeFlags = new ByteWriter();
+
+            if (ProtocolVersion == MqttProtocolVersion.V311)
+            {
+                connectAcknowledgeFlags.Write(packet.IsSessionPresent);
+            }
+
+            writer.Write(connectAcknowledgeFlags);
+            writer.Write((byte)packet.ConnectReturnCode);
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.ConnAck);
+        }
+
+        private static byte Serialize(MqttPubRelPacket packet, MqttPacketWriter writer)
+        {
+            writer.Write(packet.PacketIdentifier);
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRel, 0x02);
+        }
+
+        private static byte Serialize(MqttDisconnectPacket packet, MqttPacketWriter writer)
+        {
+            return SerializeEmptyPacketAsync(MqttControlPacketType.Disconnect, writer);
+        }
+
+        private static byte Serialize(MqttPingReqPacket packet, MqttPacketWriter writer)
+        {
+            return SerializeEmptyPacketAsync(MqttControlPacketType.PingReq, writer);
+        }
+
+        private static byte Serialize(MqttPingRespPacket packet, MqttPacketWriter writer)
+        {
+            return SerializeEmptyPacketAsync(MqttControlPacketType.PingResp, writer);
+        }
+
+        private static byte Serialize(MqttPublishPacket packet, MqttPacketWriter writer)
+        {
+            ValidatePublishPacket(packet);
+
+            writer.WriteWithLengthPrefix(packet.Topic);
+
+            if (packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
+            {
+                writer.Write(packet.PacketIdentifier);
+            }
+            else
+            {
+                if (packet.PacketIdentifier > 0)
+                {
+                    throw new MqttProtocolViolationException("Packet identifier must be empty if QoS == 0 [MQTT-2.3.1-5].");
+                }
+            }
+
+            if (packet.Payload?.Length > 0)
+            {
+                writer.Write(packet.Payload);
+            }
+
+            byte fixedHeader = 0;
+
+            if (packet.Retain)
+            {
+                fixedHeader |= 0x01;
+            }
+
+            fixedHeader |= (byte)((byte)packet.QualityOfServiceLevel << 1);
+
+            if (packet.Dup)
+            {
+                fixedHeader |= 0x08;
+            }
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Publish, fixedHeader);
+        }
+
+        private static byte Serialize(MqttPubAckPacket packet, MqttPacketWriter writer)
+        {
+            writer.Write(packet.PacketIdentifier);
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubAck);
+        }
+
+        private static byte Serialize(MqttPubRecPacket packet, MqttPacketWriter writer)
+        {
+            writer.Write(packet.PacketIdentifier);
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubRec);
+        }
+
+        private static byte Serialize(MqttPubCompPacket packet, MqttPacketWriter writer)
+        {
+            writer.Write(packet.PacketIdentifier);
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.PubComp);
+        }
+
+        private static byte Serialize(MqttSubscribePacket packet, MqttPacketWriter writer)
+        {
+            if (!packet.TopicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.8.3-3].");
+
+            writer.Write(packet.PacketIdentifier);
+
+            if (packet.TopicFilters?.Count > 0)
+            {
+                foreach (var topicFilter in packet.TopicFilters)
+                {
+                    writer.WriteWithLengthPrefix(topicFilter.Topic);
+                    writer.Write((byte)topicFilter.QualityOfServiceLevel);
+                }
+            }
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Subscribe, 0x02);
+        }
+
+        private static byte Serialize(MqttSubAckPacket packet, MqttPacketWriter writer)
+        {
+            writer.Write(packet.PacketIdentifier);
+
+            if (packet.SubscribeReturnCodes?.Any() == true)
+            {
+                foreach (var packetSubscribeReturnCode in packet.SubscribeReturnCodes)
+                {
+                    writer.Write((byte)packetSubscribeReturnCode);
+                }
+            }
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.SubAck);
+        }
+
+        private static byte Serialize(MqttUnsubscribePacket packet, MqttPacketWriter writer)
+        {
+            if (!packet.TopicFilters.Any()) throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.10.3-2].");
+
+            writer.Write(packet.PacketIdentifier);
+
+            if (packet.TopicFilters?.Any() == true)
+            {
+                foreach (var topicFilter in packet.TopicFilters)
+                {
+                    writer.WriteWithLengthPrefix(topicFilter);
+                }
+            }
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Unsubscibe, 0x02);
+        }
+
+        private static byte Serialize(MqttUnsubAckPacket packet, MqttPacketWriter writer)
+        {
+            writer.Write(packet.PacketIdentifier);
+
+            return MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.UnsubAck);
+        }
+
+        private static byte SerializeEmptyPacketAsync(MqttControlPacketType type, MqttPacketWriter writer)
+        {
+            return MqttPacketWriter.BuildFixedHeader(type);
+        }
+    }
+}

MQTTnet.Core/Serializer/MqttPacketWriter.cs

@@ -1,80 +1,46 @@
 using System;
 using System.IO;
 using System.Text;
-using System.Threading.Tasks;
-using MQTTnet.Core.Channel;
 using MQTTnet.Core.Protocol;
+using System.Collections.Generic;
 
 namespace MQTTnet.Core.Serializer
 {
-    public sealed class MqttPacketWriter : IDisposable
+    public sealed class MqttPacketWriter : BinaryWriter
     {
-        private readonly MemoryStream _buffer = new MemoryStream(512);
-
-        public void InjectFixedHeader(byte fixedHeader)
+        public MqttPacketWriter(Stream stream)
+            : base(stream)
         {
-            if (_buffer.Length == 0)
-            {
-                Write(fixedHeader);
-                Write(0);
-                return;
-            }
-
-            var backupBuffer = _buffer.ToArray();
-            var remainingLength = (int)_buffer.Length;
-
-            _buffer.SetLength(0);
-
-            _buffer.WriteByte(fixedHeader);
-
-            // Alorithm taken from http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html.
-            var x = remainingLength;
-            do
-            {
-                var encodedByte = x % 128;
-                x = x / 128;
-                if (x > 0)
-                {
-                    encodedByte = encodedByte | 128;
-                }
-
-                _buffer.WriteByte((byte)encodedByte);
-            } while (x > 0);
-
-            _buffer.Write(backupBuffer, 0, backupBuffer.Length);
         }
 
-        public void InjectFixedHeader(MqttControlPacketType packetType, byte flags = 0)
+        public static byte BuildFixedHeader(MqttControlPacketType packetType, byte flags = 0)
         {
-            var fixedHeader = (byte)((byte)packetType << 4);
+            var fixedHeader = (int)packetType << 4;
             fixedHeader |= flags;
-            InjectFixedHeader(fixedHeader);
+            return (byte)fixedHeader;
         }
 
-        public void Write(byte value)
-        {
-            _buffer.WriteByte(value);
-        }
-
-        public void Write(ushort value)
+        public override void Write(ushort value)
         {
             var buffer = BitConverter.GetBytes(value);
-            _buffer.WriteByte(buffer[1]);
-            _buffer.WriteByte(buffer[0]);
+            Write(buffer[1], buffer[0]);
+        }
+
+        public new void Write(params byte[] values)
+        {
+            base.Write(values);
+        }
+
+        public new void Write(byte value)
+        {
+            base.Write(value);
         }
 
         public void Write(ByteWriter value)
         {
             if (value == null) throw new ArgumentNullException(nameof(value));
 
-            _buffer.WriteByte(value.Value);
-        }
-
-        public void Write(params byte[] value)
-        {
-            if (value == null) throw new ArgumentNullException(nameof(value));
-
-            _buffer.Write(value, 0, value.Length);
+            Write(value.Value);
         }
 
         public void WriteWithLengthPrefix(string value)
@@ -90,16 +56,27 @@ namespace MQTTnet.Core.Serializer
             Write(value);
         }
 
-        public Task WriteToAsync(IMqttCommunicationChannel destination)
+        public static void BuildLengthHeader(int length, List<byte> header)
         {
-            if (destination == null) throw new ArgumentNullException(nameof(destination));
+            if (length == 0)
+            {
+                header.Add(0);
+                return;
+            }
 
-            return destination.WriteAsync(_buffer.ToArray());
-        }
+            // Alorithm taken from http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html.
+            var x = length;
+            do
+            {
+                var encodedByte = x % 128;
+                x = x / 128;
+                if (x > 0)
+                {
+                    encodedByte = encodedByte | 128;
+                }
 
-        public void Dispose()
-        {
-            _buffer?.Dispose();
+                header.Add((byte)encodedByte);
+            } while (x > 0);
         }
     }
 }

MQTTnet.Core/Serializer/MqttProtocolVersion.cs

@@ -0,0 +1,8 @@
+namespace MQTTnet.Core.Serializer
+{
+    public enum MqttProtocolVersion
+    {
+        V311,
+        V310
+    }
+}

MQTTnet.Core/Server/ConnectedMqttClient.cs

@@ -0,0 +1,11 @@
+using MQTTnet.Core.Serializer;
+
+namespace MQTTnet.Core.Server
+{
+    public class ConnectedMqttClient
+    {
+        public string ClientId { get; set; }
+
+        public MqttProtocolVersion ProtocolVersion { get; set; }
+    }
+}

MQTTnet.Core/Server/GetOrCreateClientSessionResult.cs

@@ -0,0 +1,9 @@
+namespace MQTTnet.Core.Server
+{
+    public sealed class GetOrCreateClientSessionResult
+    {
+        public bool IsExistingSession { get; set; }
+
+        public MqttClientSession Session { get; set; }
+    }
+}

MQTTnet.Core/Server/IMqttServer.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using MQTTnet.Core.Adapter;
+
+namespace MQTTnet.Core.Server
+{
+    public interface IMqttServer
+    {
+        event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+        event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
+
+        IList<ConnectedMqttClient> GetConnectedClients();
+        void InjectClient(string identifier, IMqttCommunicationAdapter adapter);
+        void Publish(MqttApplicationMessage applicationMessage);
+        void Start();
+        void Stop();
+    }
+}

MQTTnet.Core/Server/IMqttServerFactory.cs

@@ -0,0 +1,7 @@
+namespace MQTTnet.Core.Server
+{
+    public interface IMqttServerFactory
+    {
+        IMqttServer CreateMqttServer(MqttServerOptions options);
+    }
+}

MQTTnet.Core/Server/MqttApplicationMessageReceivedEventArgs.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace MQTTnet.Core.Server
+{
+    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; }
+    }
+}