Update ReleaseNotes.md

* Moved the usage of certificate provider into the server listener so that each connection has the posibility of receiving a new SSL cert.

* Removed warning from unused field.

* Reduced changeds on original codebase.

---------

Co-authored-by: Jeff Scherrer <Jeff.Scherrer@vw.com>

.github/workflows/ReleaseNotes.md

@@ -1,9 +1,10 @@
-* [Core] Fixed a memory leak in _AsyncSignal_ implementation (#1586, thanks to @mario-zelger).
-* [Core] Fixed an issue with bounds handling in _MqttBufferReader_ (#1593).
-* [Core] Performance improvements and reduced memory usage due to improved buffer copies (#1599, thanks to @xljiulang).
-* [Server] Fix not properly reset statistics (#1587, thanks to @damikun).
-* [Server] Now using an empty string as the sender client ID for injected application messages (#1583, thanks to @xljiulang).
-* [Server] Improved memory usage for ASP.NET connections (#1582, thanks to @xljiulang).
-* [Server] Improved memory usage and performance for ASP.NET integration (#1596, thanks to @xljiulang).
-* [Server] Add support for interception of will messages (#1613).
-* [Server] Fixed wrong topic filter detections (#1615, thanks to @logicaloud).
+* [Core] Added net7.0 builds (#1635, thanks to @YAJeff).
+* [Client] Added support for passing MQTT v5 options (User properties etc.) for disconnects.
+* [Client] An internal exception is no longer caught silently when calling _DisconnectAsync_ to indicate that the disconnect is not clean (BREAKING CHANGE).
+* [Client] MQTTv5 features are now checked and an exception is thrown if they are used when using protocol version 3.1.1 and lower. These checks can be disabled in client options. (BREAKING CHANGE!).
+* [Server] Exposed MQTT v5 sent properties from the affected client in _ClientDisconnectedAsync_ event.
+* [Server] Fixed wrong client ID passed to _InterceptingUnsubscriptionEventArgs_ (#1631, thanks to @ghord). 
+* [Server] Exposed socket settings for TCP keep alive in TCP options (#1544).
+* [Server] Exposed server session items at server level and allow custom session items for injected application messages (#1638).
+* [Server] Improved performance for retained message handling when subscribing using "DoNotSendOnSubscribe" or "SendAtSubscribeIfNewSubscriptionOnly" (#1661, thanks to @Int32Overflow).
+* [Server] Added support for changing the used TLS certificate while the server is running (#1652, thanks to @YAJeff). The certificate provider will now be invoked for every new connection!

.github/workflows/ci.yml

@@ -3,7 +3,7 @@ name: CI
 on: [push, pull_request]
 
 env:
-  VERSION: "4.1.4.${{github.run_number}}"
+  VERSION: "4.2.0.${{github.run_number}}"
 
 jobs:
   build:
@@ -22,6 +22,7 @@ jobs:
           dotnet-version: |
             3.1.x
             6.0.x
+            7.0.x
 
       - name: Setup MSBuild
         uses: microsoft/setup-msbuild@v1.1

Samples/Client/Client_Connection_Samples.cs

@@ -16,6 +16,28 @@ namespace MQTTnet.Samples.Client;
 
 public static class Client_Connection_Samples
 {
+    public static async Task Clean_Disconnect()
+    {
+        /*
+         * This sample disconnects in a clean way. This will send a MQTT DISCONNECT packet
+         * to the server and close the connection afterwards.
+         *
+         * See sample _Connect_Client_ for more details.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("broker.hivemq.com").Build();
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            // This will send the DISCONNECT packet. Calling _Dispose_ without DisconnectAsync the 
+            // connection is closed in a "not clean" way. See MQTT specification for more details.
+            await mqttClient.DisconnectAsync(new MqttClientDisconnectOptionsBuilder().WithReason(MqttClientDisconnectOptionsReason.NormalDisconnection).Build());
+        }
+    }
+
     public static async Task Connect_Client()
     {
         /*
@@ -232,7 +254,7 @@ public static class Client_Connection_Samples
 
             // Calling _DisconnectAsync_ will send a DISCONNECT packet before closing the connection.
             // Using a reason code requires MQTT version 5.0.0!
-            await mqttClient.DisconnectAsync(MqttClientDisconnectReason.ImplementationSpecificError);
+            await mqttClient.DisconnectAsync(MqttClientDisconnectOptionsReason.ImplementationSpecificError);
         }
     }
 
@@ -297,7 +319,7 @@ public static class Client_Connection_Samples
         /*
          * This sample sends a PINGREQ packet to the server and waits for a reply.
          *
-         * This is only supported in METTv5.0.0+.
+         * This is only supported in MQTTv5.0.0+.
          */
 
         var mqttFactory = new MqttFactory();

Samples/Program.cs

@@ -4,7 +4,13 @@
 
 using System.Reflection;
 
-Console.WriteLine("Welcome to MQTTnet samples!");
+Console.BackgroundColor = ConsoleColor.White;
+Console.BackgroundColor = ConsoleColor.Red;
+Console.Title = "Samples - MQTTnet";
+Console.WriteLine("----------------------------------------------");
+Console.WriteLine("-         Welcome to MQTTnet samples!        -");
+Console.WriteLine("----------------------------------------------");
+Console.ResetColor();
 Console.WriteLine();
 
 var sampleClasses = Assembly.GetExecutingAssembly().GetExportedTypes().OrderBy(c => c.Name).ToList();
@@ -16,7 +22,11 @@ foreach (var sampleClass in sampleClasses)
     index++;
 }
 
+Console.WriteLine();
+Console.ForegroundColor = ConsoleColor.Green;
 Console.Write("Please choose sample class (press Enter to continue): ");
+Console.ResetColor();
+
 var input = Console.ReadLine();
 var selectedIndex = int.Parse(input ?? "0");
 var selectedSampleClass = sampleClasses[selectedIndex];
@@ -29,12 +39,19 @@ foreach (var sampleMethod in sampleMethods)
     index++;
 }
 
+Console.WriteLine();
+Console.ForegroundColor = ConsoleColor.Green;
 Console.Write("Please choose sample (press Enter to continue): ");
+Console.ResetColor();
+
 input = Console.ReadLine();
 selectedIndex = int.Parse(input ?? "0");
 var selectedSampleMethod = sampleMethods[selectedIndex];
 
+Console.WriteLine();
+Console.ForegroundColor = ConsoleColor.White;
 Console.WriteLine("Executing sample...");
+Console.ResetColor();
 Console.WriteLine();
 
 try

Samples/Server/Server_ASP_NET_Samples.cs

@@ -17,7 +17,7 @@ using MQTTnet.Server;
 
 namespace MQTTnet.Samples.Server;
 
-public static class Server_Asp_Net_Samples
+public static class Server_ASP_NET_Samples
 {
     public static Task Start_Server_With_WebSockets_Support()
     {

Samples/Server/Server_Diagnostics_Samples.cs

@@ -0,0 +1,53 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using MQTTnet.Internal;
+using MQTTnet.Packets;
+using MQTTnet.Server;
+
+namespace MQTTnet.Samples.Server;
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+// ReSharper disable EmptyConstructor
+// ReSharper disable MemberCanBeMadeStatic.Local
+
+public static class Server_Diagnostics_Samples
+{
+    public static async Task Get_Notified_When_Client_Received_Message()
+    {
+        /*
+         * This sample starts a MQTT server and attaches an event which gets fired whenever
+         * a client received and acknowledged a PUBLISH packet.
+         */
+        
+        var mqttFactory = new MqttFactory();
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithDefaultEndpoint().Build();
+        
+        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
+        {
+            // Attach the event handler.
+            mqttServer.ClientAcknowledgedPublishPacketAsync += e =>
+            {
+                Console.WriteLine($"Client '{e.ClientId}' acknowledged packet {e.PublishPacket.PacketIdentifier} with topic '{e.PublishPacket.Topic}'");
+                
+                // It is also possible to read additional data from the client response. This requires casting the response packet.
+                var qos1AcknowledgePacket = e.AcknowledgePacket as MqttPubAckPacket;
+                Console.WriteLine($"QoS 1 reason code: {qos1AcknowledgePacket?.ReasonCode}");
+                
+                var qos2AcknowledgePacket = e.AcknowledgePacket as MqttPubCompPacket;
+                Console.WriteLine($"QoS 2 reason code: {qos1AcknowledgePacket?.ReasonCode}");
+                return CompletedTask.Instance;
+            };
+            
+            await mqttServer.StartAsync();
+
+            Console.WriteLine("Press Enter to exit.");
+            Console.ReadLine();
+
+            await mqttServer.StopAsync();
+        }
+    }
+}

Samples/Server/Server_TLS_Samples.cs

@@ -0,0 +1,75 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+// ReSharper disable UnusedType.Global
+// ReSharper disable UnusedMember.Global
+// ReSharper disable InconsistentNaming
+
+using System.Net;
+using System.Security.Cryptography;
+using System.Security.Cryptography.X509Certificates;
+using MQTTnet.Server;
+
+namespace MQTTnet.Samples.Server;
+
+public static class Server_TLS_Samples
+{
+    public static async Task Run_Server_With_Self_Signed_Certificate()
+    {
+        /*
+         * This sample starts a simple MQTT server which will accept any TCP connection.
+         * It also has an encrypted connection using a self signed TLS certificate.
+         *
+         * See sample "Run_Minimal_Server" for more details.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        // This certificate is self signed so that
+        var certificate = CreateSelfSignedCertificate("1.3.6.1.5.5.7.3.1");
+        
+        var mqttServerOptions = new MqttServerOptionsBuilder().WithEncryptionCertificate(certificate).WithEncryptedEndpoint().Build();
+
+        using (var mqttServer = mqttFactory.CreateMqttServer(mqttServerOptions))
+        {
+            await mqttServer.StartAsync();
+
+            Console.WriteLine("Press Enter to exit.");
+            Console.ReadLine();
+
+            // Stop and dispose the MQTT server if it is no longer needed!
+            await mqttServer.StopAsync();
+        }
+    }
+
+    static X509Certificate2 CreateSelfSignedCertificate(string oid)
+    {
+        var sanBuilder = new SubjectAlternativeNameBuilder();
+        sanBuilder.AddIpAddress(IPAddress.Loopback);
+        sanBuilder.AddIpAddress(IPAddress.IPv6Loopback);
+        sanBuilder.AddDnsName("localhost");
+
+        using (var rsa = RSA.Create())
+        {
+            var certRequest = new CertificateRequest("CN=localhost", rsa, HashAlgorithmName.SHA512, RSASignaturePadding.Pkcs1);
+
+            certRequest.CertificateExtensions.Add(
+                new X509KeyUsageExtension(X509KeyUsageFlags.DataEncipherment | X509KeyUsageFlags.KeyEncipherment | X509KeyUsageFlags.DigitalSignature, false));
+
+            certRequest.CertificateExtensions.Add(new X509EnhancedKeyUsageExtension(new OidCollection { new(oid) }, false));
+
+            certRequest.CertificateExtensions.Add(sanBuilder.Build());
+
+            using (var certificate = certRequest.CreateSelfSigned(DateTimeOffset.Now.AddMinutes(-10), DateTimeOffset.Now.AddMinutes(10)))
+            {
+                var pfxCertificate = new X509Certificate2(
+                    certificate.Export(X509ContentType.Pfx),
+                    (string)null!,
+                    X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
+
+                return pfxCertificate;
+            }
+        }
+    }
+}

Source/MQTTnet.AspnetCore/Client/Tcp/TcpConnection.cs

@@ -44,7 +44,7 @@ namespace MQTTnet.AspNetCore.Client.Tcp
             _sender = new SocketSender(_socket, PipeScheduler.ThreadPool);
             _receiver = new SocketReceiver(_socket, PipeScheduler.ThreadPool);
         }
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER
         public override ValueTask DisposeAsync()
 #else
         public Task DisposeAsync()
@@ -57,7 +57,7 @@ namespace MQTTnet.AspNetCore.Client.Tcp
 
             _socket?.Dispose();
 
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER
 
             return base.DisposeAsync();
         }

Source/MQTTnet.AspnetCore/EndpointRouterExtensions.cs

@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER
 
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Routing;

Source/MQTTnet.AspnetCore/MQTTnet.AspNetCore.csproj

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>netstandard2.0;netcoreapp2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>netstandard2.0;netcoreapp2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
 
         <AssemblyName>MQTTnet.AspNetCore</AssemblyName>
         <RootNamespace>MQTTnet.AspNetCore</RootNamespace>
@@ -51,11 +51,11 @@
         <DefineConstants>RELEASE;NETSTANDARD2_0</DefineConstants>
     </PropertyGroup>
 
-    <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0' or '$(TargetFramework)' == 'net6.0' ">
+    <ItemGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0' or '$(TargetFramework)' == 'net6.0' or '$(TargetFramework)' == 'net7.0' ">
         <FrameworkReference Include="Microsoft.AspNetCore.App" />
     </ItemGroup>
 
-    <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp3.1' and '$(TargetFramework)' != 'net5.0' and '$(TargetFramework)' != 'net6.0' ">
+    <ItemGroup Condition="'$(TargetFramework)' != 'netcoreapp3.1' and '$(TargetFramework)' != 'net5.0' and '$(TargetFramework)' != 'net6.0' and '$(TargetFramework)' != 'net7.0' ">
         <PackageReference Include="Microsoft.AspNetCore.Http.Connections" Version="1.1.0" />
     </ItemGroup>
 

Source/MQTTnet.AspnetCore/MqttConnectionContext.cs

@@ -211,8 +211,17 @@ namespace MQTTnet.AspNetCore
                 {
                     var buffer = PacketFormatterAdapter.Encode(packet);
 
-                    WritePacketBuffer(_output, buffer);
-                    await _output.FlushAsync(cancellationToken).ConfigureAwait(false);
+                    if (buffer.Payload.Count == 0)
+                    {
+                        // zero copy
+                        // https://github.com/dotnet/runtime/blob/e31ddfdc4f574b26231233dc10c9a9c402f40590/src/libraries/System.IO.Pipelines/src/System/IO/Pipelines/StreamPipeWriter.cs#L279
+                        await _output.WriteAsync(buffer.Packet, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        WritePacketBuffer(_output, buffer);
+                        await _output.FlushAsync(cancellationToken).ConfigureAwait(false);
+                    }
 
                     BytesSent += buffer.Length;
                 }

Source/MQTTnet.Benchmarks/MQTTnet.Benchmarks.csproj

@@ -4,7 +4,7 @@
         <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
         <OutputType>Exe</OutputType>
         <DebugType>Full</DebugType>
-        <TargetFrameworks>net6.0</TargetFrameworks>
+        <TargetFrameworks>net6.0;net7.0</TargetFrameworks>
         <LangVersion>7.2</LangVersion>
         <IsPackable>false</IsPackable>
         <EnableNETAnalyzers>false</EnableNETAnalyzers>
@@ -26,6 +26,10 @@
         <PackageReference Include="System.IO.Pipelines" Version="5.0.0" />
     </ItemGroup>
 
+    <ItemGroup Condition="'$(TargetFramework)' == 'net7.0'">
+        <PackageReference Include="System.IO.Pipelines" Version="7.0.0" />
+    </ItemGroup>
+
     <ItemGroup>
         <ProjectReference Include="..\..\Source\MQTTnet.AspnetCore\MQTTnet.AspNetCore.csproj" />
         <ProjectReference Include="..\MQTTnet.Tests\MQTTnet.Tests.csproj" />

Source/MQTTnet.Benchmarks/SendPacketAsyncBenchmark.cs

@@ -0,0 +1,68 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Jobs;
+using MQTTnet.Formatter;
+using System;
+using System.IO;
+using System.IO.Pipelines;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Benchmarks
+{
+    [SimpleJob(RuntimeMoniker.Net60)]
+    [RPlotExporter, RankColumn]
+    [MemoryDiagnoser]
+    public class SendPacketAsyncBenchmark : BaseBenchmark
+    {
+        MemoryStream stream;
+        MqttPacketBuffer buffer;
+
+        [GlobalSetup]
+        public void GlobalSetup()
+        {
+            stream = new MemoryStream(1024);
+            var packet = new ArraySegment<byte>(new byte[10]);
+            buffer = new MqttPacketBuffer(packet);
+        }
+
+        [Benchmark(Baseline = true)]
+        public async ValueTask Before()
+        {
+            stream.Position = 0;
+            var output = PipeWriter.Create(stream);
+
+            WritePacketBuffer(output, buffer);
+            await output.FlushAsync();
+        }
+
+        [Benchmark]
+        public async ValueTask After()
+        {
+            stream.Position = 0;
+            var output = PipeWriter.Create(stream);
+
+            if (buffer.Payload.Count == 0)
+            {
+                await output.WriteAsync(buffer.Packet).ConfigureAwait(false);
+            }
+            else
+            {
+                WritePacketBuffer(output, buffer);
+                await output.FlushAsync().ConfigureAwait(false);
+            }
+        }
+
+
+        static void WritePacketBuffer(PipeWriter output, MqttPacketBuffer buffer)
+        {
+            // copy MqttPacketBuffer's Packet and Payload to the same buffer block of PipeWriter
+            // MqttPacket will be transmitted within the bounds of a WebSocket frame after PipeWriter.FlushAsync
+
+            var span = output.GetSpan(buffer.Length);
+
+            buffer.Packet.AsSpan().CopyTo(span);
+            buffer.Payload.AsSpan().CopyTo(span.Slice(buffer.Packet.Count));
+
+            output.Advance(buffer.Length);
+        }
+    }
+}

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
         

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

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
         

Source/MQTTnet.Extensions.Rpc/MqttRpcClient.cs

@@ -8,6 +8,7 @@ using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Client;
 using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Protocol;
 
@@ -17,9 +18,9 @@ namespace MQTTnet.Extensions.Rpc
     {
         readonly IMqttClient _mqttClient;
         readonly MqttRpcClientOptions _options;
-        
+
         readonly ConcurrentDictionary<string, AsyncTaskCompletionSource<byte[]>> _waitingCalls = new ConcurrentDictionary<string, AsyncTaskCompletionSource<byte[]>>();
-        
+
         public MqttRpcClient(IMqttClient mqttClient, MqttRpcClientOptions options)
         {
             _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
@@ -83,11 +84,14 @@ namespace MQTTnet.Extensions.Rpc
                 throw new MqttProtocolViolationException("RPC response topic is empty.");
             }
 
-            var requestMessage = new MqttApplicationMessageBuilder().WithTopic(requestTopic)
-                .WithPayload(payload)
-                .WithQualityOfServiceLevel(qualityOfServiceLevel)
-                .WithResponseTopic(responseTopic)
-                .Build();
+            var requestMessageBuilder = new MqttApplicationMessageBuilder().WithTopic(requestTopic).WithPayload(payload).WithQualityOfServiceLevel(qualityOfServiceLevel);
+
+            if (_mqttClient.Options.ProtocolVersion == MqttProtocolVersion.V500)
+            {
+                requestMessageBuilder.WithResponseTopic(responseTopic);
+            }
+
+            var requestMessage = requestMessageBuilder.Build();
 
             try
             {

Source/MQTTnet.Extensions.WebSocket4Net/MQTTnet.Extensions.WebSocket4Net.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
         

Source/MQTTnet.TestApp/MQTTnet.TestApp.csproj

@@ -1,9 +1,9 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
         <DebugType>Full</DebugType>
-        <TargetFrameworks>net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>net5.0;net6.0;net7.0</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
         <IsPackable>false</IsPackable>
         <EnableNETAnalyzers>false</EnableNETAnalyzers>

Source/MQTTnet.Tests/Clients/LowLevelMqttClient/LowLevelMqttClient_Tests.cs

@@ -14,7 +14,7 @@ using MQTTnet.LowLevelClient;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 
-namespace MQTTnet.Tests.Client
+namespace MQTTnet.Tests.Clients.LowLevelMqttClient
 {
     [TestClass]
     public sealed class LowLevelMqttClient_Tests : BaseTestClass

Source/MQTTnet.Tests/Clients/ManagedMqttClient/ManagedMqttClient_Tests.cs

@@ -17,7 +17,7 @@ using MQTTnet.Protocol;
 using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
 
-namespace MQTTnet.Tests.Client
+namespace MQTTnet.Tests.Clients.ManagedMqttClient
 {
     [TestClass]
     public sealed class ManagedMqttClient_Tests : BaseTestClass
@@ -164,7 +164,7 @@ namespace MQTTnet.Tests.Client
                     .Build();
 
                 var dyingClient = testEnvironment.CreateClient();
-                var dyingManagedClient = new ManagedMqttClient(dyingClient, testEnvironment.ClientLogger);
+                var dyingManagedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(dyingClient, testEnvironment.ClientLogger);
 
                 await dyingManagedClient.StartAsync(new ManagedMqttClientOptionsBuilder().WithClientOptions(clientOptions).Build());
 
@@ -199,7 +199,7 @@ namespace MQTTnet.Tests.Client
             {
                 var server = await testEnvironment.StartServer();
 
-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
+                var managedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
                 var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort);
 
                 var connected = GetConnectedTask(managedClient);
@@ -226,7 +226,7 @@ namespace MQTTnet.Tests.Client
 
                 await testEnvironment.StartServer();
 
-                var managedClient = new ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
+                var managedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(testEnvironment.CreateClient(), new MqttNetEventLogger());
                 var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("localhost", testEnvironment.ServerPort);
                 var storage = new ManagedMqttClientTestStorage();
 
@@ -439,7 +439,7 @@ namespace MQTTnet.Tests.Client
             }
         }
 
-        async Task<ManagedMqttClient> CreateManagedClientAsync(
+        async Task<MQTTnet.Extensions.ManagedClient.ManagedMqttClient> CreateManagedClientAsync(
             TestEnvironment testEnvironment,
             IMqttClient underlyingClient = null,
             TimeSpan? connectionCheckInterval = null,
@@ -456,7 +456,7 @@ namespace MQTTnet.Tests.Client
             // at connection check intervals
             managedOptions.ConnectionCheckInterval = connectionCheckInterval ?? TimeSpan.FromSeconds(0.1);
 
-            var managedClient = new ManagedMqttClient(underlyingClient ?? testEnvironment.CreateClient(), new MqttNetEventLogger());
+            var managedClient = new MQTTnet.Extensions.ManagedClient.ManagedMqttClient(underlyingClient ?? testEnvironment.CreateClient(), new MqttNetEventLogger());
 
             var connected = GetConnectedTask(managedClient);
 
@@ -473,7 +473,7 @@ namespace MQTTnet.Tests.Client
         ///         name="managedClient" />
         ///     has connected
         /// </summary>
-        Task GetConnectedTask(ManagedMqttClient managedClient)
+        Task GetConnectedTask(MQTTnet.Extensions.ManagedClient.ManagedMqttClient managedClient)
         {
             var connected = new TaskCompletionSource<bool>();
 
@@ -495,7 +495,7 @@ namespace MQTTnet.Tests.Client
         ///         name="expectedNumberOfMessages" />
         ///     have been received
         /// </summary>
-        Task<List<MqttApplicationMessage>> SetupReceivingOfMessages(ManagedMqttClient managedClient, int expectedNumberOfMessages)
+        Task<List<MqttApplicationMessage>> SetupReceivingOfMessages(MQTTnet.Extensions.ManagedClient.ManagedMqttClient managedClient, int expectedNumberOfMessages)
         {
             var receivedMessages = new List<MqttApplicationMessage>();
             var result = new AsyncTaskCompletionSource<List<MqttApplicationMessage>>();

Source/MQTTnet.Tests/Clients/MqttClient/MqttClient_Connection_Tests.cs

@@ -0,0 +1,162 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
+using MQTTnet.Formatter;
+using MQTTnet.Internal;
+using MQTTnet.Protocol;
+using MQTTnet.Server;
+
+namespace MQTTnet.Tests.Clients.MqttClient
+{
+    [TestClass]
+    public sealed class MqttClient_Connection_Tests : BaseTestClass
+    {
+        [TestMethod]
+        [ExpectedException(typeof(MqttCommunicationException))]
+        public async Task Connect_To_Invalid_Server_Port_Not_Opened()
+        {
+            var client = new MqttFactory().CreateMqttClient();
+            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5)))
+            {
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", 12345).Build(), timeout.Token);
+            }
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(OperationCanceledException))]
+        public async Task Connect_To_Invalid_Server_Wrong_IP()
+        {
+            var client = new MqttFactory().CreateMqttClient();
+            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(2)))
+            {
+                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build(), timeout.Token);
+            }
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(MqttCommunicationException))]
+        public async Task Connect_To_Invalid_Server_Wrong_Protocol()
+        {
+            var client = new MqttFactory().CreateMqttClient();
+            await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("http://127.0.0.1", 12345).WithTimeout(TimeSpan.FromSeconds(2)).Build());
+        }
+
+        [TestMethod]
+        public async Task ConnectTimeout_Throws_Exception()
+        {
+            var factory = new MqttFactory();
+            using (var client = factory.CreateMqttClient())
+            {
+                var disconnectHandlerCalled = false;
+                try
+                {
+                    client.DisconnectedAsync += args =>
+                    {
+                        disconnectHandlerCalled = true;
+                        return CompletedTask.Instance;
+                    };
+
+                    await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build());
+
+                    Assert.Fail("Must fail!");
+                }
+                catch (Exception exception)
+                {
+                    Assert.IsNotNull(exception);
+                    Assert.IsInstanceOfType(exception, typeof(MqttCommunicationException));
+                }
+
+                await LongTestDelay(); // disconnected handler is called async
+                Assert.IsTrue(disconnectHandlerCalled);
+            }
+        }
+
+        [TestMethod]
+        public async Task Disconnect_Clean()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                var server = await testEnvironment.StartServer();
+
+                ClientDisconnectedEventArgs eventArgs = null;
+                server.ClientDisconnectedAsync += args =>
+                {
+                    eventArgs = args;
+                    return CompletedTask.Instance;
+                };
+
+                var client = await testEnvironment.ConnectClient();
+
+                var disconnectOptions = testEnvironment.Factory.CreateClientDisconnectOptionsBuilder().WithReason(MqttClientDisconnectOptionsReason.MessageRateTooHigh).Build();
+
+                // Perform a clean disconnect.
+                await client.DisconnectAsync(disconnectOptions);
+
+                Assert.IsNotNull(eventArgs);
+                Assert.AreEqual(MqttClientDisconnectType.Clean, eventArgs.DisconnectType);
+            }
+        }
+
+        [TestMethod]
+        public async Task Disconnect_Clean_With_Custom_Reason()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                var server = await testEnvironment.StartServer();
+
+                ClientDisconnectedEventArgs eventArgs = null;
+                server.ClientDisconnectedAsync += args =>
+                {
+                    eventArgs = args;
+                    return CompletedTask.Instance;
+                };
+
+                var client = await testEnvironment.ConnectClient();
+
+                var disconnectOptions = testEnvironment.Factory.CreateClientDisconnectOptionsBuilder().WithReason(MqttClientDisconnectOptionsReason.MessageRateTooHigh).Build();
+
+                // Perform a clean disconnect.
+                await client.DisconnectAsync(disconnectOptions);
+
+                Assert.IsNotNull(eventArgs);
+                Assert.AreEqual(MqttDisconnectReasonCode.MessageRateTooHigh, eventArgs.ReasonCode);
+            }
+        }
+
+        [TestMethod]
+        public async Task Disconnect_Clean_With_User_Properties()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                var server = await testEnvironment.StartServer();
+
+                ClientDisconnectedEventArgs eventArgs = null;
+                server.ClientDisconnectedAsync += args =>
+                {
+                    eventArgs = args;
+                    return CompletedTask.Instance;
+                };
+
+                var client = await testEnvironment.ConnectClient();
+
+                var disconnectOptions = testEnvironment.Factory.CreateClientDisconnectOptionsBuilder().WithUserProperty("test_name", "test_value").Build();
+
+                // Perform a clean disconnect.
+                await client.DisconnectAsync(disconnectOptions);
+                
+                Assert.IsNotNull(eventArgs);
+                Assert.IsNotNull(eventArgs.UserProperties);
+                Assert.AreEqual(1, eventArgs.UserProperties.Count);
+                Assert.AreEqual("test_name", eventArgs.UserProperties[0].Name);
+                Assert.AreEqual("test_value", eventArgs.UserProperties[0].Value);
+            }
+        }
+    }
+}

Source/MQTTnet.Tests/Clients/MqttClient/MqttClient_Tests.cs

@@ -21,7 +21,7 @@ using MQTTnet.Tests.Mockups;
 
 // ReSharper disable InconsistentNaming
 
-namespace MQTTnet.Tests.Client
+namespace MQTTnet.Tests.Clients.MqttClient
 {
     [TestClass]
     public sealed class MqttClient_Tests : BaseTestClass
@@ -71,60 +71,34 @@ namespace MQTTnet.Tests.Client
         }
 
         [TestMethod]
-        [ExpectedException(typeof(MqttCommunicationException))]
-        public async Task Connect_To_Invalid_Server_Port_Not_Opened()
+        public async Task Connect_Disconnect_Connect()
         {
-            var client = new MqttFactory().CreateMqttClient();
-            await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", 12345).WithTimeout(TimeSpan.FromSeconds(5)).Build());
-        }
-
-        [TestMethod]
-        [ExpectedException(typeof(OperationCanceledException))]
-        public async Task Connect_To_Invalid_Server_Wrong_IP()
-        {
-            var client = new MqttFactory().CreateMqttClient();
-            using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(2)))
+            using (var testEnvironment = CreateTestEnvironment())
             {
-                await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build(), timeout.Token);
+                await testEnvironment.StartServer();
+
+                var clientOptions = testEnvironment.CreateDefaultClientOptions();
+                var client = testEnvironment.CreateClient();
+
+                await client.ConnectAsync(clientOptions);
+                await client.DisconnectAsync();
+                await client.ConnectAsync(clientOptions);
             }
         }
-
+        
         [TestMethod]
-        [ExpectedException(typeof(MqttCommunicationException))]
-        public async Task Connect_To_Invalid_Server_Wrong_Protocol()
+        [ExpectedException(typeof(InvalidOperationException))]
+        public async Task Connect_Multiple_Times_Should_Fail()
         {
-            var client = new MqttFactory().CreateMqttClient();
-            await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("http://127.0.0.1", 12345).WithTimeout(TimeSpan.FromSeconds(2)).Build());
-        }
-
-        [TestMethod]
-        public async Task ConnectTimeout_Throws_Exception()
-        {
-            var factory = new MqttFactory();
-            using (var client = factory.CreateMqttClient())
+            using (var testEnvironment = CreateTestEnvironment())
             {
-                var disconnectHandlerCalled = false;
-                try
-                {
-                    client.DisconnectedAsync += args =>
-                    {
-                        disconnectHandlerCalled = true;
-                        return CompletedTask.Instance;
-                    };
+                await testEnvironment.StartServer();
 
-                    await client.ConnectAsync(new MqttClientOptionsBuilder().WithTcpServer("1.2.3.4").Build());
+                var clientOptions = testEnvironment.CreateDefaultClientOptions();
+                var client = testEnvironment.CreateClient();
 
-                    Assert.Fail("Must fail!");
-                }
-                catch (Exception exception)
-                {
-                    Assert.IsNotNull(exception);
-                    Assert.IsInstanceOfType(exception, typeof(MqttCommunicationException));
-                    //Assert.IsInstanceOfType(exception.InnerException, typeof(SocketException));
-                }
-
-                await LongTestDelay(); // disconnected handler is called async
-                Assert.IsTrue(disconnectHandlerCalled);
+                await client.ConnectAsync(clientOptions);
+                await client.ConnectAsync(clientOptions);
             }
         }
 

Source/MQTTnet.Tests/Clients/MqttClientOptionsBuilder_Tests.cs

@@ -6,9 +6,8 @@ using System.Linq;
 using System.Text;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
-using MQTTnet.Extensions;
 
-namespace MQTTnet.Tests.Client
+namespace MQTTnet.Tests.Clients
 {
     [TestClass]
     public class MqttClientOptionsBuilder_Tests

Source/MQTTnet.Tests/MQTTnet.Tests.csproj

@@ -1,7 +1,7 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>net452;net461;net48;netcoreapp3.1;net6.0</TargetFrameworks>
+        <TargetFrameworks>net452;net461;net48;netcoreapp3.1;net6.0;net7.0</TargetFrameworks>
         <IsPackable>false</IsPackable>
         <LangVersion>7.3</LangVersion>
         <EnableNETAnalyzers>false</EnableNETAnalyzers>

Source/MQTTnet.Tests/Mockups/TestEnvironment.cs

@@ -238,6 +238,16 @@ namespace MQTTnet.Tests.Mockups
             }
         }
 
+        public MqttClientOptions CreateDefaultClientOptions()
+        {
+            return CreateDefaultClientOptionsBuilder().Build();
+        }
+
+        public MqttClientOptionsBuilder CreateDefaultClientOptionsBuilder()
+        {
+            return Factory.CreateClientOptionsBuilder().WithProtocolVersion(_protocolVersion).WithTcpServer("127.0.0.1", ServerPort);
+        }
+
         public ILowLevelMqttClient CreateLowLevelClient()
         {
             lock (_clients)

Source/MQTTnet.Tests/MqttApplicationMessageValidator_Tests.cs

@@ -0,0 +1,44 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Tests
+{
+    [TestClass]
+    public sealed class MqttApplicationMessageValidator_Tests
+    {
+        [TestMethod]
+        [ExpectedException(typeof(NotSupportedException))]
+        public void Succeed_When_Using_TopicAlias_And_MQTT_311()
+        {
+            MqttApplicationMessageValidator.ThrowIfNotSupported(new MqttApplicationMessageBuilder().WithTopicAlias(1).Build(), MqttProtocolVersion.V311);
+        }
+
+        [TestMethod]
+        public void Succeed_When_Using_TopicAlias_And_MQTT_500()
+        {
+            MqttApplicationMessageValidator.ThrowIfNotSupported(new MqttApplicationMessageBuilder().WithTopicAlias(1).Build(), MqttProtocolVersion.V500);
+        }
+
+        [TestMethod]
+        public void Succeed_When_Using_UserProperties_And_MQTT_500()
+        {
+            MqttApplicationMessageValidator.ThrowIfNotSupported(
+                new MqttApplicationMessageBuilder().WithTopic("A").WithUserProperty("User", "Property").Build(),
+                MqttProtocolVersion.V500);
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(NotSupportedException))]
+        public void Succeed_When_Using_WillUserProperties_And_MQTT_311()
+        {
+            MqttApplicationMessageValidator.ThrowIfNotSupported(
+                new MqttApplicationMessageBuilder().WithTopic("B").WithUserProperty("User", "Property").Build(),
+                MqttProtocolVersion.V311);
+        }
+    }
+}

Source/MQTTnet.Tests/MqttClientOptionsValidator_Tests.cs

@@ -0,0 +1,54 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Tests
+{
+    [TestClass]
+    public sealed class MqttClientOptionsValidator_Tests
+    {
+        [TestMethod]
+        public void Succeed_When_Using_UserProperties_And_MQTT_500()
+        {
+            new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500).WithUserProperty("User", "Property").WithTcpServer("FAKE").Build();
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(NotSupportedException))]
+        public void Succeed_When_Using_WillUserProperties_And_MQTT_311()
+        {
+            new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V311).WithWillUserProperty("User", "Property").WithTcpServer("FAKE").Build();
+        }
+
+        [TestMethod]
+        public void Succeed_When_Using_WillUserProperties_And_MQTT_500()
+        {
+            new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500).WithWillUserProperty("User", "Property").WithTcpServer("FAKE").Build();
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(NotSupportedException))]
+        public void Throw_When_Using_UserProperties_And_MQTT_311()
+        {
+            new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V311).WithUserProperty("User", "Property").WithTcpServer("FAKE").Build();
+        }
+
+        [TestMethod]
+        [ExpectedException(typeof(NotSupportedException))]
+        public void Throw_When_Using_WithRequestResponseInformation_And_MQTT_311()
+        {
+            new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V311).WithRequestResponseInformation().WithTcpServer("FAKE").Build();
+        }
+
+        [TestMethod]
+        public void Throw_When_Using_WithRequestResponseInformation_And_MQTT_500()
+        {
+            new MqttClientOptionsBuilder().WithProtocolVersion(MqttProtocolVersion.V500).WithRequestResponseInformation().WithTcpServer("FAKE").Build();
+        }
+    }
+}

Source/MQTTnet.Tests/MqttTopicValidator_Tests.cs

@@ -9,19 +9,13 @@ using MQTTnet.Protocol;
 namespace MQTTnet.Tests
 {
     [TestClass]
-    public class MqttTopicValidator_Tests
+    public sealed class MqttTopicValidator_Tests
     {
-        [TestMethod]
-        public void Valid_Topic()
-        {
-            MqttTopicValidator.ThrowIfInvalid("/a/b/c");
-        }
-
         [TestMethod]
         [ExpectedException(typeof(MqttProtocolViolationException))]
-        public void Invalid_Topic_Plus()
+        public void Invalid_Topic_Empty()
         {
-            MqttTopicValidator.ThrowIfInvalid("/a/+/c");
+            MqttTopicValidator.ThrowIfInvalid(string.Empty);
         }
 
         [TestMethod]
@@ -33,9 +27,15 @@ namespace MQTTnet.Tests
 
         [TestMethod]
         [ExpectedException(typeof(MqttProtocolViolationException))]
-        public void Invalid_Topic_Empty()
+        public void Invalid_Topic_Plus()
         {
-            MqttTopicValidator.ThrowIfInvalid(string.Empty);
+            MqttTopicValidator.ThrowIfInvalid("/a/+/c");
+        }
+
+        [TestMethod]
+        public void Valid_Topic()
+        {
+            MqttTopicValidator.ThrowIfInvalid("/a/b/c");
         }
     }
-}
+}

Source/MQTTnet.Tests/Server/General.cs

@@ -636,7 +636,7 @@ namespace MQTTnet.Tests.Server
                 // nothing
 
                 Assert.AreEqual(false, c1.IsConnected);
-                await c1.DisconnectAsync();
+                await c1.TryDisconnectAsync();
                 Assert.AreEqual(false, c1.IsConnected);
 
                 await Task.Delay(500);

Source/MQTTnet.Tests/Server/Tls_Tests.cs

@@ -0,0 +1,204 @@
+#if !WINDOWS_UWP && (NET48_OR_GREATER || NET5_0_OR_GREATER)
+using System;
+using System.Linq;
+using System.Net;
+using System.Security.Authentication;
+using System.Security.Cryptography;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using MQTTnet.Certificates;
+using MQTTnet.Client;
+using MQTTnet.Formatter;
+using MQTTnet.Server;
+using MQTTnet.Tests.Mockups;
+
+namespace MQTTnet.Tests.Server
+{
+    [TestClass]
+    public sealed class Tls_Tests : BaseTestClass
+    {
+        static X509Certificate2 CreateCertificate(string oid)
+        {
+            var sanBuilder = new SubjectAlternativeNameBuilder();
+            sanBuilder.AddIpAddress(IPAddress.Loopback);
+            sanBuilder.AddIpAddress(IPAddress.IPv6Loopback);
+            sanBuilder.AddDnsName("localhost");
+            
+            using (var rsa = RSA.Create())
+            {
+                var certRequest = new CertificateRequest("CN=localhost", rsa, HashAlgorithmName.SHA512, RSASignaturePadding.Pkcs1);
+
+                certRequest.CertificateExtensions.Add(
+                    new X509KeyUsageExtension(X509KeyUsageFlags.DataEncipherment | X509KeyUsageFlags.KeyEncipherment | X509KeyUsageFlags.DigitalSignature, false));
+
+                certRequest.CertificateExtensions.Add(new X509EnhancedKeyUsageExtension(new OidCollection { new Oid(oid) }, false));
+
+                certRequest.CertificateExtensions.Add(sanBuilder.Build());
+
+                using (var certificate = certRequest.CreateSelfSigned(DateTimeOffset.Now.AddMinutes(-10), DateTimeOffset.Now.AddMinutes(10)))
+                {
+                    var pfxCertificate = new X509Certificate2(
+                        certificate.Export(X509ContentType.Pfx),
+                        (string)null,
+                        X509KeyStorageFlags.MachineKeySet | X509KeyStorageFlags.Exportable);
+
+                    return pfxCertificate;
+                }
+            }
+        }
+
+        [TestMethod]
+        public async Task Tls_Swap_Test()
+        {
+            var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500);
+            var serverOptionsBuilder = testEnvironment.Factory.CreateServerOptionsBuilder();
+
+            var firstOid = "1.3.6.1.5.5.7.3.1";
+            var secondOid = "1.3.6.1.5.5.7.3.2";
+
+            var certificateProvider = new CertificateProvider
+            {
+                CurrentCertificate = CreateCertificate(firstOid)
+            };
+
+            serverOptionsBuilder.WithoutDefaultEndpoint().WithEncryptedEndpoint().WithEncryptionSslProtocol(SslProtocols.Tls12).WithEncryptionCertificate(certificateProvider);
+
+            var serverOptions = serverOptionsBuilder.Build();
+
+            var server = testEnvironment.CreateServer(serverOptions);
+
+            var publishedCount = 0;
+            server.InterceptingPublishAsync += args =>
+            {
+                Interlocked.Increment(ref publishedCount);
+
+                return Task.CompletedTask;
+            };
+
+            await server.StartAsync();
+
+            var firstClient = await ConnectClientAsync(
+                testEnvironment,
+                args =>
+                {
+                    Assert.AreEqual(firstOid, ((X509Certificate2)args.Certificate).Extensions.OfType<X509EnhancedKeyUsageExtension>().First().EnhancedKeyUsages[0].Value);
+                    return true;
+                });
+
+            var firstClientReceivedCount = 0;
+            firstClient.ApplicationMessageReceivedAsync += args =>
+            {
+                Interlocked.Increment(ref firstClientReceivedCount);
+
+                return Task.CompletedTask;
+            };
+
+            await firstClient.SubscribeAsync("TestTopic1");
+
+            await firstClient.PublishAsync(
+                new MqttApplicationMessage
+                {
+                    Topic = "TestTopic1",
+                    Payload = new byte[] { 1, 2, 3, 4 }
+                });
+
+            await testEnvironment.Server.InjectApplicationMessage(
+                new InjectedMqttApplicationMessage(
+                    new MqttApplicationMessage
+                    {
+                        Topic = "TestTopic1",
+                        Payload = new byte[] { 1, 2, 3, 4 }
+                    }));
+
+            certificateProvider.CurrentCertificate = CreateCertificate(secondOid);
+
+            // Validate that the certificate was switched
+            var secondClient = await ConnectClientAsync(
+                testEnvironment,
+                args =>
+                {
+                    Assert.AreEqual(secondOid, ((X509Certificate2)args.Certificate).Extensions.OfType<X509EnhancedKeyUsageExtension>().First().EnhancedKeyUsages[0].Value);
+                    return true;
+                });
+
+            var secondClientReceivedCount = 0;
+            secondClient.ApplicationMessageReceivedAsync += args =>
+            {
+                Interlocked.Increment(ref secondClientReceivedCount);
+
+                return Task.CompletedTask;
+            };
+
+            await secondClient.SubscribeAsync("TestTopic2");
+
+            await firstClient.PublishAsync(
+                new MqttApplicationMessage
+                {
+                    Topic = "TestTopic2",
+                    Payload = new byte[] { 1, 2, 3, 4 }
+                });
+
+            await testEnvironment.Server.InjectApplicationMessage(
+                new InjectedMqttApplicationMessage(
+                    new MqttApplicationMessage
+                    {
+                        Topic = "TestTopic2",
+                        Payload = new byte[] { 1, 2, 3, 4 }
+                    }));
+
+            // Ensure first client still works
+            await firstClient.PublishAsync(
+                new MqttApplicationMessage
+                {
+                    Topic = "TestTopic1",
+                    Payload = new byte[] { 1, 2, 3, 4 }
+                });
+
+            await testEnvironment.Server.InjectApplicationMessage(
+                new InjectedMqttApplicationMessage(
+                    new MqttApplicationMessage
+                    {
+                        Topic = "TestTopic1",
+                        Payload = new byte[] { 1, 2, 3, 4 }
+                    }));
+
+            await Task.Delay(1000);
+
+            Assert.AreEqual(6, publishedCount);
+            Assert.AreEqual(4, firstClientReceivedCount);
+            Assert.AreEqual(2, secondClientReceivedCount);
+
+            await server.StopAsync();
+        }
+
+        static async Task<IMqttClient> ConnectClientAsync(TestEnvironment testEnvironment, Func<MqttClientCertificateValidationEventArgs, bool> certValidator)
+        {
+            var clientOptionsBuilder = testEnvironment.Factory.CreateClientOptionsBuilder();
+            clientOptionsBuilder.WithClientId(Guid.NewGuid().ToString())
+                .WithTcpServer("localhost", 8883)
+                .WithTls(
+                    tls =>
+                    {
+                        tls.UseTls = true;
+                        tls.SslProtocol = SslProtocols.Tls12;
+                        tls.CertificateValidationHandler = certValidator;
+                    });
+
+            var clientOptions = clientOptionsBuilder.Build();
+            return await testEnvironment.ConnectClient(clientOptions);
+        }
+        
+        sealed class CertificateProvider : ICertificateProvider
+        {
+            public X509Certificate2 CurrentCertificate { get; set; }
+
+            public X509Certificate2 GetCertificate()
+            {
+                return CurrentCertificate;
+            }
+        }
+    }
+}
+#endif

Source/MQTTnet/Adapter/MqttChannelAdapter.cs

@@ -33,8 +33,7 @@ namespace MQTTnet.Adapter
 
         readonly AsyncLock _syncRoot = new AsyncLock();
 
-        long _bytesReceived;
-        long _bytesSent;
+        Statistics _statistics;     // mutable struct, don't make readonly!
 
         public MqttChannelAdapter(IMqttChannel channel, MqttPacketFormatterAdapter packetFormatterAdapter, MqttPacketInspector packetInspector, IMqttNetLogger logger)
         {
@@ -51,9 +50,9 @@ namespace MQTTnet.Adapter
             _logger = logger.WithSource(nameof(MqttChannelAdapter));
         }
 
-        public long BytesReceived => Interlocked.Read(ref _bytesReceived);
+        public long BytesReceived => Volatile.Read(ref _statistics._bytesReceived);
 
-        public long BytesSent => Interlocked.Read(ref _bytesSent);
+        public long BytesSent => Volatile.Read(ref _statistics._bytesSent);
 
         public X509Certificate2 ClientCertificate => _channel.ClientCertificate;
 
@@ -147,7 +146,7 @@ namespace MQTTnet.Adapter
 
                 _packetInspector?.EndReceivePacket();
 
-                Interlocked.Add(ref _bytesSent, receivedPacket.TotalLength);
+                Interlocked.Add(ref _statistics._bytesSent, receivedPacket.TotalLength);
 
                 if (PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.Unknown)
                 {
@@ -181,11 +180,7 @@ namespace MQTTnet.Adapter
             return null;
         }
 
-        public void ResetStatistics()
-        {
-            Interlocked.Exchange(ref _bytesReceived, 0L);
-            Interlocked.Exchange(ref _bytesSent, 0L);
-        }
+        public void ResetStatistics() => _statistics.Reset();
 
         public async Task SendPacketAsync(MqttPacket packet, CancellationToken cancellationToken)
         {
@@ -216,7 +211,7 @@ namespace MQTTnet.Adapter
                         await _channel.WriteAsync(packetBuffer.Packet, true, cancellationToken).ConfigureAwait(false);
                     }
 
-                    Interlocked.Add(ref _bytesReceived, packetBuffer.Length);
+                    Interlocked.Add(ref _statistics._bytesReceived, packetBuffer.Length);
                 }
                 catch (Exception exception)
                 {
@@ -459,5 +454,17 @@ namespace MQTTnet.Adapter
 
             throw new MqttCommunicationException(exception);
         }
+
+        private struct Statistics
+        {
+            public long _bytesReceived;
+            public long _bytesSent;
+
+            public void Reset()
+            {
+                Volatile.Write(ref _bytesReceived, 0);
+                Volatile.Write(ref _bytesSent, 0);
+            }
+        }
     }
 }

Source/MQTTnet/Adapter/MqttPacketInspector.cs

@@ -82,12 +82,7 @@ namespace MQTTnet.Adapter
         {
             try
             {
-                var eventArgs = new InspectMqttPacketEventArgs
-                {
-                    Buffer = buffer,
-                    Direction = direction
-                };
-
+                var eventArgs = new InspectMqttPacketEventArgs(direction, buffer);
                 _asyncEvent.InvokeAsync(eventArgs).GetAwaiter().GetResult();
             }
             catch (Exception exception)

Source/MQTTnet/Client/Connecting/MqttClientConnectedEventArgs.cs

@@ -15,7 +15,7 @@ namespace MQTTnet.Client
 
         /// <summary>
         ///     Gets the authentication result.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public MqttClientConnectResult ConnectResult { get; }
     }

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectOptions.cs

@@ -2,20 +2,35 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Generic;
+using MQTTnet.Packets;
+
 namespace MQTTnet.Client
 {
     public sealed class MqttClientDisconnectOptions
     {
         /// <summary>
-        /// Gets or sets the reason code.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the reason code.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public MqttClientDisconnectReason Reason { get; set; } = MqttClientDisconnectReason.NormalDisconnection;
+        public MqttClientDisconnectOptionsReason Reason { get; set; } = MqttClientDisconnectOptionsReason.NormalDisconnection;
 
         /// <summary>
-        /// Gets or sets the reason string.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the reason string.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public string ReasonString { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the session expiry interval.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public uint SessionExpiryInterval { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the user properties.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public List<MqttUserProperty> UserProperties { get; set; }
     }
-}
+}

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectOptionsBuilder.cs

@@ -2,32 +2,62 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System.Collections.Generic;
+using MQTTnet.Packets;
+
 namespace MQTTnet.Client
 {
     public sealed class MqttClientDisconnectOptionsBuilder
     {
-        MqttClientDisconnectReason _reason = MqttClientDisconnectReason.NormalDisconnection;
+        MqttClientDisconnectOptionsReason _reason = MqttClientDisconnectOptionsReason.NormalDisconnection;
         string _reasonString;
-        
-        public MqttClientDisconnectOptionsBuilder WithReasonString(string value)
-        {
-            _reasonString = value;
-            return this;
-        }
-        
-        public MqttClientDisconnectOptionsBuilder WithReason(MqttClientDisconnectReason value)
-        {
-            _reason = value;
-            return this;
-        }
-        
+        uint _sessionExpiryInterval;
+        List<MqttUserProperty> _userProperties;
+
         public MqttClientDisconnectOptions Build()
         {
             return new MqttClientDisconnectOptions
             {
                 Reason = _reason,
-                ReasonString = _reasonString
+                ReasonString = _reasonString,
+                UserProperties = _userProperties,
+                SessionExpiryInterval = _sessionExpiryInterval
             };
         }
+
+        public MqttClientDisconnectOptionsBuilder WithReason(MqttClientDisconnectOptionsReason value)
+        {
+            _reason = value;
+            return this;
+        }
+
+        public MqttClientDisconnectOptionsBuilder WithReasonString(string value)
+        {
+            _reasonString = value;
+            return this;
+        }
+
+        public MqttClientDisconnectOptionsBuilder WithSessionExpiryInterval(uint value)
+        {
+            _sessionExpiryInterval = value;
+            return this;
+        }
+
+        public MqttClientDisconnectOptionsBuilder WithUserProperties(List<MqttUserProperty> userProperties)
+        {
+            _userProperties = userProperties;
+            return this;
+        }
+
+        public MqttClientDisconnectOptionsBuilder WithUserProperty(string name, string value)
+        {
+            if (_userProperties == null)
+            {
+                _userProperties = new List<MqttUserProperty>();
+            }
+
+            _userProperties.Add(new MqttUserProperty(name, value));
+            return this;
+        }
     }
 }

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectOptionsReason.cs

@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+namespace MQTTnet.Client
+{
+    /// <summary>
+    /// This enum only contains values which are valid when a client sends the reason to the server.
+    /// </summary>
+    public enum MqttClientDisconnectOptionsReason
+    {
+        NormalDisconnection = 0,
+        DisconnectWithWillMessage = 4,
+        UnspecifiedError = 128,
+        MalformedPacket = 129,
+        ProtocolError = 130,
+        ImplementationSpecificError = 131,
+        TopicNameInvalid = 144,
+        ReceiveMaximumExceeded = 147,
+        TopicAliasInvalid = 148,
+        PacketTooLarge = 149,
+        MessageRateTooHigh = 150,
+        QuotaExceeded = 151,
+        AdministrativeAction = 152,
+        PayloadFormatInvalid = 153
+    }
+}

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectOptionsValidator.cs

@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Client
+{
+    public static class MqttClientDisconnectOptionsValidator
+    {
+        public static void ThrowIfNotSupported(MqttClientDisconnectOptions options, MqttProtocolVersion protocolVersion)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+
+            if (protocolVersion == MqttProtocolVersion.V500)
+            {
+                // Everything is supported.
+                return;
+            }
+
+            if (options.ReasonString?.Any() == true)
+            {
+                Throw(nameof(options.ReasonString));
+            }
+
+            if (options.Reason != MqttClientDisconnectOptionsReason.NormalDisconnection)
+            {
+                Throw(nameof(options.Reason));
+            }
+        }
+
+        static void Throw(string featureName)
+        {
+            throw new NotSupportedException($"Feature {featureName} requires MQTT version 5.0.0.");
+        }
+    }
+}

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectedEventArgs.cs

@@ -3,27 +3,47 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
+using MQTTnet.Packets;
 
 namespace MQTTnet.Client
 {
     public sealed class MqttClientDisconnectedEventArgs : EventArgs
     {
-        public bool ClientWasConnected { get; internal set; }
+        public MqttClientDisconnectedEventArgs(
+            bool clientWasConnected,
+            MqttClientConnectResult connectResult,
+            MqttClientDisconnectReason reason,
+            string reasonString,
+            List<MqttUserProperty> userProperties,
+            Exception exception)
+        {
+            ClientWasConnected = clientWasConnected;
+            ConnectResult = connectResult;
+            Exception = exception;
+            Reason = reason;
+            ReasonString = reasonString;
+            UserProperties = userProperties;
+        }
 
-        public Exception Exception { get; internal set; }
+        public bool ClientWasConnected { get; }
 
         /// <summary>
-        /// Gets the authentication result.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets the authentication result.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public MqttClientConnectResult ConnectResult { get; internal set; }
+        public MqttClientConnectResult ConnectResult { get; }
+
+        public Exception Exception { get; }
 
         /// <summary>
-        /// Gets or sets the reason.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the reason.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public MqttClientDisconnectReason Reason { get; internal set; }
-        
-        public string ReasonString { get; internal set; }
+        public MqttClientDisconnectReason Reason { get; }
+
+        public string ReasonString { get; }
+
+        public List<MqttUserProperty> UserProperties { get; }
     }
-}
+}

Source/MQTTnet/Client/MqttClient.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
@@ -36,13 +37,20 @@ namespace MQTTnet.Client
         readonly IMqttNetLogger _rootLogger;
 
         IMqttChannelAdapter _adapter;
-        CancellationTokenSource _backgroundCancellationTokenSource;
+
         bool _cleanDisconnectInitiated;
         volatile int _connectionStatus;
-        MqttClientDisconnectReason _disconnectReason;
+
+        // The value for this field can be set from two different enums.
+        // They contain the same values but the set is reduced in one case.
+        int _disconnectReason;
         string _disconnectReasonString;
+        List<MqttUserProperty> _disconnectUserProperties;
+
         Task _keepAlivePacketsSenderTask;
         DateTime _lastPacketSentTimestamp;
+
+        CancellationTokenSource _mqttClientAlive;
         MqttPacketDispatcher _packetDispatcher;
         Task _packetReceiverTask;
         AsyncQueue<MqttPublishPacket> _publishPacketReceiverQueue;
@@ -84,25 +92,15 @@ namespace MQTTnet.Client
             add => _inspectPacketEvent.AddHandler(value);
             remove => _inspectPacketEvent.RemoveHandler(value);
         }
-        
+
         public bool IsConnected => (MqttClientConnectionStatus)_connectionStatus == MqttClientConnectionStatus.Connected;
 
         public MqttClientOptions Options { get; private set; }
 
         public async Task<MqttClientConnectResult> ConnectAsync(MqttClientOptions options, CancellationToken cancellationToken = default)
         {
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-
-            if (options.ChannelOptions == null)
-            {
-                throw new ArgumentException("ChannelOptions are not set.");
-            }
-
+            ThrowIfOptionsInvalid(options);
             ThrowIfConnected("It is not allowed to connect with a server after the connection is established.");
-
             ThrowIfDisposed();
 
             if (CompareExchangeConnectionStatus(MqttClientConnectionStatus.Connecting, MqttClientConnectionStatus.Disconnected) != MqttClientConnectionStatus.Disconnected)
@@ -121,28 +119,29 @@ namespace MQTTnet.Client
                     await _connectingEvent.InvokeAsync(new MqttClientConnectingEventArgs(options));
                 }
 
+                Cleanup();
+
                 _packetIdentifierProvider.Reset();
                 _packetDispatcher = new MqttPacketDispatcher();
 
-                _backgroundCancellationTokenSource = new CancellationTokenSource();
-                var backgroundCancellationToken = _backgroundCancellationTokenSource.Token;
+                _mqttClientAlive = new CancellationTokenSource();
+                var mqttClientAliveToken = _mqttClientAlive.Token;
 
                 var adapter = _adapterFactory.CreateClientAdapter(options, new MqttPacketInspector(_inspectPacketEvent, _rootLogger), _rootLogger);
                 _adapter = adapter;
 
-                using (var effectiveCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(backgroundCancellationToken, cancellationToken))
+                if (cancellationToken.CanBeCanceled)
                 {
-                    _logger.Verbose("Trying to connect with server '{0}'.", options.ChannelOptions);
-                    await adapter.ConnectAsync(effectiveCancellationToken.Token).ConfigureAwait(false);
-                    _logger.Verbose("Connection with server established.");
-
-                    _publishPacketReceiverQueue?.Dispose();
-                    _publishPacketReceiverQueue = new AsyncQueue<MqttPublishPacket>();
-                    _publishPacketReceiverTask = Task.Run(() => ProcessReceivedPublishPackets(backgroundCancellationToken), backgroundCancellationToken);
-
-                    _packetReceiverTask = Task.Run(() => TryReceivePacketsAsync(backgroundCancellationToken), backgroundCancellationToken);
-
-                    connectResult = await AuthenticateAsync(options, effectiveCancellationToken.Token).ConfigureAwait(false);
+                    connectResult = await ConnectInternal(cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    // Fall back to the general timeout specified in the options if the user passed
+                    // CancellationToken.None or similar.
+                    using (var timeout = new CancellationTokenSource(Options.Timeout))
+                    {
+                        connectResult = await ConnectInternal(timeout.Token).ConfigureAwait(false);
+                    }
                 }
 
                 _lastPacketSentTimestamp = DateTime.UtcNow;
@@ -156,7 +155,7 @@ namespace MQTTnet.Client
 
                 if (keepAliveInterval != TimeSpan.Zero)
                 {
-                    _keepAlivePacketsSenderTask = Task.Run(() => TrySendKeepAliveMessagesAsync(backgroundCancellationToken), backgroundCancellationToken);
+                    _keepAlivePacketsSenderTask = Task.Run(() => TrySendKeepAliveMessagesAsync(mqttClientAliveToken), mqttClientAliveToken);
                 }
 
                 CompareExchangeConnectionStatus(MqttClientConnectionStatus.Connected, MqttClientConnectionStatus.Connecting);
@@ -173,7 +172,7 @@ namespace MQTTnet.Client
             }
             catch (Exception exception)
             {
-                _disconnectReason = MqttClientDisconnectReason.UnspecifiedError;
+                _disconnectReason = (int)MqttClientDisconnectOptionsReason.UnspecifiedError;
 
                 _logger.Error(exception, "Error while connecting with server.");
 
@@ -193,6 +192,7 @@ namespace MQTTnet.Client
             ThrowIfDisposed();
 
             var clientWasConnected = IsConnected;
+
             if (DisconnectIsPendingOrFinished())
             {
                 return;
@@ -200,14 +200,34 @@ namespace MQTTnet.Client
 
             try
             {
-                _disconnectReason = MqttClientDisconnectReason.NormalDisconnection;
+                if (!clientWasConnected)
+                {
+                    ThrowNotConnected();
+                }
+
+                _disconnectReason = (int)options.Reason;
                 _cleanDisconnectInitiated = true;
 
-                if (clientWasConnected)
+                if (Options.ValidateFeatures)
+                {
+                    MqttClientDisconnectOptionsValidator.ThrowIfNotSupported(options, _adapter.PacketFormatterAdapter.ProtocolVersion);
+                }
+
+                // Sending the DISCONNECT may fail due to connection issues. The resulting exception
+                // must be throw to let the caller know that the disconnect is not a clean one.
+                var disconnectPacket = MqttPacketFactories.Disconnect.Create(options);
+
+                if (cancellationToken.CanBeCanceled)
                 {
-                    var disconnectPacket = MqttPacketFactories.Disconnect.Create(options);
                     await SendAsync(disconnectPacket, cancellationToken).ConfigureAwait(false);
                 }
+                else
+                {
+                    using (var timeout = new CancellationTokenSource(Options.Timeout))
+                    {
+                        await SendAsync(disconnectPacket, timeout.Token).ConfigureAwait(false);
+                    }
+                }
             }
             finally
             {
@@ -239,6 +259,11 @@ namespace MQTTnet.Client
             ThrowIfDisposed();
             ThrowIfNotConnected();
 
+            if (Options.ValidateFeatures)
+            {
+                MqttApplicationMessageValidator.ThrowIfNotSupported(applicationMessage, _adapter.PacketFormatterAdapter.ProtocolVersion);
+            }
+
             var publishPacket = MqttPacketFactories.Publish.Create(applicationMessage);
 
             switch (applicationMessage.QualityOfServiceLevel)
@@ -296,13 +321,29 @@ namespace MQTTnet.Client
                 MqttTopicValidator.ThrowIfInvalidSubscribe(topicFilter.Topic);
             }
 
+            if (Options.ValidateFeatures)
+            {
+                MqttClientSubscribeOptionsValidator.ThrowIfNotSupported(options, _adapter.PacketFormatterAdapter.ProtocolVersion);
+            }
+
             ThrowIfDisposed();
             ThrowIfNotConnected();
 
             var subscribePacket = MqttPacketFactories.Subscribe.Create(options);
             subscribePacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
 
-            var subAckPacket = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket, cancellationToken).ConfigureAwait(false);
+            MqttSubAckPacket subAckPacket;
+            if (cancellationToken.CanBeCanceled)
+            {
+                subAckPacket = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                using (var timeout = new CancellationTokenSource(Options.Timeout))
+                {
+                    subAckPacket = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket, timeout.Token).ConfigureAwait(false);
+                }
+            }
 
             return _clientSubscribeResultFactory.Create(subscribePacket, subAckPacket);
         }
@@ -314,13 +355,34 @@ namespace MQTTnet.Client
                 throw new ArgumentNullException(nameof(options));
             }
 
+            foreach (var topicFilter in options.TopicFilters)
+            {
+                MqttTopicValidator.ThrowIfInvalidSubscribe(topicFilter);
+            }
+
             ThrowIfDisposed();
             ThrowIfNotConnected();
 
+            if (Options.ValidateFeatures)
+            {
+                MqttClientUnsubscribeOptionsValidator.ThrowIfNotSupported(options, _adapter.PacketFormatterAdapter.ProtocolVersion);
+            }
+
             var unsubscribePacket = MqttPacketFactories.Unsubscribe.Create(options);
             unsubscribePacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
 
-            var unsubAckPacket = await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket, cancellationToken).ConfigureAwait(false);
+            MqttUnsubAckPacket unsubAckPacket;
+            if (cancellationToken.CanBeCanceled)
+            {
+                unsubAckPacket = await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket, cancellationToken).ConfigureAwait(false);
+            }
+            else
+            {
+                using (var timeout = new CancellationTokenSource(Options.Timeout))
+                {
+                    unsubAckPacket = await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket, timeout.Token).ConfigureAwait(false);
+                }
+            }
 
             return _clientUnsubscribeResultFactory.Create(unsubscribePacket, unsubAckPacket);
         }
@@ -376,7 +438,7 @@ namespace MQTTnet.Client
                 var connAckPacket = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket, cancellationToken).ConfigureAwait(false);
 
                 var clientConnectResultFactory = new MqttClientConnectResultFactory();
-                result = clientConnectResultFactory.Create(connAckPacket, options.ProtocolVersion);
+                result = clientConnectResultFactory.Create(connAckPacket, _adapter.PacketFormatterAdapter.ProtocolVersion);
             }
             catch (Exception exception)
             {
@@ -397,19 +459,19 @@ namespace MQTTnet.Client
         {
             try
             {
-                _backgroundCancellationTokenSource?.Cancel(false);
+                _mqttClientAlive?.Cancel(false);
             }
             finally
             {
-                _backgroundCancellationTokenSource?.Dispose();
-                _backgroundCancellationTokenSource = null;
+                _mqttClientAlive?.Dispose();
+                _mqttClientAlive = null;
 
                 _publishPacketReceiverQueue?.Dispose();
                 _publishPacketReceiverQueue = null;
 
                 _adapter?.Dispose();
                 _adapter = null;
-                
+
                 _packetDispatcher?.Dispose();
                 _packetDispatcher = null;
             }
@@ -420,6 +482,26 @@ namespace MQTTnet.Client
             return (MqttClientConnectionStatus)Interlocked.CompareExchange(ref _connectionStatus, (int)value, (int)comparand);
         }
 
+        async Task<MqttClientConnectResult> ConnectInternal(CancellationToken cancellationToken)
+        {
+            var backgroundCancellationToken = _mqttClientAlive.Token;
+
+            using (var effectiveCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(backgroundCancellationToken, cancellationToken))
+            {
+                _logger.Verbose("Trying to connect with server '{0}'.", Options.ChannelOptions);
+                await _adapter.ConnectAsync(effectiveCancellationToken.Token).ConfigureAwait(false);
+                _logger.Verbose("Connection with server established.");
+
+                _publishPacketReceiverQueue?.Dispose();
+                _publishPacketReceiverQueue = new AsyncQueue<MqttPublishPacket>();
+
+                _publishPacketReceiverTask = Task.Run(() => ProcessReceivedPublishPackets(backgroundCancellationToken), backgroundCancellationToken);
+                _packetReceiverTask = Task.Run(() => TryReceivePacketsAsync(backgroundCancellationToken), backgroundCancellationToken);
+
+                return await AuthenticateAsync(Options, effectiveCancellationToken.Token).ConfigureAwait(false);
+            }
+        }
+
         async Task DisconnectCoreAsync(Task sender, Exception exception, MqttClientConnectResult connectResult, bool clientWasConnected)
         {
             TryInitiateDisconnect();
@@ -446,10 +528,10 @@ namespace MQTTnet.Client
             try
             {
                 _packetDispatcher.Dispose(new MqttClientDisconnectedException(exception));
-                
-                var receiverTask = WaitForTaskAsync(_packetReceiverTask, sender);
-                var publishPacketReceiverTask = WaitForTaskAsync(_publishPacketReceiverTask, sender);
-                var keepAliveTask = WaitForTaskAsync(_keepAlivePacketsSenderTask, sender);
+
+                var receiverTask = _packetReceiverTask.WaitAsync(sender, _logger);
+                var publishPacketReceiverTask = _publishPacketReceiverTask.WaitAsync(sender, _logger);
+                var keepAliveTask = _keepAlivePacketsSenderTask.WaitAsync(sender, _logger);
 
                 await Task.WhenAll(receiverTask, publishPacketReceiverTask, keepAliveTask).ConfigureAwait(false);
             }
@@ -465,14 +547,13 @@ namespace MQTTnet.Client
 
                 _logger.Info("Disconnected.");
 
-                var eventArgs = new MqttClientDisconnectedEventArgs
-                {
-                    ClientWasConnected = clientWasConnected,
-                    Exception = exception,
-                    ConnectResult = connectResult,
-                    Reason = _disconnectReason,
-                    ReasonString = _disconnectReasonString
-                };
+                var eventArgs = new MqttClientDisconnectedEventArgs(
+                    clientWasConnected,
+                    connectResult,
+                    (MqttClientDisconnectReason)_disconnectReason,
+                    _disconnectReasonString,
+                    _disconnectUserProperties,
+                    exception);
 
                 // This handler must be executed in a new thread because otherwise a dead lock may happen
                 // when trying to reconnect in that handler etc.
@@ -535,7 +616,6 @@ namespace MQTTnet.Client
         {
             var applicationMessage = MqttApplicationMessageFactory.Create(publishPacket);
             var eventArgs = new MqttApplicationMessageReceivedEventArgs(Options.ClientId, applicationMessage, publishPacket, AcknowledgeReceivedPublishPacket);
-
             await _applicationMessageReceivedEvent.InvokeAsync(eventArgs).ConfigureAwait(false);
 
             return eventArgs;
@@ -554,8 +634,9 @@ namespace MQTTnet.Client
 
         Task ProcessReceivedDisconnectPacket(MqttDisconnectPacket disconnectPacket)
         {
-            _disconnectReason = (MqttClientDisconnectReason)disconnectPacket.ReasonCode;
+            _disconnectReason = (int)disconnectPacket.ReasonCode;
             _disconnectReasonString = disconnectPacket.ReasonString;
+            _disconnectUserProperties = disconnectPacket.UserProperties;
 
             // Also dispatch disconnect to waiting threads to generate a proper exception.
             _packetDispatcher.Dispose(new MqttClientUnexpectedDisconnectReceivedException(disconnectPacket));
@@ -617,7 +698,6 @@ namespace MQTTnet.Client
             publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
 
             var pubAckPacket = await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket, cancellationToken).ConfigureAwait(false);
-
             return _clientPublishResultFactory.Create(pubAckPacket);
         }
 
@@ -693,7 +773,7 @@ namespace MQTTnet.Client
         {
             if (IsConnected)
             {
-                throw new MqttProtocolViolationException(message);
+                throw new InvalidOperationException(message);
             }
         }
 
@@ -701,17 +781,40 @@ namespace MQTTnet.Client
         {
             if (!IsConnected)
             {
-                throw new MqttCommunicationException("The client is not connected.");
+                ThrowNotConnected();
             }
         }
 
+        static void ThrowIfOptionsInvalid(MqttClientOptions options)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+
+            if (options.ChannelOptions == null)
+            {
+                throw new ArgumentException("ChannelOptions are not set.");
+            }
+
+            if (options.ValidateFeatures)
+            {
+                MqttClientOptionsValidator.ThrowIfNotSupported(options);
+            }
+        }
+
+        static void ThrowNotConnected()
+        {
+            throw new MqttCommunicationException("The client is not connected.");
+        }
+
         void TryInitiateDisconnect()
         {
             lock (_disconnectLock)
             {
                 try
                 {
-                    _backgroundCancellationTokenSource?.Cancel(false);
+                    _mqttClientAlive?.Cancel(false);
                 }
                 catch (Exception exception)
                 {
@@ -831,7 +934,7 @@ namespace MQTTnet.Client
                 {
                     exception = aggregateException.GetBaseException();
                 }
-                
+
                 if (exception is OperationCanceledException)
                 {
                 }
@@ -910,36 +1013,5 @@ namespace MQTTnet.Client
                 _logger.Verbose("Stopped sending keep alive packets.");
             }
         }
-
-        async Task WaitForTaskAsync(Task task, Task sender)
-        {
-            if (task == null)
-            {
-                return;
-            }
-
-            if (task == sender)
-            {
-                // Return here to avoid deadlocks, but first any eventual exception in the task
-                // must be handled to avoid not getting an unhandled task exception
-                if (!task.IsFaulted)
-                {
-                    return;
-                }
-
-                // By accessing the Exception property the exception is considered handled and will
-                // not result in an unhandled task exception later by the finalizer
-                _logger.Warning(task.Exception, "Error while waiting for background task.");
-                return;
-            }
-
-            try
-            {
-                await task.ConfigureAwait(false);
-            }
-            catch (OperationCanceledException)
-            {
-            }
-        }
     }
 }

Source/MQTTnet/Client/MqttClientExtensions.cs

@@ -14,20 +14,28 @@ namespace MQTTnet.Client
 {
     public static class MqttClientExtensions
     {
-        public static Task DisconnectAsync(this IMqttClient client, MqttClientDisconnectReason reason = MqttClientDisconnectReason.NormalDisconnection, string reasonString = null)
+        public static Task DisconnectAsync(
+            this IMqttClient client,
+            MqttClientDisconnectOptionsReason reason = MqttClientDisconnectOptionsReason.NormalDisconnection,
+            string reasonString = null,
+            uint sessionExpiryInterval = 0,
+            List<MqttUserProperty> userProperties = null,
+            CancellationToken cancellationToken = default)
         {
             if (client == null)
             {
                 throw new ArgumentNullException(nameof(client));
             }
 
-            return client.DisconnectAsync(
-                new MqttClientDisconnectOptions
-                {
-                    Reason = reason,
-                    ReasonString = reasonString
-                },
-                CancellationToken.None);
+            var disconnectOptions = new MqttClientDisconnectOptions
+            {
+                Reason = reason,
+                ReasonString = reasonString,
+                SessionExpiryInterval = sessionExpiryInterval,
+                UserProperties = userProperties
+            };
+
+            return client.DisconnectAsync(disconnectOptions, cancellationToken);
         }
 
         public static Task<MqttClientPublishResult> PublishBinaryAsync(
@@ -128,6 +136,29 @@ namespace MQTTnet.Client
             return mqttClient.SubscribeAsync(subscribeOptions, cancellationToken);
         }
 
+        public static async Task<bool> TryDisconnectAsync(
+            this IMqttClient client,
+            MqttClientDisconnectOptionsReason reason = MqttClientDisconnectOptionsReason.NormalDisconnection,
+            string reasonString = null)
+        {
+            if (client == null)
+            {
+                throw new ArgumentNullException(nameof(client));
+            }
+
+            try
+            {
+                await client.DisconnectAsync(reason, reasonString).ConfigureAwait(false);
+                return true;
+            }
+            catch
+            {
+                // Ignore all errors.
+            }
+
+            return false;
+        }
+
         public static async Task<bool> TryPingAsync(this IMqttClient client, CancellationToken cancellationToken = default)
         {
             if (client == null)

Source/MQTTnet/Client/Options/MqttClientOptions.cs

@@ -14,13 +14,13 @@ namespace MQTTnet.Client
     {
         /// <summary>
         ///     Gets or sets the authentication data.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public byte[] AuthenticationData { get; set; }
 
         /// <summary>
         ///     Gets or sets the authentication method.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public string AuthenticationMethod { get; set; }
 
@@ -58,6 +58,10 @@ namespace MQTTnet.Client
         /// </summary>
         public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(15);
 
+        /// <summary>
+        ///     Gets or sets the maximum packet size.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
         public uint MaximumPacketSize { get; set; }
 
         public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
@@ -65,24 +69,26 @@ namespace MQTTnet.Client
         /// <summary>
         ///     Gets or sets the receive maximum.
         ///     This gives the maximum length of the receive messages.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public ushort ReceiveMaximum { get; set; }
 
         /// <summary>
         ///     Gets or sets the request problem information.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public bool RequestProblemInformation { get; set; } = true;
 
         /// <summary>
         ///     Gets or sets the request response information.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public bool RequestResponseInformation { get; set; }
 
         /// <summary>
         ///     Gets or sets the session expiry interval.
         ///     The time after a session expires when it's not actively used.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public uint SessionExpiryInterval { get; set; }
 
@@ -95,6 +101,7 @@ namespace MQTTnet.Client
         /// <summary>
         ///     Gets or sets the topic alias maximum.
         ///     This gives the maximum length of the topic alias.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public ushort TopicAliasMaximum { get; set; }
 
@@ -103,8 +110,10 @@ namespace MQTTnet.Client
         ///     client.
         ///     If successful, this means that loop detection will be more effective and that retained messages will be propagated
         ///     correctly.
-        ///     Not all brokers support this feature so it may be necessary to set it to false if your bridge does not connect
-        ///     properly.
+        ///     <remarks>
+        ///         Not all brokers support this feature so it may be necessary to set it to false if your bridge does not
+        ///         connect properly.
+        ///     </remarks>
         /// </summary>
         public bool TryPrivate { get; set; } = true;
 
@@ -115,28 +124,41 @@ namespace MQTTnet.Client
         ///     As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add
         ///     metadata to MQTT messages and pass information between publisher, broker, and subscriber.
         ///     The feature is very similar to the HTTP header concept.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public List<MqttUserProperty> UserProperties { get; set; }
 
+        /// <summary>
+        ///     When this feature is enabled the client will check if used properties are supported in the selected protocol
+        ///     version.
+        ///     This feature can be validated if an application message is generated one time but sent via different protocol
+        ///     versions.
+        ///     Default values are applied if the validation is off and features are not supported.
+        /// </summary>
+        public bool ValidateFeatures { get; set; } = true;
+
         /// <summary>
         ///     Gets or sets the content type of the will message.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public string WillContentType { get; set; }
 
         /// <summary>
         ///     Gets or sets the correlation data of the will message.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public byte[] WillCorrelationData { get; set; }
 
         /// <summary>
         ///     Gets or sets the will delay interval.
         ///     This is the time between the client disconnect and the time the will message will be sent.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public uint WillDelayInterval { get; set; }
 
         /// <summary>
         ///     Gets or sets the message expiry interval of the will message.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public uint WillMessageExpiryInterval { get; set; }
 
@@ -147,8 +169,9 @@ namespace MQTTnet.Client
 
         /// <summary>
         ///     Gets or sets the payload format indicator of the will message.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public MqttPayloadFormatIndicator WillPayloadFormatIndicator { get; set; }
+        public MqttPayloadFormatIndicator WillPayloadFormatIndicator { get; set; } = MqttPayloadFormatIndicator.Unspecified;
 
         /// <summary>
         ///     Gets or sets the QoS level of the will message.
@@ -157,6 +180,7 @@ namespace MQTTnet.Client
 
         /// <summary>
         ///     Gets or sets the response topic of the will message.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public string WillResponseTopic { get; set; }
 
@@ -172,6 +196,7 @@ namespace MQTTnet.Client
 
         /// <summary>
         ///     Gets or sets the user properties of the will message.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public List<MqttUserProperty> WillUserProperties { get; set; }
 

Source/MQTTnet/Client/Options/MqttClientOptionsBuilder.cs

@@ -46,7 +46,7 @@ namespace MQTTnet.Client
                         Certificates = _tlsParameters.Certificates?.ToList(),
 #endif
 
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER
                         ApplicationProtocols = _tlsParameters.ApplicationProtocols,
 #endif
                     };
@@ -74,6 +74,8 @@ namespace MQTTnet.Client
 
             _options.ChannelOptions = (IMqttClientChannelOptions)_tcpOptions ?? _webSocketOptions;
 
+            MqttClientOptionsValidator.ThrowIfNotSupported(_options);
+            
             return _options;
         }
 
@@ -337,16 +339,6 @@ namespace MQTTnet.Client
 
         public MqttClientOptionsBuilder WithUserProperty(string name, string value)
         {
-            if (name is null)
-            {
-                throw new ArgumentNullException(nameof(name));
-            }
-
-            if (value is null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-
             if (_options.UserProperties == null)
             {
                 _options.UserProperties = new List<MqttUserProperty>();

Source/MQTTnet/Client/Options/MqttClientOptionsBuilderTlsParameters.cs

@@ -4,7 +4,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Net.Security;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 
@@ -13,10 +12,10 @@ namespace MQTTnet.Client
     public sealed class MqttClientOptionsBuilderTlsParameters
     {
         public bool UseTls { get; set; }
-        
+
         public Func<MqttClientCertificateValidationEventArgs, bool> CertificateValidationHandler { get; set; }
 
-#if NET48 || NETCOREAPP3_1 || NET5 || NET6
+#if NET48 || NETCOREAPP3_1_OR_GREATER
         public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls12 | SslProtocols.Tls13;
 #else
         public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls12 | (SslProtocols)0x00003000 /*Tls13*/;
@@ -28,14 +27,14 @@ namespace MQTTnet.Client
         public IEnumerable<X509Certificate> Certificates { get; set; }
 #endif
 
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
-        public List<SslApplicationProtocol> ApplicationProtocols { get;set; }
+#if NETCOREAPP3_1_OR_GREATER
+        public List<System.Net.Security.SslApplicationProtocol> ApplicationProtocols { get; set; }
 #endif
 
-	    public bool AllowUntrustedCertificates { get; set; }
+        public bool AllowUntrustedCertificates { get; set; }
 
         public bool IgnoreCertificateChainErrors { get; set; }
 
         public bool IgnoreCertificateRevocationErrors { get; set; }
     }
-}
+}

Source/MQTTnet/Client/Options/MqttClientOptionsValidator.cs

@@ -0,0 +1,114 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Client
+{
+    public static class MqttClientOptionsValidator
+    {
+        public static void ThrowIfNotSupported(MqttClientOptions options)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+
+            if (options.ProtocolVersion == MqttProtocolVersion.V500)
+            {
+                // Everything is supported.
+                return;
+            }
+            
+            if (options.WillContentType?.Any() == true)
+            {
+                Throw(nameof(options.WillContentType));
+            }
+
+            if (options.UserProperties?.Any() == true)
+            {
+                Throw(nameof(options.UserProperties));
+            }
+
+            if (options.RequestProblemInformation)
+            {
+                // Since this value is a boolean and true by default, validation would
+                // require a nullable boolean.
+                //Throw(nameof(options.RequestProblemInformation));
+            }
+
+            if (options.RequestResponseInformation)
+            {
+                Throw(nameof(options.RequestResponseInformation));
+            }
+
+            if (options.ReceiveMaximum > 0)
+            {
+                Throw(nameof(options.ReceiveMaximum));
+            }
+            
+            if (options.MaximumPacketSize > 0)
+            {
+                Throw(nameof(options.MaximumPacketSize));
+            }
+
+            // Authentication relevant properties.
+            
+            if (options.AuthenticationData?.Any() == true)
+            {
+                Throw(nameof(options.AuthenticationData));
+            }
+
+            if (options.AuthenticationMethod?.Any() == true)
+            {
+                Throw(nameof(options.AuthenticationMethod));
+            }
+
+            // Will relevant properties.
+            
+            if (options.WillPayloadFormatIndicator != MqttPayloadFormatIndicator.Unspecified)
+            {
+                Throw(nameof(options.WillPayloadFormatIndicator));
+            }
+
+            if (options.WillContentType?.Any() == true)
+            {
+                Throw(nameof(options.WillContentType));
+            }
+
+            if (options.WillCorrelationData?.Any() == true)
+            {
+                Throw(nameof(options.WillCorrelationData));
+            }
+            
+            if (options.WillResponseTopic?.Any() == true)
+            {
+                Throw(nameof(options.WillResponseTopic));
+            }
+            
+            if (options.WillDelayInterval > 0)
+            {
+                Throw(nameof(options.WillDelayInterval));
+            }
+            
+            if (options.WillMessageExpiryInterval > 0)
+            {
+                Throw(nameof(options.WillMessageExpiryInterval));
+            }
+            
+            if (options.WillUserProperties?.Any() == true)
+            {
+                Throw(nameof(options.WillUserProperties));
+            }
+        }
+
+        static void Throw(string featureName)
+        {
+            throw new NotSupportedException($"Feature {featureName} requires MQTT version 5.0.0.");
+        }
+    }
+}

Source/MQTTnet/Client/Options/MqttClientTlsOptions.cs

@@ -29,13 +29,13 @@ namespace MQTTnet.Client
         public List<X509Certificate> Certificates { get; set; }
 #endif
 
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER
         public List<System.Net.Security.SslApplicationProtocol> ApplicationProtocols { get; set; }
         
         public System.Net.Security.CipherSuitesPolicy CipherSuitesPolicy { get; set; }
 #endif
 
-#if NET48 || NETCOREAPP3_1 || NET5 || NET6
+#if NET48 || NETCOREAPP3_1_OR_GREATER
         public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls12 | SslProtocols.Tls13;
 #else
         public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls12 | (SslProtocols)0x00003000 /*Tls13*/;

Source/MQTTnet/Client/Publishing/MqttClientPublishResult.cs

@@ -9,9 +9,18 @@ namespace MQTTnet.Client
 {
     public sealed class MqttClientPublishResult
     {
+        public MqttClientPublishResult(ushort? packetIdentifier, MqttClientPublishReasonCode reasonCode, string reasonString, IReadOnlyCollection<MqttUserProperty> userProperties)
+        {
+            PacketIdentifier = packetIdentifier;
+            ReasonCode = reasonCode;
+            ReasonString = reasonString;
+            UserProperties = userProperties;
+        }
+
         /// <summary>
         ///     Returns if the overall status of the publish is a success. This can be the reason code _Success_ or
-        ///     _NoMatchingSubscribers_. _NoMatchingSubscribers_ usually indicates only that no other client is interested in the topic but overall transmit
+        ///     _NoMatchingSubscribers_. _NoMatchingSubscribers_ usually indicates only that no other client is interested in the
+        ///     topic but overall transmit
         ///     to the server etc. was a success.
         /// </summary>
         public bool IsSuccess => ReasonCode == MqttClientPublishReasonCode.Success || ReasonCode == MqttClientPublishReasonCode.NoMatchingSubscribers;
@@ -19,19 +28,19 @@ namespace MQTTnet.Client
         /// <summary>
         ///     Gets the packet identifier which was used for this publish.
         /// </summary>
-        public ushort? PacketIdentifier { get; set; }
+        public ushort? PacketIdentifier { get; }
 
         /// <summary>
         ///     Gets or sets the reason code.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public MqttClientPublishReasonCode ReasonCode { get; set; } = MqttClientPublishReasonCode.Success;
+        public MqttClientPublishReasonCode ReasonCode { get; } = MqttClientPublishReasonCode.Success;
 
         /// <summary>
         ///     Gets or sets the reason string.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public string ReasonString { get; set; }
+        public string ReasonString { get; }
 
         /// <summary>
         ///     Gets or sets the user properties.
@@ -40,8 +49,8 @@ namespace MQTTnet.Client
         ///     As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add
         ///     metadata to MQTT messages and pass information between publisher, broker, and subscriber.
         ///     The feature is very similar to the HTTP header concept.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public IReadOnlyCollection<MqttUserProperty> UserProperties { get; internal set; }
+        public IReadOnlyCollection<MqttUserProperty> UserProperties { get; }
     }
 }

Source/MQTTnet/Client/Publishing/MqttClientPublishResultFactory.cs

@@ -10,25 +10,23 @@ namespace MQTTnet.Client
 {
     public sealed class MqttClientPublishResultFactory
     {
-        static readonly MqttClientPublishResult EmptySuccessResult = new MqttClientPublishResult();
         static readonly IReadOnlyCollection<MqttUserProperty> EmptyUserProperties = new List<MqttUserProperty>();
+        static readonly MqttClientPublishResult AtMostOnceSuccessResult = new MqttClientPublishResult(null, MqttClientPublishReasonCode.Success, null, EmptyUserProperties);
 
         public MqttClientPublishResult Create(MqttPubAckPacket pubAckPacket)
         {
             // QoS 0 has no response. So we treat it as a success always.
             if (pubAckPacket == null)
             {
-                return EmptySuccessResult;
+                return AtMostOnceSuccessResult;
             }
 
-            var result = new MqttClientPublishResult
-            {
+            var result = new MqttClientPublishResult(
+                pubAckPacket.PacketIdentifier,
                 // Both enums have the same values. So it can be easily converted.
-                ReasonCode = (MqttClientPublishReasonCode)(int)pubAckPacket.ReasonCode,
-                PacketIdentifier = pubAckPacket.PacketIdentifier,
-                ReasonString = pubAckPacket.ReasonString,
-                UserProperties = pubAckPacket.UserProperties ?? EmptyUserProperties
-            };
+                (MqttClientPublishReasonCode)(int)pubAckPacket.ReasonCode,
+                pubAckPacket.ReasonString,
+                pubAckPacket.UserProperties ?? EmptyUserProperties);
 
             return result;
         }
@@ -37,43 +35,28 @@ namespace MQTTnet.Client
         {
             if (pubRecPacket == null || pubCompPacket == null)
             {
-                return new MqttClientPublishResult
-                {
-                    ReasonCode = MqttClientPublishReasonCode.UnspecifiedError
-                };
+                var packetIdentifier = pubRecPacket?.PacketIdentifier ?? pubCompPacket?.PacketIdentifier;
+                return new MqttClientPublishResult(packetIdentifier, MqttClientPublishReasonCode.ImplementationSpecificError, null, EmptyUserProperties);
             }
 
-            MqttClientPublishResult result;
-
             // The PUBCOMP is the last packet in QoS 2. So we use the results from that instead of PUBREC.
             if (pubCompPacket.ReasonCode == MqttPubCompReasonCode.PacketIdentifierNotFound)
             {
-                result = new MqttClientPublishResult
-                {
-                    PacketIdentifier = pubCompPacket.PacketIdentifier,
-                    ReasonCode = MqttClientPublishReasonCode.UnspecifiedError,
-                    ReasonString = pubCompPacket.ReasonString,
-                    UserProperties = pubCompPacket.UserProperties ?? EmptyUserProperties
-                };
-
-                return result;
+                return new MqttClientPublishResult(
+                    pubCompPacket.PacketIdentifier,
+                    MqttClientPublishReasonCode.UnspecifiedError,
+                    pubCompPacket.ReasonString,
+                    pubCompPacket.UserProperties ?? EmptyUserProperties);
             }
 
-            result = new MqttClientPublishResult
-            {
-                PacketIdentifier = pubCompPacket.PacketIdentifier,
-                ReasonCode = MqttClientPublishReasonCode.Success,
-                ReasonString = pubCompPacket.ReasonString,
-                UserProperties = pubCompPacket.UserProperties ?? EmptyUserProperties
-            };
-
+            var reasonCode = MqttClientPublishReasonCode.Success;
             if (pubRecPacket.ReasonCode != MqttPubRecReasonCode.Success)
             {
                 // Both enums share the same values.
-                result.ReasonCode = (MqttClientPublishReasonCode)pubRecPacket.ReasonCode;
+                reasonCode = (MqttClientPublishReasonCode)pubRecPacket.ReasonCode;
             }
 
-            return result;
+            return new MqttClientPublishResult(pubCompPacket.PacketIdentifier, reasonCode, null, pubCompPacket.UserProperties ?? EmptyUserProperties);
         }
     }
 }

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeOptions.cs

@@ -10,27 +10,31 @@ namespace MQTTnet.Client
     public sealed class MqttClientSubscribeOptions
     {
         /// <summary>
-        /// Gets or sets a list of topic filters the client wants to subscribe to.
-        /// Topic filters can include regular topics or wild cards.
-        /// </summary>
-        public List<MqttTopicFilter> TopicFilters { get; set; } = new List<MqttTopicFilter>();
-
-        /// <summary>
-        /// Gets or sets the subscription identifier.
-        /// The client can specify a subscription identifier when subscribing.
-        /// The broker will establish and store the mapping relationship between this subscription and subscription identifier when successfully create or modify subscription.
-        /// The broker will return the subscription identifier associated with this PUBLISH packet and the PUBLISH packet to the client when need to forward PUBLISH packets matching this subscription to this client.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the subscription identifier.
+        ///     The client can specify a subscription identifier when subscribing.
+        ///     The broker will establish and store the mapping relationship between this subscription and subscription identifier
+        ///     when successfully create or modify subscription.
+        ///     The broker will return the subscription identifier associated with this PUBLISH packet and the PUBLISH packet to
+        ///     the client when need to forward PUBLISH packets matching this subscription to this client.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public uint SubscriptionIdentifier { get; set; }
 
         /// <summary>
-        /// Gets or sets the user properties.
-        /// In MQTT 5, user properties are basic UTF-8 string key-value pairs that you can append to almost every type of MQTT packet.
-        /// As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add metadata to MQTT messages and pass information between publisher, broker, and subscriber.
-        /// The feature is very similar to the HTTP header concept.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets a list of topic filters the client wants to subscribe to.
+        ///     Topic filters can include regular topics or wild cards.
+        /// </summary>
+        public List<MqttTopicFilter> TopicFilters { get; set; } = new List<MqttTopicFilter>();
+
+        /// <summary>
+        ///     Gets or sets the user properties.
+        ///     In MQTT 5, user properties are basic UTF-8 string key-value pairs that you can append to almost every type of MQTT
+        ///     packet.
+        ///     As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add
+        ///     metadata to MQTT messages and pass information between publisher, broker, and subscriber.
+        ///     The feature is very similar to the HTTP header concept.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public List<MqttUserProperty> UserProperties { get; set; }
     }
-}
+}

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeOptionsBuilder.cs

@@ -14,26 +14,9 @@ namespace MQTTnet.Client
     {
         readonly MqttClientSubscribeOptions _subscribeOptions = new MqttClientSubscribeOptions();
 
-        /// <summary>
-        /// Adds the user property to the subscribe options.
-        /// Hint: MQTT 5 feature only.
-        /// </summary>
-        /// <param name="name">The property name.</param>
-        /// <param name="value">The property value.</param>
-        /// <returns>A new instance of the <see cref="MqttApplicationMessageBuilder"/> class.</returns>
-        public MqttClientSubscribeOptionsBuilder WithUserProperty(string name, string value)
+        public MqttClientSubscribeOptions Build()
         {
-            if (name == null) throw new ArgumentNullException(nameof(name));
-            if (value == null) throw new ArgumentNullException(nameof(value));
-
-            if (_subscribeOptions.UserProperties == null)
-            {
-                _subscribeOptions.UserProperties = new List<MqttUserProperty>();
-            }
-
-            _subscribeOptions.UserProperties.Add(new MqttUserProperty(name, value));
-
-            return this;
+            return _subscribeOptions;
         }
 
         public MqttClientSubscribeOptionsBuilder WithSubscriptionIdentifier(uint subscriptionIdentifier)
@@ -42,7 +25,7 @@ namespace MQTTnet.Client
             {
                 throw new MqttProtocolViolationException("Subscription identifier cannot be 0.");
             }
-            
+
             _subscribeOptions.SubscriptionIdentifier = subscriptionIdentifier;
             return this;
         }
@@ -54,19 +37,23 @@ namespace MQTTnet.Client
             bool retainAsPublished = false,
             MqttRetainHandling retainHandling = MqttRetainHandling.SendAtSubscribe)
         {
-            return WithTopicFilter(new MqttTopicFilter
-            {
-                Topic = topic,
-                QualityOfServiceLevel = qualityOfServiceLevel,
-                NoLocal = noLocal,
-                RetainAsPublished = retainAsPublished,
-                RetainHandling = retainHandling
-            });
+            return WithTopicFilter(
+                new MqttTopicFilter
+                {
+                    Topic = topic,
+                    QualityOfServiceLevel = qualityOfServiceLevel,
+                    NoLocal = noLocal,
+                    RetainAsPublished = retainAsPublished,
+                    RetainHandling = retainHandling
+                });
         }
 
         public MqttClientSubscribeOptionsBuilder WithTopicFilter(Action<MqttTopicFilterBuilder> topicFilterBuilder)
         {
-            if (topicFilterBuilder == null) throw new ArgumentNullException(nameof(topicFilterBuilder));
+            if (topicFilterBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(topicFilterBuilder));
+            }
 
             var internalTopicFilterBuilder = new MqttTopicFilterBuilder();
             topicFilterBuilder(internalTopicFilterBuilder);
@@ -76,14 +63,20 @@ namespace MQTTnet.Client
 
         public MqttClientSubscribeOptionsBuilder WithTopicFilter(MqttTopicFilterBuilder topicFilterBuilder)
         {
-            if (topicFilterBuilder == null) throw new ArgumentNullException(nameof(topicFilterBuilder));
+            if (topicFilterBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(topicFilterBuilder));
+            }
 
             return WithTopicFilter(topicFilterBuilder.Build());
         }
 
         public MqttClientSubscribeOptionsBuilder WithTopicFilter(MqttTopicFilter topicFilter)
         {
-            if (topicFilter == null) throw new ArgumentNullException(nameof(topicFilter));
+            if (topicFilter == null)
+            {
+                throw new ArgumentNullException(nameof(topicFilter));
+            }
 
             if (_subscribeOptions.TopicFilters == null)
             {
@@ -95,9 +88,20 @@ namespace MQTTnet.Client
             return this;
         }
 
-        public MqttClientSubscribeOptions Build()
+        /// <summary>
+        ///     Adds the user property to the subscribe options.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public MqttClientSubscribeOptionsBuilder WithUserProperty(string name, string value)
         {
-            return _subscribeOptions;
+            if (_subscribeOptions.UserProperties == null)
+            {
+                _subscribeOptions.UserProperties = new List<MqttUserProperty>();
+            }
+
+            _subscribeOptions.UserProperties.Add(new MqttUserProperty(name, value));
+
+            return this;
         }
     }
-}
+}

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeOptionsValidator.cs

@@ -0,0 +1,58 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+
+namespace MQTTnet.Client
+{
+    public static class MqttClientSubscribeOptionsValidator
+    {
+        public static void ThrowIfNotSupported(MqttClientSubscribeOptions options, MqttProtocolVersion protocolVersion)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+            
+            if (protocolVersion == MqttProtocolVersion.V500)
+            {
+                // Everything is supported.
+                return;
+            }
+
+            if (options.UserProperties?.Any() == true)
+            {
+                Throw(nameof(options.UserProperties));
+            }
+            
+            if (options.SubscriptionIdentifier != 0)
+            {
+                Throw(nameof(options.SubscriptionIdentifier));
+            }
+            
+            if (options.TopicFilters?.Any(t => t.NoLocal) == true)
+            {
+                Throw("NoLocal");
+            }
+            
+            if (options.TopicFilters?.Any(t => t.RetainAsPublished) == true)
+            {
+                Throw("RetainAsPublished");
+            }
+            
+            if (options.TopicFilters?.Any(t => t.RetainHandling != MqttRetainHandling.SendAtSubscribe) == true)
+            {
+                Throw("RetainHandling");
+            }
+        }
+        
+        static void Throw(string featureName)
+        {
+            throw new NotSupportedException($"Feature {featureName} requires MQTT version 5.0.0.");
+        }
+    }
+}

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeResult.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using MQTTnet.Packets;
 
@@ -9,23 +10,34 @@ namespace MQTTnet.Client
 {
     public sealed class MqttClientSubscribeResult
     {
-        public IReadOnlyCollection<MqttClientSubscribeResultItem> Items { get; internal set; }
+        public MqttClientSubscribeResult(ushort packetIdentifier, IReadOnlyCollection<MqttClientSubscribeResultItem> items, string reasonString, IReadOnlyCollection<MqttUserProperty> userProperties)
+        {
+            PacketIdentifier = packetIdentifier;
+            Items = items ?? throw new ArgumentNullException(nameof(items));
+            ReasonString = reasonString;
+            UserProperties = userProperties ?? throw new ArgumentNullException(nameof(userProperties));
+        }
+
+        /// <summary>
+        /// Gets the result for every topic filter item.
+        /// </summary>
+        public IReadOnlyCollection<MqttClientSubscribeResultItem> Items { get; }
         
         /// <summary>
         /// Gets the user properties which were part of the SUBACK packet.
-        /// MQTTv5 only.
+        /// <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public IReadOnlyCollection<MqttUserProperty> UserProperties { get; internal set; }
+        public IReadOnlyCollection<MqttUserProperty> UserProperties { get; }
         
         /// <summary>
         /// Gets the reason string.
-        /// MQTTv5 only.
+        /// <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public string ReasonString { get; internal set; }
+        public string ReasonString { get; }
 
         /// <summary>
         /// Gets the packet identifier which was used.
         /// </summary>
-        public ushort PacketIdentifier { get; internal set; }
+        public ushort PacketIdentifier { get; }
     }
 }

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeResultFactory.cs

@@ -16,42 +16,35 @@ namespace MQTTnet.Client
 
         public MqttClientSubscribeResult Create(MqttSubscribePacket subscribePacket, MqttSubAckPacket subAckPacket)
         {
-            if (subscribePacket == null) throw new ArgumentNullException(nameof(subscribePacket));
-            if (subAckPacket == null) throw new ArgumentNullException(nameof(subAckPacket));
-            
+            if (subscribePacket == null)
+            {
+                throw new ArgumentNullException(nameof(subscribePacket));
+            }
+
+            if (subAckPacket == null)
+            {
+                throw new ArgumentNullException(nameof(subAckPacket));
+            }
+
             // MQTTv5.0.0 handling.
             if (subAckPacket.ReasonCodes.Any() && subAckPacket.ReasonCodes.Count != subscribePacket.TopicFilters.Count)
             {
-                throw new MqttProtocolViolationException(
-                    "The reason codes are not matching the topic filters [MQTT-3.9.3-1].");
+                throw new MqttProtocolViolationException("The reason codes are not matching the topic filters [MQTT-3.9.3-1].");
             }
-            
+
             var items = new List<MqttClientSubscribeResultItem>();
             for (var i = 0; i < subscribePacket.TopicFilters.Count; i++)
             {
                 items.Add(CreateSubscribeResultItem(i, subscribePacket, subAckPacket));
             }
-            
-            var result = new MqttClientSubscribeResult
-            {
-                PacketIdentifier = subAckPacket.PacketIdentifier,
-                ReasonString = subAckPacket.ReasonString,
-                UserProperties = subAckPacket.UserProperties ?? EmptyUserProperties,
-                Items = items
-            };
-            
-            return result;
+
+            return new MqttClientSubscribeResult(subAckPacket.PacketIdentifier, items, subAckPacket.ReasonString, subAckPacket.UserProperties ?? EmptyUserProperties);
         }
 
         static MqttClientSubscribeResultItem CreateSubscribeResultItem(int index, MqttSubscribePacket subscribePacket, MqttSubAckPacket subAckPacket)
         {
-            var resultCode = (MqttClientSubscribeResultCode) subAckPacket.ReasonCodes[index];
-
-            return new MqttClientSubscribeResultItem
-            {
-                TopicFilter = subscribePacket.TopicFilters[index],
-                ResultCode = resultCode,
-            };
+            var resultCode = (MqttClientSubscribeResultCode)subAckPacket.ReasonCodes[index];
+            return new MqttClientSubscribeResultItem(subscribePacket.TopicFilters[index], resultCode);
         }
     }
 }

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeResultItem.cs

@@ -2,22 +2,29 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using MQTTnet.Packets;
 
 namespace MQTTnet.Client
 {
     public sealed class MqttClientSubscribeResultItem
     {
+        public MqttClientSubscribeResultItem(MqttTopicFilter topicFilter, MqttClientSubscribeResultCode resultCode)
+        {
+            TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter));
+            ResultCode = resultCode;
+        }
+
         /// <summary>
         /// Gets or sets the topic filter.
         /// The topic filter can contain topics and wildcards.
         /// </summary>
-        public MqttTopicFilter TopicFilter { get; internal set; }
+        public MqttTopicFilter TopicFilter { get; }
 
         /// <summary>
         /// Gets or sets the result code.
-        /// Hint: MQTT 5 feature only.
+        /// <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public MqttClientSubscribeResultCode ResultCode { get; internal set; }
+        public MqttClientSubscribeResultCode ResultCode { get; }
     }
 }

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeOptions.cs

@@ -10,18 +10,20 @@ namespace MQTTnet.Client
     public sealed class MqttClientUnsubscribeOptions
     {
         /// <summary>
-        /// Gets or sets a list of topic filters the client wants to unsubscribe from.
-        /// Topic filters can include regular topics or wild cards.
+        ///     Gets or sets a list of topic filters the client wants to unsubscribe from.
+        ///     Topic filters can include regular topics or wild cards.
         /// </summary>
         public List<string> TopicFilters { get; set; } = new List<string>();
 
         /// <summary>
-        /// Gets or sets the user properties.
-        /// In MQTT 5, user properties are basic UTF-8 string key-value pairs that you can append to almost every type of MQTT packet.
-        /// As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add metadata to MQTT messages and pass information between publisher, broker, and subscriber.
-        /// The feature is very similar to the HTTP header concept.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the user properties.
+        ///     In MQTT 5, user properties are basic UTF-8 string key-value pairs that you can append to almost every type of MQTT
+        ///     packet.
+        ///     As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add
+        ///     metadata to MQTT messages and pass information between publisher, broker, and subscriber.
+        ///     The feature is very similar to the HTTP header concept.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public List<MqttUserProperty> UserProperties { get; set; } = new List<MqttUserProperty>();
+        public List<MqttUserProperty> UserProperties { get; set; }
     }
-}
+}

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeOptionsBuilder.cs

@@ -8,48 +8,21 @@ using MQTTnet.Packets;
 
 namespace MQTTnet.Client
 {
-    public class MqttClientUnsubscribeOptionsBuilder
+    public sealed class MqttClientUnsubscribeOptionsBuilder
     {
-        private readonly MqttClientUnsubscribeOptions _unsubscribeOptions = new MqttClientUnsubscribeOptions();
+        readonly MqttClientUnsubscribeOptions _unsubscribeOptions = new MqttClientUnsubscribeOptions();
 
-        /// <summary>
-        /// Adds the user property to the unsubscribe options.
-        /// Hint: MQTT 5 feature only.
-        /// </summary>
-        /// <param name="name">The property name.</param>
-        /// <param name="value">The property value.</param>
-        /// <returns>A new instance of the <see cref="MqttClientUnsubscribeOptionsBuilder"/> class.</returns>
-        public MqttClientUnsubscribeOptionsBuilder WithUserProperty(string name, string value)
+        public MqttClientUnsubscribeOptions Build()
         {
-            if (name is null) throw new ArgumentNullException(nameof(name));
-            if (value is null) throw new ArgumentNullException(nameof(value));
-
-            return WithUserProperty(new MqttUserProperty(name, value));
-        }
-
-        /// <summary>
-        /// Adds the user property to the unsubscribe options.
-        /// Hint: MQTT 5 feature only.
-        /// </summary>
-        /// <param name="userProperty">The user property.</param>
-        /// <returns>A new instance of the <see cref="MqttClientUnsubscribeOptionsBuilder"/> class.</returns>
-        public MqttClientUnsubscribeOptionsBuilder WithUserProperty(MqttUserProperty userProperty)
-        {
-            if (userProperty is null) throw new ArgumentNullException(nameof(userProperty));
-
-            if (_unsubscribeOptions.UserProperties is null)
-            {
-                _unsubscribeOptions.UserProperties = new List<MqttUserProperty>();
-            }
-
-            _unsubscribeOptions.UserProperties.Add(userProperty);
-
-            return this;
+            return _unsubscribeOptions;
         }
 
         public MqttClientUnsubscribeOptionsBuilder WithTopicFilter(string topic)
         {
-            if (topic is null) throw new ArgumentNullException(nameof(topic));
+            if (topic is null)
+            {
+                throw new ArgumentNullException(nameof(topic));
+            }
 
             if (_unsubscribeOptions.TopicFilters is null)
             {
@@ -63,14 +36,42 @@ namespace MQTTnet.Client
 
         public MqttClientUnsubscribeOptionsBuilder WithTopicFilter(MqttTopicFilter topicFilter)
         {
-            if (topicFilter is null) throw new ArgumentNullException(nameof(topicFilter));
+            if (topicFilter is null)
+            {
+                throw new ArgumentNullException(nameof(topicFilter));
+            }
 
             return WithTopicFilter(topicFilter.Topic);
         }
 
-        public MqttClientUnsubscribeOptions Build()
+        /// <summary>
+        ///     Adds the user property to the unsubscribe options.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public MqttClientUnsubscribeOptionsBuilder WithUserProperty(string name, string value)
         {
-            return _unsubscribeOptions;
+            return WithUserProperty(new MqttUserProperty(name, value));
+        }
+
+        /// <summary>
+        ///     Adds the user property to the unsubscribe options.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public MqttClientUnsubscribeOptionsBuilder WithUserProperty(MqttUserProperty userProperty)
+        {
+            if (userProperty is null)
+            {
+                throw new ArgumentNullException(nameof(userProperty));
+            }
+
+            if (_unsubscribeOptions.UserProperties is null)
+            {
+                _unsubscribeOptions.UserProperties = new List<MqttUserProperty>();
+            }
+
+            _unsubscribeOptions.UserProperties.Add(userProperty);
+
+            return this;
         }
     }
-}
+}

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeOptionsValidator.cs

@@ -0,0 +1,37 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using MQTTnet.Formatter;
+
+namespace MQTTnet.Client
+{
+    public static class MqttClientUnsubscribeOptionsValidator
+    {
+        public static void ThrowIfNotSupported(MqttClientUnsubscribeOptions options, MqttProtocolVersion protocolVersion)
+        {
+            if (options == null)
+            {
+                throw new ArgumentNullException(nameof(options));
+            }
+
+            if (protocolVersion == MqttProtocolVersion.V500)
+            {
+                // Everything is supported.
+                return;
+            }
+
+            if (options.UserProperties?.Any() == true)
+            {
+                Throw(nameof(options.UserProperties));
+            }
+        }
+
+        static void Throw(string featureName)
+        {
+            throw new NotSupportedException($"Feature {featureName} requires MQTT version 5.0.0.");
+        }
+    }
+}

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeResult.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
 using System.Collections.Generic;
 using MQTTnet.Packets;
 
@@ -9,23 +10,38 @@ namespace MQTTnet.Client
 {
     public sealed class MqttClientUnsubscribeResult
     {
-        public IReadOnlyCollection<MqttClientUnsubscribeResultItem> Items { get; internal set; }
+        public MqttClientUnsubscribeResult(
+            ushort packetIdentifier,
+            IReadOnlyCollection<MqttClientUnsubscribeResultItem> items,
+            string reasonString,
+            IReadOnlyCollection<MqttUserProperty> userProperties)
+        {
+            PacketIdentifier = packetIdentifier;
+            Items = items ?? throw new ArgumentNullException(nameof(items));
+            ReasonString = reasonString;
+            UserProperties = userProperties ?? throw new ArgumentNullException(nameof(userProperties));
+        }
 
         /// <summary>
-        /// Gets the user properties which were part of the UNSUBACK packet.
-        /// MQTTv5 only.
+        ///     Gets the result for every topic filter item.
         /// </summary>
-        public IReadOnlyCollection<MqttUserProperty> UserProperties { get; internal set; }
-        
+        public IReadOnlyCollection<MqttClientUnsubscribeResultItem> Items { get; }
+
         /// <summary>
-        /// Gets the reason string.
-        /// MQTTv5 only.
+        ///     Gets the packet identifier which was used.
         /// </summary>
-        public string ReasonString { get; internal set; }
-        
+        public ushort PacketIdentifier { get; }
+
         /// <summary>
-        /// Gets the packet identifier which was used.
+        ///     Gets the reason string.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public ushort PacketIdentifier { get; internal set; }
+        public string ReasonString { get; }
+
+        /// <summary>
+        ///     Gets the user properties which were part of the UNSUBACK packet.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public IReadOnlyCollection<MqttUserProperty> UserProperties { get; }
     }
-}
+}

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeResultFactory.cs

@@ -12,17 +12,23 @@ namespace MQTTnet.Client
     public sealed class MqttClientUnsubscribeResultFactory
     {
         static readonly IReadOnlyCollection<MqttUserProperty> EmptyUserProperties = new List<MqttUserProperty>();
-        
+
         public MqttClientUnsubscribeResult Create(MqttUnsubscribePacket unsubscribePacket, MqttUnsubAckPacket unsubAckPacket)
         {
-            if (unsubscribePacket == null) throw new ArgumentNullException(nameof(unsubscribePacket));
-            if (unsubAckPacket == null) throw new ArgumentNullException(nameof(unsubAckPacket));
+            if (unsubscribePacket == null)
+            {
+                throw new ArgumentNullException(nameof(unsubscribePacket));
+            }
+
+            if (unsubAckPacket == null)
+            {
+                throw new ArgumentNullException(nameof(unsubAckPacket));
+            }
 
             // MQTTv3.1.1 has no reason code at all!
             if (unsubAckPacket.ReasonCodes != null && unsubAckPacket.ReasonCodes.Count != unsubscribePacket.TopicFilters.Count)
             {
-                throw new MqttProtocolViolationException(
-                    "The return codes are not matching the topic filters [MQTT-3.9.3-1].");
+                throw new MqttProtocolViolationException("The return codes are not matching the topic filters [MQTT-3.9.3-1].");
             }
 
             var items = new List<MqttClientUnsubscribeResultItem>();
@@ -30,33 +36,21 @@ namespace MQTTnet.Client
             {
                 items.Add(CreateUnsubscribeResultItem(i, unsubscribePacket, unsubAckPacket));
             }
-            
-            var result = new MqttClientUnsubscribeResult
-            {
-                PacketIdentifier = unsubAckPacket.PacketIdentifier,
-                ReasonString = unsubAckPacket.ReasonString,
-                UserProperties = unsubAckPacket.UserProperties ?? EmptyUserProperties,
-                Items = items
-            };
-            
-            return result;
+
+            return new MqttClientUnsubscribeResult(unsubscribePacket.PacketIdentifier, items, unsubAckPacket.ReasonString, unsubAckPacket.UserProperties ?? EmptyUserProperties);
         }
-        
+
         static MqttClientUnsubscribeResultItem CreateUnsubscribeResultItem(int index, MqttUnsubscribePacket unsubscribePacket, MqttUnsubAckPacket unsubAckPacket)
         {
             var resultCode = MqttClientUnsubscribeResultCode.Success;
-            
+
             if (unsubAckPacket.ReasonCodes != null)
             {
                 // MQTTv3.1.1 has no reason code and no return code!.
-                resultCode = (MqttClientUnsubscribeResultCode) unsubAckPacket.ReasonCodes[index];
+                resultCode = (MqttClientUnsubscribeResultCode)unsubAckPacket.ReasonCodes[index];
             }
-            
-            return new MqttClientUnsubscribeResultItem
-            {
-                TopicFilter = unsubscribePacket.TopicFilters[index],
-                ResultCode = resultCode
-            };
+
+            return new MqttClientUnsubscribeResultItem(unsubscribePacket.TopicFilters[index], resultCode);
         }
     }
 }

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeResultItem.cs

@@ -2,20 +2,28 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
+using System;
+
 namespace MQTTnet.Client
 {
     public sealed class MqttClientUnsubscribeResultItem
     {
+        public MqttClientUnsubscribeResultItem(string topicFilter, MqttClientUnsubscribeResultCode resultCode)
+        {
+            TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter));
+            ResultCode = resultCode;
+        }
+
         /// <summary>
-        /// Gets or sets the topic filter.
-        /// The topic filter can contain topics and wildcards.
+        ///     Gets or sets the result code.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public string TopicFilter { get; internal set; }
-        
+        public MqttClientUnsubscribeResultCode ResultCode { get; }
+
         /// <summary>
-        /// Gets or sets the result code.
-        /// Hint: MQTT 5 feature only.
+        ///     Gets or sets the topic filter.
+        ///     The topic filter can contain topics and wildcards.
         /// </summary>
-        public MqttClientUnsubscribeResultCode ResultCode { get; internal set; }
+        public string TopicFilter { get; }
     }
 }

Source/MQTTnet/Diagnostics/PacketInspection/InspectMqttPacketEventArgs.cs

@@ -8,8 +8,14 @@ namespace MQTTnet.Diagnostics
 {
     public sealed class InspectMqttPacketEventArgs : EventArgs
     {
-        public MqttPacketFlowDirection Direction { get; internal set; }
+        public InspectMqttPacketEventArgs(MqttPacketFlowDirection direction, byte[] buffer)
+        {
+            Direction = direction;
+            Buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
+        }
 
-        public byte[] Buffer { get; set; }
+        public byte[] Buffer { get; }
+
+        public MqttPacketFlowDirection Direction { get; }
     }
 }

Source/MQTTnet/Diagnostics/Runtime/TargetFrameworkProvider.cs

@@ -30,6 +30,8 @@ namespace MQTTnet.Diagnostics
                 return "net5.0";
 #elif NET6_0
                 return "net6.0";
+#elif NET7_0
+                return "net7.0";
 #endif
             }
         }

Source/MQTTnet/Formatter/MqttDisconnectPacketFactory.cs

@@ -39,6 +39,8 @@ namespace MQTTnet.Formatter
             else
             {
                 packet.ReasonCode = (MqttDisconnectReasonCode)clientDisconnectOptions.Reason;
+                packet.UserProperties = clientDisconnectOptions.UserProperties;
+                packet.SessionExpiryInterval = clientDisconnectOptions.SessionExpiryInterval;
             }
 
             return packet;

Source/MQTTnet/Implementations/CrossPlatformSocket.cs

@@ -72,8 +72,8 @@ namespace MQTTnet.Implementations
             get => _socket.GetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveInterval) as int? ?? 0;
             set => _socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveInterval, value);
 #else
-            get { throw new NotSupportedException("TcpKeepAliveInterval requires at least net5.0."); }
-            set { throw new NotSupportedException("TcpKeepAliveInterval requires at least net5.0."); }
+            get { throw new NotSupportedException("TcpKeepAliveInterval requires at least netcoreapp3.0."); }
+            set { throw new NotSupportedException("TcpKeepAliveInterval requires at least netcoreapp3.0."); }
 #endif
         }
 
@@ -83,8 +83,8 @@ namespace MQTTnet.Implementations
             get => _socket.GetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveRetryCount) as int? ?? 0;
             set => _socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveRetryCount, value);
 #else
-            get { throw new NotSupportedException("TcpKeepAliveRetryCount requires at least net5.0."); }
-            set { throw new NotSupportedException("TcpKeepAliveRetryCount requires at least net5.0."); }
+            get { throw new NotSupportedException("TcpKeepAliveRetryCount requires at least netcoreapp3.0."); }
+            set { throw new NotSupportedException("TcpKeepAliveRetryCount requires at least netcoreapp3.0."); }
 #endif
         }
 
@@ -94,8 +94,8 @@ namespace MQTTnet.Implementations
             get => _socket.GetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveTime) as int? ?? 0;
             set => _socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.TcpKeepAliveTime, value);
 #else
-            get { throw new NotSupportedException("TcpKeepAliveTime requires at least net5.0."); }
-            set { throw new NotSupportedException("TcpKeepAliveTime requires at least net5.0."); }
+            get { throw new NotSupportedException("TcpKeepAliveTime requires at least netcoreapp3.0."); }
+            set { throw new NotSupportedException("TcpKeepAliveTime requires at least netcoreapp3.0."); }
 #endif
         }
 
@@ -155,7 +155,7 @@ namespace MQTTnet.Implementations
             }
             catch (ObjectDisposedException)
             {
-                // This will happen when _socket.EndAccept gets called by Task library but the socket is already disposed.
+                // This will happen when _socket.EndAccept_ gets called by Task library but the socket is already disposed.
                 return null;
             }
         }
@@ -181,17 +181,18 @@ namespace MQTTnet.Implementations
 
             try
             {
-#if NET5_0_OR_GREATER
-
+#if NETCOREAPP3_0_OR_GREATER
                 if (_networkStream != null)
                 {
                     await _networkStream.DisposeAsync().ConfigureAwait(false);
                 }
-
-                await _socket.ConnectAsync(host, port, cancellationToken).ConfigureAwait(false);
 #else
                 _networkStream?.Dispose();
+#endif
 
+#if NET5_0_OR_GREATER
+                await _socket.ConnectAsync(host, port, cancellationToken).ConfigureAwait(false);
+#else
                 // Workaround for: https://github.com/dotnet/corefx/issues/24430
                 using (cancellationToken.Register(_socketDisposeAction))
                 {
@@ -220,7 +221,7 @@ namespace MQTTnet.Implementations
             }
             catch (ObjectDisposedException)
             {
-                // This will happen when _socket.EndConnect gets called by Task library but the socket is already disposed.
+                // This will happen when _socket.EndConnect_ gets called by Task library but the socket is already disposed.
                 cancellationToken.ThrowIfCancellationRequested();
             }
         }
@@ -247,38 +248,44 @@ namespace MQTTnet.Implementations
             _socket.Listen(connectionBacklog);
         }
 
+#if NET452 || NET461
         public async Task<int> ReceiveAsync(ArraySegment<byte> buffer, SocketFlags socketFlags)
         {
             try
             {
-#if NET452 || NET461
                 return await Task.Factory.FromAsync(SocketWrapper.BeginReceive, _socket.EndReceive, new SocketWrapper(_socket, buffer, socketFlags)).ConfigureAwait(false);
-#else
-                return await _socket.ReceiveAsync(buffer, socketFlags).ConfigureAwait(false);
-#endif
             }
             catch (ObjectDisposedException)
             {
-                // This will happen when _socket.EndReceive gets called by Task library but the socket is already disposed.
+                // This will happen when _socket.EndReceive_ gets called by Task library but the socket is already disposed.
                 return -1;
             }
         }
+#else
+        public Task<int> ReceiveAsync(ArraySegment<byte> buffer, SocketFlags socketFlags)
+        {
+            return _socket.ReceiveAsync(buffer, socketFlags);
+        }
+#endif
 
+#if NET452 || NET461
         public async Task SendAsync(ArraySegment<byte> buffer, SocketFlags socketFlags)
         {
             try
             {
-#if NET452 || NET461
                 await Task.Factory.FromAsync(SocketWrapper.BeginSend, _socket.EndSend, new SocketWrapper(_socket, buffer, socketFlags)).ConfigureAwait(false);
-#else
-                await _socket.SendAsync(buffer, socketFlags).ConfigureAwait(false);
-#endif
             }
             catch (ObjectDisposedException)
             {
-                // This will happen when _socket.EndConnect gets called by Task library but the socket is already disposed.
+                // This will happen when _socket.EndSend_ gets called by Task library but the socket is already disposed.
             }
         }
+#else
+        public Task SendAsync(ArraySegment<byte> buffer, SocketFlags socketFlags)
+        {
+            return _socket.SendAsync(buffer, socketFlags);
+        }
+#endif
 
 #if NET452 || NET461
         sealed class SocketWrapper

Source/MQTTnet/Implementations/MqttTcpChannel.cs

@@ -103,7 +103,7 @@ namespace MQTTnet.Implementations
                     var sslStream = new SslStream(networkStream, false, InternalUserCertificateValidationCallback);
                     try
                     {
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETCOREAPP3_1_OR_GREATER
                         var sslOptions = new SslClientAuthenticationOptions
                         {
                             ApplicationProtocols = _tcpOptions.TlsOptions.ApplicationProtocols,
@@ -127,7 +127,7 @@ namespace MQTTnet.Implementations
                     }
                     catch
                     {
-#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0_OR_GREATER
+#if NETSTANDARD2_1 || NETCOREAPP3_1_OR_GREATER
                         await sslStream.DisposeAsync().ConfigureAwait(false);
 #else
                         sslStream.Dispose();

Source/MQTTnet/Implementations/MqttTcpServerAdapter.cs

@@ -1,44 +1,51 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
-
 #if !WINDOWS_UWP
-using MQTTnet.Adapter;
-using MQTTnet.Diagnostics;
-using MQTTnet.Server;
 using System;
 using System.Collections.Generic;
 using System.Net;
 using System.Net.Sockets;
-using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
 using MQTTnet.Internal;
+using MQTTnet.Server;
 
 namespace MQTTnet.Implementations
 {
     public sealed class MqttTcpServerAdapter : IMqttServerAdapter
     {
         readonly List<MqttTcpServerListener> _listeners = new List<MqttTcpServerListener>();
+        
+        CancellationTokenSource _cancellationTokenSource;
 
         MqttServerOptions _serverOptions;
-        CancellationTokenSource _cancellationTokenSource;
-        
+
         public Func<IMqttChannelAdapter, Task> ClientHandler { get; set; }
 
         public bool TreatSocketOpeningErrorAsWarning { get; set; }
 
+        public void Dispose()
+        {
+            Cleanup();
+        }
+
         public Task StartAsync(MqttServerOptions options, IMqttNetLogger logger)
         {
-            if (_cancellationTokenSource != null) throw new InvalidOperationException("Server is already started.");
+            if (_cancellationTokenSource != null)
+            {
+                throw new InvalidOperationException("Server is already started.");
+            }
 
             _serverOptions = options;
-            
+
             _cancellationTokenSource = new CancellationTokenSource();
 
             if (options.DefaultEndpointOptions.IsEnabled)
             {
-                RegisterListeners(options.DefaultEndpointOptions, null, logger, _cancellationTokenSource.Token);
+                RegisterListeners(options.DefaultEndpointOptions, logger, _cancellationTokenSource.Token);
             }
 
             if (options.TlsEndpointOptions?.IsEnabled == true)
@@ -48,13 +55,7 @@ namespace MQTTnet.Implementations
                     throw new ArgumentException("TLS certificate is not set.");
                 }
 
-                var tlsCertificate = options.TlsEndpointOptions.CertificateProvider.GetCertificate();
-                if (!tlsCertificate.HasPrivateKey)
-                {
-                    throw new InvalidOperationException("The certificate for TLS encryption must contain the private key.");
-                }
-
-                RegisterListeners(options.TlsEndpointOptions, tlsCertificate, logger, _cancellationTokenSource.Token);
+                RegisterListeners(options.TlsEndpointOptions, logger, _cancellationTokenSource.Token);
             }
 
             return CompletedTask.Instance;
@@ -66,11 +67,6 @@ namespace MQTTnet.Implementations
             return CompletedTask.Instance;
         }
 
-        public void Dispose()
-        {
-            Cleanup();
-        }
-
         void Cleanup()
         {
             try
@@ -91,11 +87,22 @@ namespace MQTTnet.Implementations
             }
         }
 
-        void RegisterListeners(MqttServerTcpEndpointBaseOptions tcpEndpointOptions, X509Certificate2 tlsCertificate, IMqttNetLogger logger, CancellationToken cancellationToken)
+        Task OnClientAcceptedAsync(IMqttChannelAdapter channelAdapter)
+        {
+            var clientHandler = ClientHandler;
+            if (clientHandler == null)
+            {
+                return CompletedTask.Instance;
+            }
+
+            return clientHandler(channelAdapter);
+        }
+
+        void RegisterListeners(MqttServerTcpEndpointBaseOptions tcpEndpointOptions, IMqttNetLogger logger, CancellationToken cancellationToken)
         {
             if (!tcpEndpointOptions.BoundInterNetworkAddress.Equals(IPAddress.None))
             {
-                var listenerV4 = new MqttTcpServerListener(AddressFamily.InterNetwork, _serverOptions, tcpEndpointOptions, tlsCertificate, logger)
+                var listenerV4 = new MqttTcpServerListener(AddressFamily.InterNetwork, _serverOptions, tcpEndpointOptions, logger)
                 {
                     ClientHandler = OnClientAcceptedAsync
                 };
@@ -108,7 +115,7 @@ namespace MQTTnet.Implementations
 
             if (!tcpEndpointOptions.BoundInterNetworkV6Address.Equals(IPAddress.None))
             {
-                var listenerV6 = new MqttTcpServerListener(AddressFamily.InterNetworkV6, _serverOptions, tcpEndpointOptions, tlsCertificate, logger)
+                var listenerV6 = new MqttTcpServerListener(AddressFamily.InterNetworkV6, _serverOptions, tcpEndpointOptions, logger)
                 {
                     ClientHandler = OnClientAcceptedAsync
                 };
@@ -119,17 +126,6 @@ namespace MQTTnet.Implementations
                 }
             }
         }
-
-        Task OnClientAcceptedAsync(IMqttChannelAdapter channelAdapter)
-        {
-            var clientHandler = ClientHandler;
-            if (clientHandler == null)
-            {
-                return CompletedTask.Instance;
-            }
-
-            return clientHandler(channelAdapter);
-        }
     }
 }
 #endif

Source/MQTTnet/Implementations/MqttTcpServerListener.cs

@@ -27,8 +27,7 @@ namespace MQTTnet.Implementations
         readonly MqttServerOptions _serverOptions;
         readonly MqttServerTcpEndpointBaseOptions _options;
         readonly MqttServerTlsTcpEndpointOptions _tlsOptions;
-        readonly X509Certificate2 _tlsCertificate;
-
+        
         CrossPlatformSocket _socket;
         IPEndPoint _localEndPoint;
 
@@ -36,13 +35,11 @@ namespace MQTTnet.Implementations
             AddressFamily addressFamily,
             MqttServerOptions serverOptions,
             MqttServerTcpEndpointBaseOptions tcpEndpointOptions,
-            X509Certificate2 tlsCertificate,
             IMqttNetLogger logger)
         {
             _addressFamily = addressFamily;
             _serverOptions = serverOptions ?? throw new ArgumentNullException(nameof(serverOptions));
             _options = tcpEndpointOptions ?? throw new ArgumentNullException(nameof(tcpEndpointOptions));
-            _tlsCertificate = tlsCertificate;
             _rootLogger = logger;
             _logger = logger.WithSource(nameof(MqttTcpServerListener));
 
@@ -66,7 +63,7 @@ namespace MQTTnet.Implementations
 
                 _localEndPoint = new IPEndPoint(boundIp, _options.Port);
 
-                _logger.Info("Starting TCP listener (Endpoint='{0}', TLS={1}).", _localEndPoint, _tlsCertificate != null);
+                _logger.Info("Starting TCP listener (Endpoint={0}, TLS={1})", _localEndPoint, _tlsOptions?.CertificateProvider != null);
 
                 _socket = new CrossPlatformSocket(_addressFamily);
 
@@ -86,6 +83,26 @@ namespace MQTTnet.Implementations
                     _socket.LingerState = _options.LingerState;
                 }
 
+                if (_options.KeepAlive.HasValue)
+                {
+                    _socket.KeepAlive = _options.KeepAlive.Value;
+                }
+                
+                if (_options.TcpKeepAliveInterval.HasValue)
+                {
+                    _socket.TcpKeepAliveInterval = _options.TcpKeepAliveInterval.Value;
+                }
+                
+                if (_options.TcpKeepAliveRetryCount.HasValue)
+                {
+                    _socket.TcpKeepAliveInterval = _options.TcpKeepAliveRetryCount.Value;
+                }
+                
+                if (_options.TcpKeepAliveTime.HasValue)
+                {
+                    _socket.TcpKeepAliveTime = _options.TcpKeepAliveTime.Value;
+                }
+                
                 _socket.Bind(_localEndPoint);
                 
                 // Get the local endpoint back from the socket. The port may have changed.
@@ -95,7 +112,7 @@ namespace MQTTnet.Implementations
                 
                 _socket.Listen(_options.ConnectionBacklog);
                 
-                _logger.Verbose("TCP listener started (Endpoint='{0}'.", _localEndPoint);
+                _logger.Verbose("TCP listener started (Endpoint={0})", _localEndPoint);
                 
                 Task.Run(() => AcceptClientConnectionsAsync(cancellationToken), cancellationToken).RunInBackground(_logger);
 
@@ -108,7 +125,7 @@ namespace MQTTnet.Implementations
                     throw;
                 }
 
-                _logger.Warning(exception, "Error while creating listener socket for local end point '{0}'.", _localEndPoint);
+                _logger.Warning(exception, "Error while starting TCP listener (Endpoint={0})", _localEndPoint);
                 return false;
             }
         }
@@ -116,10 +133,6 @@ namespace MQTTnet.Implementations
         public void Dispose()
         {
             _socket?.Dispose();
-
-#if !NET452
-            _tlsCertificate?.Dispose();
-#endif
         }
 
         async Task AcceptClientConnectionsAsync(CancellationToken cancellationToken)
@@ -150,7 +163,7 @@ namespace MQTTnet.Implementations
                         }
                     }
 
-                    _logger.Error(exception, "Error while accepting connection at TCP listener {0} TLS={1}.", _localEndPoint, _tlsCertificate != null);
+                    _logger.Error(exception, "Error while accepting TCP connection (Endpoint={0})", _localEndPoint);
                     await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
                 }
             }
@@ -165,24 +178,26 @@ namespace MQTTnet.Implementations
             {
                 remoteEndPoint = clientSocket.RemoteEndPoint.ToString();
 
-                _logger.Verbose("Client '{0}' accepted by TCP listener '{1}, {2}'.",
-                    remoteEndPoint,
-                    _localEndPoint,
-                    _addressFamily == AddressFamily.InterNetwork ? "ipv4" : "ipv6");
+                _logger.Verbose("TCP client '{0}' accepted (Local endpoint={1})", remoteEndPoint, _localEndPoint);
 
                 clientSocket.NoDelay = _options.NoDelay;
                 stream = clientSocket.GetStream();
-                X509Certificate2 clientCertificate = null;
-
-                if (_tlsCertificate != null)
+                var clientCertificate = _tlsOptions?.CertificateProvider?.GetCertificate();
+                
+                if (clientCertificate != null)
                 {
+                    if (!clientCertificate.HasPrivateKey)
+                    {
+                        throw new InvalidOperationException("The certificate for TLS encryption must contain the private key.");
+                    }
+
                     var sslStream = new SslStream(stream, false, _tlsOptions.RemoteCertificateValidationCallback);
 
-                    #if NETCOREAPP3_1 || NET5_0_OR_GREATER
+                    #if NETCOREAPP3_1_OR_GREATER
                         await sslStream.AuthenticateAsServerAsync(
-                            new SslServerAuthenticationOptions()
+                            new SslServerAuthenticationOptions
                             {
-                                ServerCertificate = _tlsCertificate,
+                                ServerCertificate = clientCertificate,
                                 ClientCertificateRequired = _tlsOptions.ClientCertificateRequired,
                                 EnabledSslProtocols = _tlsOptions.SslProtocol,
                                 CertificateRevocationCheckMode = _tlsOptions.CheckCertificateRevocation ? X509RevocationMode.Online : X509RevocationMode.NoCheck,
@@ -191,7 +206,7 @@ namespace MQTTnet.Implementations
                             }).ConfigureAwait(false);
                     #else
                         await sslStream.AuthenticateAsServerAsync(
-                            _tlsCertificate,
+                            clientCertificate,
                             _tlsOptions.ClientCertificateRequired,
                             _tlsOptions.SslProtocol,
                             _tlsOptions.CheckCertificateRevocation).ConfigureAwait(false);
@@ -234,7 +249,7 @@ namespace MQTTnet.Implementations
                     return;
                 }
 
-                _logger.Error(exception, "Error while handling client connection.");
+                _logger.Error(exception, "Error while handling TCP client connection");
             }
             finally
             {
@@ -249,10 +264,7 @@ namespace MQTTnet.Implementations
                 }
             }
 
-            _logger.Verbose("Client '{0}' disconnected at TCP listener '{1}, {2}'.",
-                remoteEndPoint,
-                _localEndPoint,
-                _addressFamily == AddressFamily.InterNetwork ? "ipv4" : "ipv6");
+            _logger.Verbose("TCP client '{0}' disconnected (Local endpoint={1})", remoteEndPoint, _localEndPoint);
         }
     }
 }

Source/MQTTnet/Internal/AsyncQueue.cs

@@ -22,7 +22,11 @@ namespace MQTTnet.Internal
 
         public void Clear()
         {
+#if NETCOREAPP3_1_OR_GREATER
+            _queue.Clear();
+#else
             Interlocked.Exchange(ref _queue, new ConcurrentQueue<TItem>());
+#endif
         }
 
         public void Dispose()
@@ -32,6 +36,16 @@ namespace MQTTnet.Internal
                 _signal.Dispose();
 
                 _isDisposed = true;
+
+#if !NETSTANDARD1_3 && !WINDOWS_UWP
+                if (typeof(IDisposable).IsAssignableFrom(typeof(TItem)))
+                {
+                    while (_queue.TryDequeue(out TItem item))
+                    {
+                        (item as IDisposable).Dispose();
+                    }
+                }
+#endif
             }
         }
 

Source/MQTTnet/Internal/TaskExtensions.cs

@@ -2,8 +2,9 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using MQTTnet.Diagnostics;
+using System;
 using System.Threading.Tasks;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Internal
 {
@@ -11,7 +12,8 @@ namespace MQTTnet.Internal
     {
         public static void RunInBackground(this Task task, MqttNetSourceLogger logger = null)
         {
-            task?.ContinueWith(t =>
+            task?.ContinueWith(
+                t =>
                 {
                     // Consume the exception first so that we get no exception regarding the not observed exception.
                     var exception = t.Exception;
@@ -19,5 +21,41 @@ namespace MQTTnet.Internal
                 },
                 TaskContinuationOptions.OnlyOnFaulted);
         }
+
+        public static async Task WaitAsync(this Task task, Task sender, MqttNetSourceLogger logger)
+        {
+            if (logger == null)
+            {
+                throw new ArgumentNullException(nameof(logger));
+            }
+
+            if (task == null)
+            {
+                return;
+            }
+
+            if (task == sender)
+            {
+                // Return here to avoid deadlocks, but first any eventual exception in the task
+                // must be handled to avoid not getting an unhandled task exception
+                if (!task.IsFaulted)
+                {
+                    return;
+                }
+
+                // By accessing the Exception property the exception is considered handled and will
+                // not result in an unhandled task exception later by the finalizer
+                logger.Warning(task.Exception, "Error while waiting for background task.");
+                return;
+            }
+
+            try
+            {
+                await task.ConfigureAwait(false);
+            }
+            catch (OperationCanceledException)
+            {
+            }
+        }
     }
-}
+}

Source/MQTTnet/MQTTnet.csproj

@@ -10,7 +10,7 @@
     </Target>
 
     <PropertyGroup>
-        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0</TargetFrameworks>
+        <TargetFrameworks>netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net7.0</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net461</TargetFrameworks>
         <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' AND '$(MSBuildRuntimeType)' != 'Core' ">$(TargetFrameworks);uap10.0</TargetFrameworks>
         <LangVersion>7.3</LangVersion>
@@ -89,4 +89,4 @@
         <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="6.2.10" />
     </ItemGroup>
 
-</Project>
+</Project>

Source/MQTTnet/MqttApplicationMessageBuilder.cs

@@ -55,14 +55,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the content type to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithContentType(string contentType)
         {
             _contentType = contentType;
@@ -71,18 +65,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the correlation data to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <param
-        ///     name="correlationData">
-        ///     The correlation data.
-        /// </param>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithCorrelationData(byte[] correlationData)
         {
             _correlationData = correlationData;
@@ -91,18 +75,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the message expiry interval in seconds to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <param
-        ///     name="messageExpiryInterval">
-        ///     The message expiry interval.
-        /// </param>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithMessageExpiryInterval(uint messageExpiryInterval)
         {
             _messageExpiryInterval = messageExpiryInterval;
@@ -185,18 +159,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the payload format indicator to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <param
-        ///     name="payloadFormatIndicator">
-        ///     The payload format indicator.
-        /// </param>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithPayloadFormatIndicator(MqttPayloadFormatIndicator payloadFormatIndicator)
         {
             _payloadFormatIndicator = payloadFormatIndicator;
@@ -220,18 +184,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the response topic to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <param
-        ///     name="responseTopic">
-        ///     The response topic.
-        /// </param>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithResponseTopic(string responseTopic)
         {
             _responseTopic = responseTopic;
@@ -251,18 +205,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the subscription identifier to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <param
-        ///     name="subscriptionIdentifier">
-        ///     The subscription identifier.
-        /// </param>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithSubscriptionIdentifier(uint subscriptionIdentifier)
         {
             if (_subscriptionIdentifiers == null)
@@ -289,18 +233,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the topic alias to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <param
-        ///     name="topicAlias">
-        ///     The topic alias.
-        /// </param>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithTopicAlias(ushort topicAlias)
         {
             _topicAlias = topicAlias;
@@ -309,22 +243,8 @@ namespace MQTTnet
 
         /// <summary>
         ///     Adds the user property to the message.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// <param
-        ///     name="name">
-        ///     The property name.
-        /// </param>
-        /// <param
-        ///     name="value">
-        ///     The property value.
-        /// </param>
-        /// <returns>
-        ///     A new instance of the
-        ///     <see
-        ///         cref="MqttApplicationMessageBuilder" />
-        ///     class.
-        /// </returns>
         public MqttApplicationMessageBuilder WithUserProperty(string name, string value)
         {
             if (_userProperties == null)

Source/MQTTnet/MqttApplicationMessageValidator.cs

@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using MQTTnet.Formatter;
+using MQTTnet.Protocol;
+
+namespace MQTTnet
+{
+    public static class MqttApplicationMessageValidator
+    {
+        public static void ThrowIfNotSupported(MqttApplicationMessage applicationMessage, MqttProtocolVersion protocolVersion)
+        {
+            if (applicationMessage == null)
+            {
+                throw new ArgumentNullException(nameof(applicationMessage));
+            }
+
+            if (protocolVersion == MqttProtocolVersion.V500)
+            {
+                // Everything is supported.
+                return;
+            }
+
+            if (applicationMessage.ContentType?.Any() == true)
+            {
+                Throw(nameof(applicationMessage.ContentType));
+            }
+            
+            if (applicationMessage.UserProperties?.Any() == true)
+            {
+                Throw(nameof(applicationMessage.UserProperties));
+            }
+            
+            if (applicationMessage.CorrelationData?.Any() == true)
+            {
+                Throw(nameof(applicationMessage.CorrelationData));
+            }
+            
+            if (applicationMessage.ResponseTopic?.Any() == true)
+            {
+                Throw(nameof(applicationMessage.ResponseTopic));
+            }
+            
+            if (applicationMessage.SubscriptionIdentifiers?.Any() == true)
+            {
+                Throw(nameof(applicationMessage.SubscriptionIdentifiers));
+            }
+            
+            if (applicationMessage.TopicAlias > 0)
+            {
+                Throw(nameof(applicationMessage.TopicAlias));
+            }
+            
+            if (applicationMessage.PayloadFormatIndicator != MqttPayloadFormatIndicator.Unspecified)
+            {
+                Throw(nameof(applicationMessage.PayloadFormatIndicator));
+            }
+        }
+        
+        static void Throw(string featureName)
+        {
+            throw new NotSupportedException($"Feature {featureName} requires MQTT version 5.0.0.");
+        }
+    }
+}

Source/MQTTnet/Packets/MqttTopicFilter.cs

@@ -10,8 +10,8 @@ namespace MQTTnet.Packets
     {
         /// <summary>
         ///     Gets or sets a value indicating whether the sender will not receive its own published application messages.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        /// Hint: MQTT 5 feature only.
         public bool NoLocal { get; set; }
 
         /// <summary>
@@ -27,15 +27,15 @@ namespace MQTTnet.Packets
 
         /// <summary>
         ///     Gets or sets a value indicating whether messages are retained as published or not.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public bool RetainAsPublished { get; set; }
 
         /// <summary>
         ///     Gets or sets the retain handling.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
-        public MqttRetainHandling RetainHandling { get; set; }
+        public MqttRetainHandling RetainHandling { get; set; } = MqttRetainHandling.SendAtSubscribe;
 
         /// <summary>
         ///     Gets or sets the MQTT topic.

Source/MQTTnet/Protocol/MqttTopicValidator.cs

@@ -11,7 +11,10 @@ namespace MQTTnet.Protocol
     {
         public static void ThrowIfInvalid(MqttApplicationMessage applicationMessage)
         {
-            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
+            if (applicationMessage == null)
+            {
+                throw new ArgumentNullException(nameof(applicationMessage));
+            }
 
             if (applicationMessage.TopicAlias == 0)
             {
@@ -26,7 +29,7 @@ namespace MQTTnet.Protocol
                 throw new MqttProtocolViolationException("Topic should not be empty.");
             }
 
-            foreach(var @char in topic)
+            foreach (var @char in topic)
             {
                 if (@char == '+')
                 {
@@ -54,4 +57,4 @@ namespace MQTTnet.Protocol
             }
         }
     }
-}
+}

Source/MQTTnet/Server/Events/ClientDisconnectedEventArgs.cs

@@ -4,17 +4,30 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
+using MQTTnet.Packets;
+using MQTTnet.Protocol;
 
 namespace MQTTnet.Server
 {
     public sealed class ClientDisconnectedEventArgs : EventArgs
     {
-        public ClientDisconnectedEventArgs(string clientId, MqttClientDisconnectType disconnectType, string endpoint, IDictionary sessionItems)
+        readonly MqttDisconnectPacket _disconnectPacket;
+
+        public ClientDisconnectedEventArgs(
+            string clientId,
+            MqttDisconnectPacket disconnectPacket,
+            MqttClientDisconnectType disconnectType,
+            string endpoint,
+            IDictionary sessionItems)
         {
             ClientId = clientId ?? throw new ArgumentNullException(nameof(clientId));
             DisconnectType = disconnectType;
             Endpoint = endpoint;
             SessionItems = sessionItems ?? throw new ArgumentNullException(nameof(sessionItems));
+
+            // The DISCONNECT packet can be null in case of a non clean disconnect or session takeover.
+            _disconnectPacket = disconnectPacket;
         }
 
         /// <summary>
@@ -27,9 +40,37 @@ namespace MQTTnet.Server
 
         public string Endpoint { get; }
 
+        /// <summary>
+        ///     Gets the reason code sent by the client.
+        ///     Only available for clean disconnects.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public MqttDisconnectReasonCode? ReasonCode => _disconnectPacket?.ReasonCode;
+
+        /// <summary>
+        ///     Gets the reason string sent by the client.
+        ///     Only available for clean disconnects.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public string ReasonString => _disconnectPacket?.ReasonString;
+
+        /// <summary>
+        ///     Gets the session expiry interval sent by the client.
+        ///     Only available for clean disconnects.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public uint SessionExpiryInterval => _disconnectPacket?.SessionExpiryInterval ?? 0;
+
         /// <summary>
         ///     Gets or sets a key/value collection that can be used to share data within the scope of this session.
         /// </summary>
         public IDictionary SessionItems { get; }
+
+        /// <summary>
+        ///     Gets the user properties sent by the client.
+        ///     Only available for clean disconnects.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
+        /// </summary>
+        public List<MqttUserProperty> UserProperties => _disconnectPacket?.UserProperties;
     }
 }

Source/MQTTnet/Server/Events/PreparingSessionEventArgs.cs

@@ -10,7 +10,7 @@ namespace MQTTnet.Server
 {
     public sealed class PreparingSessionEventArgs : EventArgs
     {
-        public string Id { get; internal set; }
+        public string Id { get; set; }
 
         // TODO: Allow adding of packets to the queue etc.
 

Source/MQTTnet/Server/Events/ValidatingConnectionEventArgs.cs

@@ -9,7 +9,6 @@ using System.Security.Cryptography.X509Certificates;
 using System.Text;
 using MQTTnet.Adapter;
 using MQTTnet.Formatter;
-using MQTTnet.Implementations;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
@@ -20,10 +19,11 @@ namespace MQTTnet.Server
     {
         readonly MqttConnectPacket _connectPacket;
 
-        public ValidatingConnectionEventArgs(MqttConnectPacket connectPacket, IMqttChannelAdapter clientAdapter)
+        public ValidatingConnectionEventArgs(MqttConnectPacket connectPacket, IMqttChannelAdapter clientAdapter, IDictionary sessionItems)
         {
             _connectPacket = connectPacket ?? throw new ArgumentNullException(nameof(connectPacket));
             ChannelAdapter = clientAdapter ?? throw new ArgumentNullException(nameof(clientAdapter));
+            SessionItems = sessionItems ?? throw new ArgumentNullException(nameof(sessionItems));
         }
 
         /// <summary>
@@ -34,13 +34,13 @@ namespace MQTTnet.Server
 
         /// <summary>
         ///     Gets or sets the authentication data.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public byte[] AuthenticationData => _connectPacket.AuthenticationData;
 
         /// <summary>
         ///     Gets or sets the authentication method.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public string AuthenticationMethod => _connectPacket.AuthenticationMethod;
 
@@ -99,7 +99,7 @@ namespace MQTTnet.Server
         ///     Gets or sets the reason code. When a MQTTv3 client connects the enum value must be one which is
         ///     also supported in MQTTv3. Otherwise the connection attempt will fail because not all codes can be
         ///     converted properly.
-        ///     MQTTv5 only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public MqttConnectReasonCode ReasonCode { get; set; } = MqttConnectReasonCode.Success;
 
@@ -114,19 +114,19 @@ namespace MQTTnet.Server
 
         /// <summary>
         ///     Gets the request problem information.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public bool RequestProblemInformation => _connectPacket.RequestProblemInformation;
 
         /// <summary>
         ///     Gets the request response information.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public bool RequestResponseInformation => _connectPacket.RequestResponseInformation;
 
         /// <summary>
         ///     Gets or sets the response authentication data.
-        ///     MQTTv5 only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public byte[] ResponseAuthenticationData { get; set; }
 
@@ -137,14 +137,14 @@ namespace MQTTnet.Server
         ///     As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add
         ///     metadata to MQTT messages and pass information between publisher, broker, and subscriber.
         ///     The feature is very similar to the HTTP header concept.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public List<MqttUserProperty> ResponseUserProperties { get; set; }
 
         /// <summary>
         ///     Gets or sets the server reference. This can be used together with i.e. "Server Moved" to send
         ///     a different server address to the client.
-        ///     MQTTv5 only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public string ServerReference { get; set; }
 
@@ -158,7 +158,7 @@ namespace MQTTnet.Server
         /// <summary>
         ///     Gets or sets a key/value collection that can be used to share data within the scope of this session.
         /// </summary>
-        public IDictionary SessionItems { get; internal set; }
+        public IDictionary SessionItems { get; }
 
         /// <summary>
         ///     Gets or sets the topic alias maximum.
@@ -169,7 +169,7 @@ namespace MQTTnet.Server
 
         [Obsolete("This property name has a typo. Use 'UserName' instead. This one will be removed soon.")]
         public string Username => _connectPacket.Username;
-        
+
         public string UserName => _connectPacket.Username;
 
         /// <summary>
@@ -179,7 +179,7 @@ namespace MQTTnet.Server
         ///     As long as you don’t exceed the maximum message size, you can use an unlimited number of user properties to add
         ///     metadata to MQTT messages and pass information between publisher, broker, and subscriber.
         ///     The feature is very similar to the HTTP header concept.
-        ///     Hint: MQTT 5 feature only.
+        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
         /// </summary>
         public List<MqttUserProperty> UserProperties => _connectPacket.UserProperties;
 

Source/MQTTnet/Server/InjectedMqttApplicationMessage.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections;
 
 namespace MQTTnet.Server
 {
@@ -13,8 +14,15 @@ namespace MQTTnet.Server
             ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
         }
 
-        public string SenderClientId { get; set; } = string.Empty;
+        public MqttApplicationMessage ApplicationMessage { get; }
 
-        public MqttApplicationMessage ApplicationMessage { get; set; }
+        /// <summary>
+        ///     Gets or sets the session items which should be used for all event handlers which are involved in message
+        ///     processing.
+        ///     If _null_ is specified the singleton session items from the server are used instead.
+        /// </summary>
+        public IDictionary CustomSessionItems { get; set; }
+
+        public string SenderClientId { get; set; } = string.Empty;
     }
 }

Source/MQTTnet/Server/Internal/MqttClient.cs

@@ -57,12 +57,12 @@ namespace MQTTnet.Server
 
         public IMqttChannelAdapter ChannelAdapter { get; }
 
+        public MqttDisconnectPacket DisconnectPacket { get; set; }
+
         public string Endpoint { get; }
 
         public string Id => _connectPacket.ClientId;
 
-        public bool IsCleanDisconnect { get; private set; }
-
         public bool IsRunning { get; private set; }
 
         public bool IsTakenOver { get; set; }
@@ -95,8 +95,7 @@ namespace MQTTnet.Server
             {
                 var cancellationToken = _cancellationToken.Token;
 
-                _ = Task.Factory.StartNew(() => SendPacketsLoop(cancellationToken), cancellationToken, TaskCreationOptions.PreferFairness, TaskScheduler.Default)
-                    .ConfigureAwait(false);
+                _ = Task.Factory.StartNew(() => SendPacketsLoop(cancellationToken), cancellationToken, TaskCreationOptions.PreferFairness, TaskScheduler.Default).ConfigureAwait(false);
 
                 IsRunning = true;
 
@@ -111,7 +110,9 @@ namespace MQTTnet.Server
                 _cancellationToken = null;
             }
 
-            if (!IsTakenOver && !IsCleanDisconnect && Session.LatestConnectPacket.WillFlag && !Session.WillMessageSent)
+            var isCleanDisconnect = DisconnectPacket != null;
+
+            if (!IsTakenOver && !isCleanDisconnect && Session.LatestConnectPacket.WillFlag && !Session.WillMessageSent)
             {
                 var willPublishPacket = MqttPacketFactories.Publish.Create(Session.LatestConnectPacket);
                 var willApplicationMessage = MqttApplicationMessageFactory.Create(willPublishPacket);
@@ -431,9 +432,9 @@ namespace MQTTnet.Server
                     {
                         throw new MqttProtocolViolationException("A PINGRESP Packet is sent by the Server to the Client in response to a PINGREQ Packet only.");
                     }
-                    else if (currentPacket is MqttDisconnectPacket)
+                    else if (currentPacket is MqttDisconnectPacket disconnectPacket)
                     {
-                        IsCleanDisconnect = true;
+                        DisconnectPacket = disconnectPacket;
                         return;
                     }
                     else

Source/MQTTnet/Server/Internal/MqttClientSessionsManager.cs

@@ -387,8 +387,8 @@ namespace MQTTnet.Server
 
                     if (client.Id != null && !client.IsTakenOver && _eventContainer.ClientDisconnectedEvent.HasHandlers)
                     {
-                        var disconnectType = client.IsCleanDisconnect ? MqttClientDisconnectType.Clean : MqttClientDisconnectType.NotClean;
-                        var eventArgs = new ClientDisconnectedEventArgs(client.Id, disconnectType, endpoint, client.Session.Items);
+                        var disconnectType = client.DisconnectPacket != null ? MqttClientDisconnectType.Clean : MqttClientDisconnectType.NotClean;
+                        var eventArgs = new ClientDisconnectedEventArgs(client.Id, client.DisconnectPacket, disconnectType, endpoint, client.Session.Items);
 
                         await _eventContainer.ClientDisconnectedEvent.InvokeAsync(eventArgs).ConfigureAwait(false);
                     }
@@ -592,8 +592,13 @@ namespace MQTTnet.Server
 
                     if (_eventContainer.ClientDisconnectedEvent.HasHandlers)
                     {
-                        var eventArgs = new ClientDisconnectedEventArgs(oldClient.Id, MqttClientDisconnectType.Takeover, oldClient.Endpoint, oldClient.Session.Items);
-
+                        var eventArgs = new ClientDisconnectedEventArgs(
+                            oldClient.Id,
+                            null,
+                            MqttClientDisconnectType.Takeover,
+                            oldClient.Endpoint,
+                            oldClient.Session.Items);
+                        
                         await _eventContainer.ClientDisconnectedEvent.TryInvokeAsync(eventArgs, _logger).ConfigureAwait(false);
                     }
                 }
@@ -664,11 +669,9 @@ namespace MQTTnet.Server
 
         async Task<ValidatingConnectionEventArgs> ValidateConnection(MqttConnectPacket connectPacket, IMqttChannelAdapter channelAdapter)
         {
-            var eventArgs = new ValidatingConnectionEventArgs(connectPacket, channelAdapter)
-            {
-                SessionItems = new ConcurrentDictionary<object, object>()
-            };
-
+            // TODO: Load session items from persisted sessions in the future.
+            var sessionItems = new ConcurrentDictionary<object, object>();
+            var eventArgs = new ValidatingConnectionEventArgs(connectPacket, channelAdapter, sessionItems);
             await _eventContainer.ValidatingConnectionEvent.InvokeAsync(eventArgs).ConfigureAwait(false);
 
             // Check the client ID and set a random one if supported.

Source/MQTTnet/Server/Internal/MqttClientStatistics.cs

@@ -10,14 +10,14 @@ namespace MQTTnet.Server
 {
     public sealed class MqttClientStatistics
     {
-        long _receivedApplicationMessagesCount;
+        Statistics _statistics = new Statistics     // mutable struct, don't make readonly!
+        {
+            // Start with 1 because the CONNACK packet is not counted here.
+            _receivedPacketsCount = 1,
 
-        // Start with 1 because the CONNACK packet is not counted here.
-        long _receivedPacketsCount = 1;
-        long _sentApplicationMessagesCount;
-
-        // Start with 1 because the CONNECT packet is not counted here.
-        long _sentPacketsCount = 1;
+            // Start with 1 because the CONNECT packet is not counted here.
+            _sentPacketsCount = 1
+        };
 
         public MqttClientStatistics()
         {
@@ -30,7 +30,6 @@ namespace MQTTnet.Server
         }
 
         public DateTime ConnectedTimestamp { get; }
-
         public DateTime LastNonKeepAlivePacketReceivedTimestamp { get; private set; }
 
         /// <summary>
@@ -43,13 +42,13 @@ namespace MQTTnet.Server
         /// </summary>
         public DateTime LastPacketSentTimestamp { get; private set; }
 
-        public long ReceivedApplicationMessagesCount => Interlocked.Read(ref _receivedApplicationMessagesCount);
+        public long SentApplicationMessagesCount => Volatile.Read(ref _statistics._sentApplicationMessagesCount);
 
-        public long ReceivedPacketsCount => Interlocked.Read(ref _receivedPacketsCount);
+        public long ReceivedApplicationMessagesCount => Volatile.Read(ref _statistics._receivedApplicationMessagesCount);
 
-        public long SentApplicationMessagesCount => Interlocked.Read(ref _sentApplicationMessagesCount);
+        public long SentPacketsCount => Volatile.Read(ref _statistics._sentPacketsCount);
 
-        public long SentPacketsCount => Interlocked.Read(ref _sentPacketsCount);
+        public long ReceivedPacketsCount => Volatile.Read(ref _statistics._receivedPacketsCount);
 
         public void HandleReceivedPacket(MqttPacket packet)
         {
@@ -61,11 +60,11 @@ namespace MQTTnet.Server
             // This class is tracking all values from Clients perspective!
             LastPacketSentTimestamp = DateTime.UtcNow;
 
-            Interlocked.Increment(ref _sentPacketsCount);
+            Interlocked.Increment(ref _statistics._sentPacketsCount);
 
             if (packet is MqttPublishPacket)
             {
-                Interlocked.Increment(ref _sentApplicationMessagesCount);
+                Interlocked.Increment(ref _statistics._sentApplicationMessagesCount);
             }
 
             if (!(packet is MqttPingReqPacket || packet is MqttPingRespPacket))
@@ -73,6 +72,7 @@ namespace MQTTnet.Server
                 LastNonKeepAlivePacketReceivedTimestamp = LastPacketReceivedTimestamp;
             }
         }
+        public void ResetStatistics() => _statistics.Reset();
 
         public void HandleSentPacket(MqttPacket packet)
         {
@@ -84,20 +84,29 @@ namespace MQTTnet.Server
             // This class is tracking all values from Clients perspective!
             LastPacketReceivedTimestamp = DateTime.UtcNow;
 
-            Interlocked.Increment(ref _receivedPacketsCount);
+            Interlocked.Increment(ref _statistics._receivedPacketsCount);
 
             if (packet is MqttPublishPacket)
             {
-                Interlocked.Increment(ref _receivedApplicationMessagesCount);
+                Interlocked.Increment(ref _statistics._receivedApplicationMessagesCount);
             }
         }
 
-        public void ResetStatistics()
+        private struct Statistics
         {
-            Interlocked.Exchange(ref _sentApplicationMessagesCount, 0);
-            Interlocked.Exchange(ref _receivedApplicationMessagesCount, 0);
-            Interlocked.Exchange(ref _sentPacketsCount, 0);
-            Interlocked.Exchange(ref _receivedPacketsCount, 0);
+            public long _receivedPacketsCount;
+            public long _sentPacketsCount;
+
+            public long _receivedApplicationMessagesCount;
+            public long _sentApplicationMessagesCount;
+
+            public void Reset()
+            {
+                Volatile.Write(ref _receivedPacketsCount, 0);
+                Volatile.Write(ref _sentPacketsCount, 0);
+                Volatile.Write(ref _receivedApplicationMessagesCount, 0);
+                Volatile.Write(ref _sentApplicationMessagesCount, 0);
+            }
         }
     }
 }

Source/MQTTnet/Server/Internal/MqttClientSubscriptionsManager.cs

@@ -403,6 +403,18 @@ namespace MQTTnet.Server
             CreateSubscriptionResult createSubscriptionResult,
             SubscribeResult subscribeResult)
         {
+            if (createSubscriptionResult.Subscription.RetainHandling == MqttRetainHandling.DoNotSendOnSubscribe)
+            {
+                // This is a MQTT V5+ feature.
+                return;
+            }
+
+            if (createSubscriptionResult.Subscription.RetainHandling == MqttRetainHandling.SendAtSubscribeIfNewSubscriptionOnly && !createSubscriptionResult.IsNewSubscription)
+            {
+                // This is a MQTT V5+ feature.
+                return;
+            }
+
             for (var index = retainedMessages.Count - 1; index >= 0; index--)
             {
                 var retainedMessage = retainedMessages[index];
@@ -411,18 +423,6 @@ namespace MQTTnet.Server
                     continue;
                 }
 
-                if (createSubscriptionResult.Subscription.RetainHandling == MqttRetainHandling.DoNotSendOnSubscribe)
-                {
-                    // This is a MQTT V5+ feature.
-                    continue;
-                }
-
-                if (createSubscriptionResult.Subscription.RetainHandling == MqttRetainHandling.SendAtSubscribeIfNewSubscriptionOnly && !createSubscriptionResult.IsNewSubscription)
-                {
-                    // This is a MQTT V5+ feature.
-                    continue;
-                }
-
                 if (MqttTopicFilterComparer.Compare(retainedMessage.Topic, createSubscriptionResult.Subscription.Topic) != MqttTopicFilterCompareResult.IsMatch)
                 {
                     continue;
@@ -483,7 +483,7 @@ namespace MQTTnet.Server
 
         async Task<InterceptingUnsubscriptionEventArgs> InterceptUnsubscribe(string topicFilter, MqttSubscription mqttSubscription, CancellationToken cancellationToken)
         {
-            var clientUnsubscribingTopicEventArgs = new InterceptingUnsubscriptionEventArgs(cancellationToken, topicFilter, _session.Items, topicFilter)
+            var clientUnsubscribingTopicEventArgs = new InterceptingUnsubscriptionEventArgs(cancellationToken, _session.Id, _session.Items, topicFilter)
             {
                 Response =
                 {

Source/MQTTnet/Server/MqttServer.cs

@@ -28,8 +28,6 @@ namespace MQTTnet.Server
         readonly MqttRetainedMessagesManager _retainedMessagesManager;
         readonly IMqttNetLogger _rootLogger;
 
-        readonly IDictionary _sessionItems = new ConcurrentDictionary<object, object>();
-
         CancellationTokenSource _cancellationTokenSource;
 
         public MqttServer(MqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
@@ -167,6 +165,12 @@ namespace MQTTnet.Server
 
         public bool IsStarted => _cancellationTokenSource != null;
 
+        /// <summary>
+        ///     Gives access to the session items which belong to this server. This session items are passed
+        ///     to several events instead of the client session items if the event is caused by the server instead of a client.
+        /// </summary>
+        public IDictionary ServerSessionItems { get; } = new ConcurrentDictionary<object, object>();
+
         public Task DeleteRetainedMessagesAsync()
         {
             ThrowIfNotStarted();
@@ -228,9 +232,11 @@ namespace MQTTnet.Server
                 throw new NotSupportedException("Injected application messages must contain a topic. Topic alias is not supported.");
             }
 
+            var sessionItems = injectedApplicationMessage.CustomSessionItems ?? ServerSessionItems;
+            
             return _clientSessionsManager.DispatchApplicationMessage(
                 injectedApplicationMessage.SenderClientId,
-                _sessionItems,
+                sessionItems,
                 injectedApplicationMessage.ApplicationMessage,
                 cancellationToken);
         }

Source/MQTTnet/Server/Options/MqttServerOptionsBuilder.cs

@@ -7,8 +7,6 @@ using System.Net;
 using System.Net.Security;
 using System.Security.Authentication;
 using MQTTnet.Certificates;
-using System.Threading.Tasks;
-
 #if !WINDOWS_UWP
 using System.Security.Cryptography.X509Certificates;
 #endif
@@ -19,7 +17,22 @@ namespace MQTTnet.Server
     public class MqttServerOptionsBuilder
     {
         readonly MqttServerOptions _options = new MqttServerOptions();
-        
+
+        public MqttServerOptions Build()
+        {
+            return _options;
+        }
+
+#if !WINDOWS_UWP
+        public MqttServerOptionsBuilder WithClientCertificate(RemoteCertificateValidationCallback validationCallback = null, bool checkCertificateRevocation = false)
+        {
+            _options.TlsEndpointOptions.ClientCertificateRequired = true;
+            _options.TlsEndpointOptions.CheckCertificateRevocation = checkCertificateRevocation;
+            _options.TlsEndpointOptions.RemoteCertificateValidationCallback = validationCallback;
+            return this;
+        }
+#endif
+
         public MqttServerOptionsBuilder WithConnectionBacklog(int value)
         {
             _options.DefaultEndpointOptions.ConnectionBacklog = value;
@@ -27,12 +40,6 @@ namespace MQTTnet.Server
             return this;
         }
 
-        public MqttServerOptionsBuilder WithMaxPendingMessagesPerClient(int value)
-        {
-            _options.MaxPendingMessagesPerClient = value;
-            return this;
-        }
-
         public MqttServerOptionsBuilder WithDefaultCommunicationTimeout(TimeSpan value)
         {
             _options.DefaultCommunicationTimeout = value;
@@ -45,12 +52,6 @@ namespace MQTTnet.Server
             return this;
         }
 
-        public MqttServerOptionsBuilder WithDefaultEndpointPort(int value)
-        {
-            _options.DefaultEndpointOptions.Port = value;
-            return this;
-        }
-
         public MqttServerOptionsBuilder WithDefaultEndpointBoundIPAddress(IPAddress value)
         {
             _options.DefaultEndpointOptions.BoundInterNetworkAddress = value ?? IPAddress.Any;
@@ -63,9 +64,15 @@ namespace MQTTnet.Server
             return this;
         }
 
-        public MqttServerOptionsBuilder WithoutDefaultEndpoint()
+        public MqttServerOptionsBuilder WithDefaultEndpointPort(int value)
         {
-            _options.DefaultEndpointOptions.IsEnabled = false;
+            _options.DefaultEndpointOptions.Port = value;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithDefaultEndpointReuseAddress()
+        {
+            _options.DefaultEndpointOptions.ReuseAddress = true;
             return this;
         }
 
@@ -75,12 +82,6 @@ namespace MQTTnet.Server
             return this;
         }
 
-        public MqttServerOptionsBuilder WithEncryptedEndpointPort(int value)
-        {
-            _options.TlsEndpointOptions.Port = value;
-            return this;
-        }
-
         public MqttServerOptionsBuilder WithEncryptedEndpointBoundIPAddress(IPAddress value)
         {
             _options.TlsEndpointOptions.BoundInterNetworkAddress = value;
@@ -93,10 +94,91 @@ namespace MQTTnet.Server
             return this;
         }
 
+        public MqttServerOptionsBuilder WithEncryptedEndpointPort(int value)
+        {
+            _options.TlsEndpointOptions.Port = value;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithEncryptionSslProtocol(SslProtocols value)
+        {
+            _options.TlsEndpointOptions.SslProtocol = value;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithKeepAlive()
+        {
+            _options.DefaultEndpointOptions.KeepAlive = true;
+            _options.TlsEndpointOptions.KeepAlive = true;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithMaxPendingMessagesPerClient(int value)
+        {
+            _options.MaxPendingMessagesPerClient = value;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithoutDefaultEndpoint()
+        {
+            _options.DefaultEndpointOptions.IsEnabled = false;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithoutEncryptedEndpoint()
+        {
+            _options.TlsEndpointOptions.IsEnabled = false;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithPersistentSessions(bool value = true)
+        {
+            _options.EnablePersistentSessions = value;
+            return this;
+        }
+
+#if !WINDOWS_UWP
+        public MqttServerOptionsBuilder WithRemoteCertificateValidationCallback(RemoteCertificateValidationCallback value)
+        {
+            _options.TlsEndpointOptions.RemoteCertificateValidationCallback = value;
+            return this;
+        }
+#endif
+
+        public MqttServerOptionsBuilder WithTcpKeepAliveInterval(int value)
+        {
+            _options.DefaultEndpointOptions.TcpKeepAliveInterval = value;
+            _options.TlsEndpointOptions.TcpKeepAliveInterval = value;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithTcpKeepAliveRetryCount(int value)
+        {
+            _options.DefaultEndpointOptions.TcpKeepAliveRetryCount = value;
+            _options.TlsEndpointOptions.TcpKeepAliveRetryCount = value;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithTcpKeepAliveTime(int value)
+        {
+            _options.DefaultEndpointOptions.TcpKeepAliveTime = value;
+            _options.TlsEndpointOptions.TcpKeepAliveTime = value;
+            return this;
+        }
+
+        public MqttServerOptionsBuilder WithTlsEndpointReuseAddress()
+        {
+            _options.TlsEndpointOptions.ReuseAddress = true;
+            return this;
+        }
+
 #if !WINDOWS_UWP
         public MqttServerOptionsBuilder WithEncryptionCertificate(byte[] value, IMqttServerCertificateCredentials credentials = null)
         {
-            if (value == null) throw new ArgumentNullException(nameof(value));
+            if (value == null)
+            {
+                throw new ArgumentNullException(nameof(value));
+            }
 
             _options.TlsEndpointOptions.CertificateProvider = new BlobCertificateProvider(value)
             {
@@ -108,103 +190,26 @@ namespace MQTTnet.Server
 
         public MqttServerOptionsBuilder WithEncryptionCertificate(X509Certificate2 certificate)
         {
-            if (certificate == null) throw new ArgumentNullException(nameof(certificate));
+            if (certificate == null)
+            {
+                throw new ArgumentNullException(nameof(certificate));
+            }
 
             _options.TlsEndpointOptions.CertificateProvider = new X509CertificateProvider(certificate);
             return this;
         }
-#endif
 
-        public MqttServerOptionsBuilder WithEncryptionSslProtocol(SslProtocols value)
+        public MqttServerOptionsBuilder WithEncryptionCertificate(ICertificateProvider certificateProvider)
         {
-            _options.TlsEndpointOptions.SslProtocol = value;
-            return this;
-        }
+            if (certificateProvider == null)
+            {
+                throw new ArgumentNullException(nameof(certificateProvider));
+            }
+
+            _options.TlsEndpointOptions.CertificateProvider = certificateProvider;
 
-#if !WINDOWS_UWP
-        public MqttServerOptionsBuilder WithClientCertificate(RemoteCertificateValidationCallback validationCallback = null, bool checkCertificateRevocation = false)
-        {
-            _options.TlsEndpointOptions.ClientCertificateRequired = true;
-            _options.TlsEndpointOptions.CheckCertificateRevocation = checkCertificateRevocation;
-            _options.TlsEndpointOptions.RemoteCertificateValidationCallback = validationCallback;
             return this;
         }
 #endif
-
-        public MqttServerOptionsBuilder WithoutEncryptedEndpoint()
-        {
-            _options.TlsEndpointOptions.IsEnabled = false;
-            return this;
-        }
-
-#if !WINDOWS_UWP
-        public MqttServerOptionsBuilder WithRemoteCertificateValidationCallback(RemoteCertificateValidationCallback value)
-        {
-            _options.TlsEndpointOptions.RemoteCertificateValidationCallback = value;
-            return this;
-        }
-#endif
-        
-        // public MqttServerOptionsBuilder WithApplicationMessageInterceptor(IMqttServerApplicationMessageInterceptor value)
-        // {
-        //     _options.ApplicationMessageInterceptor = value;
-        //     return this;
-        // }
-        //
-        // public MqttServerOptionsBuilder WithApplicationMessageInterceptor(Action<InterceptingMqttClientPublishEventArgs> value)
-        // {
-        //     _options.ApplicationMessageInterceptor = new MqttServerApplicationMessageInterceptorDelegate(value);
-        //     return this;
-        // }
-        //
-        // public MqttServerOptionsBuilder WithApplicationMessageInterceptor(Func<InterceptingMqttClientPublishEventArgs, Task> value)
-        // {
-        //     _options.ApplicationMessageInterceptor = new MqttServerApplicationMessageInterceptorDelegate(value);
-        //     return this;
-        // }
-
-        // public MqttServerOptionsBuilder WithMultiThreadedApplicationMessageInterceptor(Action<InterceptingMqttClientPublishEventArgs> value)
-        // {
-        //     _options.ApplicationMessageInterceptor = new MqttServerMultiThreadedApplicationMessageInterceptorDelegate(value);
-        //     return this;
-        // }
-        //
-        // public MqttServerOptionsBuilder WithMultiThreadedApplicationMessageInterceptor(Func<InterceptingMqttClientPublishEventArgs, Task> value)
-        // {
-        //     _options.ApplicationMessageInterceptor = new MqttServerMultiThreadedApplicationMessageInterceptorDelegate(value);
-        //     return this;
-        // }
-        
-        public MqttServerOptionsBuilder WithDefaultEndpointReuseAddress()
-        {
-            _options.DefaultEndpointOptions.ReuseAddress = true;
-            return this;
-        }
-
-        public MqttServerOptionsBuilder WithTlsEndpointReuseAddress()
-        {
-            _options.TlsEndpointOptions.ReuseAddress = true;
-            return this;
-        }
-
-        public MqttServerOptionsBuilder WithPersistentSessions(bool value = true)
-        {
-            _options.EnablePersistentSessions = value;
-            return this;
-        }
-        
-        // /// <summary>
-        // /// Gets or sets the client ID which is used when publishing messages from the server directly.
-        // /// </summary>
-        // public MqttServerOptionsBuilder WithClientId(string value)
-        // {
-        //     _options.ClientId = value;
-        //     return this;
-        // }
-
-        public MqttServerOptions Build()
-        {
-            return _options;
-        }
     }
-}
+}

Source/MQTTnet/Server/Options/MqttServerTcpEndpointBaseOptions.cs

@@ -17,6 +17,30 @@ namespace MQTTnet.Server
 
         public bool NoDelay { get; set; } = true;
 
+        /// <summary>
+        ///     Gets or sets whether the sockets keep alive feature should be used.
+        ///     The value _null_ indicates that the OS and framework defaults should be used.
+        /// </summary>
+        public bool? KeepAlive { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the TCP keep alive interval.
+        ///     The value _null_ indicates that the OS and framework defaults should be used.
+        /// </summary>
+        public int? TcpKeepAliveInterval { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the TCP keep alive retry count.
+        ///     The value _null_ indicates that the OS and framework defaults should be used.
+        /// </summary>
+        public int? TcpKeepAliveRetryCount { get; set; }
+
+        /// <summary>
+        ///     Gets or sets the TCP keep alive time.
+        ///     The value _null_ indicates that the OS and framework defaults should be used.
+        /// </summary>
+        public int? TcpKeepAliveTime { get; set; }
+
         public LingerOption LingerState { get; set; } = new LingerOption(true, 0);
 
 #if WINDOWS_UWP

Source/MQTTnet/Server/Options/MqttServerTlsTcpEndpointOptions.cs

@@ -24,8 +24,8 @@ namespace MQTTnet.Server
         public bool CheckCertificateRevocation { get; set; }
 
         public SslProtocols SslProtocol { get; set; } = SslProtocols.Tls12;
-        
-#if NETCOREAPP3_1 || NET5_0_OR_GREATER
+
+#if NETCOREAPP3_1_OR_GREATER
         public System.Net.Security.CipherSuitesPolicy CipherSuitesPolicy { get; set; }
 #endif
     }