Add password protected code signing certificate to enable build process.

Merge develop
Update documentation
2026-10-15 00:15:15 +08:00 · 2017-12-22 12:02:25 +01:00 · 2017-12-18 14:17:31 +01:00 · 2017-12-14 13:24:50 +01:00 · 2017-12-14 13:23:12 +01:00 · 2017-12-14 13:12:18 +01:00
238 changed files with 7030 additions and 4330 deletions
@@ -0,0 +1,8 @@
+exclude:
+- /Frameworks/.*
+- /MQTTnet.TestApp.NetCore/Program.cs
+- /Tests/MQTTnet.TestApp.NetFramework/.*
+- /Tests/MQTTnet.TestApp.UniversalWindows/.*
+component_depth: 1
+languages:
+- csharp
@@ -197,7 +197,7 @@ ClientBin/
 *.dbmdl
 *.dbproj.schemaview
 *.jfm
-*.pfx
+# *.pfx
 *.publishsettings
 orleans.codegen.cs

@@ -289,3 +289,7 @@ __pycache__/


 Build/nuget.exe
+*.js
+*.map
+
+/Tests/MQTTnet.TestApp.NetCore/RetainedMessages.json
@@ -0,0 +1,28 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>MQTTnet.AspNetCore</id>
+    <version>2.6.0</version>
+    <authors>Christian Kratky</authors>
+    <owners>Christian Kratky</owners>
+    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
+    <projectUrl>https://github.com/chkr1011/MQTTnet</projectUrl>
+    <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>This is a support library to integrate MQTTnet into AspNetCore.</description>
+    <releaseNotes>* Updated to MQTTnet 2.6.0.
+    </releaseNotes>
+    <copyright>Copyright Christian Kratky 2016-2017</copyright>
+    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin</tags> 
+    <dependencies>
+      <group targetFramework="netstandard2.0">
+        <dependency id="MQTTnet" version="2.6.0" />
+      </group>
+    </dependencies>
+  </metadata>
+
+  <files>
+    <!-- .NET Standard 2.0 -->
+    <file src="..\Frameworks\MQTTnet.AspNetCore\bin\Release\netstandard2.0\MQTTnet.AspNetCore.*" target="lib\netstandard2.0\"/>
+  </files>
+</package>
@@ -0,0 +1,47 @@
+<?xml version="1.0"?>
+<package >
+  <metadata>
+    <id>MQTTnet.Extensions.Rpc</id>
+    <version>2.6.0</version>
+    <authors>Christian Kratky</authors>
+    <owners>Christian Kratky</owners>
+    <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
+    <projectUrl>https://github.com/chkr1011/MQTTnet</projectUrl>
+    <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description>This is a extension library which allows executing synchronous device calls including a response using MQTTnet.</description>
+    <releaseNotes>* Initial version.
+    </releaseNotes>
+    <copyright>Copyright Christian Kratky 2016-2017</copyright>
+    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin</tags> 
+    <dependencies>
+      <group targetFramework="netstandard2.0">
+        <dependency id="MQTTnet" version="2.6.0-rc1" />
+      </group>
+      <group targetFramework="netstandard1.3">
+        <dependency id="MQTTnet" version="2.6.0-rc1" />  
+      </group>
+
+      <group targetFramework="netstandard2.0">
+        <dependency id="MQTTnet" version="2.6.0-rc1" />
+      </group>
+      
+      <group targetFramework="uap10.0">
+        <dependency id="MQTTnet" version="2.6.0-rc1" />
+      </group>
+        
+      <group targetFramework="net452">
+        <dependency id="MQTTnet" version="2.6.0-rc1" />
+      </group>
+
+      <group targetFramework="net461">
+        <dependency id="MQTTnet" version="2.6.0-rc1" />
+      </group>
+    </dependencies>
+  </metadata>
+
+  <files>
+    <!-- .NET Standard 2.0 -->
+    <file src="..\Frameworks\MQTTnet.AspNetCore\bin\Release\netstandard2.0\MQTTnet.AspNetCore.*" target="lib\netstandard2.0\"/>
+  </files>
+</package>
@@ -2,50 +2,81 @@
 <package >
  <metadata>
    <id>MQTTnet</id>
-    <version>2.3.0</version>
+    <version>2.6.0</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>* [Client] Added support for web socket communication channel (thanks to nowakpiotr)
-* [Core] Huge performance optimizations (thanks to JanEggers)
-* [Client] Fixed an issue when calling _DisconnectAsync_ and the connection is already closed.
-* [Core] Added several new interfaces
-* [Core] Added a factory for creation of application messages
-* [Core] Fixed issues in connection handling
-* [Client] Fixed issues with subscribing/unsubscribing (breaking change!)
+    <description>MQTTnet is a high performance .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker).</description>
+    <releaseNotes>* [Core] Merged projects (BREAKING CHANGE! But only namespace changes).
+* [Core] Added a strong name for the assembly.
+* [Core] Performance optimizations.
+* [Core] Fixed a logging issue when dealing with IOExceptions.
+* [Core] Fixed a typo in the global logger class (BREAKING CHANGE! Please find new example in Wiki).
+* [Core] Added support for project compilation under macOS (Thanks to @FourOnes).
+* [Client] The certificate for encryption is now loaded as a _X509Certificate2_ which prodives more data (Thanks to @cvellan).
+* [Client] Fixed an issue in _ManagedClient_ which can cause the client to stop when publishing subscriptions.
+* [Client] Fixed an issue in _ManagedClient_ which prevents changing the QoS of an existing subscription (BREAKING CHANGE!).
+* [Client] Fixed an issue in _MqttClientOptionsBuilder_ which prevents adding TLS options to the client options when calling _Build()_. (Thanks to @cvellan).
+* [Client] Added an overload for subscribing at both clients which reduces required code.
+* [Client] Added the _ClientId_ to the application message interceptor context.
+* [Server] The application message interceptor can now delete any received application message.
+* [Server] Added a ConnectionValidator context to align with other APIs (BREAKING CHANGE! Please find new example in Wiki).
+* [Server] Added an interface for the _MqttServerOptions_.
+* [Server] Added packet statistics for the connected clients.
+* [Server] Fixed a security issue which sends retained packages to a failed subscription.
+* [Server] Fixed the response (MaximumQoS) of a subscription (Thanks to @redbeans2017).
+* [Server] The keep alive timeouts are now checked for every client (Thanks to @RainerMueller82).
+* [Server] The used IP addresses can be specified now (IPAddress.Any as default).
    </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> 
+    <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin</tags> 
    <dependencies>

      <group targetFramework="netstandard1.3">
-        <dependency id="NETStandard.Library" version="1.6.1" />
-        <dependency id="System.Net.Security" version="4.3.1" />
+        <dependency id="NETStandard.Library" version="1.3.0" />
+        <dependency id="System.Net.Security" version="4.3.2" />
+        <dependency id="System.Net.WebSockets" version="4.3.0" />
+        <dependency id="System.Net.WebSockets.Client" version="4.3.1" />      
+      </group>
+
+      <group targetFramework="netstandard2.0">
+        <dependency id="NETStandard.Library" version="2.0.0" />
+        <dependency id="System.Net.Security" version="4.3.2" />
+        <dependency id="System.Net.WebSockets" version="4.3.0" />
+        <dependency id="System.Net.WebSockets.Client" version="4.3.1" />
      </group>
      
      <group targetFramework="uap10.0">
-        <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="5.4.0" />
+        <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="5.4.1" />
+      </group>
+        
+      <group targetFramework="net452">
+      </group>
+
+      <group targetFramework="net461">
      </group>

    </dependencies>
  </metadata>

  <files>
+    
    <!-- .NET Standard 1.3 -->
-    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\netstandard1.3\MQTTnet.Core.*" target="lib\netstandard1.3\"/>
    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\netstandard1.3\MQTTnet.*" target="lib\netstandard1.3\"/>
+    
+    <!-- .NET Standard 2.0 -->
+    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\netstandard2.0\MQTTnet.*" target="lib\netstandard2.0\"/>

    <!-- Universal Windows -->
-    <file src="..\Frameworks\MQTTnet.UniversalWindows\bin\Release\MQTTnet.Core.*" target="lib\uap10.0\"/>
-    <file src="..\Frameworks\MQTTnet.UniversalWindows\bin\Release\MQTTnet.*" target="lib\uap10.0\"/>
+    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\uap10.0\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\"/>
+    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\net452\MQTTnet.*" target="lib\net452\"/>
+
+    <file src="..\Frameworks\MQTTnet.Netstandard\bin\Release\net461\MQTTnet.*" target="lib\net461\"/>
    
  </files>
 </package>
@@ -1,12 +1,33 @@
-param([string]$version)
+param([string]$assemblyVersion, [string]$nugetVersion)

 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"
+$vswhere = ${Env:\ProgramFiles(x86)} + '\Microsoft Visual Studio\Installer\vswhere'

-Remove-Item .\NuGet -Force -Recurse
-New-Item -ItemType Directory -Force -Path .\NuGet
-.\NuGet.exe pack MQTTnet.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $version
+$path = &$vswhere -latest -products * -requires Microsoft.Component.MSBuild -property installationPath
+if ($path) {
+    $msbuild = join-path $path 'MSBuild\15.0\Bin\MSBuild.exe'
+
+	# Build the core library
+    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net461" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard1.3" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard2.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Frameworks\MQTTnet.Netstandard\MQTTnet.Netstandard.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="uap10.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    
+	# Build the ASP.NET Core 2.0 extension
+	&$msbuild ..\Frameworks\MQTTnet.AspNetCore\MQTTnet.AspNetCore.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard2.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+
+	# Build the RPC extension
+	&$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net452" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="net461" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard1.3" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="netstandard2.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+    &$msbuild ..\Extensions\MQTTnet.Extensions.Rpc\MQTTnet.Extensions.Rpc.csproj /t:Build /p:Configuration="Release" /p:TargetFramework="uap10.0" /p:FileVersion=$assemblyVersion /p:AssemblyVersion=$assemblyVersion /verbosity:m
+
+    Remove-Item .\NuGet -Force -Recurse
+    New-Item -ItemType Directory -Force -Path .\NuGet
+    .\NuGet.exe pack MQTTnet.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $nugetVersion
+    .\NuGet.exe pack MQTTnet.AspNetCore.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $nugetVersion
+	.\NuGet.exe pack MQTTnet.Extensions.Rpc.nuspec -Verbosity detailed -Symbols -OutputDir "NuGet" -Version $nugetVersion
+}
@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
+    <AssemblyVersion>0.0.0.0</AssemblyVersion>
+    <FileVersion>0.0.0.0</FileVersion>
+    <Product />
+    <Company />
+    <Authors />
+    <PackageId />
+    <Version>0.0.0.0</Version>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
+    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    <NugetTargetMoniker>UAP,Version=v10.0</NugetTargetMoniker>
+    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
+    <TargetPlatformVersion>10.0.16299.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
+    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
+    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\Frameworks\MQTTnet.Netstandard\MQTTnet.NetStandard.csproj" />
+  </ItemGroup>
+
+</Project>
@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+using MQTTnet.Client;
+using MQTTnet.Internal;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Extensions.Rpc
+{
+    public sealed class MqttRpcClient : IDisposable
+    {
+        private const string ResponseTopic = "$MQTTnet.RPC/+/+/response";
+        private readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
+        private readonly IMqttClient _mqttClient;
+        private bool _isEnabled;
+
+        public MqttRpcClient(IMqttClient mqttClient)
+        {
+            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+
+            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
+        }
+
+        public async Task EnableAsync()
+        {
+            await _mqttClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(ResponseTopic).WithAtLeastOnceQoS().Build());
+            _isEnabled = true;
+        }
+
+        public async Task DisableAsync()
+        {
+            await _mqttClient.UnsubscribeAsync(ResponseTopic);
+            _isEnabled = false;
+        }
+
+        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            if (methodName == null) throw new ArgumentNullException(nameof(methodName));
+
+            if (methodName.Contains("/") || methodName.Contains("+") || methodName.Contains("#"))
+            {
+                throw new ArgumentException("The method name cannot contain /, + or #.");
+            }
+
+            if (!_isEnabled)
+            {
+                throw new InvalidOperationException("The RPC client is not enabled.");
+            }
+
+            var requestTopic = $"$MQTTnet.RPC/{Guid.NewGuid():N}/{methodName}";
+            var responseTopic = requestTopic + "/response";
+
+            var requestMessage = new MqttApplicationMessageBuilder()
+                .WithTopic(requestTopic)
+                .WithPayload(payload)
+                .WithQualityOfServiceLevel(qualityOfServiceLevel)
+                .Build();
+
+            try
+            {
+                var tcs = new TaskCompletionSource<byte[]>();
+                if (!_waitingCalls.TryAdd(responseTopic, tcs))
+                {
+                    throw new InvalidOperationException();
+                }
+
+                await _mqttClient.PublishAsync(requestMessage);
+                return await tcs.Task.TimeoutAfter(timeout);
+            }
+            finally
+            {
+                _waitingCalls.TryRemove(responseTopic, out _);
+            }
+        }
+
+        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
+        {
+            if (!_waitingCalls.TryRemove(eventArgs.ApplicationMessage.Topic, out TaskCompletionSource<byte[]> tcs))
+            {
+                return;
+            }
+
+            if (tcs.Task.IsCompleted || tcs.Task.IsCanceled)
+            {
+                return;
+            }
+
+            tcs.TrySetResult(eventArgs.ApplicationMessage.Payload);
+        }
+
+        public void Dispose()
+        {
+            foreach (var tcs in _waitingCalls)
+            {
+                tcs.Value.SetCanceled();
+            }
+
+            _waitingCalls.Clear();
+        }
+    }
+}
@@ -0,0 +1 @@
+
@@ -0,0 +1,52 @@
+using System;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.DependencyInjection;
+using System.Linq;
+using MQTTnet.Server;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ApplicationBuilderExtensions
+    {
+        public static IApplicationBuilder UseMqttEndpoint(this IApplicationBuilder app, string path = "/mqtt")
+        {
+            app.UseWebSockets();
+            app.Use(async (context, next) =>
+            {
+                if (context.Request.Path == path && context.WebSockets.IsWebSocketRequest)
+                {
+                    string subprotocol = null;
+
+                    if (context.Request.Headers.TryGetValue("Sec-WebSocket-Protocol", out var requestedSubProtocolValues)
+                     && requestedSubProtocolValues.Count > 0
+                     && requestedSubProtocolValues.Any(v => v.ToLower() == "mqtt")
+                     )
+                    {
+                        subprotocol = "mqtt";
+                    }
+
+                    var adapter = app.ApplicationServices.GetRequiredService<MqttWebSocketServerAdapter>();
+                    using (var webSocket = await context.WebSockets.AcceptWebSocketAsync(subprotocol))
+                    {
+                        await adapter.AcceptWebSocketAsync(webSocket);
+                    }
+                }
+                else
+                {
+                    await next();
+                }
+            });
+
+            return app;
+        }
+
+        public static IApplicationBuilder UseMqttServer(this IApplicationBuilder app, Action<IMqttServer> configure)
+        {
+            var server = app.ApplicationServices.GetRequiredService<IMqttServer>();
+
+            configure(server);
+
+            return app;
+        }
+    }
+}
@@ -0,0 +1,28 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <AssemblyVersion>0.0.0.0</AssemblyVersion>
+    <FileVersion>0.0.0.0</FileVersion>
+    <Version>0.0.0.0</Version>
+    <Product />
+    <Company />
+    <Authors />
+    <PackageId />
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
+    <DefineConstants>RELEASE;NETSTANDARD2_0</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.0.0" />
+    <PackageReference Include="Microsoft.AspNetCore.WebSockets" Version="2.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="2.0.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MQTTnet.Netstandard\MQTTnet.NetStandard.csproj" />
+  </ItemGroup>
+
+</Project>
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Hosting;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Server;
+
+namespace MQTTnet.AspNetCore
+{
+    public class MqttHostedServer : MqttServer, IHostedService
+    {
+        private readonly IMqttServerOptions _options;
+
+        public MqttHostedServer(IMqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger) : base(adapters, logger)
+        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            return StartAsync(_options);
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            return StopAsync();
+        }
+    }
+}
@@ -0,0 +1,42 @@
+using System;
+using System.Net.WebSockets;
+using System.Threading.Tasks;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Serializer;
+using MQTTnet.Server;
+
+namespace MQTTnet.AspNetCore
+{
+    public sealed class MqttWebSocketServerAdapter : IMqttServerAdapter, IDisposable
+    {
+        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        public Task StartAsync(IMqttServerOptions options)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task AcceptWebSocketAsync(WebSocket webSocket)
+        {
+            if (webSocket == null) throw new ArgumentNullException(nameof(webSocket));
+
+            var channel = new MqttWebSocketServerChannel(webSocket);
+            var clientAdapter = new MqttChannelAdapter(channel, new MqttPacketSerializer(), new MqttNetLogger());
+
+            var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
+            ClientAccepted?.Invoke(this, eventArgs);
+            return eventArgs.SessionTask;
+        }
+        
+        public void Dispose()
+        {
+            StopAsync();
+        }
+    }
+}
@@ -0,0 +1,60 @@
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Channel;
+using MQTTnet.Implementations;
+
+namespace MQTTnet.AspNetCore
+{
+    public class MqttWebSocketServerChannel : IMqttChannel, IDisposable
+    {
+        private WebSocket _webSocket;
+
+        public MqttWebSocketServerChannel(WebSocket webSocket)
+        {
+            _webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
+
+            SendStream = new WebSocketStream(_webSocket);
+            ReceiveStream = SendStream;
+        }
+
+        public Stream SendStream { get; private set; }
+        public Stream ReceiveStream { get; private set; }
+
+        public Task ConnectAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public async Task DisconnectAsync()
+        {
+            if (_webSocket == null)
+            {
+                return;
+            }
+
+            try
+            {
+                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
+            }
+            finally
+            {
+                Dispose();
+            }
+        }
+
+        public void Dispose()
+        {
+            SendStream?.Dispose();
+            ReceiveStream?.Dispose();
+
+            _webSocket?.Dispose();
+
+            SendStream = null;
+            ReceiveStream = null;
+            _webSocket = null;
+        }
+    }
+}
@@ -0,0 +1,28 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Server;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, IMqttServerOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            services.AddSingleton(options);
+            services.AddSingleton<IMqttNetLogger>(new MqttNetLogger());
+            services.AddSingleton<MqttHostedServer>();
+            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
+            services.AddSingleton<IMqttServer>(s => s.GetService<MqttHostedServer>());
+            
+            services.AddSingleton<MqttWebSocketServerAdapter>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttWebSocketServerAdapter>());
+
+            return services;
+        }
+    }
+}
@@ -1,129 +0,0 @@
-using System;
-using System.Net;
-using System.Net.Security;
-using System.Net.Sockets;
-using System.Security.Authentication;
-using System.Security.Cryptography.X509Certificates;
-using System.Threading;
-using System.Threading.Tasks;
-using MQTTnet.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);
-                }
-            }
-        }
-    }
-}
@@ -1,116 +0,0 @@
-using System;
-using System.Net.Security;
-using System.Net.Sockets;
-using System.Security.Authentication;
-using System.Security.Cryptography.X509Certificates;
-using System.Threading.Tasks;
-using 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;
-        }
-    }
-}
@@ -1,55 +0,0 @@
-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();
-        }
-    }
-}
@@ -1,77 +0,0 @@
-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();
-        }
-    }
-}
@@ -1,125 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
-  <PropertyGroup>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{A480EF90-0EAA-4D9A-B271-47A9C47F6F7D}</ProjectGuid>
-    <OutputType>Library</OutputType>
-    <AppDesignerFolder>Properties</AppDesignerFolder>
-    <RootNamespace>MQTTnet</RootNamespace>
-    <AssemblyName>MQTTnet</AssemblyName>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <FileAlignment>512</FileAlignment>
-    <TargetFrameworkProfile />
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>full</DebugType>
-    <Optimize>false</Optimize>
-    <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
-    <DebugType>pdbonly</DebugType>
-    <Optimize>true</Optimize>
-    <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <ErrorReport>prompt</ErrorReport>
-    <WarningLevel>4</WarningLevel>
-    <Prefer32Bit>false</Prefer32Bit>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Any CPU|AnyCPU'">
-    <OutputPath>bin\Any CPU\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>AnyCPU</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x86\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
-    <OutputPath>bin\x86\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Any CPU|x86'">
-    <OutputPath>bin\x86\Any CPU\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x86</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
-    <DebugSymbols>true</DebugSymbols>
-    <OutputPath>bin\x64\Debug\</OutputPath>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugType>full</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
-    <OutputPath>bin\x64\Release\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Any CPU|x64'">
-    <OutputPath>bin\x64\Any CPU\</OutputPath>
-    <DefineConstants>TRACE</DefineConstants>
-    <Optimize>true</Optimize>
-    <DebugType>pdbonly</DebugType>
-    <PlatformTarget>x64</PlatformTarget>
-    <ErrorReport>prompt</ErrorReport>
-    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="Implementations\MqttWebSocketChannel.cs" />
-    <Compile Include="Implementations\WebSocketStream.cs" />
-    <Compile Include="MqttClientFactory.cs" />
-    <Compile Include="MqttServerFactory.cs" />
-    <Compile Include="Implementations\MqttServerAdapter.cs" />
-    <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="Implementations\MqttTcpChannel.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\MQTTnet.Core\MQTTnet.Core.csproj">
-      <Project>{2ecb99e4-72d0-4c23-99ba-93d511d3967d}</Project>
-      <Name>MQTTnet.Core</Name>
-    </ProjectReference>
-  </ItemGroup>
-  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
-  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
-       Other similar extension points exist, see Microsoft.Common.targets.
-  <Target Name="BeforeBuild">
-  </Target>
-  <Target Name="AfterBuild">
-  </Target>
-  -->
-</Project>
@@ -1,33 +0,0 @@
-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();
-            }
-        }
-    }
-}
@@ -1,18 +0,0 @@
-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() });
-        }
-    }
-}
@@ -1,15 +0,0 @@
-using System.Reflection;
-using System.Runtime.InteropServices;
-
-[assembly: AssemblyTitle("MQTTnet")]
-[assembly: AssemblyDescription("MQTTnet for .NET Framework")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("Christian Kratky")]
-[assembly: AssemblyProduct("MQTTnet")]
-[assembly: AssemblyCopyright("Copyright © Christian Kratky 2016-2017")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-[assembly: ComVisible(false)]
-[assembly: Guid("a480ef90-0eaa-4d9a-b271-47a9c47f6f7d")]
-[assembly: AssemblyVersion("2.3.0.0")]
-[assembly: AssemblyFileVersion("2.3.0.0")]
@@ -2,17 +2,16 @@
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Core.Client;
-using MQTTnet.Core.Packets;
-using MQTTnet.Core.Serializer;
+using MQTTnet.Packets;
+using MQTTnet.Serializer;

-namespace MQTTnet.Core.Adapter
+namespace MQTTnet.Adapter
 {
-    public interface IMqttCommunicationAdapter
+    public interface IMqttChannelAdapter
    {
        IMqttPacketSerializer PacketSerializer { get; }

-        Task ConnectAsync(TimeSpan timeout, MqttClientOptions options);
+        Task ConnectAsync(TimeSpan timeout);

        Task DisconnectAsync(TimeSpan timeout);

@@ -0,0 +1,14 @@
+using System;
+using System.Threading.Tasks;
+using MQTTnet.Server;
+
+namespace MQTTnet.Adapter
+{
+    public interface IMqttServerAdapter
+    {
+        event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        Task StartAsync(IMqttServerOptions options);
+        Task StopAsync();
+    }
+}
@@ -0,0 +1,195 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Channel;
+using MQTTnet.Diagnostics;
+using MQTTnet.Exceptions;
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Adapter
+{
+    public class MqttChannelAdapter : IMqttChannelAdapter
+    {
+        private const uint ErrorOperationAborted = 0x800703E3;
+
+        private static readonly byte[] EmptyBody = new byte[0];
+
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
+        private readonly IMqttNetLogger _logger;
+        private readonly IMqttChannel _channel;
+
+        public MqttChannelAdapter(IMqttChannel channel, IMqttPacketSerializer serializer, IMqttNetLogger logger)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _channel = channel ?? throw new ArgumentNullException(nameof(channel));
+            PacketSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
+        }
+
+        public IMqttPacketSerializer PacketSerializer { get; }
+
+        public Task ConnectAsync(TimeSpan timeout)
+        {
+            _logger.Trace<MqttChannelAdapter>("Connecting [Timeout={0}]", timeout);
+
+            return ExecuteAndWrapExceptionAsync(() => _channel.ConnectAsync().TimeoutAfter(timeout));
+        }
+
+        public Task DisconnectAsync(TimeSpan timeout)
+        {
+            _logger.Trace<MqttChannelAdapter>("Disconnecting [Timeout={0}]", timeout);
+
+            return ExecuteAndWrapExceptionAsync(() => _channel.DisconnectAsync().TimeoutAfter(timeout));
+        }
+
+        public Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets)
+        {
+            return ExecuteAndWrapExceptionAsync(async () =>
+            {
+                await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
+                try
+                {
+                    foreach (var packet in packets)
+                    {
+                        if (packet == null)
+                        {
+                            continue;
+                        }
+
+                        _logger.Trace<MqttChannelAdapter>("TX >>> {0} [Timeout={1}]", packet, timeout);
+
+                        var chunks = PacketSerializer.Serialize(packet);
+                        foreach (var chunk in chunks)
+                        {
+                            await _channel.SendStream.WriteAsync(chunk.Array, chunk.Offset, chunk.Count, cancellationToken).ConfigureAwait(false);
+                        }
+                    }
+
+                    if (timeout > TimeSpan.Zero)
+                    {
+                        await _channel.SendStream.FlushAsync(cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        await _channel.SendStream.FlushAsync(cancellationToken).ConfigureAwait(false);
+                    }
+                }
+                finally
+                {
+                    _semaphore.Release();
+                }
+            });
+        }
+
+        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            MqttBasePacket packet = null;
+            await ExecuteAndWrapExceptionAsync(async () =>
+            {
+                ReceivedMqttPacket receivedMqttPacket;
+                if (timeout > TimeSpan.Zero)
+                {
+                    receivedMqttPacket = await ReceiveAsync(_channel.ReceiveStream, cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
+                }
+                else
+                {
+                    receivedMqttPacket = await ReceiveAsync(_channel.ReceiveStream, cancellationToken).ConfigureAwait(false);
+                }
+
+                if (receivedMqttPacket == null || cancellationToken.IsCancellationRequested)
+                {
+                    throw new TaskCanceledException();
+                }
+
+                packet = PacketSerializer.Deserialize(receivedMqttPacket.Header, receivedMqttPacket.Body);
+                if (packet == null)
+                {
+                    throw new MqttProtocolViolationException("Received malformed packet.");
+                }
+
+                _logger.Trace<MqttChannelAdapter>("RX <<< {0}", packet);
+            }).ConfigureAwait(false);
+
+            return packet;
+        }
+
+        private static async Task<ReceivedMqttPacket> ReceiveAsync(Stream stream, CancellationToken cancellationToken)
+        {
+            var header = MqttPacketReader.ReadHeaderFromSource(stream, cancellationToken);
+            if (header == null)
+            {
+                return null;
+            }
+
+            if (header.BodyLength == 0)
+            {
+                return new ReceivedMqttPacket(header, EmptyBody);
+            }
+
+            var body = new byte[header.BodyLength];
+
+            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, body);
+        }
+
+        private static async Task ExecuteAndWrapExceptionAsync(Func<Task> action)
+        {
+            try
+            {
+                await action().ConfigureAwait(false);
+            }
+            catch (TaskCanceledException)
+            {
+                throw;
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationTimedOutException)
+            {
+                throw;
+            }
+            catch (MqttCommunicationException)
+            {
+                throw;
+            }
+            catch (COMException comException)
+            {
+                if ((uint) comException.HResult == ErrorOperationAborted)
+                {
+                    throw new OperationCanceledException();
+                }
+
+                throw new MqttCommunicationException(comException);
+            }
+            catch (IOException exception)
+            {
+                if (exception.InnerException is SocketException socketException)
+                {
+                    if (socketException.SocketErrorCode == SocketError.ConnectionAborted)
+                    {
+                        throw new OperationCanceledException();
+                    }
+                }
+
+                throw new MqttCommunicationException(exception);
+            }
+            catch (Exception exception)
+            {
+                throw new MqttCommunicationException(exception);
+            }
+        }
+    }
+}
@@ -0,0 +1,17 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Packets;
+
+namespace MQTTnet.Adapter
+{
+    public static class MqttChannelAdapterExtensions
+    {
+        public static Task SendPacketsAsync(this IMqttChannelAdapter adapter, TimeSpan timeout, CancellationToken cancellationToken, params MqttBasePacket[] packets)
+        {
+            if (adapter == null) throw new ArgumentNullException(nameof(adapter));
+
+            return adapter.SendPacketsAsync(timeout, cancellationToken, packets);
+        }
+    }
+}
@@ -1,7 +1,7 @@
-using MQTTnet.Core.Exceptions;
-using MQTTnet.Core.Protocol;
+using MQTTnet.Exceptions;
+using MQTTnet.Protocol;

-namespace MQTTnet.Core.Adapter
+namespace MQTTnet.Adapter
 {
    public class MqttConnectingFailedException : MqttCommunicationException
    {
@@ -0,0 +1,17 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Adapter
+{
+    public class MqttServerAdapterClientAcceptedEventArgs : EventArgs
+    {
+        public MqttServerAdapterClientAcceptedEventArgs(IMqttChannelAdapter client)
+        {
+            Client = client ?? throw new ArgumentNullException(nameof(client));
+        }
+
+        public IMqttChannelAdapter Client { get; }
+
+        public Task SessionTask { get; set; }
+    }
+}
@@ -1,12 +1,11 @@
 using System;
-using System.IO;
-using MQTTnet.Core.Packets;
+using MQTTnet.Packets;

-namespace MQTTnet.Core.Adapter
+namespace MQTTnet.Adapter
 {
    public class ReceivedMqttPacket
    {
-        public ReceivedMqttPacket(MqttPacketHeader header, MemoryStream body)
+        public ReceivedMqttPacket(MqttPacketHeader header, byte[] body)
        {
            Header = header ?? throw new ArgumentNullException(nameof(header));
            Body = body ?? throw new ArgumentNullException(nameof(body));
@@ -14,6 +13,6 @@ namespace MQTTnet.Core.Adapter

        public MqttPacketHeader Header { get; }

-        public MemoryStream Body { get; }
+        public byte[] Body { get; }
    }
 }
@@ -0,0 +1,16 @@
+using System;
+using System.Threading.Tasks;
+
+namespace MQTTnet
+{
+    public static class ApplicationMessagePublisherExtensions
+    {
+        public static Task PublishAsync(this IApplicationMessagePublisher client, params MqttApplicationMessage[] applicationMessages)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
+
+            return client.PublishAsync(applicationMessages);
+        }
+    }
+}
@@ -0,0 +1,14 @@
+using System.IO;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Channel
+{
+    public interface IMqttChannel
+    {
+        Stream SendStream { get; }
+        Stream ReceiveStream { get; }
+
+        Task ConnectAsync();
+        Task DisconnectAsync();
+    }
+}
@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Client
+{
+    public interface IMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher
+    {
+        bool IsConnected { get; }
+
+        event EventHandler<MqttClientConnectedEventArgs> Connected;
+        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
+
+        Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options);
+        Task DisconnectAsync();
+
+        Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
+        Task UnsubscribeAsync(IEnumerable<string> topics);
+    }
+}
@@ -0,0 +1,10 @@
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+
+namespace MQTTnet.Client
+{
+    public interface IMqttClientAdapterFactory
+    {
+        IMqttChannelAdapter CreateClientAdapter(IMqttClientChannelOptions options, IMqttNetLogger logger);
+    }
+}
@@ -0,0 +1,7 @@
+namespace MQTTnet.Client
+{
+    public interface IMqttClientChannelOptions
+    {
+        MqttClientTlsOptions TlsOptions { get; }
+    }
+}
@@ -0,0 +1,8 @@
+namespace MQTTnet.Client
+{
+    public interface IMqttClientCredentials
+    {
+        string Password { get; }
+        string Username { get; }
+    }
+}
@@ -0,0 +1,16 @@
+using MQTTnet.Diagnostics;
+using MQTTnet.ManagedClient;
+
+namespace MQTTnet.Client
+{
+    public interface IMqttClientFactory
+    {
+        IMqttClient CreateMqttClient();
+
+        IMqttClient CreateMqttClient(IMqttNetLogger logger);
+        
+        IManagedMqttClient CreateManagedMqttClient();
+
+        IManagedMqttClient CreateManagedMqttClient(IMqttNetLogger logger);
+    }
+}
@@ -0,0 +1,20 @@
+using System;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Client
+{
+    public interface IMqttClientOptions
+    {
+        string ClientId { get; }
+
+        IMqttClientCredentials Credentials { get; }
+        bool CleanSession { get; }
+        MqttApplicationMessage WillMessage { get; }
+        
+        TimeSpan CommunicationTimeout { get; }
+        TimeSpan KeepAlivePeriod { get; }
+        MqttProtocolVersion ProtocolVersion { get; }
+
+        IMqttClientChannelOptions ChannelOptions { get; }
+    }
+}
@@ -3,82 +3,78 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Diagnostics;
-using MQTTnet.Core.Exceptions;
-using MQTTnet.Core.Internal;
-using MQTTnet.Core.Packets;
-using MQTTnet.Core.Protocol;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Exceptions;
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+using MQTTnet.Protocol;

-namespace MQTTnet.Core.Client
+namespace MQTTnet.Client
 {
-    public class MqttClient : IMqttClient
+    public class MqttClient : IMqttClient, IDisposable
    {
-        private readonly HashSet<ushort> _unacknowledgedPublishPackets = new HashSet<ushort>();
-        private readonly MqttPacketDispatcher _packetDispatcher = new MqttPacketDispatcher();
-        private readonly MqttClientOptions _options;
-        private readonly IMqttCommunicationAdapter _adapter;
+        private readonly IMqttClientAdapterFactory _adapterFactory;
+        private readonly MqttPacketDispatcher _packetDispatcher;
+        private readonly IMqttNetLogger _logger;

+        private IMqttClientOptions _options;
+        private bool _isReceivingPackets;
        private int _latestPacketIdentifier;
        private CancellationTokenSource _cancellationTokenSource;
+        private IMqttChannelAdapter _adapter;

-        public MqttClient(MqttClientOptions options, IMqttCommunicationAdapter adapter)
+        public MqttClient(IMqttClientAdapterFactory channelFactory, IMqttNetLogger logger)
        {
-            _options = options ?? throw new ArgumentNullException(nameof(options));
-            _adapter = adapter ?? throw new ArgumentNullException(nameof(adapter));
-
-            _adapter.PacketSerializer.ProtocolVersion = options.ProtocolVersion;
+            _adapterFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            
+            _packetDispatcher = new MqttPacketDispatcher(logger);
        }

-        public event EventHandler Connected;
-        public event EventHandler Disconnected;
+        public event EventHandler<MqttClientConnectedEventArgs> Connected;
+        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;

-        public bool IsConnected => _cancellationTokenSource != null && !_cancellationTokenSource.IsCancellationRequested;
+        public bool IsConnected { get; private set; }

-        public async Task ConnectAsync(MqttApplicationMessage willApplicationMessage = null)
+        public async Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options)
        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+            if (options.ChannelOptions == null) throw new ArgumentException("ChannelOptions are not set.");
+
            ThrowIfConnected("It is not allowed to connect with a server after the connection is established.");

            try
            {
+                _options = options;
                _cancellationTokenSource = new CancellationTokenSource();
                _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.");
+                _adapter = _adapterFactory.CreateClientAdapter(options.ChannelOptions, _logger);
+                
+                _logger.Trace<MqttClient>("Trying to connect with server.");
+                await _adapter.ConnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
+                _logger.Trace<MqttClient>("Connection with server established.");

-                StartReceivePackets(_cancellationTokenSource.Token);
+                await StartReceivingPacketsAsync(_cancellationTokenSource.Token).ConfigureAwait(false);
+                var connectResponse = await AuthenticateAsync(options.WillMessage).ConfigureAwait(false);

-                var connectPacket = new MqttConnectPacket
-                {
-                    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);
-                }
-
-                MqttTrace.Verbose(nameof(MqttClient), "MQTT connection with server established.");
+                _logger.Trace<MqttClient>("MQTT connection with server established.");

                if (_options.KeepAlivePeriod != TimeSpan.Zero)
                {
-                    StartSendKeepAliveMessages(_cancellationTokenSource.Token);
+                    StartSendingKeepAliveMessages(_cancellationTokenSource.Token);
                }

-                Connected?.Invoke(this, EventArgs.Empty);
+                IsConnected = true;
+                Connected?.Invoke(this, new MqttClientConnectedEventArgs(connectResponse.IsSessionPresent));
+                return new MqttClientConnectResult(connectResponse.IsSessionPresent);
            }
-            catch (Exception)
+            catch (Exception exception)
            {
+                _logger.Error<MqttClient>(exception, "Error while connecting with server.");
                await DisconnectInternalAsync().ConfigureAwait(false);
                throw;
            }
@@ -135,7 +131,7 @@ namespace MQTTnet.Core.Client
                TopicFilters = topicFilters.ToList()
            };

-            await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket);
+            await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket).ConfigureAwait(false);
        }

        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
@@ -143,31 +139,31 @@ namespace MQTTnet.Core.Client
            ThrowIfNotConnected();

            var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
+            var packetGroups = publishPackets.GroupBy(p => p.QualityOfServiceLevel).OrderBy(g => g.Key); 

-            foreach (var qosGroup in publishPackets.GroupBy(p => p.QualityOfServiceLevel))
+            foreach (var qosGroup in packetGroups)
            {
-                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);
+                            await _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, qosGroup).ConfigureAwait(false);
                            break;
                        }
                    case MqttQualityOfServiceLevel.AtLeastOnce:
                        {
-                            foreach (var publishPacket in qosPackets)
+                            foreach (var publishPacket in qosGroup)
                            {
                                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
-                                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket);
+                                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket).ConfigureAwait(false);
                            }

                            break;
                        }
                    case MqttQualityOfServiceLevel.ExactlyOnce:
                        {
-                            foreach (var publishPacket in qosPackets)
+                            foreach (var publishPacket in qosGroup)
                            {
                                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
                                var pubRecPacket = await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket).ConfigureAwait(false);
@@ -184,6 +180,32 @@ namespace MQTTnet.Core.Client
            }
        }

+        public void Dispose()
+        {
+            _cancellationTokenSource?.Dispose();
+        }
+
+        private async Task<MqttConnAckPacket> AuthenticateAsync(MqttApplicationMessage willApplicationMessage)
+        {
+            var connectPacket = new MqttConnectPacket
+            {
+                ClientId = _options.ClientId,
+                Username = _options.Credentials?.Username,
+                Password = _options.Credentials?.Password,
+                CleanSession = _options.CleanSession,
+                KeepAlivePeriod = (ushort)_options.KeepAlivePeriod.TotalSeconds,
+                WillMessage = willApplicationMessage
+            };
+
+            var response = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket).ConfigureAwait(false);
+            if (response.ConnectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
+            {
+                throw new MqttConnectingFailedException(response.ConnectReturnCode);
+            }
+
+            return response;
+        }
+
        private void ThrowIfNotConnected()
        {
            if (!IsConnected) throw new MqttCommunicationException("The client is not connected.");
@@ -196,6 +218,9 @@ namespace MQTTnet.Core.Client

        private async Task DisconnectInternalAsync()
        {
+            var clientWasConnected = IsConnected;
+            IsConnected = false;
+
            var cts = _cancellationTokenSource;
            if (cts == null || cts.IsCancellationRequested)
            {
@@ -208,16 +233,17 @@ namespace MQTTnet.Core.Client

            try
            {
-                await _adapter.DisconnectAsync(_options.DefaultCommunicationTimeout).ConfigureAwait(false);
-                MqttTrace.Information(nameof(MqttClient), "Disconnected from adapter.");
+                await _adapter.DisconnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
+                _logger.Info<MqttClient>("Disconnected from adapter.");
            }
            catch (Exception exception)
            {
-                MqttTrace.Warning(nameof(MqttClient), exception, "Error while disconnecting from adapter.");
+                _logger.Warning<MqttClient>(exception, "Error while disconnecting from adapter.");
            }
            finally
            {
-                Disconnected?.Invoke(this, EventArgs.Empty);
+                _logger.Info<MqttClient>("Disconnected.");
+                Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected));
            }
        }

@@ -225,29 +251,29 @@ namespace MQTTnet.Core.Client
        {
            try
            {
-                MqttTrace.Information(nameof(MqttClient), "Received <<< {0}", packet);
+                _logger.Info<MqttClient>("Received <<< {0}", packet);
+                
+                if (packet is MqttPublishPacket publishPacket)
+                {
+                    await ProcessReceivedPublishPacketAsync(publishPacket).ConfigureAwait(false);
+                    return;
+                }

                if (packet is MqttPingReqPacket)
                {
-                    await SendAsync(new MqttPingRespPacket());
+                    await SendAsync(new MqttPingRespPacket()).ConfigureAwait(false);
                    return;
                }

                if (packet is MqttDisconnectPacket)
                {
-                    await DisconnectAsync();
-                    return;
-                }
-
-                if (packet is MqttPublishPacket publishPacket)
-                {
-                    await ProcessReceivedPublishPacket(publishPacket);
+                    await DisconnectAsync().ConfigureAwait(false);
                    return;
                }

                if (packet is MqttPubRelPacket pubRelPacket)
                {
-                    await ProcessReceivedPubRelPacket(pubRelPacket);
+                    await ProcessReceivedPubRelPacket(pubRelPacket).ConfigureAwait(false);
                    return;
                }

@@ -255,7 +281,7 @@ namespace MQTTnet.Core.Client
            }
            catch (Exception exception)
            {
-                MqttTrace.Error(nameof(MqttClient), exception, "Unhandled exception while processing received packet.");
+                _logger.Error<MqttClient>(exception, "Unhandled exception while processing received packet.");
            }
        }

@@ -264,40 +290,33 @@ namespace MQTTnet.Core.Client
            try
            {
                var applicationMessage = publishPacket.ToApplicationMessage();
-                ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(applicationMessage));
+                ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(_options.ClientId, applicationMessage));
            }
            catch (Exception exception)
            {
-                MqttTrace.Error(nameof(MqttClient), exception, "Unhandled exception while handling application message.");
+                _logger.Error<MqttClient>(exception, "Unhandled exception while handling application message.");
            }
        }

-        private async Task ProcessReceivedPublishPacket(MqttPublishPacket publishPacket)
+        private Task ProcessReceivedPublishPacketAsync(MqttPublishPacket publishPacket)
        {
            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
            {
                FireApplicationMessageReceivedEvent(publishPacket);
-                return;
+                return Task.FromResult(0);
            }

            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
            {
                FireApplicationMessageReceivedEvent(publishPacket);
-                await SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier });
-                return;
+                return SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier });
            }

            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
            {
                // QoS 2 is implement as method "B" [4.3.3 QoS 2: Exactly once delivery]
-                lock (_unacknowledgedPublishPackets)
-                {
-                    _unacknowledgedPublishPackets.Add(publishPacket.PacketIdentifier);
-                }
-
                FireApplicationMessageReceivedEvent(publishPacket);
-                await SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier });
-                return;
+                return SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier });
            }

            throw new MqttCommunicationException("Received a not supported QoS level.");
@@ -305,24 +324,19 @@ namespace MQTTnet.Core.Client

        private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket)
        {
-            lock (_unacknowledgedPublishPackets)
-            {
-                _unacknowledgedPublishPackets.Remove(pubRelPacket.PacketIdentifier);
-            }
-
            return SendAsync(pubRelPacket.CreateResponse<MqttPubCompPacket>());
        }

        private Task SendAsync(MqttBasePacket packet)
        {
-            return _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, _cancellationTokenSource.Token, packet);
+            return _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, packet);
        }

        private async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket) where TResponsePacket : MqttBasePacket
        {
-            var wait = _packetDispatcher.WaitForPacketAsync(requestPacket, typeof(TResponsePacket), _options.DefaultCommunicationTimeout);
-            await _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, _cancellationTokenSource.Token, requestPacket).ConfigureAwait(false);
-            return (TResponsePacket)await wait.ConfigureAwait(false);
+            var packetAwaiter = _packetDispatcher.WaitForPacketAsync(requestPacket, typeof(TResponsePacket), _options.CommunicationTimeout);
+            await _adapter.SendPacketsAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token, requestPacket).ConfigureAwait(false);
+            return (TResponsePacket)await packetAwaiter.ConfigureAwait(false);
        }

        private ushort GetNewPacketIdentifier()
@@ -332,23 +346,24 @@ namespace MQTTnet.Core.Client

        private async Task SendKeepAliveMessagesAsync(CancellationToken cancellationToken)
        {
-            MqttTrace.Information(nameof(MqttClient), "Start sending keep alive packets.");
+            _logger.Info<MqttClient>("Start sending keep alive packets.");

            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
-                    await Task.Delay(_options.KeepAlivePeriod, cancellationToken).ConfigureAwait(false);
-                    if (cancellationToken.IsCancellationRequested)
-                    {
-                        return;
-                    }
-
                    await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket()).ConfigureAwait(false);
+                    await Task.Delay(_options.KeepAlivePeriod, cancellationToken).ConfigureAwait(false);
                }
            }
-            catch (TaskCanceledException)
+            catch (OperationCanceledException)
            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                await DisconnectInternalAsync().ConfigureAwait(false);
            }
            catch (MqttCommunicationException exception)
            {
@@ -357,29 +372,32 @@ namespace MQTTnet.Core.Client
                    return;
                }

-                MqttTrace.Warning(nameof(MqttClient), exception, "MQTT communication exception while sending/receiving keep alive packets.");
+                _logger.Warning<MqttClient>(exception, "MQTT communication exception while sending/receiving keep alive packets.");
                await DisconnectInternalAsync().ConfigureAwait(false);
            }
            catch (Exception exception)
            {
-                MqttTrace.Warning(nameof(MqttClient), exception, "Unhandled exception while sending/receiving keep alive packets.");
+                _logger.Warning<MqttClient>(exception, "Unhandled exception while sending/receiving keep alive packets.");
                await DisconnectInternalAsync().ConfigureAwait(false);
            }
            finally
            {
-                MqttTrace.Information(nameof(MqttClient), "Stopped sending keep alive packets.");
+                _logger.Info<MqttClient>("Stopped sending keep alive packets.");
            }
        }

-        private async Task ReceivePackets(CancellationToken cancellationToken)
+        private async Task ReceivePacketsAsync(CancellationToken cancellationToken)
        {
-            MqttTrace.Information(nameof(MqttClient), "Start receiving packets.");
+            _logger.Info<MqttClient>("Start receiving packets.");

            try
            {
                while (!cancellationToken.IsCancellationRequested)
                {
+                    _isReceivingPackets = true;
+
                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+
                    if (cancellationToken.IsCancellationRequested)
                    {
                        return;
@@ -388,8 +406,14 @@ namespace MQTTnet.Core.Client
                    StartProcessReceivedPacket(packet, cancellationToken);
                }
            }
-            catch (TaskCanceledException)
+            catch (OperationCanceledException)
            {
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                await DisconnectInternalAsync().ConfigureAwait(false);
            }
            catch (MqttCommunicationException exception)
            {
@@ -398,38 +422,51 @@ namespace MQTTnet.Core.Client
                    return;
                }

-                MqttTrace.Warning(nameof(MqttClient), exception, "MQTT communication exception while receiving packets.");
+                _logger.Warning<MqttClient>(exception, "MQTT communication exception while receiving packets.");
                await DisconnectInternalAsync().ConfigureAwait(false);
            }
            catch (Exception exception)
            {
-                MqttTrace.Error(nameof(MqttClient), exception, "Unhandled exception while receiving packets.");
+                _logger.Error<MqttClient>(exception, "Unhandled exception while receiving packets.");
                await DisconnectInternalAsync().ConfigureAwait(false);
            }
            finally
            {
-                MqttTrace.Information(nameof(MqttClient), "Stopped receiving packets.");
+                _logger.Info<MqttClient>("Stopped receiving packets.");
            }
        }

        private void StartProcessReceivedPacket(MqttBasePacket packet, CancellationToken cancellationToken)
        {
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(async () => await ProcessReceivedPacketAsync(packet), cancellationToken).ConfigureAwait(false);
+            Task.Run(
+                async () => await ProcessReceivedPacketAsync(packet).ConfigureAwait(false),
+                cancellationToken).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }

-        private void StartReceivePackets(CancellationToken cancellationToken)
+        private async Task StartReceivingPacketsAsync(CancellationToken cancellationToken)
        {
+            _isReceivingPackets = false;
+
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(async () => await ReceivePackets(cancellationToken), cancellationToken).ConfigureAwait(false); ;
+            Task.Run(
+                async () => await ReceivePacketsAsync(cancellationToken).ConfigureAwait(false),
+                cancellationToken).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+            while (!_isReceivingPackets && !cancellationToken.IsCancellationRequested)
+            {
+                await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken).ConfigureAwait(false);
+            }
        }

-        private void StartSendKeepAliveMessages(CancellationToken cancellationToken)
+        private void StartSendingKeepAliveMessages(CancellationToken cancellationToken)
        {
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(async () => await SendKeepAliveMessagesAsync(cancellationToken), cancellationToken).ConfigureAwait(false);
+            Task.Run(
+                async () => await SendKeepAliveMessagesAsync(cancellationToken).ConfigureAwait(false), 
+                cancellationToken).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
        }
    }
@@ -0,0 +1,12 @@
+namespace MQTTnet.Client
+{
+    public class MqttClientConnectResult
+    {
+        public MqttClientConnectResult(bool isSessionPresent)
+        {
+            IsSessionPresent = isSessionPresent;
+        }
+
+        public bool IsSessionPresent { get; }
+    }
+}
@@ -0,0 +1,14 @@
+using System;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientConnectedEventArgs : EventArgs
+    {
+        public MqttClientConnectedEventArgs(bool isSessionPresent)
+        {
+            IsSessionPresent = isSessionPresent;
+        }
+
+        public bool IsSessionPresent { get; }
+    }
+}
@@ -0,0 +1,9 @@
+namespace MQTTnet.Client
+{
+    public class MqttClientCredentials : IMqttClientCredentials
+    {
+        public string Username { get; set; }
+
+        public string Password { get; set; }
+    }
+}
@@ -0,0 +1,14 @@
+using System;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientDisconnectedEventArgs : EventArgs
+    {
+        public MqttClientDisconnectedEventArgs(bool clientWasConnected)
+        {
+            ClientWasConnected = clientWasConnected;
+        }
+
+        public bool ClientWasConnected { get; }
+    }
+}
@@ -2,20 +2,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using MQTTnet.Core.Packets;
+using MQTTnet.Protocol;

-namespace MQTTnet.Core.Client
+namespace MQTTnet.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));
@@ -24,6 +16,14 @@ namespace MQTTnet.Core.Client
            return client.SubscribeAsync(topicFilters.ToList());
        }

+        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
+        }
+
        public static Task UnsubscribeAsync(this IMqttClient client, params string[] topicFilters)
        {
            if (client == null) throw new ArgumentNullException(nameof(client));
@@ -0,0 +1,24 @@
+using System;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientOptions : IMqttClientOptions
+    {
+        public MqttApplicationMessage WillMessage { get; set; }
+
+        public string ClientId { get; set; } = Guid.NewGuid().ToString("N");
+
+        public bool CleanSession { get; set; } = true;
+
+        public IMqttClientCredentials Credentials { get; set; } = new MqttClientCredentials();
+
+        public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(5);
+
+        public TimeSpan CommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
+        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
+
+        public IMqttClientChannelOptions ChannelOptions { get; set; }
+    }
+}
@@ -0,0 +1,135 @@
+using System;
+using System.Linq;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientOptionsBuilder
+    {
+        private readonly MqttClientOptions _options = new MqttClientOptions();
+        private MqttClientTcpOptions _tcpOptions;
+        private MqttClientWebSocketOptions _webSocketOptions;
+
+        private MqttClientTlsOptions _tlsOptions;
+
+        public MqttClientOptionsBuilder WithProtocolVersion(MqttProtocolVersion value)
+        {
+            _options.ProtocolVersion = value;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithCommunicationTimeout(TimeSpan value)
+        {
+            _options.CommunicationTimeout = value;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithCleanSession(bool value = true)
+        {
+            _options.CleanSession = value;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithKeepAlivePeriod(TimeSpan value)
+        {
+            _options.KeepAlivePeriod = value;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithClientId(string value)
+        {
+            _options.ClientId = value;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithWillMessage(MqttApplicationMessage value)
+        {
+            _options.WillMessage = value;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithCredentials(string username, string password = null)
+        {
+            _options.Credentials = new MqttClientCredentials
+            {
+                Username = username,
+                Password = password
+            };
+
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithTcpServer(string server, int? port = null)
+        {
+            _tcpOptions = new MqttClientTcpOptions
+            {
+                Server = server,
+                Port = port
+            };
+
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithWebSocketServer(string uri)
+        {
+            _webSocketOptions = new MqttClientWebSocketOptions
+            {
+                Uri = uri
+            };
+
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithTls(
+            bool allowUntrustedCertificates = false,
+            bool ignoreCertificateChainErrors = false,
+            bool ignoreCertificateRevocationErrors = false,
+            params byte[][] certificates)
+        {
+            _tlsOptions = new MqttClientTlsOptions
+            {
+                UseTls = true,
+                AllowUntrustedCertificates = allowUntrustedCertificates,
+                IgnoreCertificateChainErrors = ignoreCertificateChainErrors,
+                IgnoreCertificateRevocationErrors = ignoreCertificateRevocationErrors,
+                Certificates = certificates?.ToList()
+            };
+
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithTls()
+        {
+            _tlsOptions = new MqttClientTlsOptions
+            {
+                UseTls = true
+            };
+
+            return this;
+        }
+
+        public IMqttClientOptions Build()
+        {
+            if (_tlsOptions != null)
+            {
+                if (_tcpOptions == null && _webSocketOptions == null)
+                {
+                    throw new InvalidOperationException("A channel (TCP or WebSocket) must be set if TLS is configured.");
+                }
+
+                if (_tcpOptions != null)
+                {
+                    _tcpOptions.TlsOptions = _tlsOptions;
+                }
+                else if (_webSocketOptions != null)
+                {
+                    _webSocketOptions.TlsOptions = _tlsOptions;
+                }
+            }
+
+            _options.ChannelOptions = (IMqttClientChannelOptions)_tcpOptions ?? _webSocketOptions;
+
+            return _options;
+        }
+    }
+}
@@ -0,0 +1,11 @@
+namespace MQTTnet.Client
+{
+    public class MqttClientTcpOptions : IMqttClientChannelOptions
+    {
+        public string Server { get; set; }
+
+        public int? Port { get; set; }
+
+        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
+    }
+}
@@ -1,10 +1,10 @@
 using System;

-namespace MQTTnet.Core.Client
+namespace MQTTnet.Client
 {
-    public static class MqttClientOptionsExtensions
+    public static class MqttClientTcpOptionsExtensions
    {
-        public static int GetPort(this MqttClientOptions options)
+        public static int GetPort(this MqttClientTcpOptions options)
        {
            if (options == null) throw new ArgumentNullException(nameof(options));

@@ -0,0 +1,17 @@
+using System.Collections.Generic;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientTlsOptions
+    {
+        public bool UseTls { get; set; }
+
+        public bool IgnoreCertificateRevocationErrors { get; set; }
+
+        public bool IgnoreCertificateChainErrors { get; set; }
+
+        public bool AllowUntrustedCertificates { get; set; }
+
+        public List<byte[]> Certificates { get; set; }
+    }
+}
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Net;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientWebSocketOptions : IMqttClientChannelOptions
+    {
+        public string Uri { get; set; }
+
+        public IDictionary<string, string> RequestHeaders { get; set; }
+
+        public ICollection<string> SubProtocols { get; set; }
+
+        public CookieContainer CookieContainer { get; set; }
+
+        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
+    }
+}
@@ -1,17 +1,23 @@
 using System;
-using System.Threading.Tasks;
-using MQTTnet.Core.Diagnostics;
-using MQTTnet.Core.Exceptions;
-using MQTTnet.Core.Internal;
-using MQTTnet.Core.Packets;
 using System.Collections.Concurrent;
+using System.Threading.Tasks;
+using MQTTnet.Diagnostics;
+using MQTTnet.Exceptions;
+using MQTTnet.Internal;
+using MQTTnet.Packets;

-namespace MQTTnet.Core.Client
+namespace MQTTnet.Client
 {
    public class MqttPacketDispatcher
    {
        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>>>();
+        private readonly IMqttNetLogger _logger;
+
+        public MqttPacketDispatcher(IMqttNetLogger logger)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }

        public async Task<MqttBasePacket> WaitForPacketAsync(MqttBasePacket request, Type responseType, TimeSpan timeout)
        {
@@ -20,11 +26,11 @@ namespace MQTTnet.Core.Client
            var packetAwaiter = AddPacketAwaiter(request, responseType);
            try
            {
-                return await packetAwaiter.Task.TimeoutAfter(timeout);
+                return await packetAwaiter.Task.TimeoutAfter(timeout).ConfigureAwait(false);
            }
            catch (MqttCommunicationTimedOutException)
            {
-                MqttTrace.Warning(nameof(MqttPacketDispatcher), "Timeout while waiting for packet of type '{0}'.", responseType.Name);
+                _logger.Warning<MqttPacketDispatcher>("Timeout while waiting for packet of type '{0}'.", responseType.Name);
                throw;
            }
            finally
@@ -67,10 +73,11 @@ namespace MQTTnet.Core.Client
        private TaskCompletionSource<MqttBasePacket> AddPacketAwaiter(MqttBasePacket request, Type responseType)
        {
            var tcs = new TaskCompletionSource<MqttBasePacket>();
-            if (request is IMqttPacketWithIdentifier withIdent)
+
+            if (request is IMqttPacketWithIdentifier requestWithIdentifier)
            {
                var byId = _packetByResponseTypeAndIdentifier.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
-                byId[withIdent.PacketIdentifier] = tcs;
+                byId[requestWithIdentifier.PacketIdentifier] = tcs;
            }
            else
            {
@@ -82,10 +89,10 @@ namespace MQTTnet.Core.Client

        private void RemovePacketAwaiter(MqttBasePacket request, Type responseType)
        {
-            if (request is IMqttPacketWithIdentifier withIdent)
+            if (request is IMqttPacketWithIdentifier requestWithIdentifier)
            {
                var byId = _packetByResponseTypeAndIdentifier.GetOrAdd(responseType, key => new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>());
-                byId.TryRemove(withIdent.PacketIdentifier, out var _);
+                byId.TryRemove(requestWithIdentifier.PacketIdentifier, out var _);
            }
            else
            {
@@ -1,7 +1,6 @@
-using MQTTnet.Core.Packets;
-using MQTTnet.Core.Protocol;
+using MQTTnet.Protocol;

-namespace MQTTnet.Core.Client
+namespace MQTTnet.Client
 {
    public class MqttSubscribeResult
    {
@@ -0,0 +1,21 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public interface IMqttNetLogger
+    {
+        event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
+
+        void Trace<TSource>(string message, params object[] parameters);
+
+        void Info<TSource>(string message, params object[] parameters);
+
+        void Warning<TSource>(Exception exception, string message, params object[] parameters);
+
+        void Warning<TSource>(string message, params object[] parameters);
+
+        void Error<TSource>(Exception exception, string message, params object[] parameters);
+
+        void Error<TSource>(string message, params object[] parameters);
+    }
+}
@@ -0,0 +1,18 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public static class MqttNetGlobalLogger
+    {
+        public static event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
+
+        public static bool HasListeners => LogMessagePublished != null;
+
+        public static void Publish(MqttNetLogMessage logMessage)
+        {
+            if (logMessage == null) throw new ArgumentNullException(nameof(logMessage));
+
+            LogMessagePublished?.Invoke(null, new MqttNetLogMessagePublishedEventArgs(logMessage));
+        }
+    }
+}
@@ -0,0 +1,13 @@
+namespace MQTTnet.Diagnostics
+{
+    public enum MqttNetLogLevel
+    {
+        Verbose,
+
+        Info,
+
+        Warning,
+
+        Error
+    }
+}
@@ -0,0 +1,32 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public sealed class MqttNetLogMessage
+    {
+        public MqttNetLogMessage(string logId, DateTime timestamp, int threadId, string source, MqttNetLogLevel level, string message, Exception exception)
+        {
+            LogId = logId;
+            Timestamp = timestamp;
+            ThreadId = threadId;
+            Source = source;
+            Level = level;
+            Message = message;
+            Exception = exception;
+        }
+
+        public string LogId { get; }
+
+        public DateTime Timestamp { get; }
+
+        public int ThreadId { get; }
+
+        public string Source { get; }
+
+        public MqttNetLogLevel Level { get; }
+
+        public string Message { get; }
+
+        public Exception Exception { get; }
+    }
+}
@@ -0,0 +1,14 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public sealed class MqttNetLogMessagePublishedEventArgs : EventArgs
+    {
+        public MqttNetLogMessagePublishedEventArgs(MqttNetLogMessage logMessage)
+        {
+            TraceMessage = logMessage ?? throw new ArgumentNullException(nameof(logMessage));
+        }
+
+        public MqttNetLogMessage TraceMessage { get; }
+    }
+}
@@ -0,0 +1,74 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public class MqttNetLogger : IMqttNetLogger
+    {
+        private readonly string _logId;
+
+        public MqttNetLogger(string logId = null)
+        {
+            _logId = logId;
+        }
+
+        public event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
+
+        public void Trace<TSource>(string message, params object[] parameters)
+        {
+            Publish<TSource>(MqttNetLogLevel.Verbose, null, message, parameters);
+        }
+
+        public void Info<TSource>(string message, params object[] parameters)
+        {
+            Publish<TSource>(MqttNetLogLevel.Info, null, message, parameters);
+        }
+
+        public void Warning<TSource>(Exception exception, string message, params object[] parameters)
+        {
+            Publish<TSource>(MqttNetLogLevel.Warning, exception, message, parameters);
+        }
+
+        public void Warning<TSource>(string message, params object[] parameters)
+        {
+            Warning<TSource>(null, message, parameters);
+        }
+
+        public void Error<TSource>(Exception exception, string message, params object[] parameters)
+        {
+            Publish<TSource>(MqttNetLogLevel.Error, exception, message, parameters);
+        }
+
+        public void Error<TSource>(string message, params object[] parameters)
+        {
+            Warning<TSource>(null, message, parameters);
+        }
+
+        private void Publish<TSource>(MqttNetLogLevel logLevel, Exception exception, string message, object[] parameters)
+        {
+            var hasLocalListeners = LogMessagePublished != null;
+            var hasGlobalListeners = MqttNetGlobalLogger.HasListeners;
+
+            if (!hasLocalListeners && !hasGlobalListeners)
+            {
+                return;
+            }
+
+            if (parameters.Length > 0)
+            {
+                message = string.Format(message, parameters);
+            }
+
+            var traceMessage = new MqttNetLogMessage(_logId, DateTime.Now, Environment.CurrentManagedThreadId, typeof(TSource).Name, logLevel, message, exception);
+
+            if (hasGlobalListeners)
+            {
+                MqttNetGlobalLogger.Publish(traceMessage);
+            }
+
+            if (hasLocalListeners)
+            {
+                LogMessagePublished?.Invoke(this, new MqttNetLogMessagePublishedEventArgs(traceMessage));
+            }
+        }
+    }
+}
@@ -0,0 +1,23 @@
+namespace MQTTnet.Diagnostics
+{
+    public static class TargetFrameworkInfoProvider
+    {
+        public static string TargetFramework
+        {
+            get
+            {
+#if NET452
+                return "net452";
+#elif NET461
+                return "net461";
+#elif NETSTANDARD1_3
+                return "netstandard1.3";
+#elif NETSTANDARD2_0
+                return "netstandard2.0";
+#elif WINDOWS_UWP
+                return "uap10.0";
+#endif
+            }
+        }
+    }
+}
@@ -1,6 +1,6 @@
 using System;

-namespace MQTTnet.Core.Exceptions
+namespace MQTTnet.Exceptions
 {
    public class MqttCommunicationException : Exception
    {
@@ -17,10 +17,5 @@ namespace MQTTnet.Core.Exceptions
            : base(message)
        {
        }
-
-        public MqttCommunicationException(string message, Exception innerException)
-            : base(message, innerException)
-        {
-        }
    }
 }
@@ -1,4 +1,4 @@
-namespace MQTTnet.Core.Exceptions
+namespace MQTTnet.Exceptions
 {
    public sealed class MqttCommunicationTimedOutException : MqttCommunicationException
    {
@@ -1,6 +1,6 @@
 using System;

-namespace MQTTnet.Core.Exceptions
+namespace MQTTnet.Exceptions
 {
    public sealed class MqttProtocolViolationException : Exception
    {
@@ -0,0 +1,10 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MQTTnet
+{
+    public interface IApplicationMessagePublisher
+    {
+        Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages);
+    }
+}
@@ -0,0 +1,9 @@
+using System;
+
+namespace MQTTnet
+{
+    public interface IApplicationMessageReceiver
+    {
+        event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+    }
+}
@@ -0,0 +1,26 @@
+using System;
+using MQTTnet.Adapter;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttClientAdapterFactory : IMqttClientAdapterFactory
+    {
+        public IMqttChannelAdapter CreateClientAdapter(IMqttClientChannelOptions options, IMqttNetLogger logger)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            switch (options)
+            {
+                case MqttClientTcpOptions tcpOptions:
+                    return new MqttChannelAdapter(new MqttTcpChannel(tcpOptions), new MqttPacketSerializer(), logger);
+                case MqttClientWebSocketOptions webSocketOptions:
+                    return new MqttChannelAdapter(new MqttWebSocketChannel(webSocketOptions), new MqttPacketSerializer(), logger);
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+    }
+}
@@ -0,0 +1,75 @@
+#if WINDOWS_UWP
+using System;
+using System.Threading.Tasks;
+using Windows.Networking.Sockets;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Serializer;
+using MQTTnet.Server;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
+    {
+        private readonly IMqttNetLogger _logger;
+        private StreamSocketListener _defaultEndpointSocket;
+
+        public MqttServerAdapter(IMqttNetLogger logger)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }
+
+        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        public async Task StartAsync(IMqttServerOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            if (_defaultEndpointSocket != null) throw new InvalidOperationException("Server is already started.");
+            
+            if (options.DefaultEndpointOptions.IsEnabled)
+            {
+                _defaultEndpointSocket = new StreamSocketListener();
+                await _defaultEndpointSocket.BindServiceNameAsync(options.GetDefaultEndpointPort().ToString(), SocketProtectionLevel.PlainSocket);
+                _defaultEndpointSocket.ConnectionReceived += AcceptDefaultEndpointConnectionsAsync;
+            }
+
+            if (options.TlsEndpointOptions.IsEnabled)
+            {
+                throw new NotSupportedException("TLS servers are not supported for UWP apps.");
+            }
+        }
+
+        public Task StopAsync()
+        {
+            if (_defaultEndpointSocket != null)
+            {
+                _defaultEndpointSocket.ConnectionReceived -= AcceptDefaultEndpointConnectionsAsync;
+            }
+
+            _defaultEndpointSocket?.Dispose();
+            _defaultEndpointSocket = null;
+
+            return Task.FromResult(0);
+        }
+
+        public void Dispose()
+        {
+            StopAsync();
+        }
+
+        private void AcceptDefaultEndpointConnectionsAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
+        {
+            try
+            {
+                var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(args.Socket), new MqttPacketSerializer(), _logger);
+                ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
+            }
+            catch (Exception exception)
+            {
+                _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
+            }
+        }
+    }
+}
+#endif
@@ -1,4 +1,5 @@
-using System;
+#if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
+using System;
 using System.Net;
 using System.Net.Security;
 using System.Net.Sockets;
@@ -6,39 +7,42 @@ 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;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Serializer;
+using MQTTnet.Server;

 namespace MQTTnet.Implementations
 {
    public class MqttServerAdapter : IMqttServerAdapter, IDisposable
    {
+        private readonly IMqttNetLogger _logger;
+
        private CancellationTokenSource _cancellationTokenSource;
        private Socket _defaultEndpointSocket;
        private Socket _tlsEndpointSocket;
        private X509Certificate2 _tlsCertificate;

-        private bool _isRunning;
-
-        public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
-
-        public void Start(MqttServerOptions options)
+        public MqttServerAdapter(IMqttNetLogger logger)
        {
-            if (_isRunning) throw new InvalidOperationException("Server is already started.");
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+        }

-            _isRunning = true;
+        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        public Task StartAsync(IMqttServerOptions options)
+        {
+            if (_cancellationTokenSource != null) throw new InvalidOperationException("Server is already started.");

            _cancellationTokenSource = new CancellationTokenSource();

            if (options.DefaultEndpointOptions.IsEnabled)
            {
                _defaultEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-                _defaultEndpointSocket.Bind(new IPEndPoint(IPAddress.Any, options.GetDefaultEndpointPort()));
+                _defaultEndpointSocket.Bind(new IPEndPoint(options.DefaultEndpointOptions.BoundIPAddress, options.GetDefaultEndpointPort()));
                _defaultEndpointSocket.Listen(options.ConnectionBacklog);

-                Task.Run(() => AcceptDefaultEndpointConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
+                Task.Run(async () => await AcceptDefaultEndpointConnectionsAsync(_cancellationTokenSource.Token).ConfigureAwait(false), _cancellationTokenSource.Token).ConfigureAwait(false);
            }

            if (options.TlsEndpointOptions.IsEnabled)
@@ -49,19 +53,23 @@ namespace MQTTnet.Implementations
                }

                _tlsCertificate = new X509Certificate2(options.TlsEndpointOptions.Certificate);
+                if (!_tlsCertificate.HasPrivateKey)
+                {
+                    throw new InvalidOperationException("The certificate for TLS encryption must contain the private key.");
+                }

                _tlsEndpointSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
-                _tlsEndpointSocket.Bind(new IPEndPoint(IPAddress.Any, options.GetTlsEndpointPort()));
+                _tlsEndpointSocket.Bind(new IPEndPoint(options.TlsEndpointOptions.BoundIPAddress, options.GetTlsEndpointPort()));
                _tlsEndpointSocket.Listen(options.ConnectionBacklog);

-                Task.Run(() => AcceptTlsEndpointConnectionsAsync(_cancellationTokenSource.Token), _cancellationTokenSource.Token);
+                Task.Run(async () => await AcceptTlsEndpointConnectionsAsync(_cancellationTokenSource.Token).ConfigureAwait(false), _cancellationTokenSource.Token).ConfigureAwait(false);
            }
+
+            return Task.FromResult(0);
        }

-        public void Stop()
+        public Task StopAsync()
        {
-            _isRunning = false;
-
            _cancellationTokenSource?.Cancel(false);
            _cancellationTokenSource?.Dispose();
            _cancellationTokenSource = null;
@@ -69,13 +77,17 @@ namespace MQTTnet.Implementations
            _defaultEndpointSocket?.Dispose();
            _defaultEndpointSocket = null;

+            _tlsCertificate = null;
+            
            _tlsEndpointSocket?.Dispose();
            _tlsEndpointSocket = null;
+
+            return Task.FromResult(0);
        }

        public void Dispose()
        {
-            Stop();
+            StopAsync();
        }

        private async Task AcceptDefaultEndpointConnectionsAsync(CancellationToken cancellationToken)
@@ -84,14 +96,35 @@ namespace MQTTnet.Implementations
            {
                try
                {
+                    //todo: else branch can be used with min dependency NET46
+#if NET452 || NET461
+                    var clientSocket = await Task.Factory.FromAsync(_defaultEndpointSocket.BeginAccept, _defaultEndpointSocket.EndAccept, null).ConfigureAwait(false);
+#else
                    var clientSocket = await _defaultEndpointSocket.AcceptAsync().ConfigureAwait(false);
-                    var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(clientSocket, null), new MqttPacketSerializer());
-                    ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
+#endif
+
+                    var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, null), new MqttPacketSerializer(), _logger);
+                    ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
+                }
+                catch (ObjectDisposedException)
+                {
+                    // It can happen that the listener socket is accessed after the cancellation token is already set and the listener socket is disposed.
+                }
+                catch (SocketException exception)
+                {
+                    if (exception.SocketErrorCode == SocketError.OperationAborted)
+                    {
+                        return;
+                    }
+
+                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
                }
                catch (Exception exception)
                {
-                    MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while accepting connection at default endpoint.");
-
+                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
+                }
+                finally
+                {
                    //excessive CPU consumed if in endless loop of socket errors
                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
                }
@@ -104,22 +137,42 @@ namespace MQTTnet.Implementations
            {
                try
                {
+#if NET452 || NET461
+                    var clientSocket = await Task.Factory.FromAsync(_tlsEndpointSocket.BeginAccept, _tlsEndpointSocket.EndAccept, null).ConfigureAwait(false);
+#else
                    var clientSocket = await _tlsEndpointSocket.AcceptAsync().ConfigureAwait(false);
+#endif

                    var sslStream = new SslStream(new NetworkStream(clientSocket));
                    await sslStream.AuthenticateAsServerAsync(_tlsCertificate, false, SslProtocols.Tls12, false).ConfigureAwait(false);
+                    
+                    var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, sslStream), new MqttPacketSerializer(), _logger);
+                    ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
+                }
+                catch (ObjectDisposedException)
+                {
+                    // It can happen that the listener socket is accessed after the cancellation token is already set and the listener socket is disposed.
+                }
+                catch (SocketException exception)
+                {
+                    if (exception.SocketErrorCode == SocketError.OperationAborted)
+                    {
+                        return;
+                    }

-                    var clientAdapter = new MqttChannelCommunicationAdapter(new MqttTcpChannel(clientSocket, sslStream), new MqttPacketSerializer());
-                    ClientConnected?.Invoke(this, new MqttClientConnectedEventArgs(clientSocket.RemoteEndPoint.ToString(), clientAdapter));
+                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
                }
                catch (Exception exception)
                {
-                    MqttTrace.Error(nameof(MqttServerAdapter), exception, "Error while accepting connection at TLS endpoint.");
-
+                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at TLS endpoint.");
+                }
+                finally
+                {
                    //excessive CPU consumed if in endless loop of socket errors
                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
                }
            }
        }
    }
-}
+}
+#endif
@@ -0,0 +1,133 @@
+#if WINDOWS_UWP
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Threading.Tasks;
+using Windows.Networking;
+using Windows.Networking.Sockets;
+using Windows.Security.Cryptography.Certificates;
+using MQTTnet.Channel;
+using MQTTnet.Client;
+
+namespace MQTTnet.Implementations
+{
+    public sealed class MqttTcpChannel : IMqttChannel, IDisposable
+    {
+        private readonly MqttClientTcpOptions _options;
+        private StreamSocket _socket;
+
+        public MqttTcpChannel(MqttClientTcpOptions options)
+        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public MqttTcpChannel(StreamSocket socket)
+        {
+            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
+
+            CreateStreams();
+        }
+
+        public Stream SendStream { get; private set; }
+        public Stream ReceiveStream { get; private set; }
+
+        public static Func<MqttClientTcpOptions, IEnumerable<ChainValidationResult>> CustomIgnorableServerCertificateErrorsResolver { get; set; }
+
+        public async Task ConnectAsync()
+        {
+            if (_socket == null)
+            {
+                _socket = new StreamSocket();
+            }
+
+            if (!_options.TlsOptions.UseTls)
+            {
+                await _socket.ConnectAsync(new HostName(_options.Server), _options.GetPort().ToString());
+            }
+            else
+            {
+                _socket.Control.ClientCertificate = LoadCertificate(_options);
+
+                foreach (var ignorableChainValidationResult in ResolveIgnorableServerCertificateErrors())
+                {
+                    _socket.Control.IgnorableServerCertificateErrors.Add(ignorableChainValidationResult);
+                }
+
+                await _socket.ConnectAsync(new HostName(_options.Server), _options.GetPort().ToString(), SocketProtectionLevel.Tls12);
+            }
+
+            CreateStreams();
+        }
+
+        public Task DisconnectAsync()
+        {
+            Dispose();
+            return Task.FromResult(0);
+        }
+
+        public void Dispose()
+        {
+            SendStream?.Dispose();
+            SendStream = null;
+
+            ReceiveStream?.Dispose();
+            ReceiveStream = null;
+
+            _socket?.Dispose();
+            _socket = null;
+        }
+
+        private void CreateStreams()
+        {
+            SendStream = _socket.OutputStream.AsStreamForWrite();
+            ReceiveStream = _socket.InputStream.AsStreamForRead();
+        }
+
+        private static Certificate LoadCertificate(MqttClientTcpOptions options)
+        {
+            if (options.TlsOptions.Certificates == null || !options.TlsOptions.Certificates.Any())
+            {
+                return null;
+            }
+
+            if (options.TlsOptions.Certificates.Count > 1)
+            {
+                throw new NotSupportedException("Only one client certificate is supported for UWP.");
+            }
+
+            return new Certificate(options.TlsOptions.Certificates.First().AsBuffer());
+        }
+
+        private IEnumerable<ChainValidationResult> ResolveIgnorableServerCertificateErrors()
+        {
+            if (CustomIgnorableServerCertificateErrorsResolver != null)
+            {
+                return CustomIgnorableServerCertificateErrorsResolver(_options);
+            }
+
+            var result = new List<ChainValidationResult>();
+
+            if (_options.TlsOptions.IgnoreCertificateRevocationErrors)
+            {
+                result.Add(ChainValidationResult.RevocationInformationMissing);
+                //_socket.Control.IgnorableServerCertificateErrors.Add(ChainValidationResult.Revoked); Not supported.
+                result.Add(ChainValidationResult.RevocationFailure);
+            }
+
+            if (_options.TlsOptions.IgnoreCertificateChainErrors)
+            {
+                result.Add(ChainValidationResult.IncompleteChain);
+            }
+
+            if (_options.TlsOptions.AllowUntrustedCertificates)
+            {
+                result.Add(ChainValidationResult.Untrusted);
+            }
+
+            return result;
+        }
+    }
+}
+#endif
@@ -1,25 +1,37 @@
+#if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
 using System;
 using System.Net.Security;
 using System.Net.Sockets;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
-using MQTTnet.Core.Channel;
-using MQTTnet.Core.Client;
 using System.IO;
+using System.Linq;
+using MQTTnet.Channel;
+using MQTTnet.Client;

 namespace MQTTnet.Implementations
 {
-    public sealed class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
+    public sealed class MqttTcpChannel : IMqttChannel, IDisposable
    {
+        private readonly MqttClientTcpOptions _options;
+
+        //todo: this can be used with min dependency NetStandard1.6
+#if NET452 || NET461
+        // ReSharper disable once MemberCanBePrivate.Global
+        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
+        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
+#endif
+
        private Socket _socket;
        private SslStream _sslStream;
-        
+
        /// <summary>
        /// called on client sockets are created in connect
        /// </summary>
-        public MqttTcpChannel()
+        public MqttTcpChannel(MqttClientTcpOptions options)
        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
        }

        /// <summary>
@@ -30,34 +42,36 @@ namespace MQTTnet.Implementations
        {
            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
            _sslStream = sslStream;
-            ReceiveStream = (Stream)sslStream ?? new NetworkStream(socket);
+
+            CreateStreams(socket, sslStream);
        }

-        public Stream SendStream => ReceiveStream;
+        public Stream SendStream { get; private set; }
        public Stream ReceiveStream { get; private set; }
-        public Stream RawReceiveStream => ReceiveStream;
-        
-        public async Task ConnectAsync(MqttClientOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));

+        public static Func<X509Certificate, X509Chain, SslPolicyErrors, MqttClientTcpOptions, bool> CustomCertificateValidationCallback { get; set; }
+
+        public async Task ConnectAsync()
+        {
            if (_socket == null)
            {
                _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
            }

-            await _socket.ConnectAsync(options.Server, options.GetPort()).ConfigureAwait(false);
+            //todo: else brach can be used with min dependency NET46
+#if NET452 || NET461
+            await Task.Factory.FromAsync(_socket.BeginConnect, _socket.EndConnect, _options.Server, _options.GetPort(), null).ConfigureAwait(false);
+#else
+            await _socket.ConnectAsync(_options.Server, _options.GetPort()).ConfigureAwait(false);
+#endif

-            if (options.TlsOptions.UseTls)
+            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);
+                _sslStream = new SslStream(new NetworkStream(_socket, true), false, InternalUserCertificateValidationCallback);
+                await _sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(_options), SslProtocols.Tls12, _options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
            }
+            
+            CreateStreams(_socket, _sslStream);
        }

        public Task DisconnectAsync()
@@ -75,7 +89,38 @@ namespace MQTTnet.Implementations
            _sslStream = null;
        }

-        private static X509CertificateCollection LoadCertificates(MqttClientOptions options)
+        private bool InternalUserCertificateValidationCallback(object sender, X509Certificate x509Certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
+        {
+            if (CustomCertificateValidationCallback != null)
+            {
+                return CustomCertificateValidationCallback(x509Certificate, chain, sslPolicyErrors, _options);
+            }
+
+            if (sslPolicyErrors == SslPolicyErrors.None)
+            {
+                return true;
+            }
+
+            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.RevocationStatusUnknown || c.Status == X509ChainStatusFlags.Revoked || c.Status == X509ChainStatusFlags.RevocationStatusUnknown))
+            {
+                if (!_options.TlsOptions.IgnoreCertificateRevocationErrors)
+                {
+                    return false;
+                }
+            }
+
+            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.PartialChain))
+            {
+                if (!_options.TlsOptions.IgnoreCertificateChainErrors)
+                {
+                    return false;
+                }
+            }
+
+            return _options.TlsOptions.AllowUntrustedCertificates;
+        }
+
+        private static X509CertificateCollection LoadCertificates(MqttClientTcpOptions options)
        {
            var certificates = new X509CertificateCollection();
            if (options.TlsOptions.Certificates == null)
@@ -85,10 +130,26 @@ namespace MQTTnet.Implementations

            foreach (var certificate in options.TlsOptions.Certificates)
            {
-                certificates.Add(new X509Certificate(certificate));
+                certificates.Add(new X509Certificate2(certificate));
            }

            return certificates;
        }
+
+        private void CreateStreams(Socket socket, Stream sslStream)
+        {
+            var stream = sslStream ?? new NetworkStream(socket);
+            
+            //todo: if branch can be used with min dependency NetStandard1.6
+#if NET452 || NET461
+            SendStream = new BufferedStream(stream, BufferSize);
+            ReceiveStream = new BufferedStream(stream, BufferSize);
+#else
+            SendStream = stream;
+            ReceiveStream = stream;
+#endif
+        }
+
    }
-}
+}
+#endif
@@ -1,55 +1,103 @@
-using MQTTnet.Core.Channel;
-using MQTTnet.Core.Client;
-using System;
+using System;
 using System.IO;
 using System.Net.WebSockets;
+using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Channel;
+using MQTTnet.Client;

 namespace MQTTnet.Implementations
 {
-    public sealed class MqttWebSocketChannel : IMqttCommunicationChannel, IDisposable
+    public sealed class MqttWebSocketChannel : IMqttChannel, IDisposable
    {
+        // ReSharper disable once MemberCanBePrivate.Global
+        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
+        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
+
+        private readonly MqttClientWebSocketOptions _options;
        private ClientWebSocket _webSocket;

-        public Stream SendStream => RawReceiveStream;
-        public Stream ReceiveStream => RawReceiveStream;
-        public Stream RawReceiveStream { get; private set; }
-
-        public async Task ConnectAsync(MqttClientOptions options)
+        public MqttWebSocketChannel(MqttClientWebSocketOptions options)
        {
-            var uri = options.Server;
-            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase))
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public Stream SendStream { get; private set; }
+        public Stream ReceiveStream { get; private set; }
+
+        public async Task ConnectAsync()
+        {
+            var uri = _options.Uri;
+            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
            {
-                uri = "ws://" + uri;
+                if (_options.TlsOptions?.UseTls == false)
+                {
+                    uri = "ws://" + uri;
+                }
+                else
+                {
+                    uri = "wss://" + 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);
+            
+            if (_options.RequestHeaders != null)
+            {
+                foreach (var requestHeader in _options.RequestHeaders)
+                {
+                    _webSocket.Options.SetRequestHeader(requestHeader.Key, requestHeader.Value);
+                }    
+            }
+
+            if (_options.SubProtocols != null)
+            {
+                foreach (var subProtocol in _options.SubProtocols)
+                {
+                    _webSocket.Options.AddSubProtocol(subProtocol);
+                }
+            }
+
+            if (_options.CookieContainer != null)
+            {
+                _webSocket.Options.Cookies = _options.CookieContainer;
+            }
+
+            if (_options.TlsOptions?.UseTls == true && _options.TlsOptions?.Certificates != null)
+            {
+                _webSocket.Options.ClientCertificates = new X509CertificateCollection();
+                foreach (var certificate in _options.TlsOptions.Certificates)
+                {
+                    _webSocket.Options.ClientCertificates.Add(new X509Certificate(certificate));
+                }
+            }
+
+            await _webSocket.ConnectAsync(new Uri(uri), CancellationToken.None).ConfigureAwait(false);
+
+            SendStream = new WebSocketStream(_webSocket);
+            ReceiveStream = SendStream;
        }

        public async Task DisconnectAsync()
        {
-            RawReceiveStream = null;
-
            if (_webSocket == null)
            {
                return;
            }

-            await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
+            if (_webSocket.State == WebSocketState.Open || _webSocket.State == WebSocketState.Connecting)
+            {
+                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
+            }
+
+            Dispose();
        }

        public void Dispose()
        {
            _webSocket?.Dispose();
+            _webSocket = null;
        }
    }
 }
@@ -1,18 +1,23 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Exceptions;

 namespace MQTTnet.Implementations
 {
    public class WebSocketStream : Stream
    {
-        private readonly ClientWebSocket _webSocket;
-        
-        public WebSocketStream(ClientWebSocket webSocket)
+        private readonly WebSocket _webSocket;
+        private readonly byte[] _chunkBuffer = new byte[MqttWebSocketChannel.BufferSize];
+        private readonly Queue<byte> _buffer = new Queue<byte>(MqttWebSocketChannel.BufferSize);
+
+        public WebSocketStream(WebSocket webSocket)
        {
-            _webSocket = webSocket;
+            _webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
        }

        public override bool CanRead => true;
@@ -33,27 +38,9 @@ namespace MQTTnet.Implementations
        {
        }

-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        public override Task FlushAsync(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);
+            return Task.FromResult(0);
        }

        public override int Read(byte[] buffer, int offset, int count)
@@ -61,11 +48,58 @@ namespace MQTTnet.Implementations
            return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
        }

+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var bytesRead = 0;
+
+            // Use existing date from buffer.
+            while (count > 0 && _buffer.Any())
+            {
+                buffer[offset++] = _buffer.Dequeue();
+                count--;
+                bytesRead++;
+            }
+
+            if (count == 0)
+            {
+                return bytesRead;
+            }
+            
+            while (_webSocket.State == WebSocketState.Open)
+            {
+                await FetchChunkAsync(cancellationToken);
+
+                while (count > 0 && _buffer.Any())
+                {
+                    buffer[offset++] = _buffer.Dequeue();
+                    count--;
+                    bytesRead++;
+                }
+
+                if (count == 0)
+                {
+                    return bytesRead;
+                }
+            }
+
+            if (_webSocket.State == WebSocketState.Closed)
+            {
+                throw new MqttCommunicationException("WebSocket connection closed.");
+            }
+
+            return bytesRead;
+        }
+
        public override void Write(byte[] buffer, int offset, int count)
        {
            WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
        }

+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _webSocket.SendAsync(new ArraySegment<byte>(buffer, offset, count), WebSocketMessageType.Binary, true, cancellationToken);
+        }
+
        public override long Seek(long offset, SeekOrigin origin)
        {
            throw new NotSupportedException();
@@ -75,5 +109,21 @@ namespace MQTTnet.Implementations
        {
            throw new NotSupportedException();
        }
+
+        private async Task FetchChunkAsync(CancellationToken cancellationToken)
+        {
+            var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(_chunkBuffer, 0, _chunkBuffer.Length), cancellationToken).ConfigureAwait(false);
+
+            for (var i = 0; i < response.Count; i++)
+            {
+                var @byte = _chunkBuffer[i];
+                _buffer.Enqueue(@byte);
+            }
+
+            if (response.MessageType == WebSocketMessageType.Close)
+            {
+                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
+            }
+        }
    }
 }
@@ -1,17 +1,18 @@
-using MQTTnet.Core.Packets;
+using MQTTnet.Packets;

-namespace MQTTnet.Core.Internal
+namespace MQTTnet.Internal
 {
    internal static class MqttApplicationMessageExtensions
    {
        public static MqttApplicationMessage ToApplicationMessage(this MqttPublishPacket publishPacket)
        {
-            return new MqttApplicationMessage(
-                publishPacket.Topic,
-                publishPacket.Payload,
-                publishPacket.QualityOfServiceLevel,
-                publishPacket.Retain
-            );
+            return new MqttApplicationMessage
+            { 
+                Topic = publishPacket.Topic,
+                Payload = publishPacket.Payload,
+                QualityOfServiceLevel = publishPacket.QualityOfServiceLevel,
+                Retain = publishPacket.Retain
+            };
        }

        public static MqttPublishPacket ToPublishPacket(this MqttApplicationMessage applicationMessage)
@@ -1,21 +1,23 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Core.Exceptions;
+using MQTTnet.Exceptions;

-namespace MQTTnet.Core.Internal
+namespace MQTTnet.Internal
 {
    public static class TaskExtensions
    {
        public static async Task TimeoutAfter(this Task task, TimeSpan timeout)
        {
-            using (var cancellationTokenSource = new CancellationTokenSource())
+            if (task == null) throw new ArgumentNullException(nameof(task));
+
+            using (var timeoutCts = new CancellationTokenSource())
            {
                try
                {
-                    var timeoutTask = Task.Delay(timeout, cancellationTokenSource.Token);
+                    var timeoutTask = Task.Delay(timeout, timeoutCts.Token);
                    var finishedTask = await Task.WhenAny(timeoutTask, task).ConfigureAwait(false);
-
+                    
                    if (finishedTask == timeoutTask)
                    {
                        throw new MqttCommunicationTimedOutException();
@@ -33,18 +35,20 @@ namespace MQTTnet.Core.Internal
                }
                finally
                {
-                    cancellationTokenSource.Cancel();
+                    timeoutCts.Cancel();
                }
            }
        }

        public static async Task<TResult> TimeoutAfter<TResult>(this Task<TResult> task, TimeSpan timeout)
        {
-            using (var cancellationTokenSource = new CancellationTokenSource())
+            if (task == null) throw new ArgumentNullException(nameof(task));
+
+            using (var timeoutCts = new CancellationTokenSource())
            {
                try
                {
-                    var timeoutTask = Task.Delay(timeout, cancellationTokenSource.Token);
+                    var timeoutTask = Task.Delay(timeout, timeoutCts.Token);
                    var finishedTask = await Task.WhenAny(timeoutTask, task).ConfigureAwait(false);

                    if (finishedTask == timeoutTask)
@@ -66,7 +70,7 @@ namespace MQTTnet.Core.Internal
                }
                finally
                {
-                    cancellationTokenSource.Cancel();
+                    timeoutCts.Cancel();
                }
            }
        }
@@ -1,32 +1,65 @@
 <Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
-    <TargetFramework>netstandard1.3</TargetFramework>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.3;netstandard2.0</TargetFrameworks>
    <AssemblyName>MQTTnet</AssemblyName>
    <RootNamespace>MQTTnet</RootNamespace>
-    <AssemblyVersion>2.3.0.0</AssemblyVersion>
-    <FileVersion>2.3.0.0</FileVersion>
+    <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
+    <DebugType>Full</DebugType>
+    <AssemblyVersion>0.0.0.0</AssemblyVersion>
+    <FileVersion>0.0.0.0</FileVersion>
    <Version>0.0.0.0</Version>
    <Company />
    <Product />
    <Description />
    <Authors />
    <PackageId />
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>codeSigningKey.pfx</AssemblyOriginatorKeyFile>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)' == 'uap10.0'">
+    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    <NugetTargetMoniker>UAP,Version=v10.0</NugetTargetMoniker>
+    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
+    <TargetPlatformVersion>10.0.16299.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
+    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
+    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
  </PropertyGroup>

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'" />

  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />

-  <ItemGroup>
-    <ProjectReference Include="..\..\MQTTnet.Core\MQTTnet.Core.csproj" />
-  </ItemGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|netstandard1.3|AnyCPU'">
+    <DefineConstants>RELEASE;NETSTANDARD1_3</DefineConstants>
+  </PropertyGroup>

-  <ItemGroup>
-    <PackageReference Include="System.Net.Security" Version="4.3.1" />
+  <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">
+    <PackageReference Include="System.Net.Security" Version="4.3.2" />
    <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
-    <PackageReference Include="System.Threading.Thread" Version="4.3.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='netstandard1.3'">
+    <PackageReference Include="System.Net.Security" Version="4.3.2" />
+    <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
+    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='uap10.0'">
+    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="5.4.1" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net452'">
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net461'">
  </ItemGroup>

 </Project>
@@ -0,0 +1,21 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using MQTTnet.Client;
+
+namespace MQTTnet.ManagedClient
+{
+    public interface IManagedMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher
+    {
+        bool IsConnected { get; }
+
+        event EventHandler<MqttClientConnectedEventArgs> Connected;
+        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
+
+        Task StartAsync(IManagedMqttClientOptions options);
+        Task StopAsync();
+
+        Task SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
+        Task UnsubscribeAsync(IEnumerable<string> topics);
+    }
+}
@@ -0,0 +1,14 @@
+using System;
+using MQTTnet.Client;
+
+namespace MQTTnet.ManagedClient
+{
+    public interface IManagedMqttClientOptions
+    {
+        IMqttClientOptions ClientOptions { get; }
+
+        TimeSpan AutoReconnectDelay { get; }
+
+        IManagedMqttClientStorage Storage { get; }
+    }
+}
@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MQTTnet.ManagedClient
+{
+    public interface IManagedMqttClientStorage
+    {
+        Task SaveQueuedMessagesAsync(IList<MqttApplicationMessage> messages);
+
+        Task<IList<MqttApplicationMessage>> LoadQueuedMessagesAsync();
+    }
+}
@@ -0,0 +1,367 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
+using MQTTnet.Exceptions;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.ManagedClient
+{
+    public class ManagedMqttClient : IManagedMqttClient, IDisposable
+    {
+        private readonly BlockingCollection<MqttApplicationMessage> _messageQueue = new BlockingCollection<MqttApplicationMessage>();
+        private readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
+        private readonly SemaphoreSlim _subscriptionsSemaphore = new SemaphoreSlim(1, 1);
+
+        private readonly IMqttClient _mqttClient;
+        private readonly IMqttNetLogger _logger;
+
+        private CancellationTokenSource _connectionCancellationToken;
+        private CancellationTokenSource _publishingCancellationToken;
+
+        private ManagedMqttClientStorageManager _storageManager;
+        private IManagedMqttClientOptions _options;
+
+        private bool _subscriptionsNotPushed;
+        
+        public ManagedMqttClient(IMqttClient mqttClient, IMqttNetLogger logger)
+        {
+            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+
+            _mqttClient.Connected += OnConnected;
+            _mqttClient.Disconnected += OnDisconnected;
+            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
+        }
+
+        public bool IsConnected => _mqttClient.IsConnected;
+
+        public event EventHandler<MqttClientConnectedEventArgs> Connected;
+        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
+        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+
+        public async Task StartAsync(IManagedMqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+            if (options.ClientOptions == null) throw new ArgumentException("The client options are not set.", nameof(options));
+
+            if (!options.ClientOptions.CleanSession)
+            {
+                throw new NotSupportedException("The managed client does not support existing sessions.");
+            }
+
+            if (_connectionCancellationToken != null) throw new InvalidOperationException("The managed client is already started.");
+
+            _options = options;
+            
+            if (_options.Storage != null)
+            {
+                _storageManager = new ManagedMqttClientStorageManager(_options.Storage);
+                await _storageManager.LoadQueuedMessagesAsync().ConfigureAwait(false);
+            }
+
+            _connectionCancellationToken = new CancellationTokenSource();
+            
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Task.Run(async () => await MaintainConnectionAsync(_connectionCancellationToken.Token), _connectionCancellationToken.Token).ConfigureAwait(false);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+            _logger.Info<ManagedMqttClient>("Started");
+        }
+
+        public Task StopAsync()
+        {
+            StopPublishing();
+            StopMaintainingConnection();
+
+            while (_messageQueue.Any())
+            {
+                _messageQueue.Take();
+            }
+
+            return Task.FromResult(0);
+        }
+        
+        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
+        {
+            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
+
+            foreach (var applicationMessage in applicationMessages)
+            {
+                if (_storageManager != null)
+                {
+                    await _storageManager.AddAsync(applicationMessage).ConfigureAwait(false);
+                }
+                
+                _messageQueue.Add(applicationMessage);
+            }
+        }
+
+        public async Task SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
+        {
+            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
+
+            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                foreach (var topicFilter in topicFilters)
+                {
+                    _subscriptions[topicFilter.Topic] = topicFilter.QualityOfServiceLevel;
+                    _subscriptionsNotPushed = true;
+                }
+            }
+            finally
+            {
+                _subscriptionsSemaphore.Release();
+            }
+        }
+
+        public async Task UnsubscribeAsync(IEnumerable<string> topics)
+        {
+            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                foreach (var topic in topics)
+                {
+                    if (_subscriptions.Remove(topic))
+                    {
+                        _subscriptionsNotPushed = true;
+                    }
+                }
+            }
+            finally
+            {
+                _subscriptionsSemaphore.Release();
+            }
+        }
+
+        public void Dispose()
+        {
+            _messageQueue?.Dispose();
+            _subscriptionsSemaphore?.Dispose();
+            _connectionCancellationToken?.Dispose();
+            _publishingCancellationToken?.Dispose();
+        }
+
+        private async Task MaintainConnectionAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    await TryMaintainConnectionAsync(cancellationToken);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (Exception exception)
+            {
+                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while maintaining connection.");
+            }
+            finally
+            {
+                await _mqttClient.DisconnectAsync().ConfigureAwait(false);
+                _logger.Info<ManagedMqttClient>("Stopped");
+            }
+        }
+
+        private async Task TryMaintainConnectionAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                var connectionState = await ReconnectIfRequiredAsync().ConfigureAwait(false);
+                if (connectionState == ReconnectionResult.NotConnected)
+                {
+                    StopPublishing();
+                    await Task.Delay(_options.AutoReconnectDelay, cancellationToken).ConfigureAwait(false);
+                    return;
+                }
+
+                if (connectionState == ReconnectionResult.Reconnected || _subscriptionsNotPushed)
+                {
+                    await PushSubscriptionsAsync().ConfigureAwait(false);
+
+                    StartPublishing();
+
+                    
+                    return;
+                }
+
+                if (connectionState == ReconnectionResult.StillConnected)
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (MqttCommunicationException exception)
+            {
+                _logger.Warning<ManagedMqttClient>(exception, "Communication exception while maintaining connection.");
+            }
+            catch (Exception exception)
+            {
+                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while maintaining connection.");
+            }
+        }
+        
+        private async Task PublishQueuedMessagesAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    var message = _messageQueue.Take(cancellationToken);
+                    if (message == null)
+                    {
+                        continue;
+                    }
+
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        continue;
+                    }
+
+                    await TryPublishQueuedMessageAsync(message).ConfigureAwait(false);                 
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (Exception exception)
+            {
+                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while publishing queued application messages.");
+            }
+            finally
+            {
+                _logger.Trace<ManagedMqttClient>("Stopped publishing messages.");
+            }
+        }
+
+        private async Task TryPublishQueuedMessageAsync(MqttApplicationMessage message)
+        {
+            try
+            {
+                await _mqttClient.PublishAsync(message).ConfigureAwait(false);
+
+                if (_storageManager != null)
+                {
+                    await _storageManager.RemoveAsync(message).ConfigureAwait(false);
+                }
+            }
+            catch (MqttCommunicationException exception)
+            {
+                _logger.Warning<ManagedMqttClient>(exception, "Publishing application message failed.");
+
+                if (message.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
+                {
+                    _messageQueue.Add(message);
+                }
+            }
+            catch (Exception exception)
+            {
+                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while publishing queued application message.");
+            }
+        }
+
+        private async Task PushSubscriptionsAsync()
+        {
+            _logger.Info<ManagedMqttClient>(nameof(ManagedMqttClient), "Synchronizing subscriptions");
+
+            List<TopicFilter> subscriptions;
+            await _subscriptionsSemaphore.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                subscriptions = _subscriptions.Select(i => new TopicFilter(i.Key, i.Value)).ToList();
+                _subscriptionsNotPushed = false;
+            }
+            finally
+            {
+                _subscriptionsSemaphore.Release();
+            }
+
+            if (!subscriptions.Any())
+            {
+                return;
+            }
+
+            try
+            {
+                await _mqttClient.SubscribeAsync(subscriptions).ConfigureAwait(false);
+            }
+            catch (Exception exception)
+            {
+                _logger.Warning<ManagedMqttClient>(exception, "Synchronizing subscriptions failed");
+                _subscriptionsNotPushed = true;
+            }
+        }
+
+        private async Task<ReconnectionResult> ReconnectIfRequiredAsync()
+        {
+            if (_mqttClient.IsConnected)
+            {
+                return ReconnectionResult.StillConnected;
+            }
+
+            try
+            {
+                await _mqttClient.ConnectAsync(_options.ClientOptions).ConfigureAwait(false);
+                return ReconnectionResult.Reconnected;
+            }
+            catch (Exception)
+            {
+                return ReconnectionResult.NotConnected;
+            }
+        }
+
+        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
+        {
+            ApplicationMessageReceived?.Invoke(this, eventArgs);
+        }
+
+        private void OnDisconnected(object sender, MqttClientDisconnectedEventArgs eventArgs)
+        {
+            Disconnected?.Invoke(this, eventArgs);
+        }
+
+        private void OnConnected(object sender, MqttClientConnectedEventArgs eventArgs)
+        {
+            Connected?.Invoke(this, eventArgs);
+        }
+
+        private void StartPublishing()
+        {
+            if (_publishingCancellationToken != null)
+            {
+                StopPublishing();
+            }
+
+            var cts = new CancellationTokenSource();
+
+            _publishingCancellationToken = cts;
+
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Task.Run(async () => await PublishQueuedMessagesAsync(cts.Token).ConfigureAwait(false), cts.Token).ConfigureAwait(false);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+        }
+
+        private void StopPublishing()
+        {
+            _publishingCancellationToken?.Cancel(false);
+            _publishingCancellationToken?.Dispose();
+            _publishingCancellationToken = null;
+        }
+
+        private void StopMaintainingConnection()
+        {
+            _connectionCancellationToken?.Cancel(false);
+            _connectionCancellationToken?.Dispose();
+            _connectionCancellationToken = null;
+        }
+    }
+}
@@ -0,0 +1,31 @@
+using System;
+using System.Threading.Tasks;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.ManagedClient
+{
+    public static class ManagedMqttClientExtensions
+    {
+        public static Task SubscribeAsync(this IManagedMqttClient managedClient, params TopicFilter[] topicFilters)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+
+            return managedClient.SubscribeAsync(topicFilters);
+        }
+
+        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
+        }
+
+        public static Task UnsubscribeAsync(this IManagedMqttClient managedClient, params string[] topicFilters)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+
+            return managedClient.UnsubscribeAsync(topicFilters);
+        }
+    }
+}
@@ -0,0 +1,14 @@
+using System;
+using MQTTnet.Client;
+
+namespace MQTTnet.ManagedClient
+{
+    public class ManagedMqttClientOptions : IManagedMqttClientOptions
+    {
+        public IMqttClientOptions ClientOptions { get; set; }
+
+        public TimeSpan AutoReconnectDelay { get; set; } = TimeSpan.FromSeconds(5);
+
+        public IManagedMqttClientStorage Storage { get; set; }
+    }
+}
@@ -0,0 +1,49 @@
+using System;
+using MQTTnet.Client;
+
+namespace MQTTnet.ManagedClient
+{
+    public class ManagedMqttClientOptionsBuilder
+    {
+        private readonly ManagedMqttClientOptions _options = new ManagedMqttClientOptions();
+
+        public ManagedMqttClientOptionsBuilder WithAutoReconnectDelay(TimeSpan value)
+        {
+            _options.AutoReconnectDelay = value;
+            return this;
+        }
+
+        public ManagedMqttClientOptionsBuilder WithStorage(IManagedMqttClientStorage value)
+        {
+            _options.Storage = value;
+            return this;
+        }
+
+        public ManagedMqttClientOptionsBuilder WithClientOptions(IMqttClientOptions value)
+        {
+            _options.ClientOptions = value ?? throw new ArgumentNullException(nameof(value));
+            return this;
+        }
+
+        public ManagedMqttClientOptionsBuilder WithClientOptions(Action<MqttClientOptionsBuilder> options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            var builder = new MqttClientOptionsBuilder();
+            options(builder);
+            _options.ClientOptions = builder.Build();
+
+            return this;
+        }
+
+        public ManagedMqttClientOptions Build()
+        {
+            if (_options.ClientOptions == null)
+            {
+                throw new InvalidOperationException("The ClientOptions cannot be null.");
+            }
+
+            return _options;
+        }
+    }
+}
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.ManagedClient
+{
+    public class ManagedMqttClientStorageManager
+    {
+        private readonly List<MqttApplicationMessage> _applicationMessages = new List<MqttApplicationMessage>();
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
+        private readonly IManagedMqttClientStorage _storage;
+
+        public ManagedMqttClientStorageManager(IManagedMqttClientStorage storage)
+        {
+            _storage = storage ?? throw new ArgumentNullException(nameof(storage));
+        }
+
+        public async Task LoadQueuedMessagesAsync()
+        {
+            var loadedMessages = await _storage.LoadQueuedMessagesAsync().ConfigureAwait(false);
+            foreach (var loadedMessage in loadedMessages)
+            {
+                _applicationMessages.Add(loadedMessage);
+            }
+        }
+
+        public async Task AddAsync(MqttApplicationMessage applicationMessage)
+        {
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                _applicationMessages.Add(applicationMessage);
+                await SaveAsync().ConfigureAwait(false);
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        public async Task RemoveAsync(MqttApplicationMessage applicationMessage)
+        {
+            await _semaphore.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                var index = _applicationMessages.IndexOf(applicationMessage);
+                if (index == -1)
+                {
+                    return;
+                }
+
+                _applicationMessages.RemoveAt(index);
+                await SaveAsync().ConfigureAwait(false);
+            }
+            finally
+            {
+                _semaphore.Release();
+            }
+        }
+
+        private Task SaveAsync()
+        {
+            return _storage.SaveQueuedMessagesAsync(_applicationMessages);
+        }
+    }
+}
@@ -0,0 +1,9 @@
+namespace MQTTnet.ManagedClient
+{
+    public enum ReconnectionResult
+    {
+        StillConnected,
+        Reconnected,
+        NotConnected
+    }
+}
@@ -1,10 +1,15 @@
 using System;
-using MQTTnet.Core.Protocol;
+using MQTTnet.Protocol;

-namespace MQTTnet.Core
+namespace MQTTnet
 {
    public sealed class MqttApplicationMessage
    {
+        public MqttApplicationMessage()
+        {
+        }
+
+        [Obsolete("Use object initializer or _MqttApplicationMessageBuilder_ instead.")]
        public MqttApplicationMessage(string topic, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, bool retain)
        {
            Topic = topic ?? throw new ArgumentNullException(nameof(topic));
@@ -13,12 +18,12 @@ namespace MQTTnet.Core
            Retain = retain;
        }

-        public string Topic { get; }
+        public string Topic { get; set; }

-        public byte[] Payload { get; }
+        public byte[] Payload { get; set; }

-        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; }
+        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }

-        public bool Retain { get; }
+        public bool Retain { get; set; }
    }
 }
@@ -0,0 +1,114 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using MQTTnet.Exceptions;
+using MQTTnet.Protocol;
+
+namespace MQTTnet
+{
+    public class MqttApplicationMessageBuilder
+    {
+        private MqttQualityOfServiceLevel _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce;
+        private string _topic;
+        private byte[] _payload;
+        private bool _retain;
+
+        public MqttApplicationMessageBuilder WithTopic(string topic)
+        {
+            _topic = topic;
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithPayload(IEnumerable<byte> payload)
+        {
+            if (payload == null)
+            {
+                _payload = null;
+                return this;
+            }
+
+            _payload = payload.ToArray();
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithPayload(MemoryStream payload)
+        {
+            if (payload == null)
+            {
+                _payload = null;
+                return this;
+            }
+
+            if (payload.Length == 0)
+            {
+                _payload = new byte[0];
+            }
+            else
+            {
+                _payload = new byte[payload.Length - payload.Position];
+                payload.Read(_payload, 0, _payload.Length);
+            }
+
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithPayload(string payload)
+        {
+            if (payload == null)
+            {
+                _payload = null;
+                return this;
+            }
+
+            _payload = string.IsNullOrEmpty(payload) ? new byte[0] : Encoding.UTF8.GetBytes(payload);
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithQualityOfServiceLevel(MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            _qualityOfServiceLevel = qualityOfServiceLevel;
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithRetainFlag(bool value = true)
+        {
+            _retain = value;
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithAtLeastOnceQoS()
+        {
+            _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtLeastOnce;
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithAtMostOnceQoS()
+        {
+            _qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce;
+            return this;
+        }
+
+        public MqttApplicationMessageBuilder WithExactlyOnceQoS()
+        {
+            _qualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce;
+            return this;
+        }
+
+        public MqttApplicationMessage Build()
+        {
+            if (string.IsNullOrEmpty(_topic))
+            {
+                throw new MqttProtocolViolationException("Topic is not set.");
+            }
+
+            return new MqttApplicationMessage
+            {
+                Topic = _topic,
+                Payload = _payload ?? new byte[0],
+                QualityOfServiceLevel = _qualityOfServiceLevel,
+                Retain = _retain
+            };
+        }
+    }
+}
@@ -1,6 +1,6 @@
 using System;

-namespace MQTTnet.Core.Server
+namespace MQTTnet
 {
    public sealed class MqttApplicationMessageReceivedEventArgs : EventArgs
    {
@@ -1,33 +0,0 @@
-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();
-            }
-        }
-    }
-}
@@ -0,0 +1,52 @@
+using System;
+using System.Collections.Generic;
+using MQTTnet.Adapter;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
+using MQTTnet.Implementations;
+using MQTTnet.ManagedClient;
+using MQTTnet.Server;
+
+namespace MQTTnet
+{
+    public class MqttFactory : IMqttClientFactory, IMqttServerFactory
+    {
+        public IMqttClient CreateMqttClient()
+        {
+            return CreateMqttClient(new MqttNetLogger());
+        }
+
+        public IMqttClient CreateMqttClient(IMqttNetLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            return new MqttClient(new MqttClientAdapterFactory(), logger);
+        }
+
+        public IManagedMqttClient CreateManagedMqttClient()
+        {
+            return new ManagedMqttClient(CreateMqttClient(), new MqttNetLogger());
+        }
+
+        public IManagedMqttClient CreateManagedMqttClient(IMqttNetLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            return new ManagedMqttClient(CreateMqttClient(), logger);
+        }
+
+        public IMqttServer CreateMqttServer()
+        {
+            var logger = new MqttNetLogger();
+            return CreateMqttServer(new List<IMqttServerAdapter> { new MqttServerAdapter(logger) }, logger);
+        }
+
+        public IMqttServer CreateMqttServer(IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
+        {
+            if (adapters == null) throw new ArgumentNullException(nameof(adapters));
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            return new MqttServer(adapters, logger);
+        }
+    }
+}
@@ -1,18 +0,0 @@
-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() });
-        }
-    }
-}
@@ -1,4 +1,4 @@
-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public interface IMqttPacketWithIdentifier
    {
@@ -1,4 +1,4 @@
-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public abstract class MqttBasePacket
    {
@@ -1,4 +1,4 @@
-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public class MqttBasePublishPacket : MqttBasePacket, IMqttPacketWithIdentifier
    {
@@ -1,6 +1,6 @@
-using MQTTnet.Core.Protocol;
+using MQTTnet.Protocol;

-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public sealed class MqttConnAckPacket : MqttBasePacket
    {
@@ -10,7 +10,7 @@ namespace MQTTnet.Core.Packets

        public override string ToString()
        {
-            return nameof(MqttConnAckPacket) + ": [ConnectReturnCode=" + ConnectReturnCode + "] [IsSessionPresent=" + IsSessionPresent + "]";
+            return "ConnAck: [ConnectReturnCode=" + ConnectReturnCode + "] [IsSessionPresent=" + IsSessionPresent + "]";
        }
    }
 }
@@ -1,6 +1,6 @@
-using MQTTnet.Core.Serializer;
+using MQTTnet.Serializer;

-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public sealed class MqttConnectPacket : MqttBasePacket
    {
@@ -20,7 +20,7 @@ namespace MQTTnet.Core.Packets

        public override string ToString()
        {
-            return nameof(MqttConnectPacket) + ": [ClientId=" + ClientId + "] [Username=" + Username + "] [Password=" + Password + "] [KeepAlivePeriod=" + KeepAlivePeriod + "] [CleanSession=" + CleanSession + "]";
+            return "Connect: [ClientId=" + ClientId + "] [Username=" + Username + "] [Password=" + Password + "] [KeepAlivePeriod=" + KeepAlivePeriod + "] [CleanSession=" + CleanSession + "]";
        }
    }
 }
@@ -0,0 +1,10 @@
+namespace MQTTnet.Packets
+{
+    public sealed class MqttDisconnectPacket : MqttBasePacket
+    {
+        public override string ToString()
+        {
+            return "Disconnect";
+        }
+    }
+}
@@ -1,6 +1,6 @@
 using System;

-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public static class MqttPacketExtensions
    {
@@ -12,8 +12,7 @@ namespace MQTTnet.Core.Packets

            if (responsePacket is IMqttPacketWithIdentifier responsePacketWithIdentifier)
            {
-                var requestPacketWithIdentifier = packet as IMqttPacketWithIdentifier;
-                if (requestPacketWithIdentifier == null)
+                if (!(packet is IMqttPacketWithIdentifier requestPacketWithIdentifier))
                {
                    throw new InvalidOperationException("Response packet has PacketIdentifier but request packet does not.");
                }
@@ -1,6 +1,6 @@
-using MQTTnet.Core.Protocol;
+using MQTTnet.Protocol;

-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public class MqttPacketHeader
    {
@@ -1,10 +1,10 @@
-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public sealed class MqttPingReqPacket : MqttBasePacket
    {
        public override string ToString()
        {
-            return nameof(MqttPingReqPacket);
+            return "PingReq";
        }
    }
 }
@@ -1,10 +1,10 @@
-namespace MQTTnet.Core.Packets
+namespace MQTTnet.Packets
 {
    public sealed class MqttPingRespPacket : MqttBasePacket
    {
        public override string ToString()
        {
-            return nameof(MqttPingRespPacket);
+            return "PingResp";
        }
    }
 }
@@ -0,0 +1,10 @@
+namespace MQTTnet.Packets
+{
+    public sealed class MqttPubAckPacket : MqttBasePublishPacket
+    {
+        public override string ToString()
+        {
+            return "PubAck";
+        }
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Christian Kratky	312773d054	Add password protected code signing certificate to enable build process.	2017-12-22 12:02:25 +01:00
Christian Kratky	1ee48a978f	Merge develop	2017-12-18 14:17:31 +01:00
Christian Kratky	5ddb6b77e2	Update documentation	2017-12-14 13:24:50 +01:00
Christian Kratky	e0284886b5	Added the bound IP address to the server options.	2017-12-14 13:23:12 +01:00
Christian Kratky	44c07c2034	Fix broken ASP.NET Core integration.	2017-12-14 13:12:18 +01:00
Christian Kratky	f6b38081fc	Update documents.	2017-12-12 14:30:28 +01:00
Christian	c570509628	Merge pull request #139 from FourOnes/develop fixed: Compile Source Code Occur Errors On Mac Machine	2017-12-12 14:27:04 +01:00
limingru	e98ff1d6d6	uncomment code	2017-12-12 17:26:16 +08:00
limingru	0f54663789	fixed: Compile Source Code Occur Errors On Mac Machine	2017-12-12 17:21:22 +08:00
Christian Kratky	f91d935708	Add the ClientId to the application message interceptor.	2017-12-11 17:10:27 +01:00
Christian Kratky	fb8b60fccc	Add overload for subscribing.	2017-12-08 21:12:05 +01:00
Christian Kratky	ad8506cc30	Update documents	2017-12-07 20:41:44 +01:00
Christian Kratky	d6f88acb8d	Merge branch 'develop' of https://github.com/chkr1011/MQTTnet into develop	2017-12-07 20:37:49 +01:00
Christian Kratky	333fc4c387	Fixed an TLS issue in the MqttClientOptionsBuilder; Fix a subscription issue in the managed client.	2017-12-07 20:35:29 +01:00
Christian	5f9214e9a2	Merge pull request #134 from cvellan/patch-3 Serialized certificates loaded as X509Certificate2	2017-12-05 13:18:16 +01:00
cvellan	f974dcb647	Serialized certificates loaded as X509Certificate2 Instances of X509Certificate2 passed into an MqttClientOptionsBuilder lose data and functionality by being loaded as an X509Certificate.	2017-12-05 10:13:07 +11:00
Christian Kratky	2cb1c544f5	Add extension method for subscriptions	2017-12-04 22:40:44 +01:00
Christian Kratky	644e948489	Fix keep alive checks in server	2017-12-04 13:52:14 +01:00
Christian Kratky	d12d2648b7	Add extension for RPC calls; replace locks; Refactored storage in Managed Client	2017-12-04 10:21:37 +01:00
Christian Kratky	0ee3c8e135	Add statistics of last sent packets to the _ConnectedClient_.	2017-11-28 21:19:30 +01:00
Christian Kratky	bc959a8c3d	Performance optimizations	2017-11-27 00:25:45 +01:00
Christian Kratky	69781d822a	Update docs, fix managed client connection issue	2017-11-26 22:57:56 +01:00
Christian Kratky	611fabcd01	Performance optimizations	2017-11-25 23:10:48 +01:00
Christian Kratky	24ab285066	Update project settings	2017-11-25 20:33:04 +01:00
Christian Kratky	ee6ec14bf8	Add interface for server options. Add context class for connection validator (hide internal packets).	2017-11-25 20:12:50 +01:00
Christian Kratky	f9d67e2cd2	Merge proces, enable signing of the assembly.	2017-11-25 19:55:26 +01:00
Christian	a72516fdcc	Update README.md	2017-11-25 19:50:31 +01:00
Christian Kratky	ebfc6aab6b	Fix nuget spec	2017-11-25 16:20:07 +01:00
Christian Kratky	9c20edd3d0	Update documents	2017-11-25 16:17:44 +01:00
Christian Kratky	b02b0ccd7c	Refactor some names.	2017-11-23 22:50:26 +01:00
Christian Kratky	1bcf7ec29c	Fix ASP.NET Core breaking changes	2017-11-23 22:34:16 +01:00
Christian Kratky	e54b4f58df	Update version info. Fix typo. Add MqttServerOptionsBuilder.	2017-11-23 22:26:22 +01:00
Christian Kratky	30540729df	Merge branch 'master' into develop	2017-11-22 22:31:02 +01:00
Christian Kratky	77b80dc53e	Removed 3rd-Party libraries.	2017-11-22 22:30:55 +01:00
Christian Kratky	861d3dfa0f	Fix version info	2017-11-21 21:00:48 +01:00
Christian Kratky	e0235aedff	Refactor trace messages	2017-11-21 20:55:57 +01:00
Christian Kratky	8411382c42	Update build script	2017-11-17 21:29:37 +01:00
Christian Kratky	f8078a6894	Update version info	2017-11-17 21:26:43 +01:00
Christian Kratky	f66e8c8b3a	Merge branch 'master' of https://github.com/chkr1011/MQTTnet	2017-11-17 21:16:19 +01:00
Christian Kratky	acc269e702	Fixed WebSocket client stream	2017-11-17 21:13:01 +01:00
Christian Kratky	5bcda12ca9	Fix QoS handling in server	2017-11-16 14:17:58 +01:00
Christian Kratky	8de87c8772	Wrap COM exceptions, close client connection when server stops, process retained messages from server	2017-11-16 00:28:56 +01:00
Christian Kratky	b956623234	Merge branch 'develop' of https://github.com/chkr1011/MQTTnet into develop	2017-11-15 20:59:10 +01:00
Christian Kratky	6e615f85eb	Update docs	2017-11-15 20:59:03 +01:00
Christian	b70b469201	Merge pull request #107 from 1iveowl/master Reference to MQTT Tester - updated	2017-11-15 12:37:57 +01:00
1iveowl	c4b706f8ad	Reference to MQTT Tester	2017-11-12 23:19:37 +01:00
1iveowl	9d971003d5	Reference to MQTT Tester	2017-11-12 23:17:26 +01:00
1iveowl	c322817cb1	Reference to MQTT Tester	2017-11-12 23:16:54 +01:00
1iveowl	0c4c93784d	Reference to MQTT Tester	2017-11-12 22:59:06 +01:00
Christian	4cae09a4e9	Merge pull request #104 from JanEggers/fixedWebsocketSubprotocolNegotiation fixed websocket subprotocol negotiation	2017-11-12 19:00:38 +01:00
JanEggers	c775867db4	merged if statements	2017-11-12 16:58:13 +01:00
JanEggers	8672fb2792	fixed websocket subprotocol negotiation	2017-11-12 16:46:32 +01:00
Christian	48c47c6fcf	Merge pull request #102 from JanEggers/targetframeworkfix added net461 build	2017-11-12 14:58:25 +01:00
JanEggers	38904a6213	removed testapp again	2017-11-12 14:13:39 +01:00
JanEggers	bdadfa1c26	added net461 build	2017-11-12 14:07:33 +01:00
Christian	e38142399e	Merge pull request #101 from JanEggers/targetframeworkfix Targetframeworkfix	2017-11-12 12:55:14 +01:00
JanEggers	5cbbfedcce	added testproject for importing mqtt nugets and verify bin folder	2017-11-12 12:33:56 +01:00
JanEggers	bc97575760	downgrade dependencies to be netstandard 1.3 compliant and remove net461 shim requirement	2017-11-12 12:28:55 +01:00
JanEggers	afd56a7f6f	added indication of what Mqtt TargetFramework is used	2017-11-12 09:22:17 +01:00
Christian Kratky	0844abd7e5	Fix wrong version in nuget	2017-11-11 13:23:11 +01:00
Christian Kratky	3625363fcf	Fix references. Fix certificate handing issue	2017-11-11 13:17:54 +01:00
Christian	9692ae5617	Merge pull request #94 from JanEggers/develop Develop	2017-11-09 13:27:05 +01:00
Christian Kratky	c01edb192f	Refactoring	2017-11-09 13:26:03 +01:00
Jan Eggers	acbf9153f4	fixed the other timing issue	2017-11-09 11:06:50 +01:00
Jan Eggers	b6cd4638b9	fixed another retain msg test timing issue	2017-11-09 10:40:05 +01:00
Jan Eggers	683d97dc14	added another platform to overcome breaking change in ms.extensions.di 2.0.0	2017-11-09 10:24:49 +01:00
Jan Eggers	ad77dc0bea	improved server usage in aspnet so no exceptions are thrown on startup	2017-11-09 10:22:44 +01:00
Christian Kratky	587622af81	Refactoring	2017-11-09 08:23:40 +01:00
Christian Kratky	eaf27c1e12	Update documentation	2017-11-09 00:03:22 +01:00
Christian Kratky	1c78cd4c31	Update documentation	2017-11-08 23:36:52 +01:00
Christian Kratky	d1ab867afc	Merge branch 'master' of https://github.com/chkr1011/MQTTnet	2017-11-08 20:40:02 +01:00
Christian Kratky	522a385523	Add methods for client options builder	2017-11-08 20:26:33 +01:00
Christian Kratky	40dd620f90	Refactoring	2017-11-08 19:10:45 +01:00
Christian Kratky	7dfc19e588	Added missing ConfigureAwaits	2017-11-08 18:44:36 +01:00
Christian Kratky	0b002e8d11	Remove the RAW stream approach	2017-11-08 15:26:31 +01:00
Christian Kratky	d2e481719c	Optimized persisting of retained messages to avoid useless writes to the filesystem	2017-11-08 14:30:13 +01:00
Christian Kratky	7e48746944	Fix cleanup of client sessions	2017-11-08 00:49:49 +01:00
Christian Kratky	f481c704c9	Fixed an issue with queued client message in the server.	2017-11-07 23:30:15 +01:00
Christian	6e5b991406	Merge pull request #90 from JanEggers/develop added dependencies to nuspec and fixed build	2017-11-06 19:29:56 +01:00
Jan Eggers	e07ead53a9	fixed wait	2017-11-06 12:52:41 +01:00
Jan Eggers	e6e88e132b	possibly fixed timing issue in test	2017-11-06 12:47:31 +01:00
Jan Eggers	8778848301	added some more missing packages	2017-11-06 10:57:27 +01:00
Jan Eggers	5fbef7beb5	added more missing packages	2017-11-06 10:37:09 +01:00
Jan Eggers	387a3bc281	added dependencies to nuspec and fixed build	2017-11-06 08:36:34 +01:00
Christian Kratky	11ccb951aa	Refactor traces of server session handling	2017-11-01 13:34:39 +01:00
Christian Kratky	3a6df2eab0	Fix unit tests	2017-10-31 14:38:24 +01:00
Christian Kratky	c5e3bc70b1	Update docs	2017-10-31 14:26:29 +01:00
Christian Kratky	9c46b8fd75	Fix handling of closed streams	2017-10-31 14:10:39 +01:00
Christian Kratky	d5dc3a1361	Update docs	2017-10-31 10:34:27 +01:00
Christian Kratky	f0e8d8e98c	Update docs, extend UWP test app	2017-10-31 10:03:31 +01:00
Christian Kratky	589fd22a63	Merge	2017-10-30 19:46:12 +01:00
Christian Kratky	83821453a0	Refactor shared library. Extend error messages	2017-10-30 19:44:24 +01:00
Christian	d335b6393e	Merge pull request #89 from JanEggers/develop Develop	2017-10-30 19:38:34 +01:00
JanEggers	6240d60003	Update appveyor.yml	2017-10-30 12:41:40 +01:00
JanEggers	4519c4fe3d	Update appveyor.yml	2017-10-30 12:36:27 +01:00
JanEggers	e969b2f31f	Update appveyor.yml	2017-10-30 12:33:59 +01:00
JanEggers	44ae9093f9	Update appveyor.yml	2017-10-30 11:31:20 +01:00
JanEggers	fcd3bdf297	Update appveyor.yml	2017-10-30 11:28:10 +01:00
Jan Eggers	cbb2f43047	Merge branch 'develop' of https://github.com/JanEggers/MQTTnet into develop	2017-10-30 11:23:24 +01:00
Jan Eggers	5e74869dbc	updated testadapter	2017-10-30 11:23:18 +01:00
JanEggers	98cac153e6	Update appveyor.yml	2017-10-30 11:13:20 +01:00
JanEggers	b51a603aa9	Update appveyor.yml	2017-10-30 11:06:26 +01:00
Jan Eggers	2fe520ad46	fix uwp platformtarget for release build	2017-10-30 11:01:32 +01:00
Jan Eggers	c8846329f3	added MQTT dev sign key for uwp project	2017-10-30 10:40:09 +01:00
JanEggers	08f2db05a9	Update appveyor.yml	2017-10-29 21:21:24 +01:00
Christian	5427b488c3	Merge pull request #87 from JanEggers/appveyor added appveyor config for ci and tests	2017-10-29 20:08:12 +01:00
Christian	ec24f03324	Merge pull request #86 from JanEggers/integrate_uwp_platform migrate uwp platform to netstandard project	2017-10-29 20:07:55 +01:00
JanEggers	4ef16cfd8d	fixed project reference	2017-10-28 19:02:17 +02:00
JanEggers	177c7cbf03	added appveyor config for ci and tests	2017-10-28 17:03:52 +02:00
JanEggers	8025717658	migrate uwp platform to netstandard project	2017-10-28 16:40:10 +02:00
Christian Kratky	275d8d9f0b	Fix unit tests	2017-10-28 13:19:29 +02:00
Christian Kratky	30df7d4c9e	Fix subscribe interceptor	2017-10-28 13:19:04 +02:00
Christian Kratky	019ef1398e	Fix breaking changes	2017-10-28 10:49:03 +02:00
Christian Kratky	4a6f517e91	Refactoring	2017-10-28 10:39:57 +02:00
Christian Kratky	d560cb4c9e	Merge branch 'develop' of https://github.com/chkr1011/MQTTnet into develop	2017-10-28 10:34:32 +02:00
Christian Kratky	ba16ae6568	Add interceptor for client subscriptions	2017-10-28 10:34:25 +02:00
Christian	3b2c40d49e	Merge pull request #85 from JanEggers/LogId LogId	2017-10-28 10:18:32 +02:00
Jan Eggers	9894dbef87	fixed using	2017-10-27 12:29:26 +02:00
Jan Eggers	dd447f24d2	added LogId to options and use it to create logging scope	2017-10-27 12:29:13 +02:00
Christian	3a250723d7	Merge pull request #83 from JanEggers/UnittestsFixed Unittests fixed	2017-10-27 09:02:13 +02:00
JanEggers	e0797e5d14	enable uwp build again	2017-10-26 21:45:36 +02:00
Christian Kratky	d0f1c18a2f	Server refactoring	2017-10-26 21:22:58 +02:00
Jan Eggers	bb6eb246e8	added AspNetCore to buildscript and fixed assemblyversion of dotnet build	2017-10-26 09:01:25 +02:00
Jan Eggers	0e666f0316	use correct casing	2017-10-26 08:18:13 +02:00
Jan Eggers	0811938466	temp rename to fix casing	2017-10-26 08:15:25 +02:00
Jan Eggers	466b6a25cd	fixed unittests and addressed todo	2017-10-26 08:11:37 +02:00
Jan Eggers	15a564dcfe	removed smokebombs (stop the server in finally so other test dont fail because stop is not called in other test)	2017-10-26 07:53:22 +02:00
Christian Kratky	f85721fbf5	Restore console log of test app	2017-10-25 23:39:57 +02:00
Christian Kratky	3b366f91fc	Update docs	2017-10-25 23:26:15 +02:00
Christian Kratky	418f2b2c3f	Refactoring	2017-10-25 23:11:42 +02:00
Christian Kratky	8fa91736b6	Fix unit tests	2017-10-25 22:46:19 +02:00
Christian Kratky	a18c533603	Refactor options and add options builder	2017-10-25 22:33:07 +02:00
Christian Kratky	a9b394401b	Add support for chaning passwords	2017-10-25 19:50:37 +02:00
Christian Kratky	c257e5cb77	Merge branch 'develop' of https://github.com/chkr1011/MQTTnet into develop	2017-10-25 19:27:43 +02:00
Christian	93863ece0d	Merge pull request #81 from JTrotta/master Dynamic/Provider Password	2017-10-25 19:27:14 +02:00
Gerardo	29918fb454	Password Provider for dynamic password	2017-10-25 15:56:29 +02:00
Gerardo	412cf115a5	Merge pull request #1 from chkr1011/develop Merge base	2017-10-25 14:54:25 +02:00
Christian	8dab5d3800	Merge pull request #75 from JanEggers/mqttnet.aspnetcore Mqttnet.aspnetcore	2017-10-24 20:27:32 +02:00
Jan Eggers	2cd3bd7588	added some ui to send test msgs	2017-10-24 15:35:02 +02:00
Jan Eggers	0e0fcabc04	gently close the connection before leaving the page	2017-10-24 13:15:35 +02:00
Jan Eggers	e80d21e852	generate exception in case websocket is closed so stream does not return array of 255	2017-10-24 13:15:02 +02:00
Jan Eggers	a68343a306	fixed duplicated console log	2017-10-24 13:14:18 +02:00
Jan Eggers	d594b1447f	fixed index out of range	2017-10-24 12:45:26 +02:00
Jan Eggers	1ca9b0bd62	added aspnetcore package and adapted sample app	2017-10-24 12:45:14 +02:00
Christian Kratky	1c0b2b55b6	Fix bugs	2017-10-23 18:57:36 +02:00
Christian Kratky	41ca15120d	Merge	2017-10-23 18:57:25 +02:00
Christian	49b1706495	Set theme jekyll-theme-modernist	2017-10-23 18:55:26 +02:00
Christian Kratky	daf22c762f	Small refactorings	2017-10-23 18:49:38 +02:00
Christian	3529724bdc	Merge pull request #70 from JanEggers/msExtensions initial version of ms.extensions.logging and di	2017-10-23 18:44:17 +02:00
Jan Eggers	56a86b6127	adapted uwp platform projects	2017-10-23 14:17:06 +02:00
Jan Eggers	7e6f4453ad	added back MqttTrace consuming api	2017-10-23 12:42:31 +02:00
Christian Kratky	84a647e712	Add several new options to the WebSocket options	2017-10-22 21:10:14 +02:00
JanEggers	d10f29bbc6	initial version	2017-10-22 19:22:14 +02:00
Christian Kratky	41edc3a1ec	Update docs	2017-10-22 14:44:57 +02:00
Christian Kratky	3f080e04b9	Add topic filter builder	2017-10-22 14:44:06 +02:00
Christian Kratky	4386ef1e56	Added interceptor for application messages	2017-10-22 14:19:12 +02:00
Christian Kratky	df1dd0eec7	Refactoring	2017-10-21 20:39:38 +02:00
Christian Kratky	3954777d20	Refactoring	2017-10-21 20:12:38 +02:00
Christian Kratky	b52645f77a	Add new interface for application message receivers	2017-10-21 20:05:25 +02:00
Christian Kratky	65e6f96e59	Update docs	2017-10-21 16:01:08 +02:00
Christian Kratky	24c35de330	Refactor manage client	2017-10-21 15:49:50 +02:00
Christian Kratky	d052f409b6	Update documentation	2017-10-21 00:16:53 +02:00
Christian Kratky	f9eb6ed85e	Add support for WebSocket server via ASP.NET Core 2.0	2017-10-21 00:14:09 +02:00
Christian Kratky	11ade8c3df	Refactor tracing	2017-10-20 23:30:58 +02:00
Christian Kratky	fe88b7551c	Refactor managed MQTT client	2017-10-19 20:45:37 +02:00
Christian Kratky	bddfadaefa	Merge	2017-10-19 18:57:30 +02:00
Christian Kratky	40b1be075c	Refactoring	2017-10-19 18:50:22 +02:00
Christian	680bc4658f	Merge pull request #66 from JTrotta/develop Add support to not persistent Queue	2017-10-19 18:49:55 +02:00
Gerardo	870ed00e3c	Refactoring Added almost of the hits. Options modified but must be reviewed completely.	2017-10-19 13:21:06 +02:00
Gerardo	1f3b24d20f	Refactoring	2017-10-18 17:14:13 +02:00
Gerardo	bc19f66812	Added suport to Persistence and refoactoring	2017-10-18 16:41:54 +02:00
Christian Kratky	9915cc4492	Use event pattern correctly for incoming server connections.	2017-10-17 20:05:04 +02:00
Christian Kratky	ad4585989a	Update documentation	2017-10-17 20:04:05 +02:00
Gerardo	ea5616002a	Add support to not persistent Queue Added new class MqttClientQueued	2017-10-17 14:02:41 +02:00
Christian Kratky	1f8a781dc2	Several refactorings & code cleanup	2017-10-15 12:00:46 +02:00
Christian	fd63cf0086	Merge pull request #64 from JanEggers/useBuffering Use buffering	2017-10-15 11:30:39 +02:00
JanEggers	60bdca8716	added back buffering for .net and annotated ifdefs with minimum dependency tor remove them	2017-10-15 10:16:26 +02:00
Christian Kratky	a2971aa03b	Update version information	2017-10-15 01:12:09 +02:00
Christian	05a3acb229	Merge pull request #63 from JanEggers/platformUnified removed duplicated code by using csproj with targetframeworks	2017-10-15 00:59:43 +02:00
JanEggers	47257baba9	fixed build script	2017-10-14 16:37:42 +02:00
JanEggers	906a0ba189	removed duplicated code by using csproj with targetframeworks	2017-10-14 08:11:56 +02:00
Christian Kratky	69b02f3224	Update docs	2017-10-09 19:47:09 +02:00
Christian Kratky	a7d0ad5f43	Fix several bugs	2017-10-09 19:42:31 +02:00
Christian Kratky	59f07c868d	Add custom certificate validation handler	2017-10-09 19:03:11 +02:00
Christian Kratky	4517d80704	Add unit tests	2017-10-07 19:51:51 +02:00
Christian Kratky	9bca4aa53f	Extended certificate validation options	2017-10-07 19:37:51 +02:00
Christian Kratky	4c4539509c	Add support for ignored certificate chain errors (Self signed)	2017-10-07 19:22:26 +02:00
Christian Kratky	af3cebb266	Renamed trace class	2017-10-07 13:06:13 +02:00
Christian Kratky	d22528ca46	Fix bugs	2017-10-04 14:44:36 +02:00
Christian Kratky	67267c05fd	Refactor options	2017-10-04 13:58:51 +02:00
Christian	d23ab88add	Merge pull request #51 from JanEggers/Fix50_Eventing Fix50 eventing	2017-10-04 12:32:56 +02:00
JanEggers	1d78d675f7	improved api surface of mqttserver and fixed unittests	2017-10-02 22:55:56 +02:00
JanEggers	3079ad37ce	improved client livetime events	2017-10-02 22:55:46 +02:00
Christian Kratky	c7b7d56229	Add disconnected event to server interface	2017-10-02 20:44:56 +02:00
Christian Kratky	c97b97c677	Update readme	2017-10-01 14:23:17 +02:00
Christian Kratky	96a62551b2	Update readme	2017-10-01 14:22:14 +02:00
Christian Kratky	300c9b9ccb	Update version info	2017-10-01 14:16:15 +02:00
Christian Kratky	342085db40	Update readme	2017-10-01 14:11:05 +02:00
Christian Kratky	862f76fea2	Add support for retained application messages	2017-09-30 18:42:41 +02:00
Christian Kratky	3cce33415d	Update documents	2017-09-28 18:09:01 +02:00
Christian Kratky	d09455f78e	Add semaphore for accessing send stream	2017-09-28 09:29:47 +02:00
Christian Kratky	e947881aca	Remove lock to prevent dead locks	2017-09-27 21:20:42 +02:00
Christian Kratky	077c9ea00d	Merge	2017-09-27 21:11:11 +02:00
Christian	f8af4597f2	Merge pull request #44 from 1iveowl/master Bug fixes v3	2017-09-27 21:09:31 +02:00
Christian Kratky	32dc96ae93	Wait until receiving of packets is started before sending packets	2017-09-27 21:08:36 +02:00
Christian Kratky	153e83ee3e	Remove not needed async/await	2017-09-26 20:02:12 +02:00
Christian Kratky	6402dfd9ea	Update version info to 2.3.1	2017-09-26 20:01:57 +02:00
Christian Kratky	98bafb1f26	Fix null ref exception in UWP TCP channel	2017-09-26 20:00:35 +02:00
1iveowl	6d92937892	Fixed typo	2017-09-24 17:06:41 +02:00
1iveowl	28d31d0cf5	Increased PR quality	2017-09-24 17:03:29 +02:00
1iveowl	07fd509e74	Bug fixes	2017-09-24 16:19:59 +02:00
Christian	37a5dc7abe	Update README.md	2017-09-21 11:48:05 +02:00
Christian Kratky	8604097ada	Merge branch 'master' of https://github.com/chkr1011/MQTTnet	2017-09-20 23:31:14 +02:00
Christian Kratky	ea587d97c8	Organize solution	2017-09-20 23:31:09 +02:00
Christian	fb272b07aa	Update .bettercodehub.yml	2017-09-20 23:25:35 +02:00
Christian	7067a8e411	Create .bettercodehub.yml	2017-09-20 23:22:12 +02:00