Reorganize solution structure.

Source/MQTTnet.AspnetCore/ApplicationBuilderExtensions.cs

@@ -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.WebSockets.IsWebSocketRequest || context.Request.Path != path)
+                {
+                    await next();
+                    return;
+                }
+
+                string subProtocol = null;
+
+                if (context.Request.Headers.TryGetValue("Sec-WebSocket-Protocol", out var requestedSubProtocolValues))
+                {
+                    // Order the protocols to also match "mqtt", "mqttv-3.1", "mqttv-3.11" etc.
+                    subProtocol = requestedSubProtocolValues
+                        .OrderByDescending(p => p.Length)
+                        .FirstOrDefault(p => p.ToLower().StartsWith("mqtt"));
+                }
+
+                var adapter = app.ApplicationServices.GetRequiredService<MqttWebSocketServerAdapter>();
+                using (var webSocket = await context.WebSockets.AcceptWebSocketAsync(subProtocol))
+                {
+                    var endpoint = $"{context.Connection.RemoteIpAddress}:{context.Connection.RemotePort}";
+                    await adapter.RunWebSocketConnectionAsync(webSocket, endpoint);
+                }
+            });
+
+            return app;
+        }
+
+        public static IApplicationBuilder UseMqttServer(this IApplicationBuilder app, Action<IMqttServer> configure)
+        {
+            var server = app.ApplicationServices.GetRequiredService<IMqttServer>();
+
+            configure(server);
+
+            return app;
+        }
+    }
+}

Source/MQTTnet.AspnetCore/MQTTnet.AspNetCore.csproj

@@ -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.1" />
+    <PackageReference Include="Microsoft.AspNetCore.WebSockets" Version="2.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" Version="2.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MQTTnet\MQTTnet.csproj" />
+  </ItemGroup>
+
+</Project>

Source/MQTTnet.AspnetCore/MqttHostedServer.cs

@@ -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.CreateChildLogger(nameof(MqttHostedServer)))
+        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public Task StartAsync(CancellationToken cancellationToken)
+        {
+            return StartAsync(_options);
+        }
+
+        public Task StopAsync(CancellationToken cancellationToken)
+        {
+            return StopAsync();
+        }
+    }
+}

Source/MQTTnet.AspnetCore/MqttWebSocketServerAdapter.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Net.WebSockets;
+using System.Threading.Tasks;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Implementations;
+using MQTTnet.Serializer;
+using MQTTnet.Server;
+
+namespace MQTTnet.AspNetCore
+{
+    public class MqttWebSocketServerAdapter : IMqttServerAdapter
+    {
+        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        public Task StartAsync(IMqttServerOptions options)
+        {
+            return Task.CompletedTask;
+        }
+
+        public Task StopAsync()
+        {
+            return Task.CompletedTask;
+        }
+
+        public async Task RunWebSocketConnectionAsync(WebSocket webSocket, string endpoint)
+        {
+            if (webSocket == null) throw new ArgumentNullException(nameof(webSocket));
+
+            var clientAdapter = new MqttChannelAdapter(new MqttWebSocketChannel(webSocket, endpoint), new MqttPacketSerializer(), new MqttNetLogger().CreateChildLogger(nameof(MqttWebSocketServerAdapter)));
+
+            var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
+            ClientAccepted?.Invoke(this, eventArgs);
+
+            if (eventArgs.SessionTask != null)
+            {
+                await eventArgs.SessionTask.ConfigureAwait(false);
+            }
+        }
+        
+        public void Dispose()
+        {
+            StopAsync().GetAwaiter().GetResult();
+        }
+    }
+}

Source/MQTTnet.AspnetCore/ServiceCollectionExtensions.cs

@@ -0,0 +1,39 @@
+using System;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Server;
+using MQTTnet.Implementations;
+
+namespace MQTTnet.AspNetCore
+{
+    public static class ServiceCollectionExtensions
+    {
+        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, IMqttServerOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            var logger = new MqttNetLogger();
+            var childLogger = logger.CreateChildLogger();
+
+            services.AddSingleton(options);
+            services.AddSingleton<IMqttNetLogger>(logger);
+            services.AddSingleton(childLogger);
+            services.AddSingleton<MqttHostedServer>();
+            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
+            services.AddSingleton<IMqttServer>(s => s.GetService<MqttHostedServer>());
+
+            services.AddSingleton<MqttWebSocketServerAdapter>();
+            services.AddSingleton<MqttTcpServerAdapter>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttWebSocketServerAdapter>());
+
+            if (options.DefaultEndpointOptions.IsEnabled)
+            {
+                services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttTcpServerAdapter>());
+            }
+
+            return services;
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ApplicationMessageProcessedEventArgs.cs

@@ -0,0 +1,19 @@
+using System;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ApplicationMessageProcessedEventArgs : EventArgs
+    {
+        public ApplicationMessageProcessedEventArgs(ManagedMqttApplicationMessage applicationMessage, Exception exception)
+        {
+            ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
+            Exception = exception;
+        }
+
+        public ManagedMqttApplicationMessage ApplicationMessage { get; }
+        public Exception Exception { get; }
+
+        public bool HasFailed => Exception != null;
+        public bool HasSucceeded => Exception == null;
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/IManagedMqttClient.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using MQTTnet.Client;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public interface IManagedMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
+    {
+        bool IsStarted { get; }
+        bool IsConnected { get; }
+
+        event EventHandler<MqttClientConnectedEventArgs> Connected;
+        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
+
+        event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
+
+        Task StartAsync(IManagedMqttClientOptions options);
+        Task StopAsync();
+
+        Task SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
+        Task UnsubscribeAsync(IEnumerable<string> topics);
+
+        Task PublishAsync(IEnumerable<ManagedMqttApplicationMessage> applicationMessages);
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/IManagedMqttClientOptions.cs

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

Source/MQTTnet.Extensions.ManagedClient/IManagedMqttClientStorage.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public interface IManagedMqttClientStorage
+    {
+        Task SaveQueuedMessagesAsync(IList<ManagedMqttApplicationMessage> messages);
+
+        Task<IList<ManagedMqttApplicationMessage>> LoadQueuedMessagesAsync();
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/MQTTnet.Extensions.ManagedClient.csproj

@@ -0,0 +1,31 @@
+<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.17134.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
+    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
+    <DefaultLanguage>en</DefaultLanguage>
+    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MQTTnet\MQTTnet.csproj" />
+  </ItemGroup>
+
+</Project>

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttApplicationMessage.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ManagedMqttApplicationMessage
+    {
+        public Guid Id { get; set; } = Guid.NewGuid();
+
+        public MqttApplicationMessage ApplicationMessage { get; set; }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttApplicationMessageBuilder.cs

@@ -0,0 +1,47 @@
+using System;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ManagedMqttApplicationMessageBuilder
+    {
+        private Guid _id = Guid.NewGuid();
+        private MqttApplicationMessage _applicationMessage;
+
+        public ManagedMqttApplicationMessageBuilder WithId(Guid id)
+        {
+            _id = id;
+            return this;
+        }
+
+        public ManagedMqttApplicationMessageBuilder WithApplicationMessage(MqttApplicationMessage applicationMessage)
+        {
+            _applicationMessage = applicationMessage;
+            return this;
+        }
+
+        public ManagedMqttApplicationMessageBuilder WithApplicationMessage(Action<MqttApplicationMessageBuilder> builder)
+        {
+            if (builder == null) throw new ArgumentNullException(nameof(builder));
+
+            var internalBuilder = new MqttApplicationMessageBuilder();
+            builder(internalBuilder);
+
+            _applicationMessage = internalBuilder.Build();
+            return this;
+        }
+
+        public ManagedMqttApplicationMessage Build()
+        {
+            if (_applicationMessage == null)
+            {
+                throw new InvalidOperationException("The ApplicationMessage cannot be null.");
+            }
+
+            return new ManagedMqttApplicationMessage
+            {
+                Id = _id,
+                ApplicationMessage = _applicationMessage
+            };
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClient.cs

@@ -0,0 +1,395 @@
+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.Internal;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ManagedMqttClient : IManagedMqttClient
+    {
+        private readonly BlockingCollection<ManagedMqttApplicationMessage> _messageQueue = new BlockingCollection<ManagedMqttApplicationMessage>();
+        private readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
+        private readonly AsyncLock _subscriptionsLock = new AsyncLock();
+        private readonly List<string> _unsubscriptions = new List<string>();
+
+        private readonly IMqttClient _mqttClient;
+        private readonly IMqttNetChildLogger _logger;
+
+        private CancellationTokenSource _connectionCancellationToken;
+        private CancellationTokenSource _publishingCancellationToken;
+
+        private ManagedMqttClientStorageManager _storageManager;
+        private IManagedMqttClientOptions _options;
+
+        private bool _subscriptionsNotPushed;
+
+        public ManagedMqttClient(IMqttClient mqttClient, IMqttNetChildLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+
+            _mqttClient.Connected += OnConnected;
+            _mqttClient.Disconnected += OnDisconnected;
+            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
+
+            _logger = logger.CreateChildLogger(nameof(ManagedMqttClient));
+        }
+
+        public bool IsConnected => _mqttClient.IsConnected;
+        public bool IsStarted => _connectionCancellationToken != null;
+
+        public event EventHandler<MqttClientConnectedEventArgs> Connected;
+        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
+        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+        public event EventHandler<ApplicationMessageProcessedEventArgs> ApplicationMessageProcessed;
+        public event EventHandler SynchronizingSubscriptionsFailed;
+
+        public async Task StartAsync(IManagedMqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+            if (options.ClientOptions == null) throw new ArgumentException("The client options are not set.", nameof(options));
+
+            if (!options.ClientOptions.CleanSession)
+            {
+                throw new NotSupportedException("The managed client does not support existing sessions.");
+            }
+
+            if (_connectionCancellationToken != null) throw new InvalidOperationException("The managed client is already started.");
+
+            _options = options;
+
+            if (_options.Storage != null)
+            {
+                _storageManager = new ManagedMqttClientStorageManager(_options.Storage);
+                var messages = await _storageManager.LoadQueuedMessagesAsync().ConfigureAwait(false);
+
+                foreach (var message in messages)
+                {
+                    _messageQueue.Add(message);
+                }
+            }
+
+            _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(() => MaintainConnectionAsync(_connectionCancellationToken.Token), _connectionCancellationToken.Token);
+#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+
+            _logger.Info("Started");
+        }
+
+        public Task StopAsync()
+        {
+            StopPublishing();
+            StopMaintainingConnection();
+
+            while (_messageQueue.Any())
+            {
+                _messageQueue.Take();
+            }
+
+            return Task.FromResult(0);
+        }
+
+        public Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
+        {
+            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
+
+            return PublishAsync(applicationMessages.Select(m =>
+                new ManagedMqttApplicationMessageBuilder().WithApplicationMessage(m).Build()));
+        }
+
+        public async Task PublishAsync(IEnumerable<ManagedMqttApplicationMessage> 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));
+
+            using (await _subscriptionsLock.LockAsync(CancellationToken.None).ConfigureAwait(false))
+            {
+                foreach (var topicFilter in topicFilters)
+                {
+                    _subscriptions[topicFilter.Topic] = topicFilter.QualityOfServiceLevel;
+                    _subscriptionsNotPushed = true;
+                }
+            }
+        }
+
+        public async Task UnsubscribeAsync(IEnumerable<string> topics)
+        {
+            using (await _subscriptionsLock.LockAsync(CancellationToken.None).ConfigureAwait(false))
+            {
+                foreach (var topic in topics)
+                {
+                    if (_subscriptions.Remove(topic))
+                    {
+                        _unsubscriptions.Add(topic);
+                        _subscriptionsNotPushed = true;
+                    }
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            _messageQueue?.Dispose();
+            _subscriptionsLock?.Dispose();
+            _connectionCancellationToken?.Dispose();
+            _publishingCancellationToken?.Dispose();
+        }
+
+        private async Task MaintainConnectionAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    await TryMaintainConnectionAsync(cancellationToken).ConfigureAwait(false);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (Exception exception)
+            {
+                _logger.Error(exception, "Unhandled exception while maintaining connection.");
+            }
+            finally
+            {
+                await _mqttClient.DisconnectAsync().ConfigureAwait(false);
+                _logger.Info("Stopped");
+            }
+        }
+
+        private async Task TryMaintainConnectionAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                var connectionState = await ReconnectIfRequiredAsync().ConfigureAwait(false);
+                if (connectionState == ReconnectionResult.NotConnected)
+                {
+                    StopPublishing();
+                    await Task.Delay(_options.AutoReconnectDelay, cancellationToken).ConfigureAwait(false);
+                    return;
+                }
+
+                if (connectionState == ReconnectionResult.Reconnected || _subscriptionsNotPushed)
+                {
+                    await SynchronizeSubscriptionsAsync().ConfigureAwait(false);
+                    StartPublishing();
+                    return;
+                }
+
+                if (connectionState == ReconnectionResult.StillConnected)
+                {
+                    await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
+                }
+            }
+            catch (OperationCanceledException)
+            {
+            }
+            catch (MqttCommunicationException exception)
+            {
+                _logger.Warning(exception, "Communication exception while maintaining connection.");
+            }
+            catch (Exception exception)
+            {
+                _logger.Error(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(exception, "Unhandled exception while publishing queued application messages.");
+            }
+            finally
+            {
+                _logger.Verbose("Stopped publishing messages.");
+            }
+        }
+
+        private async Task TryPublishQueuedMessageAsync(ManagedMqttApplicationMessage message)
+        {
+            Exception transmitException = null;
+            try
+            {
+                await _mqttClient.PublishAsync(message.ApplicationMessage).ConfigureAwait(false);
+
+                if (_storageManager != null)
+                {
+                    await _storageManager.RemoveAsync(message).ConfigureAwait(false);
+                }
+            }
+            catch (MqttCommunicationException exception)
+            {
+                transmitException = exception;
+
+                _logger.Warning(exception, $"Publishing application ({message.Id}) message failed.");
+
+                if (message.ApplicationMessage.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
+                {
+                    _messageQueue.Add(message);
+                }
+            }
+            catch (Exception exception)
+            {
+                transmitException = exception;
+                _logger.Error(exception, $"Unhandled exception while publishing application message ({message.Id}).");
+            }
+            finally
+            {
+                ApplicationMessageProcessed?.Invoke(this, new ApplicationMessageProcessedEventArgs(message, transmitException));
+            }
+        }
+
+        private async Task SynchronizeSubscriptionsAsync()
+        {
+            _logger.Info(nameof(ManagedMqttClient), "Synchronizing subscriptions");
+
+            List<TopicFilter> subscriptions;
+            List<string> unsubscriptions;
+
+            using (await _subscriptionsLock.LockAsync(CancellationToken.None).ConfigureAwait(false))
+            {
+                subscriptions = _subscriptions.Select(i => new TopicFilter(i.Key, i.Value)).ToList();
+
+                unsubscriptions = new List<string>(_unsubscriptions);
+                _unsubscriptions.Clear();
+
+                _subscriptionsNotPushed = false;
+            }
+
+            if (!subscriptions.Any() && !unsubscriptions.Any())
+            {
+                return;
+            }
+
+            try
+            {
+                if (subscriptions.Any())
+                {
+                    await _mqttClient.SubscribeAsync(subscriptions).ConfigureAwait(false);
+                }
+
+                if (unsubscriptions.Any())
+                {
+                    await _mqttClient.UnsubscribeAsync(unsubscriptions).ConfigureAwait(false);
+                }
+            }
+            catch (Exception exception)
+            {
+                _logger.Warning(exception, "Synchronizing subscriptions failed.");
+                _subscriptionsNotPushed = true;
+
+                SynchronizingSubscriptionsFailed?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        private async Task<ReconnectionResult> ReconnectIfRequiredAsync()
+        {
+            if (_mqttClient.IsConnected)
+            {
+                return ReconnectionResult.StillConnected;
+            }
+
+            try
+            {
+                await _mqttClient.ConnectAsync(_options.ClientOptions).ConfigureAwait(false);
+                return ReconnectionResult.Reconnected;
+            }
+            catch (Exception)
+            {
+                return ReconnectionResult.NotConnected;
+            }
+        }
+
+        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
+        {
+            ApplicationMessageReceived?.Invoke(this, eventArgs);
+        }
+
+        private void OnDisconnected(object sender, MqttClientDisconnectedEventArgs eventArgs)
+        {
+            Disconnected?.Invoke(this, eventArgs);
+        }
+
+        private void OnConnected(object sender, MqttClientConnectedEventArgs eventArgs)
+        {
+            Connected?.Invoke(this, eventArgs);
+        }
+
+        private void StartPublishing()
+        {
+            if (_publishingCancellationToken != null)
+            {
+                StopPublishing();
+            }
+
+            var cts = new CancellationTokenSource();
+
+            _publishingCancellationToken = cts;
+
+#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Task.Run(() => PublishQueuedMessagesAsync(cts.Token), cts.Token);
+#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;
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClientExtensions.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Threading.Tasks;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public static class ManagedMqttClientExtensions
+    {
+        public static Task SubscribeAsync(this IManagedMqttClient managedClient, params TopicFilter[] topicFilters)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+
+            return managedClient.SubscribeAsync(topicFilters);
+        }
+
+        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
+        }
+
+        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build());
+        }
+
+        public static Task UnsubscribeAsync(this IManagedMqttClient managedClient, params string[] topicFilters)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+
+            return managedClient.UnsubscribeAsync(topicFilters);
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClientOptions.cs

@@ -0,0 +1,14 @@
+using System;
+using MQTTnet.Client;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ManagedMqttClientOptions : IManagedMqttClientOptions
+    {
+        public IMqttClientOptions ClientOptions { get; set; }
+
+        public TimeSpan AutoReconnectDelay { get; set; } = TimeSpan.FromSeconds(5);
+
+        public IManagedMqttClientStorage Storage { get; set; }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClientOptionsBuilder.cs

@@ -0,0 +1,74 @@
+using System;
+using MQTTnet.Client;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ManagedMqttClientOptionsBuilder
+    {
+        private readonly ManagedMqttClientOptions _options = new ManagedMqttClientOptions();
+        private MqttClientOptionsBuilder _clientOptionsBuilder;
+
+        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)
+        {
+            if (_clientOptionsBuilder != null)
+            {
+                throw new InvalidOperationException("Cannot use client options builder and client options at the same time.");
+            }
+
+            _options.ClientOptions = value ?? throw new ArgumentNullException(nameof(value));
+
+            return this;
+        }
+
+        public ManagedMqttClientOptionsBuilder WithClientOptions(MqttClientOptionsBuilder builder)
+        {
+            if (_options.ClientOptions != null)
+            {
+                throw new InvalidOperationException("Cannot use client options builder and client options at the same time.");
+            }
+
+            _clientOptionsBuilder = builder;
+            return this;
+        }
+
+        public ManagedMqttClientOptionsBuilder WithClientOptions(Action<MqttClientOptionsBuilder> options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            if (_clientOptionsBuilder == null)
+            {
+                _clientOptionsBuilder = new MqttClientOptionsBuilder();
+            }
+
+            options(_clientOptionsBuilder);
+            return this;
+        }
+
+        public ManagedMqttClientOptions Build()
+        {
+            if (_clientOptionsBuilder != null)
+            {
+                _options.ClientOptions = _clientOptionsBuilder.Build();
+            }
+
+            if (_options.ClientOptions == null)
+            {
+                throw new InvalidOperationException("The ClientOptions cannot be null.");
+            }
+
+            return _options;
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ManagedMqttClientStorageManager.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Internal;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public class ManagedMqttClientStorageManager
+    {
+        private readonly List<ManagedMqttApplicationMessage> _messages = new List<ManagedMqttApplicationMessage>();
+        private readonly AsyncLock _messagesLock = new AsyncLock();
+
+        private readonly IManagedMqttClientStorage _storage;
+
+        public ManagedMqttClientStorageManager(IManagedMqttClientStorage storage)
+        {
+            _storage = storage ?? throw new ArgumentNullException(nameof(storage));
+        }
+
+        public async Task<List<ManagedMqttApplicationMessage>> LoadQueuedMessagesAsync()
+        {
+            var loadedMessages = await _storage.LoadQueuedMessagesAsync().ConfigureAwait(false);
+            _messages.AddRange(loadedMessages);
+
+            return _messages;
+        }
+
+        public async Task AddAsync(ManagedMqttApplicationMessage applicationMessage)
+        {
+            using (await _messagesLock.LockAsync(CancellationToken.None).ConfigureAwait(false))
+            {
+                _messages.Add(applicationMessage);
+                await SaveAsync().ConfigureAwait(false);
+            }
+        }
+
+        public async Task RemoveAsync(ManagedMqttApplicationMessage applicationMessage)
+        {
+            using (await _messagesLock.LockAsync(CancellationToken.None).ConfigureAwait(false))
+            {
+                var index = _messages.IndexOf(applicationMessage);
+                if (index == -1)
+                {
+                    return;
+                }
+
+                _messages.RemoveAt(index);
+                await SaveAsync().ConfigureAwait(false);
+            }
+        }
+
+        private Task SaveAsync()
+        {
+            return _storage.SaveQueuedMessagesAsync(_messages);
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/MqttFactoryExtensions.cs

@@ -0,0 +1,24 @@
+using System;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
+
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public static class MqttFactoryExtensions
+    {
+        public static IManagedMqttClient CreateManagedMqttClient(this IMqttClientFactory factory)
+        {
+            if (factory == null) throw new ArgumentNullException(nameof(factory));
+
+            return new ManagedMqttClient(factory.CreateMqttClient(), new MqttNetLogger().CreateChildLogger());
+        }
+
+        public static IManagedMqttClient CreateManagedMqttClient(this IMqttClientFactory factory, IMqttNetLogger logger)
+        {
+            if (factory == null) throw new ArgumentNullException(nameof(factory));
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            return new ManagedMqttClient(factory.CreateMqttClient(), logger.CreateChildLogger());
+        }
+    }
+}

Source/MQTTnet.Extensions.ManagedClient/ReconnectionResult.cs

@@ -0,0 +1,9 @@
+namespace MQTTnet.Extensions.ManagedClient
+{
+    public enum ReconnectionResult
+    {
+        StillConnected,
+        Reconnected,
+        NotConnected
+    }
+}

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

@@ -0,0 +1,31 @@
+<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.17134.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
+    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
+    <DefaultLanguage>en</DefaultLanguage>
+    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MQTTnet\MQTTnet.csproj" />
+  </ItemGroup>
+
+</Project>

Source/MQTTnet.Extensions.Rpc/MqttRpcClient.cs

@@ -0,0 +1,130 @@
+using System;
+using System.Collections.Concurrent;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Extensions.Rpc
+{
+    public class MqttRpcClient : IDisposable
+    {
+        private readonly ConcurrentDictionary<string, TaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, TaskCompletionSource<byte[]>>();
+        private readonly IMqttClient _mqttClient;
+
+        public MqttRpcClient(IMqttClient mqttClient)
+        {
+            _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
+
+            _mqttClient.ApplicationMessageReceived += OnApplicationMessageReceived;
+        }
+
+        public Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            return ExecuteAsync(timeout, methodName, Encoding.UTF8.GetBytes(payload), qualityOfServiceLevel, CancellationToken.None);
+        }
+
+        public Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken)
+        {
+            return ExecuteAsync(timeout, methodName, Encoding.UTF8.GetBytes(payload), qualityOfServiceLevel, cancellationToken);
+        }
+
+        public Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            return ExecuteAsync(timeout, methodName, payload, qualityOfServiceLevel, CancellationToken.None);
+        }
+
+        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken)
+        {
+            if (methodName == null) throw new ArgumentNullException(nameof(methodName));
+
+            if (methodName.Contains("/") || methodName.Contains("+") || methodName.Contains("#"))
+            {
+                throw new ArgumentException("The method name cannot contain /, + or #.");
+            }
+
+            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.SubscribeAsync(responseTopic, qualityOfServiceLevel).ConfigureAwait(false);
+                await _mqttClient.PublishAsync(requestMessage).ConfigureAwait(false);
+                
+                using (var timeoutCts = new CancellationTokenSource(timeout))
+                using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, timeoutCts.Token))
+                {
+                    linkedCts.Token.Register(() =>
+                    {
+                        if (!tcs.Task.IsCompleted && !tcs.Task.IsFaulted && !tcs.Task.IsCanceled)
+                        {
+                            tcs.TrySetCanceled();
+                        }
+                    });
+
+                    try
+                    {
+                        var result = await tcs.Task.ConfigureAwait(false);
+                        timeoutCts.Cancel(false);
+                        return result;
+                    }
+                    catch (TaskCanceledException taskCanceledException)
+                    {
+                        if (timeoutCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested)
+                        {
+                            throw new MqttCommunicationTimedOutException(taskCanceledException);
+                        }
+                        else
+                        {
+                            throw;
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                _waitingCalls.TryRemove(responseTopic, out _);
+                await _mqttClient.UnsubscribeAsync(responseTopic).ConfigureAwait(false);
+            }
+        }
+
+        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs eventArgs)
+        {
+            if (!_waitingCalls.TryRemove(eventArgs.ApplicationMessage.Topic, out var 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();
+        }
+    }
+}

Source/MQTTnet.Extensions.Rpc/SampleCCode.c

@@ -0,0 +1,29 @@
+// If using the MQTT client PubSubClient it must be ensured  that the request topic for each method is subscribed like the following.
+_mqttClient.subscribe("MQTTnet.RPC/+/ping");
+_mqttClient.subscribe("MQTTnet.RPC/+/do_something");
+
+// It is not allowed to change the structure of the topic. Otherwise RPC will not work. So method names can be separated using
+// an _ or . but no +, # or . If it is required to distinguish between devices own rules can be defined like the following.
+_mqttClient.subscribe("MQTTnet.RPC/+/deviceA.ping");
+_mqttClient.subscribe("MQTTnet.RPC/+/deviceB.ping");
+_mqttClient.subscribe("MQTTnet.RPC/+/deviceC.getTemperature");
+
+// Within the callback of the MQTT client the topic must be checked if it belongs to MQTTnet RPC. The following code shows one
+// possible way of doing this.
+void mqtt_Callback(char *topic, byte *payload, unsigned int payloadLength)
+{
+	String topicString = String(topic);
+
+	if (topicString.startsWith("MQTTnet.RPC/")) {
+		String responseTopic = topicString + String("/response");
+
+		if (topicString.endsWith("/deviceA.ping")) {
+			mqtt_publish(responseTopic, "pong", false);
+			return;
+		}
+	}
+}
+
+// Important notes:
+// ! Do not send response message with the _retain_ flag set to true.
+// ! All required data for a RPC call and the result must be placed into the payload.

Source/MQTTnet/Adapter/IMqttChannelAdapter.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Packets;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Adapter
+{
+    public interface IMqttChannelAdapter : IDisposable
+    {
+        string Endpoint { get; }
+
+        IMqttPacketSerializer PacketSerializer { get; }
+
+        event EventHandler ReadingPacketStarted;
+
+        event EventHandler ReadingPacketCompleted;
+
+        Task ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken);
+
+        Task DisconnectAsync(TimeSpan timeout, CancellationToken cancellationToken);
+
+        Task SendPacketsAsync(TimeSpan timeout, IEnumerable<MqttBasePacket> packets, CancellationToken cancellationToken);
+
+        Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken);
+    }
+}

Source/MQTTnet/Adapter/IMqttServerAdapter.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Threading.Tasks;
+using MQTTnet.Server;
+
+namespace MQTTnet.Adapter
+{
+    public interface IMqttServerAdapter : IDisposable
+    {
+        event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        Task StartAsync(IMqttServerOptions options);
+        Task StopAsync();
+    }
+}

Source/MQTTnet/Adapter/MqttChannelAdapter.cs

@@ -0,0 +1,220 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Channel;
+using MQTTnet.Diagnostics;
+using MQTTnet.Exceptions;
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Adapter
+{
+    public class MqttChannelAdapter : IMqttChannelAdapter
+    {
+        private const uint ErrorOperationAborted = 0x800703E3;
+        private const int ReadBufferSize = 4096;  // TODO: Move buffer size to config
+
+        private readonly IMqttNetChildLogger _logger;
+        private readonly IMqttChannel _channel;
+
+        private bool _isDisposed;
+
+        public MqttChannelAdapter(IMqttChannel channel, IMqttPacketSerializer serializer, IMqttNetChildLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            _channel = channel ?? throw new ArgumentNullException(nameof(channel));
+            PacketSerializer = serializer ?? throw new ArgumentNullException(nameof(serializer));
+
+            _logger = logger.CreateChildLogger(nameof(MqttChannelAdapter));
+        }
+
+        public string Endpoint => _channel.Endpoint;
+
+        public IMqttPacketSerializer PacketSerializer { get; }
+
+        public event EventHandler ReadingPacketStarted;
+        public event EventHandler ReadingPacketCompleted;
+
+        public Task ConnectAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            ThrowIfDisposed();
+            _logger.Verbose("Connecting [Timeout={0}]", timeout);
+
+            return ExecuteAndWrapExceptionAsync(() =>
+                Internal.TaskExtensions.TimeoutAfter(ct => _channel.ConnectAsync(ct), timeout, cancellationToken));
+        }
+
+        public Task DisconnectAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            ThrowIfDisposed();
+            _logger.Verbose("Disconnecting [Timeout={0}]", timeout);
+
+            return ExecuteAndWrapExceptionAsync(() =>
+                Internal.TaskExtensions.TimeoutAfter(ct => _channel.DisconnectAsync(), timeout, cancellationToken));
+        }
+
+        public async Task SendPacketsAsync(TimeSpan timeout, IEnumerable<MqttBasePacket> packets, CancellationToken cancellationToken)
+        {
+            ThrowIfDisposed();
+
+            foreach (var packet in packets)
+            {
+                await SendPacketAsync(timeout, cancellationToken, packet).ConfigureAwait(false);
+            }
+        }
+
+        private Task SendPacketAsync(TimeSpan timeout, CancellationToken cancellationToken, MqttBasePacket packet)
+        {
+            return ExecuteAndWrapExceptionAsync(() =>
+            {
+                _logger.Verbose("TX >>> {0} [Timeout={1}]", packet, timeout);
+
+                var packetData = PacketSerializer.Serialize(packet);
+
+                return Internal.TaskExtensions.TimeoutAfter(ct => _channel.WriteAsync(
+                    packetData.Array,
+                    packetData.Offset,
+                    packetData.Count,
+                    ct), timeout, cancellationToken);
+            });
+        }
+
+        public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            ThrowIfDisposed();
+
+            MqttBasePacket packet = null;
+            await ExecuteAndWrapExceptionAsync(async () =>
+            {
+                ReceivedMqttPacket receivedMqttPacket;
+
+                if (timeout > TimeSpan.Zero)
+                {
+                    receivedMqttPacket = await Internal.TaskExtensions.TimeoutAfter(ct => ReceiveAsync(_channel, ct), timeout, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    receivedMqttPacket = await ReceiveAsync(_channel, cancellationToken).ConfigureAwait(false);
+                }
+
+                if (receivedMqttPacket == null || cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                packet = PacketSerializer.Deserialize(receivedMqttPacket);
+                if (packet == null)
+                {
+                    throw new MqttProtocolViolationException("Received malformed packet.");
+                }
+
+                _logger.Verbose("RX <<< {0}", packet);
+            }).ConfigureAwait(false);
+
+            return packet;
+        }
+
+        private async Task<ReceivedMqttPacket> ReceiveAsync(IMqttChannel channel, CancellationToken cancellationToken)
+        {
+            var fixedHeader = await MqttPacketReader.ReadFixedHeaderAsync(channel, cancellationToken).ConfigureAwait(false);
+            if (fixedHeader == null)
+            {
+                return null;
+            }
+
+            try
+            {
+                ReadingPacketStarted?.Invoke(this, EventArgs.Empty);
+
+                if (fixedHeader.RemainingLength == 0)
+                {
+                    return new ReceivedMqttPacket(fixedHeader.Flags, null);
+                }
+
+                var body = new byte[fixedHeader.RemainingLength];
+                var bodyOffset = 0;
+                var chunkSize = Math.Min(ReadBufferSize, fixedHeader.RemainingLength);
+
+                do
+                {
+                    var bytesLeft = body.Length - bodyOffset;
+                    if (chunkSize > bytesLeft)
+                    {
+                        chunkSize = bytesLeft;
+                    }
+
+                    var readBytes = await channel.ReadAsync(body, bodyOffset, chunkSize, cancellationToken) .ConfigureAwait(false);
+                    if (readBytes <= 0)
+                    {
+                        ExceptionHelper.ThrowGracefulSocketClose();
+                    }
+
+                    bodyOffset += readBytes;
+                } while (bodyOffset < body.Length);
+
+                return new ReceivedMqttPacket(fixedHeader.Flags, new MqttPacketBodyReader(body));
+            }
+            finally
+            {
+                ReadingPacketCompleted?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        private static async Task ExecuteAndWrapExceptionAsync(Func<Task> action)
+        {
+            try
+            {
+                await action().ConfigureAwait(false);
+            }
+            catch (Exception exception)
+            {
+                if (exception is TaskCanceledException ||
+                    exception is OperationCanceledException ||
+                    exception is MqttCommunicationTimedOutException ||
+                    exception is MqttCommunicationException)
+                {
+                    throw;
+                }
+
+                if (exception is IOException && exception.InnerException is SocketException socketException)
+                {
+                    if (socketException.SocketErrorCode == SocketError.ConnectionAborted)
+                    {
+                        throw new OperationCanceledException();
+                    }
+                }
+
+                if (exception is COMException comException)
+                {
+                    if ((uint)comException.HResult == ErrorOperationAborted)
+                    {
+                        throw new OperationCanceledException();
+                    }
+                }
+
+                throw new MqttCommunicationException(exception);
+            }
+        }
+
+        public void Dispose()
+        {
+            _isDisposed = true;
+
+            _channel?.Dispose();
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (_isDisposed)
+            {
+                throw new ObjectDisposedException(nameof(MqttChannelAdapter));
+            }
+        }
+    }
+}

Source/MQTTnet/Adapter/MqttConnectingFailedException.cs

@@ -0,0 +1,16 @@
+using MQTTnet.Exceptions;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Adapter
+{
+    public class MqttConnectingFailedException : MqttCommunicationException
+    {
+        public MqttConnectingFailedException(MqttConnectReturnCode returnCode)
+            : base($"Connecting with MQTT server failed ({returnCode}).")
+        {
+            ReturnCode = returnCode;
+        }
+
+        public MqttConnectReturnCode ReturnCode { get; }
+    }
+}

Source/MQTTnet/Adapter/MqttServerAdapterClientAcceptedEventArgs.cs

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

Source/MQTTnet/Adapter/ReceivedMqttPacket.cs

@@ -0,0 +1,17 @@
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Adapter
+{
+    public class ReceivedMqttPacket
+    {
+        public ReceivedMqttPacket(byte fixedHeader, MqttPacketBodyReader body)
+        {
+            FixedHeader = fixedHeader;
+            Body = body;
+        }
+
+        public byte FixedHeader { get; }
+
+        public MqttPacketBodyReader Body { get; }
+    }
+}

Source/MQTTnet/ApplicationMessagePublisherExtensions.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Threading.Tasks;
+using MQTTnet.Protocol;
+
+namespace MQTTnet
+{
+    public static class ApplicationMessagePublisherExtensions
+    {
+        public static Task PublishAsync(this IApplicationMessagePublisher publisher, params MqttApplicationMessage[] applicationMessages)
+        {
+            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
+            if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
+
+            return publisher.PublishAsync(applicationMessages);
+        }
+
+        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic)
+        {
+            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+            
+            return publisher.PublishAsync(builder => builder
+                .WithTopic(topic)
+            );
+        }
+
+        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic, string payload)
+        {
+            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return publisher.PublishAsync(builder => builder
+                .WithTopic(topic)
+                .WithPayload(payload)
+            );
+        }
+
+        public static Task PublishAsync(this IApplicationMessagePublisher publisher, string topic, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            if (publisher == null) throw new ArgumentNullException(nameof(publisher));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return publisher.PublishAsync(builder => builder
+                .WithTopic(topic)
+                .WithPayload(payload)
+                .WithQualityOfServiceLevel(qualityOfServiceLevel)
+            );
+        }
+
+        public static Task PublishAsync(this IApplicationMessagePublisher publisher, Func<MqttApplicationMessageBuilder, MqttApplicationMessageBuilder> builder)
+        {
+            var message = builder(new MqttApplicationMessageBuilder()).Build();
+            return publisher.PublishAsync(message);
+        }
+    }
+}

Source/MQTTnet/Channel/IMqttChannel.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Channel
+{
+    public interface IMqttChannel : IDisposable
+    {
+        string Endpoint { get; }
+
+        Task ConnectAsync(CancellationToken cancellationToken);
+        Task DisconnectAsync();
+
+        Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+        Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken);
+    }
+}

Source/MQTTnet/Client/IMqttClient.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Client
+{
+    public interface IMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
+    {
+        bool IsConnected { get; }
+
+        event EventHandler<MqttClientConnectedEventArgs> Connected;
+        event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
+
+        Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options);
+        Task DisconnectAsync();
+
+        Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
+        Task UnsubscribeAsync(IEnumerable<string> topics);
+    }
+}

Source/MQTTnet/Client/IMqttClientAdapterFactory.cs

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

Source/MQTTnet/Client/IMqttClientChannelOptions.cs

@@ -0,0 +1,7 @@
+namespace MQTTnet.Client
+{
+    public interface IMqttClientChannelOptions
+    {
+        MqttClientTlsOptions TlsOptions { get; }
+    }
+}

Source/MQTTnet/Client/IMqttClientCredentials.cs

@@ -0,0 +1,8 @@
+namespace MQTTnet.Client
+{
+    public interface IMqttClientCredentials
+    {
+        string Password { get; }
+        string Username { get; }
+    }
+}

Source/MQTTnet/Client/IMqttClientFactory.cs

@@ -0,0 +1,11 @@
+using MQTTnet.Diagnostics;
+
+namespace MQTTnet.Client
+{
+    public interface IMqttClientFactory
+    {
+        IMqttClient CreateMqttClient();
+
+        IMqttClient CreateMqttClient(IMqttNetLogger logger);
+    }
+}

Source/MQTTnet/Client/IMqttClientOptions.cs

@@ -0,0 +1,20 @@
+using System;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Client
+{
+    public interface IMqttClientOptions
+    {
+        string ClientId { get; }
+        bool CleanSession { get; }
+        IMqttClientCredentials Credentials { get; }
+        MqttProtocolVersion ProtocolVersion { get; }
+        IMqttClientChannelOptions ChannelOptions { get; }
+        
+        TimeSpan CommunicationTimeout { get; }
+        TimeSpan KeepAlivePeriod { get; }
+        TimeSpan? KeepAliveSendInterval { get; }
+        
+        MqttApplicationMessage WillMessage { get; }
+    }
+}

Source/MQTTnet/Client/MqttClient.cs

@@ -0,0 +1,549 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Exceptions;
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Client
+{
+    public class MqttClient : IMqttClient
+    {
+        private readonly MqttPacketIdentifierProvider _packetIdentifierProvider = new MqttPacketIdentifierProvider();
+        private readonly Stopwatch _sendTracker = new Stopwatch();
+        private readonly SemaphoreSlim _disconnectLock = new SemaphoreSlim(1, 1);
+        private readonly MqttPacketDispatcher _packetDispatcher = new MqttPacketDispatcher();
+        
+        private readonly IMqttClientAdapterFactory _adapterFactory;
+        private readonly IMqttNetChildLogger _logger;
+
+        private IMqttClientOptions _options;
+        private CancellationTokenSource _cancellationTokenSource;
+        private Task _packetReceiverTask;
+        private Task _keepAliveMessageSenderTask;
+        private IMqttChannelAdapter _adapter;
+        private bool _cleanDisconnectInitiated;
+
+        public MqttClient(IMqttClientAdapterFactory channelFactory, IMqttNetLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            _adapterFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
+            _logger = logger.CreateChildLogger(nameof(MqttClient));
+        }
+
+        public event EventHandler<MqttClientConnectedEventArgs> Connected;
+        public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
+        public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
+
+        public bool IsConnected { get; private set; }
+
+        public async Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+            if (options.ChannelOptions == null) throw new ArgumentException("ChannelOptions are not set.");
+
+            ThrowIfConnected("It is not allowed to connect with a server after the connection is established.");
+
+            try
+            {
+                _cancellationTokenSource = new CancellationTokenSource();
+                _options = options;
+                _packetIdentifierProvider.Reset();
+                _packetDispatcher.Reset();
+
+                _adapter = _adapterFactory.CreateClientAdapter(options, _logger);
+
+                _logger.Verbose($"Trying to connect with server ({_options.ChannelOptions}).");
+                await _adapter.ConnectAsync(_options.CommunicationTimeout, _cancellationTokenSource.Token).ConfigureAwait(false);
+                _logger.Verbose("Connection with server established.");
+
+                StartReceivingPackets(_cancellationTokenSource.Token);
+
+                var connectResponse = await AuthenticateAsync(options.WillMessage, _cancellationTokenSource.Token).ConfigureAwait(false);
+                _logger.Verbose("MQTT connection with server established.");
+
+                _sendTracker.Restart();
+
+                if (_options.KeepAlivePeriod != TimeSpan.Zero)
+                {
+                    StartSendingKeepAliveMessages(_cancellationTokenSource.Token);
+                }
+
+                IsConnected = true;
+                Connected?.Invoke(this, new MqttClientConnectedEventArgs(connectResponse.IsSessionPresent));
+
+                _logger.Info("Connected.");
+                return new MqttClientConnectResult(connectResponse.IsSessionPresent);
+            }
+            catch (Exception exception)
+            {
+                _logger.Error(exception, "Error while connecting with server.");
+                await DisconnectInternalAsync(null, exception).ConfigureAwait(false);
+
+                throw;
+            }
+        }
+
+        public async Task DisconnectAsync()
+        {
+            try
+            {
+                _cleanDisconnectInitiated = true;
+
+                if (IsConnected && !_cancellationTokenSource.IsCancellationRequested)
+                {
+                    await SendAsync(new MqttDisconnectPacket(), _cancellationTokenSource.Token).ConfigureAwait(false);
+                }
+            }
+            finally
+            {
+                await DisconnectInternalAsync(null, null).ConfigureAwait(false);
+            }
+        }
+
+        public async Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
+        {
+            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
+
+            ThrowIfNotConnected();
+
+            var subscribePacket = new MqttSubscribePacket
+            {
+                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
+                TopicFilters = topicFilters.ToList()
+            };
+
+            var response = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+
+            if (response.SubscribeReturnCodes.Count != subscribePacket.TopicFilters.Count)
+            {
+                throw new MqttProtocolViolationException("The return codes are not matching the topic filters [MQTT-3.9.3-1].");
+            }
+
+            return subscribePacket.TopicFilters.Select((t, i) => new MqttSubscribeResult(t, response.SubscribeReturnCodes[i])).ToList();
+        }
+
+        public async Task UnsubscribeAsync(IEnumerable<string> topicFilters)
+        {
+            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
+
+            ThrowIfNotConnected();
+
+            var unsubscribePacket = new MqttUnsubscribePacket
+            {
+                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
+                TopicFilters = topicFilters.ToList()
+            };
+
+            await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+        }
+
+        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
+        {
+            ThrowIfNotConnected();
+
+            var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
+            var packetGroups = publishPackets.GroupBy(p => p.QualityOfServiceLevel).OrderBy(g => g.Key);
+
+            foreach (var qosGroup in packetGroups)
+            {
+                switch (qosGroup.Key)
+                {
+                    case MqttQualityOfServiceLevel.AtMostOnce:
+                        {
+                            // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
+                            await SendAsync(qosGroup, _cancellationTokenSource.Token).ConfigureAwait(false);
+                            break;
+                        }
+                    case MqttQualityOfServiceLevel.AtLeastOnce:
+                        {
+                            foreach (var publishPacket in qosGroup)
+                            {
+                                publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
+                                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+                            }
+
+                            break;
+                        }
+                    case MqttQualityOfServiceLevel.ExactlyOnce:
+                        {
+                            foreach (var publishPacket in qosGroup)
+                            {
+                                publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
+
+                                var pubRecPacket = await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+                                var pubRelPacket = new MqttPubRelPacket
+                                {
+                                    PacketIdentifier = pubRecPacket.PacketIdentifier
+                                };
+
+                                await SendAndReceiveAsync<MqttPubCompPacket>(pubRelPacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+                            }
+
+                            break;
+                        }
+                    default:
+                        {
+                            throw new InvalidOperationException();
+                        }
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            _cancellationTokenSource?.Dispose();
+            _cancellationTokenSource = null;
+
+            _adapter?.Dispose();
+        }
+
+        private async Task<MqttConnAckPacket> AuthenticateAsync(MqttApplicationMessage willApplicationMessage, CancellationToken cancellationToken)
+        {
+            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, cancellationToken).ConfigureAwait(false);
+            if (response.ConnectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
+            {
+                throw new MqttConnectingFailedException(response.ConnectReturnCode);
+            }
+
+            return response;
+        }
+
+        private void ThrowIfNotConnected()
+        {
+            if (!IsConnected) throw new MqttCommunicationException("The client is not connected.");
+        }
+
+        private void ThrowIfConnected(string message)
+        {
+            if (IsConnected) throw new MqttProtocolViolationException(message);
+        }
+
+        private async Task DisconnectInternalAsync(Task sender, Exception exception)
+        {
+            await InitiateDisconnectAsync().ConfigureAwait(false);
+
+            var clientWasConnected = IsConnected;
+            IsConnected = false;
+
+            try
+            {
+                await WaitForTaskAsync(_packetReceiverTask, sender).ConfigureAwait(false);
+                await WaitForTaskAsync(_keepAliveMessageSenderTask, sender).ConfigureAwait(false);
+
+                if (_adapter != null)
+                {
+                    await _adapter.DisconnectAsync(_options.CommunicationTimeout, CancellationToken.None).ConfigureAwait(false);
+                }
+
+                _logger.Verbose("Disconnected from adapter.");
+            }
+            catch (Exception adapterException)
+            {
+                _logger.Warning(adapterException, "Error while disconnecting from adapter.");
+            }
+            finally
+            {
+                _adapter?.Dispose();
+                _adapter = null;
+                _cancellationTokenSource?.Dispose();
+                _cancellationTokenSource = null;
+                _cleanDisconnectInitiated = false;
+
+                _logger.Info("Disconnected.");
+                Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected, exception));
+            }
+        }
+
+        private async Task InitiateDisconnectAsync()
+        {
+            await _disconnectLock.WaitAsync().ConfigureAwait(false);
+            try
+            {
+                if (_cancellationTokenSource == null || _cancellationTokenSource.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                _cancellationTokenSource.Cancel(false);
+            }
+            catch (Exception adapterException)
+            {
+                _logger.Warning(adapterException, "Error while initiating disconnect.");
+            }
+            finally
+            {
+                _disconnectLock.Release();
+            }
+        }
+
+        private Task SendAsync(MqttBasePacket packet, CancellationToken cancellationToken)
+        {
+            return SendAsync(new[] { packet }, cancellationToken);
+        }
+
+        private Task SendAsync(IEnumerable<MqttBasePacket> packets, CancellationToken cancellationToken)
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                throw new TaskCanceledException();
+            }
+
+            _sendTracker.Restart();
+            return _adapter.SendPacketsAsync(_options.CommunicationTimeout, packets, cancellationToken);
+        }
+
+        private async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket, CancellationToken cancellationToken) where TResponsePacket : MqttBasePacket
+        {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                throw new TaskCanceledException();
+            }
+
+            _sendTracker.Restart();
+
+            ushort identifier = 0;
+            if (requestPacket is IMqttPacketWithIdentifier packetWithIdentifier && packetWithIdentifier.PacketIdentifier.HasValue)
+            {
+                identifier = packetWithIdentifier.PacketIdentifier.Value;
+            }
+
+            var packetAwaiter = _packetDispatcher.AddPacketAwaiter<TResponsePacket>(identifier);
+            try
+            {
+                await _adapter.SendPacketsAsync(_options.CommunicationTimeout, new[] { requestPacket }, cancellationToken).ConfigureAwait(false);
+                var respone = await Internal.TaskExtensions.TimeoutAfter(ct => packetAwaiter.Task, _options.CommunicationTimeout, cancellationToken).ConfigureAwait(false);
+
+                return (TResponsePacket)respone;
+            }
+            catch (MqttCommunicationTimedOutException)
+            {
+                _logger.Warning(null, "Timeout while waiting for packet of type '{0}'.", typeof(TResponsePacket).Namespace);
+                throw;
+            }
+            finally
+            {
+                _packetDispatcher.RemovePacketAwaiter<TResponsePacket>(identifier);
+            }
+        }
+
+        private async Task SendKeepAliveMessagesAsync(CancellationToken cancellationToken)
+        {
+            _logger.Verbose("Start sending keep alive packets.");
+
+            try
+            {
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    var keepAliveSendInterval = TimeSpan.FromSeconds(_options.KeepAlivePeriod.TotalSeconds * 0.75);
+                    if (_options.KeepAliveSendInterval.HasValue)
+                    {
+                        keepAliveSendInterval = _options.KeepAliveSendInterval.Value;
+                    }
+
+                    var waitTime = keepAliveSendInterval - _sendTracker.Elapsed;
+                    if (waitTime <= TimeSpan.Zero)
+                    {
+                        await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket(), cancellationToken).ConfigureAwait(false);
+                        waitTime = keepAliveSendInterval;
+                    }
+
+                    await Task.Delay(waitTime, cancellationToken).ConfigureAwait(false);
+                }
+            }
+            catch (Exception exception)
+            {
+                if (_cleanDisconnectInitiated)
+                {
+                    return;
+                }
+
+                if (exception is OperationCanceledException)
+                {
+                }
+                else if (exception is MqttCommunicationException)
+                {
+                    _logger.Warning(exception, "MQTT communication exception while sending/receiving keep alive packets.");
+                }
+                else
+                {
+                    _logger.Error(exception, "Unhandled exception while sending/receiving keep alive packets.");
+                }
+
+                await DisconnectInternalAsync(_keepAliveMessageSenderTask, exception).ConfigureAwait(false);
+            }
+            finally
+            {
+                _logger.Verbose("Stopped sending keep alive packets.");
+            }
+        }
+
+        private async Task ReceivePacketsAsync(CancellationToken cancellationToken)
+        {
+            _logger.Verbose("Start receiving packets.");
+
+            try
+            {
+                while (!cancellationToken.IsCancellationRequested)
+                {
+                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+                    if (packet != null)
+                    {
+                        await ProcessReceivedPacketAsync(packet, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+            }
+            catch (Exception exception)
+            {
+                if (_cleanDisconnectInitiated)
+                {
+                    return;
+                }
+
+                if (exception is OperationCanceledException)
+                {
+                }
+                else if (exception is MqttCommunicationException)
+                {
+                    _logger.Warning(exception, "MQTT communication exception while receiving packets.");
+                }
+                else
+                {
+                    _logger.Error(exception, "Unhandled exception while receiving packets.");
+                }
+
+                _packetDispatcher.Dispatch(exception);
+                await DisconnectInternalAsync(_packetReceiverTask, exception).ConfigureAwait(false);
+            }
+            finally
+            {
+                _logger.Verbose("Stopped receiving packets.");
+            }
+        }
+
+        private Task ProcessReceivedPacketAsync(MqttBasePacket packet, CancellationToken cancellationToken)
+        {
+            if (packet is MqttPublishPacket publishPacket)
+            {
+                return ProcessReceivedPublishPacketAsync(publishPacket, cancellationToken);
+            }
+
+            if (packet is MqttPingReqPacket)
+            {
+                return SendAsync(new MqttPingRespPacket(), cancellationToken);
+            }
+
+            if (packet is MqttDisconnectPacket)
+            {
+                return DisconnectAsync();
+            }
+
+            if (packet is MqttPubRelPacket pubRelPacket)
+            {
+                return ProcessReceivedPubRelPacket(pubRelPacket, cancellationToken);
+            }
+
+            _packetDispatcher.Dispatch(packet);
+            return Task.FromResult(0);
+        }
+
+        private Task ProcessReceivedPublishPacketAsync(MqttPublishPacket publishPacket, CancellationToken cancellationToken)
+        {
+            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
+            {
+                FireApplicationMessageReceivedEvent(publishPacket);
+                return Task.FromResult(0);
+            }
+
+            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
+            {
+                FireApplicationMessageReceivedEvent(publishPacket);
+                return SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier }, cancellationToken);
+            }
+
+            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
+            {
+                // QoS 2 is implement as method "B" (4.3.3 QoS 2: Exactly once delivery)
+                FireApplicationMessageReceivedEvent(publishPacket);
+                return SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier }, cancellationToken);
+            }
+
+            throw new MqttCommunicationException("Received a not supported QoS level.");
+        }
+
+        private Task ProcessReceivedPubRelPacket(MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
+        {
+            var response = new MqttPubCompPacket
+            {
+                PacketIdentifier = pubRelPacket.PacketIdentifier
+            };
+
+            return SendAsync(response, cancellationToken);
+        }
+
+        private void StartReceivingPackets(CancellationToken cancellationToken)
+        {
+            _packetReceiverTask = Task.Run(
+                () => ReceivePacketsAsync(cancellationToken),
+                cancellationToken);
+        }
+
+        private void StartSendingKeepAliveMessages(CancellationToken cancellationToken)
+        {
+            _keepAliveMessageSenderTask = Task.Run(
+                () => SendKeepAliveMessagesAsync(cancellationToken),
+                cancellationToken);
+        }
+
+        private void FireApplicationMessageReceivedEvent(MqttPublishPacket publishPacket)
+        {
+            try
+            {
+                var applicationMessage = publishPacket.ToApplicationMessage();
+                ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(_options.ClientId, applicationMessage));
+            }
+            catch (Exception exception)
+            {
+                _logger.Error(exception, "Unhandled exception while handling application message.");
+            }
+        }
+
+        private static async Task WaitForTaskAsync(Task task, Task sender)
+        {
+            if (task == sender || task == null)
+            {
+                return;
+            }
+
+            if (task.IsCanceled || task.IsCompleted || task.IsFaulted)
+            {
+                return;
+            }
+
+            try
+            {
+                await task.ConfigureAwait(false);
+            }
+            catch (TaskCanceledException)
+            {
+            }
+        }
+    }
+}

Source/MQTTnet/Client/MqttClientConnectResult.cs

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

Source/MQTTnet/Client/MqttClientConnectedEventArgs.cs

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

Source/MQTTnet/Client/MqttClientCredentials.cs

@@ -0,0 +1,9 @@
+namespace MQTTnet.Client
+{
+    public class MqttClientCredentials : IMqttClientCredentials
+    {
+        public string Username { get; set; }
+
+        public string Password { get; set; }
+    }
+}

Source/MQTTnet/Client/MqttClientDisconnectedEventArgs.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientDisconnectedEventArgs : EventArgs
+    {
+        public MqttClientDisconnectedEventArgs(bool clientWasConnected, Exception exception)
+        {
+            ClientWasConnected = clientWasConnected;
+            Exception = exception;
+        }
+
+        public bool ClientWasConnected { get; }
+
+        public Exception Exception { get; }
+    }
+}

Source/MQTTnet/Client/MqttClientExtensions.cs

@@ -0,0 +1,43 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Client
+{
+    public static class MqttClientExtensions
+    {
+        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, params TopicFilter[] topicFilters)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
+
+            return client.SubscribeAsync(topicFilters.ToList());
+        }
+
+        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, string topic, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
+        }
+
+        public static Task<IList<MqttSubscribeResult>> SubscribeAsync(this IMqttClient client, string topic)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return client.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build());
+        }
+
+        public static Task UnsubscribeAsync(this IMqttClient client, params string[] topicFilters)
+        {
+            if (client == null) throw new ArgumentNullException(nameof(client));
+            if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
+
+            return client.UnsubscribeAsync(topicFilters.ToList());
+        }
+    }
+}

Source/MQTTnet/Client/MqttClientOptions.cs

@@ -0,0 +1,20 @@
+using System;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientOptions : IMqttClientOptions
+    {
+        public string ClientId { get; set; } = Guid.NewGuid().ToString("N");
+        public bool CleanSession { get; set; } = true;
+        public IMqttClientCredentials Credentials { get; set; } = new MqttClientCredentials();
+        public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
+        public IMqttClientChannelOptions ChannelOptions { get; set; }
+
+        public TimeSpan CommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
+        public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(15);
+        public TimeSpan? KeepAliveSendInterval { get; set; }
+        
+        public MqttApplicationMessage WillMessage { get; set; }
+    }
+}

Source/MQTTnet/Client/MqttClientOptionsBuilder.cs

@@ -0,0 +1,141 @@
+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 WithKeepAliveSendInterval(TimeSpan value)
+        {
+            _options.KeepAliveSendInterval = 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;
+        }
+    }
+}

Source/MQTTnet/Client/MqttClientTcpOptions.cs

@@ -0,0 +1,18 @@
+namespace MQTTnet.Client
+{
+    public class MqttClientTcpOptions : IMqttClientChannelOptions
+    {
+        public string Server { get; set; }
+
+        public int? Port { get; set; }
+
+        public int BufferSize { get; set; } = 4096;
+
+        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
+
+        public override string ToString()
+        {
+            return Server + ":" + this.GetPort();
+        }
+    }
+}

Source/MQTTnet/Client/MqttClientTcpOptionsExtensions.cs

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

Source/MQTTnet/Client/MqttClientTlsOptions.cs

@@ -0,0 +1,22 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
+
+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; }
+
+        public Func<X509Certificate, X509Chain, SslPolicyErrors, IMqttClientOptions, bool> CertificateValidationCallback { get; set; }
+    }
+}

Source/MQTTnet/Client/MqttClientWebSocketOptions.cs

@@ -0,0 +1,23 @@
+using System.Collections.Generic;
+using System.Net;
+
+namespace MQTTnet.Client
+{
+    public class MqttClientWebSocketOptions : IMqttClientChannelOptions
+    {
+        public string Uri { get; set; }
+
+        public IDictionary<string, string> RequestHeaders { get; set; }
+
+        public ICollection<string> SubProtocols { get; set; } = new List<string> { "mqtt" };
+
+        public CookieContainer CookieContainer { get; set; }
+
+        public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
+
+        public override string ToString()
+        {
+            return Uri;
+        }
+    }
+}

Source/MQTTnet/Client/MqttPacketDispatcher.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+using MQTTnet.Packets;
+
+namespace MQTTnet.Client
+{
+    public class MqttPacketDispatcher
+    {
+        private readonly ConcurrentDictionary<Tuple<ushort, Type>, TaskCompletionSource<MqttBasePacket>> _awaiters = new ConcurrentDictionary<Tuple<ushort, Type>, TaskCompletionSource<MqttBasePacket>>();
+        
+        public void Dispatch(Exception exception)
+        {
+            foreach (var awaiter in _awaiters)
+            {
+                Task.Run(() => awaiter.Value.TrySetException(exception)); // Task.Run fixes a dead lock. Without this the client only receives one message.
+            }
+
+            _awaiters.Clear();
+        }
+
+        public void Dispatch(MqttBasePacket packet)
+        {
+            if (packet == null) throw new ArgumentNullException(nameof(packet));
+
+            ushort identifier = 0;
+            if (packet is IMqttPacketWithIdentifier packetWithIdentifier && packetWithIdentifier.PacketIdentifier.HasValue)
+            {
+                identifier = packetWithIdentifier.PacketIdentifier.Value;
+            }
+
+            var type = packet.GetType();
+            var key = new Tuple<ushort, Type>(identifier, type);
+            
+            if (_awaiters.TryRemove(key, out var awaiter))
+            {
+                Task.Run(() => awaiter.TrySetResult(packet)); // Task.Run fixes a dead lock. Without this the client only receives one message.
+                return;
+            }
+
+            throw new InvalidOperationException($"Packet of type '{type.Name}' not handled or dispatched.");
+        }
+
+        public void Reset()
+        {
+            _awaiters.Clear();
+        }
+
+        public TaskCompletionSource<MqttBasePacket> AddPacketAwaiter<TResponsePacket>(ushort? identifier) where TResponsePacket : MqttBasePacket
+        {
+            var tcs = new TaskCompletionSource<MqttBasePacket>();
+
+            if (!identifier.HasValue)
+            {
+                identifier = 0;
+            }
+            
+            var key = new Tuple<ushort, Type>(identifier ?? 0, typeof(TResponsePacket));
+            if (!_awaiters.TryAdd(key, tcs))
+            {
+                throw new InvalidOperationException($"The packet dispatcher already has an awaiter for packet of type '{key.Item2.Name}' with identifier {key.Item1}.");
+            }
+
+            return tcs;
+        }
+
+        public void RemovePacketAwaiter<TResponsePacket>(ushort? identifier) where TResponsePacket : MqttBasePacket
+        {
+            if (!identifier.HasValue)
+            {
+                identifier = 0;
+            }
+
+            var key = new Tuple<ushort, Type>(identifier ?? 0, typeof(TResponsePacket));
+            _awaiters.TryRemove(key, out _);
+        }
+    }
+}

Source/MQTTnet/Client/MqttPacketIdentifierProvider.cs

@@ -0,0 +1,32 @@
+namespace MQTTnet.Client
+{
+    public class MqttPacketIdentifierProvider
+    {
+        private readonly object _syncRoot = new object();
+        private ushort _value;
+
+        public void Reset()
+        {
+            lock (_syncRoot)
+            {
+                _value = 0;
+            }
+        }
+
+        public ushort GetNewPacketIdentifier()
+        {
+            lock (_syncRoot)
+            {
+                _value++;
+
+                if (_value == 0)
+                {
+                    // As per official MQTT documentation the package identifier should never be 0.
+                    _value = 1;
+                }
+
+                return _value;
+            }
+        }
+    }
+}

Source/MQTTnet/Client/MqttSubscribeResult.cs

@@ -0,0 +1,17 @@
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Client
+{
+    public class MqttSubscribeResult
+    {
+        public MqttSubscribeResult(TopicFilter topicFilter, MqttSubscribeReturnCode returnCode)
+        {
+            TopicFilter = topicFilter;
+            ReturnCode = returnCode;
+        }
+
+        public TopicFilter TopicFilter { get; }
+
+        public MqttSubscribeReturnCode ReturnCode { get; }
+    }
+}

Source/MQTTnet/Diagnostics/IMqttNetChildLogger.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public interface IMqttNetChildLogger
+    {
+        IMqttNetChildLogger CreateChildLogger(string source = null);
+
+        void Verbose(string message, params object[] parameters);
+
+        void Info(string message, params object[] parameters);
+
+        void Warning(Exception exception, string message, params object[] parameters);
+
+        void Error(Exception exception, string message, params object[] parameters);
+    }
+}

Source/MQTTnet/Diagnostics/IMqttNetLogger.cs

@@ -0,0 +1,13 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public interface IMqttNetLogger
+    {
+        event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
+
+        IMqttNetChildLogger CreateChildLogger(string source = null);
+
+        void Publish(MqttNetLogLevel logLevel, string source, string message, object[] parameters, Exception exception);
+    }
+}

Source/MQTTnet/Diagnostics/MqttNetChildLogger.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public class MqttNetChildLogger : IMqttNetChildLogger
+    {
+        private readonly IMqttNetLogger _logger;
+        private readonly string _source;
+
+        public MqttNetChildLogger(IMqttNetLogger logger, string source)
+        {
+            _logger = logger;
+            _source = source;
+        }
+
+        public IMqttNetChildLogger CreateChildLogger(string source)
+        {
+            string childSource;
+            if (!string.IsNullOrEmpty(_source))
+            {
+                childSource = _source + "." + source;
+            }
+            else
+            {
+                childSource = source;
+            }
+
+            return new MqttNetChildLogger(_logger, childSource);
+        }
+
+        public void Verbose(string message, params object[] parameters)
+        {
+            _logger.Publish(MqttNetLogLevel.Verbose, _source, message, parameters, null);
+        }
+
+        public void Info(string message, params object[] parameters)
+        {
+            _logger.Publish(MqttNetLogLevel.Info, _source, message, parameters, null);
+        }
+
+        public void Warning(Exception exception, string message, params object[] parameters)
+        {
+            _logger.Publish(MqttNetLogLevel.Warning, _source, message, parameters, exception);
+        }
+
+        public void Error(Exception exception, string message, params object[] parameters)
+        {
+            _logger.Publish(MqttNetLogLevel.Error, _source, message, parameters, exception);
+        }
+    }
+}

Source/MQTTnet/Diagnostics/MqttNetGlobalLogger.cs

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

Source/MQTTnet/Diagnostics/MqttNetLogLevel.cs

@@ -0,0 +1,13 @@
+namespace MQTTnet.Diagnostics
+{
+    public enum MqttNetLogLevel
+    {
+        Verbose,
+
+        Info,
+
+        Warning,
+
+        Error
+    }
+}

Source/MQTTnet/Diagnostics/MqttNetLogMessage.cs

@@ -0,0 +1,43 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public class MqttNetLogMessage
+    {
+        public MqttNetLogMessage(string logId, DateTime timestamp, int threadId, string source, MqttNetLogLevel level, string message, Exception exception)
+        {
+            LogId = logId;
+            Timestamp = timestamp;
+            ThreadId = threadId;
+            Source = source;
+            Level = level;
+            Message = message;
+            Exception = exception;
+        }
+
+        public string LogId { get; }
+
+        public DateTime Timestamp { get; }
+
+        public int ThreadId { get; }
+
+        public string Source { get; }
+
+        public MqttNetLogLevel Level { get; }
+
+        public string Message { get; }
+
+        public Exception Exception { get; }
+
+        public override string ToString()
+        {
+            var result = $"[{Timestamp:O}] [{LogId}] [{ThreadId}] [{Source}] [{Level}]: {Message}";
+            if (Exception != null)
+            {
+                result += Environment.NewLine + Exception;
+            }
+
+            return result;
+        }
+    }
+}

Source/MQTTnet/Diagnostics/MqttNetLogMessagePublishedEventArgs.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace MQTTnet.Diagnostics
+{
+    public class MqttNetLogMessagePublishedEventArgs : EventArgs
+    {
+        public MqttNetLogMessagePublishedEventArgs(MqttNetLogMessage logMessage)
+        {
+            TraceMessage = logMessage ?? throw new ArgumentNullException(nameof(logMessage));
+        }
+
+        public MqttNetLogMessage TraceMessage { get; }
+    }
+}

Source/MQTTnet/Diagnostics/MqttNetLogger.cs

@@ -0,0 +1,56 @@
+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 IMqttNetChildLogger CreateChildLogger(string source = null)
+        {
+            return new MqttNetChildLogger(this, source);
+        }
+
+        public void Publish(MqttNetLogLevel logLevel, string source, string message, object[] parameters, Exception exception)
+        {
+            var hasLocalListeners = LogMessagePublished != null;
+            var hasGlobalListeners = MqttNetGlobalLogger.HasListeners;
+
+            if (!hasLocalListeners && !hasGlobalListeners)
+            {
+                return;
+            }
+
+            if (parameters?.Length > 0)
+            {
+                try
+                {
+                    message = string.Format(message, parameters);
+                }
+                catch
+                {
+                    message = "MESSAGE FORMAT INVALID: " + message;
+                }
+            }
+
+            var traceMessage = new MqttNetLogMessage(_logId, DateTime.UtcNow, Environment.CurrentManagedThreadId, source, logLevel, message, exception);
+
+            if (hasGlobalListeners)
+            {
+                MqttNetGlobalLogger.Publish(traceMessage);
+            }
+
+            if (hasLocalListeners)
+            {
+                LogMessagePublished?.Invoke(this, new MqttNetLogMessagePublishedEventArgs(traceMessage));
+            }
+        }
+    }
+}

Source/MQTTnet/Diagnostics/TargetFrameworkInfoProvider.cs

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

Source/MQTTnet/Exceptions/MqttCommunicationException.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace MQTTnet.Exceptions
+{
+    public class MqttCommunicationException : Exception
+    {
+        protected MqttCommunicationException()
+        {
+        }
+
+        public MqttCommunicationException(Exception innerException)
+            : base(innerException.Message, innerException)
+        {
+        }
+
+        public MqttCommunicationException(string message)
+            : base(message)
+        {
+        }
+    }
+}

Source/MQTTnet/Exceptions/MqttCommunicationTimedOutException.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace MQTTnet.Exceptions
+{
+    public class MqttCommunicationTimedOutException : MqttCommunicationException
+    {
+        public MqttCommunicationTimedOutException()
+        {
+        }
+
+        public MqttCommunicationTimedOutException(Exception innerException) : base(innerException)
+        {
+        }
+    }
+}

Source/MQTTnet/Exceptions/MqttProtocolViolationException.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace MQTTnet.Exceptions
+{
+    public class MqttProtocolViolationException : Exception
+    {
+        public MqttProtocolViolationException(string message)
+            : base(message)
+        {
+        }
+    }
+}

Source/MQTTnet/IApplicationMessagePublisher.cs

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

Source/MQTTnet/IApplicationMessageReceiver.cs

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

Source/MQTTnet/Implementations/MqttClientAdapterFactory.cs

@@ -0,0 +1,36 @@
+using System;
+using MQTTnet.Adapter;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttClientAdapterFactory : IMqttClientAdapterFactory
+    {
+        public IMqttChannelAdapter CreateClientAdapter(IMqttClientOptions options, IMqttNetChildLogger logger)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            var serializer = new MqttPacketSerializer { ProtocolVersion = options.ProtocolVersion };
+
+            switch (options.ChannelOptions)
+            {
+                case MqttClientTcpOptions _:
+                    {
+                        return new MqttChannelAdapter(new MqttTcpChannel(options), serializer, logger);
+                    }
+
+                case MqttClientWebSocketOptions webSocketOptions:
+                    {
+                        return new MqttChannelAdapter(new MqttWebSocketChannel(webSocketOptions), serializer, logger);
+                    }
+
+                default:
+                    {
+                        throw new NotSupportedException();
+                    }
+            }
+        }
+    }
+}

Source/MQTTnet/Implementations/MqttTcpChannel.Uwp.cs

@@ -0,0 +1,166 @@
+#if WINDOWS_UWP
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices.WindowsRuntime;
+using System.Threading;
+using System.Threading.Tasks;
+using Windows.Networking;
+using Windows.Networking.Sockets;
+using Windows.Security.Cryptography.Certificates;
+using MQTTnet.Channel;
+using MQTTnet.Client;
+using MQTTnet.Server;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttTcpChannel : IMqttChannel
+    {
+        private readonly MqttClientTcpOptions _options;
+        private readonly int _bufferSize;
+
+        private StreamSocket _socket;
+        private Stream _readStream;
+        private Stream _writeStream;
+
+        public MqttTcpChannel(IMqttClientOptions clientOptions)
+        {
+            _options = (MqttClientTcpOptions)clientOptions.ChannelOptions;
+            _bufferSize = _options.BufferSize;
+        }
+
+        public MqttTcpChannel(StreamSocket socket, IMqttServerOptions serverOptions)
+        {
+            _socket = socket ?? throw new ArgumentNullException(nameof(socket));
+            _bufferSize = serverOptions.DefaultEndpointOptions.BufferSize;
+
+            CreateStreams();
+        }
+
+        public static Func<MqttClientTcpOptions, IEnumerable<ChainValidationResult>> CustomIgnorableServerCertificateErrorsResolver { get; set; }
+
+        public string Endpoint => _socket?.Information?.RemoteAddress?.ToString(); // TODO: Check if contains also the port.
+
+        public async Task ConnectAsync(CancellationToken cancellationToken)
+        {
+            if (_socket == null)
+            {
+                _socket = new StreamSocket();
+                _socket.Control.NoDelay = true;
+                _socket.Control.KeepAlive = true;
+            }
+
+            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 Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _readStream.ReadAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            await _writeStream.WriteAsync(buffer, offset, count, cancellationToken);
+            await _writeStream.FlushAsync(cancellationToken);
+        }
+
+        public void Dispose()
+        {
+            TryDispose(_readStream, () => _readStream = null);
+            TryDispose(_writeStream, () => _writeStream = null);
+            TryDispose(_socket, () => _socket = null);
+        }
+
+        private static Certificate LoadCertificate(IMqttClientChannelOptions 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;
+        }
+
+        private void CreateStreams()
+        {
+            _readStream = _socket.InputStream.AsStreamForRead(_bufferSize);
+            _writeStream = _socket.OutputStream.AsStreamForWrite(_bufferSize);
+        }
+
+        private static void TryDispose(IDisposable disposable, Action afterDispose)
+        {
+            try
+            {
+                disposable?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                afterDispose();
+            }
+        }
+    }
+}
+#endif

Source/MQTTnet/Implementations/MqttTcpChannel.cs

@@ -0,0 +1,179 @@
+#if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
+using System;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading.Tasks;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using MQTTnet.Channel;
+using MQTTnet.Client;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttTcpChannel : IMqttChannel
+    {
+        private readonly IMqttClientOptions _clientOptions;
+        private readonly MqttClientTcpOptions _options;
+        
+        private Socket _socket;
+        private Stream _stream;
+
+        /// <summary>
+        /// called on client sockets are created in connect
+        /// </summary>
+        public MqttTcpChannel(IMqttClientOptions clientOptions)
+        {
+            _clientOptions = clientOptions ?? throw new ArgumentNullException(nameof(clientOptions));
+            _options = (MqttClientTcpOptions)clientOptions.ChannelOptions;
+        }
+
+        /// <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));
+
+            CreateStream(sslStream);
+        }
+
+        [Obsolete("There is a new callback at the TLS options. This one will be deleted soon.")]
+        public static Func<X509Certificate, X509Chain, SslPolicyErrors, MqttClientTcpOptions, bool> CustomCertificateValidationCallback { get; set; }
+
+        public string Endpoint => _socket?.RemoteEndPoint?.ToString();
+
+        public async Task ConnectAsync(CancellationToken cancellationToken)
+        {
+            if (_socket == null)
+            {
+                _socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
+            }
+
+#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
+
+            SslStream sslStream = null;
+            if (_options.TlsOptions.UseTls)
+            {
+                sslStream = new SslStream(new NetworkStream(_socket, true), false, InternalUserCertificateValidationCallback);
+                await sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(), SslProtocols.Tls12, _options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
+            }
+
+            CreateStream(sslStream);
+        }
+
+        public Task DisconnectAsync()
+        {
+            Dispose();
+            return Task.FromResult(0);
+        }
+
+        public Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _stream.ReadAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _stream.WriteAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public void Dispose()
+        {
+            TryDispose(_stream, () => _stream = null);
+            TryDispose(_socket, () => _socket = null);
+        }
+
+        private bool InternalUserCertificateValidationCallback(object sender, X509Certificate x509Certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
+        {
+            // Try the instance callback.
+            if (_options.TlsOptions.CertificateValidationCallback != null)
+            {
+                return _options.TlsOptions.CertificateValidationCallback(x509Certificate, chain, sslPolicyErrors,_clientOptions);
+            }
+
+            // Try static callback.
+            if (CustomCertificateValidationCallback != null)
+            {
+                return CustomCertificateValidationCallback(x509Certificate, chain, sslPolicyErrors, _options);
+            }
+
+            if (sslPolicyErrors == SslPolicyErrors.None)
+            {
+                return true;
+            }
+
+            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.RevocationStatusUnknown || c.Status == X509ChainStatusFlags.Revoked || c.Status == X509ChainStatusFlags.RevocationStatusUnknown))
+            {
+                if (!_options.TlsOptions.IgnoreCertificateRevocationErrors)
+                {
+                    return false;
+                }
+            }
+
+            if (chain.ChainStatus.Any(c => c.Status == X509ChainStatusFlags.PartialChain))
+            {
+                if (!_options.TlsOptions.IgnoreCertificateChainErrors)
+                {
+                    return false;
+                }
+            }
+
+            return _options.TlsOptions.AllowUntrustedCertificates;
+        }
+
+        private X509CertificateCollection LoadCertificates()
+        {
+            var certificates = new X509CertificateCollection();
+            if (_options.TlsOptions.Certificates == null)
+            {
+                return certificates;
+            }
+
+            foreach (var certificate in _options.TlsOptions.Certificates)
+            {
+                certificates.Add(new X509Certificate2(certificate));
+            }
+
+            return certificates;
+        }
+
+        private void CreateStream(Stream stream)
+        {
+            if (stream != null)
+            {
+                _stream = stream;
+            }
+            else
+            {
+                _stream = new NetworkStream(_socket, true);
+            }
+        }
+
+        private static void TryDispose(IDisposable disposable, Action afterDispose)
+        {
+            try
+            {
+                disposable?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                afterDispose();
+            }
+        }
+    }
+}
+#endif

Source/MQTTnet/Implementations/MqttTcpServerAdapter.Uwp.cs

@@ -0,0 +1,85 @@
+#if WINDOWS_UWP
+using System;
+using System.Threading.Tasks;
+using Windows.Networking.Sockets;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Serializer;
+using MQTTnet.Server;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttTcpServerAdapter : IMqttServerAdapter
+    {
+        private readonly IMqttNetChildLogger _logger;
+
+        private IMqttServerOptions _options;
+        private StreamSocketListener _listener;
+
+        public MqttTcpServerAdapter(IMqttNetChildLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            _logger = logger.CreateChildLogger(nameof(MqttTcpServerAdapter));
+        }
+
+        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        public async Task StartAsync(IMqttServerOptions options)
+        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+
+            if (_listener != null) throw new InvalidOperationException("Server is already started.");
+
+            if (options.DefaultEndpointOptions.IsEnabled)
+            {
+                _listener = new StreamSocketListener();
+
+                // This also affects the client sockets.
+                _listener.Control.NoDelay = true;
+                _listener.Control.KeepAlive = true;
+                _listener.Control.QualityOfService = SocketQualityOfService.LowLatency;
+                _listener.ConnectionReceived += AcceptDefaultEndpointConnectionsAsync;
+                
+                await _listener.BindServiceNameAsync(options.DefaultEndpointOptions.Port.ToString(), SocketProtectionLevel.PlainSocket);
+            }
+
+            if (options.TlsEndpointOptions.IsEnabled)
+            {
+                throw new NotSupportedException("TLS servers are not supported for UWP apps.");
+            }
+        }
+
+        public Task StopAsync()
+        {
+            if (_listener != null)
+            {
+                _listener.ConnectionReceived -= AcceptDefaultEndpointConnectionsAsync;
+            }
+
+            _listener?.Dispose();
+            _listener = null;
+
+            return Task.FromResult(0);
+        }
+
+        public void Dispose()
+        {
+            StopAsync().GetAwaiter().GetResult();
+        }
+
+        private void AcceptDefaultEndpointConnectionsAsync(StreamSocketListener sender, StreamSocketListenerConnectionReceivedEventArgs args)
+        {
+            try
+            {
+                var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(args.Socket, _options), new MqttPacketSerializer(), _logger);
+                ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
+            }
+            catch (Exception exception)
+            {
+                _logger.Error(exception, "Error while accepting connection at default endpoint.");
+            }
+        }
+    }
+}
+#endif

Source/MQTTnet/Implementations/MqttTcpServerAdapter.cs

@@ -0,0 +1,111 @@
+#if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
+using System;
+using System.Collections.Generic;
+using System.Net.Sockets;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Server;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttTcpServerAdapter : IMqttServerAdapter
+    {
+        private readonly List<MqttTcpServerListener> _listeners = new List<MqttTcpServerListener>();
+        private readonly IMqttNetChildLogger _logger;
+
+        private CancellationTokenSource _cancellationTokenSource;
+
+        public MqttTcpServerAdapter(IMqttNetChildLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            _logger = logger.CreateChildLogger(nameof(MqttTcpServerAdapter));
+        }
+
+        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)
+            {
+                RegisterListeners(options.DefaultEndpointOptions, null);
+            }
+
+            if (options.TlsEndpointOptions.IsEnabled)
+            {
+                if (options.TlsEndpointOptions.Certificate == null)
+                {
+                    throw new ArgumentException("TLS certificate is not set.");
+                }
+
+                var tlsCertificate = new X509Certificate2(options.TlsEndpointOptions.Certificate);
+                if (!tlsCertificate.HasPrivateKey)
+                {
+                    throw new InvalidOperationException("The certificate for TLS encryption must contain the private key.");
+                }
+
+                RegisterListeners(options.TlsEndpointOptions, tlsCertificate);
+            }
+
+            return Task.FromResult(0);
+        }
+
+        public Task StopAsync()
+        {
+            Dispose();
+            return Task.FromResult(0);
+        }
+
+        public void Dispose()
+        {
+            _cancellationTokenSource?.Cancel(false);
+            _cancellationTokenSource?.Dispose();
+            _cancellationTokenSource = null;
+
+            foreach (var listener in _listeners)
+            {
+                listener.Dispose();
+            }
+
+            _listeners.Clear();
+        }
+
+        private void RegisterListeners(MqttServerTcpEndpointBaseOptions options, X509Certificate2 tlsCertificate)
+        {
+            var listenerV4 = new MqttTcpServerListener(
+                AddressFamily.InterNetwork,
+                options,
+                tlsCertificate,
+                _cancellationTokenSource.Token,
+                _logger);
+
+            listenerV4.ClientAccepted += OnClientAccepted;
+            listenerV4.Start();
+            _listeners.Add(listenerV4);
+
+            var listenerV6 = new MqttTcpServerListener(
+                AddressFamily.InterNetworkV6,
+                options,
+                tlsCertificate,
+                _cancellationTokenSource.Token,
+                _logger);
+
+            listenerV6.ClientAccepted += OnClientAccepted;
+            listenerV6.Start();
+            _listeners.Add(listenerV6);
+        }
+
+        private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs e)
+        {
+            ClientAccepted?.Invoke(this, e);
+        }
+    }
+}
+#endif

Source/MQTTnet/Implementations/MqttTcpServerListener.cs

@@ -0,0 +1,109 @@
+#if NET452 || NET461 || NETSTANDARD1_3 || NETSTANDARD2_0
+using System;
+using System.Net;
+using System.Net.Security;
+using System.Net.Sockets;
+using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
+using MQTTnet.Serializer;
+using MQTTnet.Server;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttTcpServerListener : IDisposable
+    {
+        private readonly IMqttNetChildLogger _logger;
+        private readonly CancellationToken _cancellationToken;
+        private readonly AddressFamily _addressFamily;
+        private readonly MqttServerTcpEndpointBaseOptions _options;
+        private readonly X509Certificate2 _tlsCertificate;
+
+        private Socket _socket;
+
+        public MqttTcpServerListener(
+            AddressFamily addressFamily,
+            MqttServerTcpEndpointBaseOptions options,
+            X509Certificate2 tlsCertificate,
+            CancellationToken cancellationToken,
+            IMqttNetChildLogger logger)
+        {
+            _addressFamily = addressFamily;
+            _options = options;
+            _tlsCertificate = tlsCertificate;
+            _cancellationToken = cancellationToken;
+            _logger = logger.CreateChildLogger(nameof(MqttTcpServerListener));
+        }
+
+        public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
+
+        public void Start()
+        {
+            var boundIp = _options.BoundInterNetworkAddress;
+            if (_addressFamily == AddressFamily.InterNetworkV6)
+            {
+                boundIp = _options.BoundInterNetworkV6Address;
+            }
+
+            _socket = new Socket(_addressFamily, SocketType.Stream, ProtocolType.Tcp);
+            _socket.Bind(new IPEndPoint(boundIp, _options.Port));
+
+            _logger.Info($"Starting TCP listener for {_socket.LocalEndPoint} TLS={_tlsCertificate != null}.");
+
+            _socket.Listen(_options.ConnectionBacklog);
+            Task.Run(AcceptClientConnectionsAsync, _cancellationToken);
+        }
+
+        private async Task AcceptClientConnectionsAsync()
+        {
+            while (!_cancellationToken.IsCancellationRequested)
+            {
+                try
+                {
+#if NET452 || NET461
+                    var clientSocket = await Task.Factory.FromAsync(_socket.BeginAccept, _socket.EndAccept, null).ConfigureAwait(false);
+#else
+                    var clientSocket = await _socket.AcceptAsync().ConfigureAwait(false);
+#endif
+                    clientSocket.NoDelay = true;
+
+                    if (_tlsCertificate != null)
+                    {
+                        var sslStream = new SslStream(new NetworkStream(clientSocket), false);
+                        await sslStream.AuthenticateAsServerAsync(_tlsCertificate, false, SslProtocols.Tls12, false).ConfigureAwait(false);
+                    }
+
+                    var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, null), new MqttPacketSerializer(), _logger);
+                    ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
+                }
+                catch (ObjectDisposedException)
+                {
+                    // It can happen that the listener socket is accessed after the cancellation token is already set and the listener socket is disposed.
+                }
+                catch (Exception exception)
+                {
+                    if (exception is SocketException s && s.SocketErrorCode == SocketError.OperationAborted)
+                    {
+                        return;
+                    }
+
+                    _logger.Error(exception, $"Error while accepting connection at TCP listener {_socket.LocalEndPoint} TLS={_tlsCertificate != null}.");
+                    await Task.Delay(TimeSpan.FromSeconds(1), _cancellationToken).ConfigureAwait(false);
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            _socket?.Dispose();
+
+#if NETSTANDARD1_3 || NETSTANDARD2_0 || NET461
+            _tlsCertificate?.Dispose();
+#endif
+        }
+    }
+}
+#endif

Source/MQTTnet/Implementations/MqttWebSocketChannel.cs

@@ -0,0 +1,136 @@
+using System;
+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 class MqttWebSocketChannel : IMqttChannel
+    {
+        private readonly SemaphoreSlim _sendLock = new SemaphoreSlim(1, 1);
+        private readonly MqttClientWebSocketOptions _options;
+
+        private WebSocket _webSocket;
+        
+        public MqttWebSocketChannel(MqttClientWebSocketOptions options)
+        {
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+        }
+
+        public MqttWebSocketChannel(WebSocket webSocket, string endpoint)
+        {
+            _webSocket = webSocket ?? throw new ArgumentNullException(nameof(webSocket));
+            Endpoint = endpoint;
+        }
+
+        public string Endpoint { get; }
+
+        public async Task ConnectAsync(CancellationToken cancellationToken)
+        {
+            var uri = _options.Uri;
+            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
+            {
+                if (_options.TlsOptions?.UseTls == false)
+                {
+                    uri = "ws://" + uri;
+                }
+                else
+                {
+                    uri = "wss://" + uri;
+                }
+            }
+
+            var clientWebSocket = new ClientWebSocket();
+
+            if (_options.RequestHeaders != null)
+            {
+                foreach (var requestHeader in _options.RequestHeaders)
+                {
+                    clientWebSocket.Options.SetRequestHeader(requestHeader.Key, requestHeader.Value);
+                }
+            }
+
+            if (_options.SubProtocols != null)
+            {
+                foreach (var subProtocol in _options.SubProtocols)
+                {
+                    clientWebSocket.Options.AddSubProtocol(subProtocol);
+                }
+            }
+
+            if (_options.CookieContainer != null)
+            {
+                clientWebSocket.Options.Cookies = _options.CookieContainer;
+            }
+
+            if (_options.TlsOptions?.UseTls == true && _options.TlsOptions?.Certificates != null)
+            {
+                clientWebSocket.Options.ClientCertificates = new X509CertificateCollection();
+                foreach (var certificate in _options.TlsOptions.Certificates)
+                {
+                    clientWebSocket.Options.ClientCertificates.Add(new X509Certificate(certificate));
+                }
+            }
+
+            await clientWebSocket.ConnectAsync(new Uri(uri), cancellationToken).ConfigureAwait(false);
+            _webSocket = clientWebSocket;
+        }
+
+        public async Task DisconnectAsync()
+        {
+            if (_webSocket == null)
+            {
+                return;
+            }
+
+            if (_webSocket.State == WebSocketState.Open || _webSocket.State == WebSocketState.Connecting)
+            {
+                await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
+            }
+
+            Dispose();
+        }
+
+        public async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer, offset, count), cancellationToken).ConfigureAwait(false);
+            return response.Count;
+        }
+
+        public async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            // This lock is required because the client will throw an exception if _SendAsync_ is 
+            // called from multiple threads at the same time. But this issue only happens with several
+            // framework versions.
+            await _sendLock.WaitAsync(cancellationToken).ConfigureAwait(false);
+            try
+            {
+                await _webSocket.SendAsync(new ArraySegment<byte>(buffer, offset, count), WebSocketMessageType.Binary, true, cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                _sendLock.Release();
+            }
+        }
+
+        public void Dispose()
+        {
+            _sendLock?.Dispose();
+
+            try
+            {
+                _webSocket?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            finally
+            {
+                _webSocket = null;
+            }
+        }
+    }
+}

Source/MQTTnet/Internal/AsyncAutoResetEvent.cs

@@ -0,0 +1,108 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Internal
+{
+    // Inspired from Stephen Toub (https://blogs.msdn.microsoft.com/pfxteam/2012/02/11/building-async-coordination-primitives-part-2-asyncautoresetevent/) and Chris Gillum (https://stackoverflow.com/a/43012490)
+    public class AsyncAutoResetEvent
+    {
+        private readonly LinkedList<TaskCompletionSource<bool>> _waiters = new LinkedList<TaskCompletionSource<bool>>();
+        private bool _isSignaled;
+
+        public AsyncAutoResetEvent() : this(false)
+        { }
+
+        public AsyncAutoResetEvent(bool signaled)
+        {
+            _isSignaled = signaled;
+        }
+
+        public Task<bool> WaitOneAsync()
+        {
+            return WaitOneAsync(CancellationToken.None);
+        }
+
+        public Task<bool> WaitOneAsync(TimeSpan timeout)
+        {
+            return WaitOneAsync(timeout, CancellationToken.None);
+        }
+
+        public Task<bool> WaitOneAsync(CancellationToken cancellationToken)
+        {
+            return WaitOneAsync(Timeout.InfiniteTimeSpan, cancellationToken);
+        }
+
+        public async Task<bool> WaitOneAsync(TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            TaskCompletionSource<bool> tcs;
+
+            lock (_waiters)
+            {
+                if (_isSignaled)
+                {
+                    _isSignaled = false;
+                    return true;
+                }
+                else if (timeout == TimeSpan.Zero)
+                {
+                    return _isSignaled;
+                }
+                else
+                {
+                    tcs = new TaskCompletionSource<bool>();
+                    _waiters.AddLast(tcs);
+                }
+            }
+
+            Task winner = await Task.WhenAny(tcs.Task, Task.Delay(timeout, cancellationToken)).ConfigureAwait(false);
+            if (winner == tcs.Task)
+            {
+                // The task was signaled.
+                return true;
+            }
+            else
+            {
+                // We timed-out; remove our reference to the task.
+                // This is an O(n) operation since waiters is a LinkedList<T>.
+                lock (_waiters)
+                {
+                    _waiters.Remove(tcs);
+                    if (winner.Status == TaskStatus.Canceled)
+                    {
+                        throw new OperationCanceledException(cancellationToken);
+                    }
+                    else
+                    {
+                        throw new TimeoutException();
+                    }
+                }
+            }
+        }
+
+        public void Set()
+        {
+            TaskCompletionSource<bool> toRelease = null;
+
+            lock (_waiters)
+            {
+                if (_waiters.Count > 0)
+                {
+                    // Signal the first task in the waiters list.
+                    toRelease = _waiters.First.Value;
+                    _waiters.RemoveFirst();
+                }
+                else if (!_isSignaled)
+                {
+                    // No tasks are pending
+                    _isSignaled = true;
+                }
+            }
+
+            toRelease?.SetResult(true);
+        }
+    }
+}

Source/MQTTnet/Internal/AsyncLock.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Internal
+{
+    // From Stephen Toub (https://blogs.msdn.microsoft.com/pfxteam/2012/02/12/building-async-coordination-primitives-part-6-asynclock/)
+    public class AsyncLock : IDisposable
+    {
+        private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
+        private readonly Task<IDisposable> _releaser;
+
+        public AsyncLock()
+        {
+            _releaser = Task.FromResult((IDisposable)new Releaser(this));
+        }
+
+        public Task<IDisposable> LockAsync(CancellationToken cancellationToken)
+        {
+            Task wait = _semaphore.WaitAsync(cancellationToken);
+            return wait.IsCompleted ?
+                        _releaser :
+                        wait.ContinueWith((_, state) => (IDisposable)state,
+                            _releaser.Result, cancellationToken,
+                            TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+        }
+
+        public void Dispose()
+        {
+            _semaphore?.Dispose();
+        }
+
+        private class Releaser : IDisposable
+        {
+            private readonly AsyncLock _toRelease;
+
+            internal Releaser(AsyncLock toRelease)
+            {
+                _toRelease = toRelease;
+            }
+
+            public void Dispose()
+            {
+                _toRelease._semaphore.Release();
+            }
+        }
+    }
+}

Source/MQTTnet/Internal/ExceptionHelper.cs

@@ -0,0 +1,12 @@
+using MQTTnet.Exceptions;
+
+namespace MQTTnet.Internal
+{
+    public static class ExceptionHelper
+    {
+        public static void ThrowGracefulSocketClose()
+        {
+            throw new MqttCommunicationException("Connection gracefully closed from the remote party.");
+        }
+    }
+}

Source/MQTTnet/Internal/MqttApplicationMessageExtensions.cs

@@ -0,0 +1,35 @@
+using MQTTnet.Packets;
+
+namespace MQTTnet.Internal
+{
+    public static class MqttApplicationMessageExtensions
+    {
+        public static MqttApplicationMessage ToApplicationMessage(this MqttPublishPacket publishPacket)
+        {
+            return new MqttApplicationMessage
+            { 
+                Topic = publishPacket.Topic,
+                Payload = publishPacket.Payload,
+                QualityOfServiceLevel = publishPacket.QualityOfServiceLevel,
+                Retain = publishPacket.Retain
+            };
+        }
+
+        public static MqttPublishPacket ToPublishPacket(this MqttApplicationMessage applicationMessage)
+        {
+            if (applicationMessage == null)
+            {
+                return null;
+            }
+
+            return new MqttPublishPacket
+            {
+                Topic = applicationMessage.Topic,
+                Payload = applicationMessage.Payload,
+                QualityOfServiceLevel = applicationMessage.QualityOfServiceLevel,
+                Retain = applicationMessage.Retain,
+                Dup = false
+            };
+        }
+    }
+}

Source/MQTTnet/Internal/TaskExtensions.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Exceptions;
+
+namespace MQTTnet.Internal
+{
+    public static class TaskExtensions
+    {
+        public static async Task TimeoutAfter(Func<CancellationToken, Task> action, TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            if (action == null) throw new ArgumentNullException(nameof(action));
+
+            using (var timeoutCts = new CancellationTokenSource(timeout))
+            using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken))
+            {
+                try
+                {
+                    await action(linkedCts.Token).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException exception)
+                {
+                    var timeoutReached = timeoutCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested;
+                    if (timeoutReached)
+                    {
+                        throw new MqttCommunicationTimedOutException(exception);
+                    }
+
+                    throw;
+                }
+            }
+        }
+
+        public static async Task<TResult> TimeoutAfter<TResult>(Func<CancellationToken, Task<TResult>> action, TimeSpan timeout, CancellationToken cancellationToken)
+        {
+            if (action == null) throw new ArgumentNullException(nameof(action));
+
+            using (var timeoutCts = new CancellationTokenSource(timeout))
+            using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, cancellationToken))
+            {
+                try
+                {
+                    return await action(linkedCts.Token).ConfigureAwait(false);
+                }
+                catch (OperationCanceledException exception)
+                {
+                    var timeoutReached = timeoutCts.IsCancellationRequested && !cancellationToken.IsCancellationRequested;
+                    if (timeoutReached)
+                    {
+                        throw new MqttCommunicationTimedOutException(exception);
+                    }
+
+                    throw;
+                }
+            }
+        }     
+    }
+}

Source/MQTTnet/Internal/TestMqttChannel.cs

@@ -0,0 +1,43 @@
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Channel;
+
+namespace MQTTnet.Internal
+{
+    public class TestMqttChannel : IMqttChannel
+    {
+        private readonly MemoryStream _stream;
+
+        public TestMqttChannel(MemoryStream stream)
+        {
+            _stream = stream;
+        }
+
+        public void Dispose()
+        {
+        }
+
+        public string Endpoint { get; }
+
+        public Task ConnectAsync(CancellationToken cancellationToken)
+        {
+            return Task.FromResult(0);
+        }
+
+        public Task DisconnectAsync()
+        {
+            return Task.FromResult(0);
+        }
+
+        public Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _stream.ReadAsync(buffer, offset, count, cancellationToken);
+        }
+
+        public Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _stream.WriteAsync(buffer, offset, count, cancellationToken);
+        }
+    }
+}

Source/MQTTnet/MQTTnet.csproj

@@ -0,0 +1,68 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
+    <TargetFrameworks Condition=" '$(OS)' != 'Windows_NT' ">netstandard1.3;netstandard2.0</TargetFrameworks>
+    <AssemblyName>MQTTnet</AssemblyName>
+    <RootNamespace>MQTTnet</RootNamespace>
+    <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
+    <AssemblyVersion>0.0.0.0</AssemblyVersion>
+    <FileVersion>0.0.0.0</FileVersion>
+    <Version>0.0.0.0</Version>
+    <Company />
+    <Product />
+    <Description />
+    <Authors />
+    <PackageId />
+    <SignAssembly>false</SignAssembly>
+    <DelaySign>false</DelaySign>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(TargetFramework)'=='uap10.0'">
+    <CopyLocalLockFileAssemblies>false</CopyLocalLockFileAssemblies>
+    <NugetTargetMoniker>UAP,Version=v10.0</NugetTargetMoniker>
+    <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
+    <TargetPlatformVersion>10.0.17134.0</TargetPlatformVersion>
+    <TargetPlatformMinVersion>10.0.10240.0</TargetPlatformMinVersion>
+    <TargetFrameworkIdentifier>.NETCore</TargetFrameworkIdentifier>
+    <TargetFrameworkVersion>v5.0</TargetFrameworkVersion>
+    <DefineConstants>$(DefineConstants);WINDOWS_UWP</DefineConstants>
+    <DefaultLanguage>en</DefaultLanguage>
+    <LanguageTargets>$(MSBuildExtensionsPath)\Microsoft\WindowsXaml\v$(VisualStudioVersion)\Microsoft.Windows.UI.Xaml.CSharp.targets</LanguageTargets>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)'=='Debug'">
+    <DebugType>Full</DebugType>
+  </PropertyGroup>
+  
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x86'" />
+
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
+
+  <PropertyGroup Condition="'$(Configuration)|$(TargetFramework)|$(Platform)'=='Release|netstandard1.3|AnyCPU'">
+    <DefineConstants>RELEASE;NETSTANDARD1_3</DefineConstants>
+  </PropertyGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">
+    <PackageReference Include="System.Net.Security" Version="4.3.2" />
+    <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
+    <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.2" />
+  </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.2" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='uap10.0'">
+    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="6.1.4" />
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net452'">
+  </ItemGroup>
+
+  <ItemGroup Condition="'$(TargetFramework)'=='net461'">
+  </ItemGroup>
+
+</Project>

Source/MQTTnet/MqttApplicationMessage.cs

@@ -0,0 +1,15 @@
+using MQTTnet.Protocol;
+
+namespace MQTTnet
+{
+    public class MqttApplicationMessage
+    {
+        public string Topic { get; set; }
+
+        public byte[] Payload { get; set; }
+
+        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
+
+        public bool Retain { get; set; }
+    }
+}

Source/MQTTnet/MqttApplicationMessageBuilder.cs

@@ -0,0 +1,119 @@
+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(Stream payload)
+        {
+            return WithPayload(payload, payload.Length - payload.Position);
+        }
+
+        public MqttApplicationMessageBuilder WithPayload(Stream payload, long length)
+        {
+            if (payload == null)
+            {
+                _payload = null;
+                return this;
+            }
+
+            if (payload.Length == 0)
+            {
+                _payload = new byte[0];
+            }
+            else
+            {
+                _payload = new byte[length];
+                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
+            };
+        }
+    }
+}

Source/MQTTnet/MqttApplicationMessageExtensions.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Text;
+
+namespace MQTTnet
+{
+    public static class MqttApplicationMessageExtensions
+    {
+        public static string ConvertPayloadToString(this MqttApplicationMessage applicationMessage)
+        {
+            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
+
+            if (applicationMessage.Payload == null)
+            {
+                return null;
+            }
+
+            if (applicationMessage.Payload.Length == 0)
+            {
+                return string.Empty;
+            }
+
+            return Encoding.UTF8.GetString(applicationMessage.Payload, 0, applicationMessage.Payload.Length);
+        }
+    }
+}

Source/MQTTnet/MqttApplicationMessageReceivedEventArgs.cs

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

Source/MQTTnet/MqttFactory.cs

@@ -0,0 +1,46 @@
+using System;
+using System.Collections.Generic;
+using MQTTnet.Adapter;
+using MQTTnet.Client;
+using MQTTnet.Diagnostics;
+using MQTTnet.Implementations;
+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 IMqttServer CreateMqttServer()
+        {
+            var logger = new MqttNetLogger();
+            return CreateMqttServer(logger);
+        }
+
+        public IMqttServer CreateMqttServer(IMqttNetLogger logger)
+        {
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
+
+            return CreateMqttServer(new List<IMqttServerAdapter> { new MqttTcpServerAdapter(logger.CreateChildLogger()) }, 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.CreateChildLogger());
+        }
+    }
+}

Source/MQTTnet/Packets/IMqttPacketWithIdentifier.cs

@@ -0,0 +1,7 @@
+namespace MQTTnet.Packets
+{
+    public interface IMqttPacketWithIdentifier
+    {
+        ushort? PacketIdentifier { get; set; }
+    }
+}

Source/MQTTnet/Packets/MqttBasePacket.cs

@@ -0,0 +1,6 @@
+namespace MQTTnet.Packets
+{
+    public abstract class MqttBasePacket
+    {
+    }
+}

Source/MQTTnet/Packets/MqttBasePublishPacket.cs

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

Source/MQTTnet/Packets/MqttConnAckPacket.cs

@@ -0,0 +1,16 @@
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Packets
+{
+    public class MqttConnAckPacket : MqttBasePacket
+    {
+        public bool IsSessionPresent { get; set; }
+
+        public MqttConnectReturnCode ConnectReturnCode { get; set; }
+
+        public override string ToString()
+        {
+            return "ConnAck: [ConnectReturnCode=" + ConnectReturnCode + "] [IsSessionPresent=" + IsSessionPresent + "]";
+        }
+    }
+}

Source/MQTTnet/Packets/MqttConnectPacket.cs

@@ -0,0 +1,26 @@
+using MQTTnet.Serializer;
+
+namespace MQTTnet.Packets
+{
+    public class MqttConnectPacket : MqttBasePacket
+    {
+        public MqttProtocolVersion ProtocolVersion { get; set; }
+
+        public string ClientId { get; set; }
+
+        public string Username { get; set; }
+
+        public string Password { get; set; }
+
+        public ushort KeepAlivePeriod { get; set; }
+
+        public bool CleanSession { get; set; }
+
+        public MqttApplicationMessage WillMessage { get; set; }
+
+        public override string ToString()
+        {
+            return "Connect: [ClientId=" + ClientId + "] [Username=" + Username + "] [Password=" + Password + "] [KeepAlivePeriod=" + KeepAlivePeriod + "] [CleanSession=" + CleanSession + "]";
+        }
+    }
+}

Source/MQTTnet/Packets/MqttDisconnectPacket.cs

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

Source/MQTTnet/Packets/MqttPingReqPacket.cs

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

Source/MQTTnet/Packets/MqttPingRespPacket.cs

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

Source/MQTTnet/Packets/MqttPubAckPacket.cs

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

Source/MQTTnet/Packets/MqttPubCompPacket.cs

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

Source/MQTTnet/Packets/MqttPubRecPacket.cs

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

Source/MQTTnet/Packets/MqttPubRelPacket.cs

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

Source/MQTTnet/Packets/MqttPublishPacket.cs

@@ -0,0 +1,27 @@
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Packets
+{
+    public class MqttPublishPacket : MqttBasePublishPacket
+    {
+        public bool Retain { get; set; }
+
+        public MqttQualityOfServiceLevel QualityOfServiceLevel { get; set; }
+
+        public bool Dup { get; set; }
+
+        public string Topic { get; set; }
+
+        public byte[] Payload { get; set; }
+
+        public override string ToString()
+        {
+            return "Publish: [Topic=" + Topic + "]" +
+                " [Payload.Length=" + Payload?.Length + "]" +
+                " [QoSLevel=" + QualityOfServiceLevel + "]" +
+                " [Dup=" + Dup + "]" +
+                " [Retain=" + Retain + "]" +
+                " [PacketIdentifier=" + PacketIdentifier + "]";
+        }
+    }
+}

Source/MQTTnet/Packets/MqttSubAckPacket.cs

@@ -0,0 +1,19 @@
+using System.Collections.Generic;
+using System.Linq;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Packets
+{
+    public class MqttSubAckPacket : MqttBasePacket, IMqttPacketWithIdentifier
+    {
+        public ushort? PacketIdentifier { get; set; }
+
+        public IList<MqttSubscribeReturnCode> SubscribeReturnCodes { get; } = new List<MqttSubscribeReturnCode>();
+
+        public override string ToString()
+        {
+            var subscribeReturnCodesText = string.Join(",", SubscribeReturnCodes.Select(f => f.ToString()));
+            return "SubAck: [PacketIdentifier=" + PacketIdentifier + "] [SubscribeReturnCodes=" + subscribeReturnCodesText + "]";
+        }
+    }
+}

Source/MQTTnet/Packets/MqttSubscribePacket.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace MQTTnet.Packets
+{
+    public class MqttSubscribePacket : MqttBasePacket, IMqttPacketWithIdentifier
+    {
+        public ushort? PacketIdentifier { get; set; }
+
+        public IList<TopicFilter> TopicFilters { get; set; } = new List<TopicFilter>();
+
+        public override string ToString()
+        {
+            var topicFiltersText = string.Join(",", TopicFilters.Select(f => f.Topic + "@" + f.QualityOfServiceLevel));
+            return "Subscribe: [PacketIdentifier=" + PacketIdentifier + "] [TopicFilters=" + topicFiltersText + "]";
+        }
+    }
+}

Source/MQTTnet/Packets/MqttUnsubAckPacket.cs

@@ -0,0 +1,12 @@
+namespace MQTTnet.Packets
+{
+    public class MqttUnsubAckPacket : MqttBasePacket, IMqttPacketWithIdentifier
+    {
+        public ushort? PacketIdentifier { get; set; }
+
+        public override string ToString()
+        {
+            return "UnsubAck: [PacketIdentifier=" + PacketIdentifier + "]";
+        }
+    }
+}