Add Unit Tests

.github/workflows/ReleaseNotes.md

@@ -1,3 +1,4 @@
-* [Server] Added new events for delivered and dropped messages (#1866, thanks to @kallayj).
-* [Server] The server will no longer treat a client which is receiving a large payload as alive. The packet must be received completely within the keep alive boundaries (BREAKING CHANGE!, #1883).
-* [Server] Fixed "service not registered" exception in ASP.NET integration (#1889).
+* [Client] Fixed _PlatformNotSupportedException_ when using Blazor (#1755, thanks to @Nickztar).
+* [Server] Fixed _NullReferenceException_ in retained messages management (#1762, thanks to @logicaloud).
+* [Server] Exposed new option which allows disabling packet fragmentation (#1753).
+* [Server] Expired sessions will no longer be used when a client connects (#1756).

.github/workflows/ci.yml

@@ -3,7 +3,7 @@ name: CI
 on: [push, pull_request]
 
 env:
-  VERSION: "4.3.3.${{github.run_number}}"
+  VERSION: "4.2.1.${{github.run_number}}"
 
 jobs:
   build:
@@ -54,7 +54,7 @@ jobs:
         uses: darenm/Setup-VSTest@v1
 
       - name: Core Tests
-        run: vstest.console.exe Source\MQTTnet.Tests\bin\Release\net7.0\MQTTnet.Tests.dll
+        run: vstest.console.exe Source\MQTTnet.Tests\bin\Release\net6.0\MQTTnet.Tests.dll
 
       - name: ASP.NET Tests
         run: vstest.console.exe Source\MQTTnet.AspNetCore.Tests\bin\Release\netcoreapp3.1\MQTTnet.AspNetCore.Tests.dll

MQTTnet.sln.DotSettings

@@ -240,7 +240,6 @@ See the LICENSE file in the project root for more information.</s:String>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002ECSharpPlaceAttributeOnSameLineMigration/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateBlankLinesAroundFieldToBlankLinesAroundProperty/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/Environment/SettingsMigration/IsMigratorApplied/=JetBrains_002EReSharper_002EPsi_002ECSharp_002ECodeStyle_002ESettingsUpgrade_002EMigrateThisQualifierSettings/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/UserDictionary/Words/=catched/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=CONNACK/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=PINGREQ/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=PINGRESP/@EntryIndexedValue">True</s:Boolean>

Samples/Client/Client_Connection_Samples.cs

@@ -7,7 +7,6 @@
 // ReSharper disable InconsistentNaming
 
 using System.Security.Authentication;
-using System.Security.Cryptography.X509Certificates;
 using MQTTnet.Client;
 using MQTTnet.Extensions.WebSocket4Net;
 using MQTTnet.Formatter;
@@ -71,6 +70,32 @@ public static class Client_Connection_Samples
             await mqttClient.DisconnectAsync(mqttClientDisconnectOptions, CancellationToken.None);
         }
     }
+    
+    public static async Task Connect_With_Amazon_AWS()
+    {
+        /*
+         * This sample creates a simple MQTT client and connects to an Amazon Web Services broker.
+         *
+         * The broker requires special settings which are set here.
+         */
+
+        var mqttFactory = new MqttFactory();
+
+        using (var mqttClient = mqttFactory.CreateMqttClient())
+        {
+            var mqttClientOptions = new MqttClientOptionsBuilder()
+                .WithTcpServer("amazon.web.services.broker")
+                // Disabling packet fragmentation is very important!  
+                .WithoutPacketFragmentation()
+                .Build();
+            
+            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
+
+            Console.WriteLine("The MQTT client is connected.");
+
+            await mqttClient.DisconnectAsync();
+        }
+    }
 
     public static async Task Connect_Client_Timeout()
     {
@@ -136,15 +161,15 @@ public static class Client_Connection_Samples
         using (var mqttClient = mqttFactory.CreateMqttClient())
         {
             var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("mqtt.fluux.io")
-                .WithTlsOptions(
+                .WithTls(
                     o =>
                     {
                         // The used public broker sometimes has invalid certificates. This sample accepts all
                         // certificates. This should not be used in live environments.
-                        o.WithCertificateValidationHandler(_ => true);
+                        o.CertificateValidationHandler = _ => true;
 
                         // The default value is determined by the OS. Set manually to force version.
-                        o.WithSslProtocols(SslProtocols.Tls12);
+                        o.SslProtocol = SslProtocols.Tls12;
                     })
                 .Build();
 
@@ -171,7 +196,7 @@ public static class Client_Connection_Samples
 
         using (var mqttClient = mqttFactory.CreateMqttClient())
         {
-            var mqttClientOptions = new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).Build();
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithWebSocketServer("broker.hivemq.com:8000/mqtt").Build();
 
             var response = await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
 
@@ -193,7 +218,7 @@ public static class Client_Connection_Samples
 
         using (var mqttClient = mqttFactory.CreateMqttClient())
         {
-            var mqttClientOptions = new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).Build();
+            var mqttClientOptions = new MqttClientOptionsBuilder().WithWebSocketServer("broker.hivemq.com:8000/mqtt").Build();
 
             var response = await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
 
@@ -216,11 +241,13 @@ public static class Client_Connection_Samples
         using (var mqttClient = mqttFactory.CreateMqttClient())
         {
             var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883)
-                .WithTlsOptions(
-                    o => o.WithCertificateValidationHandler(
+                .WithTls(
+                    o =>
+                    {
                         // The used public broker sometimes has invalid certificates. This sample accepts all
                         // certificates. This should not be used in live environments.
-                        _ => true))
+                        o.CertificateValidationHandler = _ => true;
+                    })
                 .Build();
 
             // In MQTTv5 the response contains much more information.
@@ -235,31 +262,6 @@ public static class Client_Connection_Samples
         }
     }
 
-    public static async Task Connect_With_Amazon_AWS()
-    {
-        /*
-         * This sample creates a simple MQTT client and connects to an Amazon Web Services broker.
-         *
-         * The broker requires special settings which are set here.
-         */
-
-        var mqttFactory = new MqttFactory();
-
-        using (var mqttClient = mqttFactory.CreateMqttClient())
-        {
-            var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("amazon.web.services.broker")
-                // Disabling packet fragmentation is very important!  
-                .WithoutPacketFragmentation()
-                .Build();
-
-            await mqttClient.ConnectAsync(mqttClientOptions, CancellationToken.None);
-
-            Console.WriteLine("The MQTT client is connected.");
-
-            await mqttClient.DisconnectAsync();
-        }
-    }
-
     public static async Task Disconnect_Clean()
     {
         /*
@@ -315,19 +317,18 @@ public static class Client_Connection_Samples
         using (var mqttClient = mqttFactory.CreateMqttClient())
         {
             var mqttClientOptions = new MqttClientOptionsBuilder().WithTcpServer("mqtt.fluux.io", 8883)
-                .WithTlsOptions(
+                .WithTls(
                     o =>
                     {
-                        o.WithCertificateValidationHandler(
-                            eventArgs =>
-                            {
-                                eventArgs.Certificate.Subject.DumpToConsole();
-                                eventArgs.Certificate.GetExpirationDateString().DumpToConsole();
-                                eventArgs.Chain.ChainPolicy.RevocationMode.DumpToConsole();
-                                eventArgs.Chain.ChainStatus.DumpToConsole();
-                                eventArgs.SslPolicyErrors.DumpToConsole();
-                                return true;
-                            });
+                        o.CertificateValidationHandler = eventArgs =>
+                        {
+                            eventArgs.Certificate.Subject.DumpToConsole();
+                            eventArgs.Certificate.GetExpirationDateString().DumpToConsole();
+                            eventArgs.Chain.ChainPolicy.RevocationMode.DumpToConsole();
+                            eventArgs.Chain.ChainStatus.DumpToConsole();
+                            eventArgs.SslPolicyErrors.DumpToConsole();
+                            return true;
+                        };
                     })
                 .Build();
 
@@ -431,59 +432,6 @@ public static class Client_Connection_Samples
                         }
                     }
                 });
-
-            Console.WriteLine("Press <Enter> to exit");
-            Console.ReadLine();
         }
     }
-
-    public static async Task ConnectTls_WithCaFile()
-    {
-        var mqttFactory = new MqttFactory();
-
-        X509Certificate2Collection caChain = new X509Certificate2Collection();
-        caChain.ImportFromPem(mosquitto_org); // from https://test.mosquitto.org/ssl/mosquitto.org.crt
-
-        using (var mqttClient = mqttFactory.CreateMqttClient())
-        {
-            var mqttClientOptions = new MqttClientOptionsBuilder()
-                .WithTcpServer("test.mosquitto.org", 8883)
-                .WithTlsOptions(new MqttClientTlsOptionsBuilder()
-                    .WithTrustChain(caChain) 
-                    .Build())
-                .Build();
-
-            var connAck = await mqttClient.ConnectAsync(mqttClientOptions);
-            Console.WriteLine("Connected to test.moquitto.org:8883 with CaFile mosquitto.org.crt: " + connAck.ResultCode);
-        }
-
-
-    }
-    const string mosquitto_org = @"
------BEGIN CERTIFICATE-----
-MIIEAzCCAuugAwIBAgIUBY1hlCGvdj4NhBXkZ/uLUZNILAwwDQYJKoZIhvcNAQEL
-BQAwgZAxCzAJBgNVBAYTAkdCMRcwFQYDVQQIDA5Vbml0ZWQgS2luZ2RvbTEOMAwG
-A1UEBwwFRGVyYnkxEjAQBgNVBAoMCU1vc3F1aXR0bzELMAkGA1UECwwCQ0ExFjAU
-BgNVBAMMDW1vc3F1aXR0by5vcmcxHzAdBgkqhkiG9w0BCQEWEHJvZ2VyQGF0Y2hv
-by5vcmcwHhcNMjAwNjA5MTEwNjM5WhcNMzAwNjA3MTEwNjM5WjCBkDELMAkGA1UE
-BhMCR0IxFzAVBgNVBAgMDlVuaXRlZCBLaW5nZG9tMQ4wDAYDVQQHDAVEZXJieTES
-MBAGA1UECgwJTW9zcXVpdHRvMQswCQYDVQQLDAJDQTEWMBQGA1UEAwwNbW9zcXVp
-dHRvLm9yZzEfMB0GCSqGSIb3DQEJARYQcm9nZXJAYXRjaG9vLm9yZzCCASIwDQYJ
-KoZIhvcNAQEBBQADggEPADCCAQoCggEBAME0HKmIzfTOwkKLT3THHe+ObdizamPg
-UZmD64Tf3zJdNeYGYn4CEXbyP6fy3tWc8S2boW6dzrH8SdFf9uo320GJA9B7U1FW
-Te3xda/Lm3JFfaHjkWw7jBwcauQZjpGINHapHRlpiCZsquAthOgxW9SgDgYlGzEA
-s06pkEFiMw+qDfLo/sxFKB6vQlFekMeCymjLCbNwPJyqyhFmPWwio/PDMruBTzPH
-3cioBnrJWKXc3OjXdLGFJOfj7pP0j/dr2LH72eSvv3PQQFl90CZPFhrCUcRHSSxo
-E6yjGOdnz7f6PveLIB574kQORwt8ePn0yidrTC1ictikED3nHYhMUOUCAwEAAaNT
-MFEwHQYDVR0OBBYEFPVV6xBUFPiGKDyo5V3+Hbh4N9YSMB8GA1UdIwQYMBaAFPVV
-6xBUFPiGKDyo5V3+Hbh4N9YSMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL
-BQADggEBAGa9kS21N70ThM6/Hj9D7mbVxKLBjVWe2TPsGfbl3rEDfZ+OKRZ2j6AC
-6r7jb4TZO3dzF2p6dgbrlU71Y/4K0TdzIjRj3cQ3KSm41JvUQ0hZ/c04iGDg/xWf
-+pp58nfPAYwuerruPNWmlStWAXf0UTqRtg4hQDWBuUFDJTuWuuBvEXudz74eh/wK
-sMwfu1HFvjy5Z0iMDU8PUDepjVolOCue9ashlS4EB5IECdSR2TItnAIiIwimx839
-LdUdRudafMu5T5Xma182OC0/u/xRlEm+tvKGGmfFcN0piqVl8OrSPBgIlb+1IKJE
-m/XriWr/Cq4h/JfB7NTsezVslgkBaoU=
------END CERTIFICATE-----
-";
-
-}
+}

Samples/Client/Client_Subscribe_Samples.cs

@@ -5,8 +5,8 @@
 // ReSharper disable UnusedType.Global
 // ReSharper disable UnusedMember.Global
 // ReSharper disable InconsistentNaming
-// ReSharper disable UnusedMember.Local
 
+using MQTTnet;
 using MQTTnet.Client;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
@@ -177,62 +177,4 @@ public static class Client_Subscribe_Samples
             response.DumpToConsole();
         }
     }
-
-    static void ConcurrentProcessingDisableAutoAcknowledge(CancellationToken shutdownToken, IMqttClient mqttClient)
-    {
-        /*
-         * This sample shows how to achieve concurrent processing and not have message AutoAcknowledged
-         * This to have a proper QoS1 (at-least-once) experience for what at least MQTT specification can provide
-         */
-        mqttClient.ApplicationMessageReceivedAsync += ea =>
-        {
-            ea.AutoAcknowledge = false;
-
-            async Task ProcessAsync()
-            {
-                // DO YOUR WORK HERE!
-                await Task.Delay(1000, shutdownToken);
-                await ea.AcknowledgeAsync(shutdownToken);
-                // WARNING: If process failures are not transient the message will be retried on every restart of the client
-                //          A failed message will not be dispatched again to the client as MQTT does not have a NACK packet to let
-                //          the broker know processing failed
-                //
-                // Optionally: Use a framework like Polly to create a retry policy: https://github.com/App-vNext/Polly#retry
-            }
-
-            _ = Task.Run(ProcessAsync, shutdownToken);
-
-            return Task.CompletedTask;
-        };
-    }
-
-    static void ConcurrentProcessingWithLimit(CancellationToken shutdownToken, IMqttClient mqttClient)
-    {
-        /*
-         * This sample shows how to achieve concurrent processing, with:
-         * - a maximum concurrency limit based on Environment.ProcessorCount
-         */
-
-        var concurrent = new SemaphoreSlim(Environment.ProcessorCount);
-
-        mqttClient.ApplicationMessageReceivedAsync += async ea =>
-        {
-            await concurrent.WaitAsync(shutdownToken).ConfigureAwait(false);
-
-            async Task ProcessAsync()
-            {
-                try
-                {
-                    // DO YOUR WORK HERE!
-                    await Task.Delay(1000, shutdownToken);
-                }
-                finally
-                {
-                    concurrent.Release();
-                }
-            }
-
-            _ = Task.Run(ProcessAsync, shutdownToken);
-        };
-    }
-}
+}

Samples/MQTTnet.Samples.csproj

@@ -2,7 +2,7 @@
 
     <PropertyGroup>
         <OutputType>Exe</OutputType>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net6.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <IsPackable>false</IsPackable>

Source/MQTTnet.AspnetCore/MqttConnectionContext.cs

@@ -33,11 +33,8 @@ namespace MQTTnet.AspNetCore
             PacketFormatterAdapter = packetFormatterAdapter ?? throw new ArgumentNullException(nameof(packetFormatterAdapter));
             _connection = connection ?? throw new ArgumentNullException(nameof(connection));
 
-            if (!(_connection is TcpConnection tcp) || tcp.IsConnected)
-            {
-                _input = connection.Transport.Input;
-                _output = connection.Transport.Output;
-            }
+            _input = connection.Transport.Input;
+            _output = connection.Transport.Output;
         }
 
         public long BytesReceived { get; private set; }
@@ -83,6 +80,8 @@ namespace MQTTnet.AspNetCore
             }
         }
 
+        public bool IsReadingPacket { get; private set; }
+
         public bool IsSecureConnection
         {
             get
@@ -162,6 +161,11 @@ namespace MQTTnet.AspNetCore
                                 BytesReceived += received;
                                 return packet;
                             }
+                            else
+                            {
+                                // we did receive something but the message is not yet complete
+                                IsReadingPacket = true;
+                            }
                         }
                         else if (readResult.IsCompleted)
                         {
@@ -182,9 +186,12 @@ namespace MQTTnet.AspNetCore
                 // completing the channel makes sure that there is no more data read after a protocol error
                 _input?.Complete(exception);
                 _output?.Complete(exception);
-
                 throw;
             }
+            finally
+            {
+                IsReadingPacket = false;
+            }
 
             cancellationToken.ThrowIfCancellationRequested();
             return null;

Source/MQTTnet.AspnetCore/MqttHostedServer.cs

@@ -2,7 +2,6 @@
 // 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 System.Threading;
 using System.Threading.Tasks;
@@ -15,27 +14,20 @@ namespace MQTTnet.AspNetCore
 {
     public sealed class MqttHostedServer : MqttServer, IHostedService
     {
-        readonly MqttFactory _mqttFactory;
-
-        public MqttHostedServer(MqttFactory mqttFactory, MqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger) : base(
-            options,
-            adapters,
-            logger)
+        public MqttHostedServer(MqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger) 
+            : base(options, adapters, logger)
         {
-            _mqttFactory = mqttFactory ?? throw new ArgumentNullException(nameof(mqttFactory));
         }
 
-        public async Task StartAsync(CancellationToken cancellationToken)
+        public Task StartAsync(CancellationToken cancellationToken)
         {
-            // The yield makes sure that the hosted service is considered up and running.
-            await Task.Yield();
-
-            _ = StartAsync();
+            _ =  StartAsync();
+            return Task.CompletedTask;
         }
 
         public Task StopAsync(CancellationToken cancellationToken)
         {
-            return StopAsync(_mqttFactory.CreateMqttServerStopOptionsBuilder().Build());
+            return StopAsync();
         }
     }
 }

Source/MQTTnet.AspnetCore/ServiceCollectionExtensions.cs

@@ -4,7 +4,6 @@
 
 using System;
 using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.DependencyInjection.Extensions;
 using Microsoft.Extensions.Hosting;
 using MQTTnet.Adapter;
 using MQTTnet.Diagnostics;
@@ -15,92 +14,6 @@ namespace MQTTnet.AspNetCore
 {
     public static class ServiceCollectionExtensions
     {
-        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, MqttServerOptions options)
-        {
-            if (services == null)
-            {
-                throw new ArgumentNullException(nameof(services));
-            }
-
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-
-            services.AddSingleton(options);
-            services.AddHostedMqttServer();
-
-            return services;
-        }
-
-        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, Action<MqttServerOptionsBuilder> configure)
-        {
-            if (services == null)
-            {
-                throw new ArgumentNullException(nameof(services));
-            }
-
-            if (configure == null)
-            {
-                throw new ArgumentNullException(nameof(configure));
-            }
-
-            var serverOptionsBuilder = new MqttServerOptionsBuilder();
-            configure.Invoke(serverOptionsBuilder);
-            var options = serverOptionsBuilder.Build();
-
-            return AddHostedMqttServer(services, options);
-        }
-
-        public static void AddHostedMqttServer(this IServiceCollection services)
-        {
-            // The user may have these services already registered.
-            services.TryAddSingleton<IMqttNetLogger>(MqttNetNullLogger.Instance);
-            services.TryAddSingleton(new MqttFactory());
-
-            services.AddSingleton<MqttHostedServer>();
-            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
-            services.AddSingleton<MqttServer>(s => s.GetService<MqttHostedServer>());
-        }
-
-        public static IServiceCollection AddHostedMqttServerWithServices(this IServiceCollection services, Action<AspNetMqttServerOptionsBuilder> configure)
-        {
-            if (services == null)
-            {
-                throw new ArgumentNullException(nameof(services));
-            }
-
-            services.AddSingleton(
-                s =>
-                {
-                    var builder = new AspNetMqttServerOptionsBuilder(s);
-                    configure(builder);
-                    return builder.Build();
-                });
-
-            services.AddHostedMqttServer();
-
-            return services;
-        }
-
-        public static IServiceCollection AddMqttConnectionHandler(this IServiceCollection services)
-        {
-            services.AddSingleton<MqttConnectionHandler>();
-            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttConnectionHandler>());
-
-            return services;
-        }
-
-        public static void AddMqttLogger(this IServiceCollection services, IMqttNetLogger logger)
-        {
-            if (services == null)
-            {
-                throw new ArgumentNullException(nameof(services));
-            }
-
-            services.AddSingleton(logger);
-        }
-
         public static IServiceCollection AddMqttServer(this IServiceCollection serviceCollection, Action<MqttServerOptionsBuilder> configure = null)
         {
             if (serviceCollection is null)
@@ -110,14 +23,57 @@ namespace MQTTnet.AspNetCore
 
             serviceCollection.AddMqttConnectionHandler();
             serviceCollection.AddHostedMqttServer(configure);
-
+            
             return serviceCollection;
         }
 
-        public static IServiceCollection AddMqttTcpServerAdapter(this IServiceCollection services)
+        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, MqttServerOptions options)
         {
-            services.AddSingleton<MqttTcpServerAdapter>();
-            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttTcpServerAdapter>());
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            services.AddSingleton(options);
+
+            services.AddHostedMqttServer();
+
+            return services;
+        }
+
+        public static IServiceCollection AddHostedMqttServer(this IServiceCollection services, Action<MqttServerOptionsBuilder> configure = null)
+        {
+            services.AddSingleton(s =>
+            {
+                var serverOptionsBuilder = new MqttServerOptionsBuilder();
+                configure?.Invoke(serverOptionsBuilder);
+                return serverOptionsBuilder.Build();
+            });
+
+            services.AddHostedMqttServer();
+
+            return services;
+        }
+
+        public static IServiceCollection AddHostedMqttServerWithServices(this IServiceCollection services, Action<AspNetMqttServerOptionsBuilder> configure)
+        {
+            services.AddSingleton(s =>
+            {
+                var builder = new AspNetMqttServerOptionsBuilder(s);
+                configure(builder);
+                return builder.Build();
+            });
+
+            services.AddHostedMqttServer();
+
+            return services;
+        }
+
+        static IServiceCollection AddHostedMqttServer(this IServiceCollection services)
+        {
+            var logger = new MqttNetEventLogger();
+
+            services.AddSingleton<IMqttNetLogger>(logger);
+            services.AddSingleton<MqttHostedServer>();
+            services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
+            services.AddSingleton<MqttServer>(s => s.GetService<MqttHostedServer>());
 
             return services;
         }
@@ -129,5 +85,21 @@ namespace MQTTnet.AspNetCore
 
             return services;
         }
+
+        public static IServiceCollection AddMqttTcpServerAdapter(this IServiceCollection services)
+        {
+            services.AddSingleton<MqttTcpServerAdapter>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttTcpServerAdapter>());
+
+            return services;
+        }
+
+        public static IServiceCollection AddMqttConnectionHandler(this IServiceCollection services)
+        {
+            services.AddSingleton<MqttConnectionHandler>();
+            services.AddSingleton<IMqttServerAdapter>(s => s.GetService<MqttConnectionHandler>());
+
+            return services;
+        }
     }
-}
+}

Source/MQTTnet.Extensions.Rpc/IMqttRpcClient.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Protocol;
@@ -8,8 +7,8 @@ namespace MQTTnet.Extensions.Rpc
 {
     public interface IMqttRpcClient : IDisposable
     {
-        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string,object> parameters = null);
+        Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel);
         
-        Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default);
+        Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken = default);
     }
 }

Source/MQTTnet.Extensions.Rpc/MqttRpcClient.cs

@@ -4,7 +4,6 @@
 
 using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -43,13 +42,13 @@ namespace MQTTnet.Extensions.Rpc
             _waitingCalls.Clear();
         }
 
-        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string, object> parameters = null)
+        public async Task<byte[]> ExecuteAsync(TimeSpan timeout, string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
         {
             using (var timeoutToken = new CancellationTokenSource(timeout))
             {
                 try
                 {
-                    return await ExecuteAsync(methodName, payload, qualityOfServiceLevel, parameters, timeoutToken.Token).ConfigureAwait(false);
+                    return await ExecuteAsync(methodName, payload, qualityOfServiceLevel, timeoutToken.Token).ConfigureAwait(false);
                 }
                 catch (OperationCanceledException exception)
                 {
@@ -63,14 +62,19 @@ namespace MQTTnet.Extensions.Rpc
             }
         }
 
-        public async Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string, object> parameters = null, CancellationToken cancellationToken = default)
+        public async Task<byte[]> ExecuteAsync(string methodName, byte[] payload, MqttQualityOfServiceLevel qualityOfServiceLevel, CancellationToken cancellationToken = default)
         {
             if (methodName == null)
             {
                 throw new ArgumentNullException(nameof(methodName));
             }
 
-            var context = new TopicGenerationContext(_mqttClient, _options, methodName, parameters, qualityOfServiceLevel);
+            if (!_mqttClient.IsConnected)
+            {
+                throw new MqttClientDisconnectedException(null);
+            }
+
+            var context = new TopicGenerationContext(_mqttClient, _options, methodName, qualityOfServiceLevel);
             var topicNames = _options.TopicGenerationStrategy.CreateRpcTopics(context);
 
             var requestTopic = topicNames.RequestTopic;

Source/MQTTnet.Extensions.Rpc/MqttRpcClientExtensions.cs

@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 using MQTTnet.Protocol;
@@ -12,13 +11,13 @@ namespace MQTTnet.Extensions.Rpc
 {
     public static class MqttRpcClientExtensions
     {
-        public static Task<byte[]> ExecuteAsync(this IMqttRpcClient client, TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel, IDictionary<string,object> parameters = null)
+        public static Task<byte[]> ExecuteAsync(this IMqttRpcClient client, TimeSpan timeout, string methodName, string payload, MqttQualityOfServiceLevel qualityOfServiceLevel)
         {
             if (client == null) throw new ArgumentNullException(nameof(client));
 
             var buffer = Encoding.UTF8.GetBytes(payload ?? string.Empty);
 
-            return client.ExecuteAsync(timeout, methodName, buffer, qualityOfServiceLevel, parameters);
+            return client.ExecuteAsync(timeout, methodName, buffer, qualityOfServiceLevel);
         }
     }
 }

Source/MQTTnet.Extensions.Rpc/Options/TopicGeneration/TopicGenerationContext.cs

@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Generic;
 using MQTTnet.Client;
 using MQTTnet.Protocol;
 
@@ -11,11 +10,9 @@ namespace MQTTnet.Extensions.Rpc
 {
     public sealed class TopicGenerationContext
     {
-        public TopicGenerationContext(IMqttClient mqttClient, MqttRpcClientOptions options, string methodName,
-            IDictionary<string, object> parameters, MqttQualityOfServiceLevel qualityOfServiceLevel)
+        public TopicGenerationContext(IMqttClient mqttClient, MqttRpcClientOptions options, string methodName, MqttQualityOfServiceLevel qualityOfServiceLevel)
         {
             MethodName = methodName ?? throw new ArgumentNullException(nameof(methodName));
-            Parameters = parameters;
             QualityOfServiceLevel = qualityOfServiceLevel;
             MqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
             Options = options ?? throw new ArgumentNullException(nameof(options));
@@ -23,8 +20,6 @@ namespace MQTTnet.Extensions.Rpc
 
         public string MethodName { get; }
 
-        public IDictionary<string, object> Parameters { get; }
-
         public IMqttClient MqttClient { get; }
 
         public MqttRpcClientOptions Options { get; }

Source/MQTTnet.Extensions.WebSocket4Net/WebSocket4NetMqttChannel.cs

@@ -47,13 +47,13 @@ namespace MQTTnet.Extensions.WebSocket4Net
             var uri = _webSocketOptions.Uri;
             if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
             {
-                if (_webSocketOptions.TlsOptions?.UseTls == true)
+                if (_webSocketOptions.TlsOptions?.UseTls == false)
                 {
-                    uri = "wss://" + uri;
+                    uri = "ws://" + uri;
                 }
                 else
                 {
-                    uri = "ws://" + uri;
+                    uri = "wss://" + uri;
                 }
             }
             
@@ -92,7 +92,18 @@ namespace MQTTnet.Extensions.WebSocket4Net
             var webSocketVersion = WebSocketVersion.None;
             var receiveBufferSize = 0;
 
-            var certificates = _webSocketOptions.TlsOptions?.ClientCertificatesProvider?.GetCertificates();
+            var certificates = new X509CertificateCollection();
+            if (_webSocketOptions.TlsOptions?.Certificates != null)
+            {
+                foreach (var certificate in _webSocketOptions.TlsOptions.Certificates)
+                {
+#if WINDOWS_UWP
+                    certificates.Add(new X509Certificate(certificate));
+#else
+                    certificates.Add(certificate);
+#endif
+                }
+            }
 
             _webSocket = new WebSocket(uri, subProtocol, cookies, customHeaders, userAgent, origin, webSocketVersion, proxy, sslProtocols, receiveBufferSize)
             {

Source/MQTTnet.TestApp/PublicBrokerTest.cs

@@ -20,25 +20,21 @@ namespace MQTTnet.TestApp
         {
 #if NET5_0_OR_GREATER
             // TLS13 is only available in Net5.0
-            var unsafeTls13 = new MqttClientTlsOptions
+            var unsafeTls13 = new MqttClientOptionsBuilderTlsParameters
             {
                 UseTls = true,
                 SslProtocol = SslProtocols.Tls13,
                 // Don't use this in production code. This handler simply allows any invalid certificate to work.
-                AllowUntrustedCertificates = true,
-                IgnoreCertificateChainErrors = true,
-                CertificateValidationHandler = _ => true
+                CertificateValidationHandler = w => true
             };
 #endif
             // Also defining TLS12 for servers that don't seem no to support TLS13.
-            var unsafeTls12 = new MqttClientTlsOptions
+            var unsafeTls12 = new MqttClientOptionsBuilderTlsParameters
             {
                 UseTls = true,
                 SslProtocol = SslProtocols.Tls12,
                 // Don't use this in production code. This handler simply allows any invalid certificate to work.
-                AllowUntrustedCertificates = true,
-                IgnoreCertificateChainErrors = true,
-                CertificateValidationHandler = _ => true
+                CertificateValidationHandler = w => true
             };
 
             // mqtt.eclipseprojects.io
@@ -48,16 +44,16 @@ namespace MQTTnet.TestApp
 
             await ExecuteTestAsync(
                 "mqtt.eclipseprojects.io WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("mqtt.eclipseprojects.io:80/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer("mqtt.eclipseprojects.io:80/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build());
 
 #if NET5_0_OR_GREATER
             await ExecuteTestAsync("mqtt.eclipseprojects.io WS TLS13",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("mqtt.eclipseprojects.io:443/mqtt"))
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer("mqtt.eclipseprojects.io:443/mqtt")
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls13).Build());
             
             await ExecuteTestAsync("mqtt.eclipseprojects.io WS TLS13 (WebSocket4Net)",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("mqtt.eclipseprojects.io:443/mqtt"))
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build(),
+                new MqttClientOptionsBuilder().WithWebSocketServer("mqtt.eclipseprojects.io:443/mqtt")
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls13).Build(),
                     true);
 #endif
 
@@ -72,12 +68,12 @@ namespace MQTTnet.TestApp
 
             await ExecuteTestAsync(
                 "test.mosquitto.org TCP TLS12",
-                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());
+                new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883).WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
 
 #if NET5_0_OR_GREATER
             await ExecuteTestAsync("test.mosquitto.org TCP TLS13",
                 new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build());
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls13).Build());
 #endif
 
             await ExecuteTestAsync(
@@ -85,26 +81,26 @@ namespace MQTTnet.TestApp
                 new MqttClientOptionsBuilder().WithTcpServer("test.mosquitto.org", 8885)
                     .WithCredentials("rw", "readwrite")
                     .WithProtocolVersion(MqttProtocolVersion.V311)
-                    .WithTlsOptions(unsafeTls12)
+                    .WithTls(unsafeTls12)
                     .Build());
 
             await ExecuteTestAsync(
                 "test.mosquitto.org WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8080/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer("test.mosquitto.org:8080/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build());
 
             await ExecuteTestAsync(
                 "test.mosquitto.org WS (WebSocket4Net)",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8080/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                new MqttClientOptionsBuilder().WithWebSocketServer("test.mosquitto.org:8080/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build(),
                 true);
 
             await ExecuteTestAsync(
                 "test.mosquitto.org WS TLS12",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8081/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer("test.mosquitto.org:8081/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
 
-            await ExecuteTestAsync(
-                "test.mosquitto.org WS TLS12 (WebSocket4Net)",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("test.mosquitto.org:8081/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build(),
-                true);
+            // await ExecuteTestAsync(
+            //     "test.mosquitto.org WS TLS12 (WebSocket4Net)",
+            //     new MqttClientOptionsBuilder().WithWebSocketServer("test.mosquitto.org:8081/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build(),
+            //     true);
 
             // broker.emqx.io
             await ExecuteTestAsync(
@@ -113,30 +109,30 @@ namespace MQTTnet.TestApp
 
             await ExecuteTestAsync(
                 "broker.emqx.io TCP TLS12",
-                new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 8883).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());
+                new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 8883).WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
 
 #if NET5_0_OR_GREATER
             await ExecuteTestAsync("broker.emqx.io TCP TLS13",
                 new MqttClientOptionsBuilder().WithTcpServer("broker.emqx.io", 8883)
-                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls13).Build());
+                    .WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls13).Build());
 #endif
 
             await ExecuteTestAsync(
                 "broker.emqx.io WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8083/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.emqx.io:8083/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build());
 
             await ExecuteTestAsync(
                 "broker.emqx.io WS (WebSocket4Net)",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8084/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.emqx.io:8084/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build(),
                 true);
 
             await ExecuteTestAsync(
                 "broker.emqx.io WS TLS12",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8084/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.emqx.io:8084/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build());
 
             await ExecuteTestAsync(
                 "broker.emqx.io WS TLS12 (WebSocket4Net)",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.emqx.io:8084/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).WithTlsOptions(unsafeTls12).Build(),
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.emqx.io:8084/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).WithTls(unsafeTls12).Build(),
                 true);
 
             // broker.hivemq.com
@@ -146,14 +142,15 @@ namespace MQTTnet.TestApp
 
             await ExecuteTestAsync(
                 "broker.hivemq.com WS",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build());
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.hivemq.com:8000/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build());
 
             await ExecuteTestAsync(
                 "broker.hivemq.com WS (WebSocket4Net)",
-                new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("broker.hivemq.com:8000/mqtt")).WithProtocolVersion(MqttProtocolVersion.V311).Build(),
+                new MqttClientOptionsBuilder().WithWebSocketServer("broker.hivemq.com:8000/mqtt").WithProtocolVersion(MqttProtocolVersion.V311).Build(),
                 true);
 
             // mqtt.swifitch.cz: Does not seem to operate any more
+
             // cloudmqtt.com: Cannot test because it does not offer a free plan any more.
 
             Write("Finished.", ConsoleColor.White);
@@ -200,10 +197,9 @@ namespace MQTTnet.TestApp
 
                 Write("[OK]\n", ConsoleColor.Green);
             }
-            catch (Exception exception)
+            catch (Exception e)
             {
-                Write("[FAILED]" + Environment.NewLine, ConsoleColor.Red);
-                Write(exception + Environment.NewLine, ConsoleColor.Red);
+                Write("[FAILED] " + e.Message + "\n", ConsoleColor.Red);
             }
         }
 

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

@@ -13,7 +13,6 @@ using MQTTnet.Exceptions;
 using MQTTnet.LowLevelClient;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server;
 
 namespace MQTTnet.Tests.Clients.LowLevelMqttClient
 {

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

@@ -22,6 +22,99 @@ namespace MQTTnet.Tests.Clients.ManagedMqttClient
     [TestClass]
     public sealed class ManagedMqttClient_Tests : BaseTestClass
     {
+        [TestMethod]
+        public async Task Expose_Custom_Connection_Error()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                var server = await testEnvironment.StartServer();
+                
+                server.ValidatingConnectionAsync += args =>
+                {
+                    args.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
+                    return CompletedTask.Instance;
+                };
+
+                var managedClient = testEnvironment.Factory.CreateManagedMqttClient();
+
+                MqttClientDisconnectedEventArgs disconnectedArgs = null;
+                managedClient.DisconnectedAsync += args =>
+                {
+                    disconnectedArgs = args;
+                    return CompletedTask.Instance;
+                };
+                
+                var clientOptions = testEnvironment.Factory.CreateManagedMqttClientOptionsBuilder().WithClientOptions(testEnvironment.CreateDefaultClientOptions()).Build();
+                await managedClient.StartAsync(clientOptions);
+
+                await LongTestDelay();
+
+                Assert.IsNotNull(disconnectedArgs);
+                Assert.AreEqual(MqttClientConnectResultCode.BadUserNameOrPassword, disconnectedArgs.ConnectResult.ResultCode);
+            }
+        }
+        
+        [TestMethod]
+        public async Task Receive_While_Not_Cleanly_Disconnected()
+        {
+            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
+            {
+                await testEnvironment.StartServer(o => o.WithPersistentSessions());
+
+                var senderClient = await testEnvironment.ConnectClient();
+
+                // Prepare managed client.
+                var managedClient = testEnvironment.Factory.CreateManagedMqttClient();
+                await managedClient.SubscribeAsync("#");
+                var receivedMessages = testEnvironment.CreateApplicationMessageHandler(managedClient);
+                
+                var managedClientOptions = new ManagedMqttClientOptions
+                {
+                    ClientOptions = testEnvironment.Factory.CreateClientOptionsBuilder()
+                        .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
+                        .WithClientId(nameof(Receive_While_Not_Cleanly_Disconnected) + "_managed")
+                        .WithCleanSession(false)
+                        .Build()
+                };
+
+                await managedClient.StartAsync(managedClientOptions);
+                await LongTestDelay();
+                await LongTestDelay();
+                
+                // Send test data.
+                await senderClient.PublishStringAsync("topic1");
+                await LongTestDelay();
+                await LongTestDelay();
+                
+                receivedMessages.AssertReceivedCountEquals(1);
+
+                // Stop the managed client but keep session at server (not clean disconnect required).
+                await managedClient.StopAsync(false);
+                await LongTestDelay();
+                
+                // Send new messages in the meantime.
+                await senderClient.PublishStringAsync("topic2", qualityOfServiceLevel: MqttQualityOfServiceLevel.ExactlyOnce);
+                await LongTestDelay();
+                
+                // Start the managed client, it should receive the new message.
+                await managedClient.StartAsync(managedClientOptions);
+                await LongTestDelay();
+                
+                receivedMessages.AssertReceivedCountEquals(2);
+                
+                // Stop and start again, no new message should be received.
+                for (var i = 0; i < 3; i++)
+                {
+                    await managedClient.StopAsync(false);
+                    await LongTestDelay();
+                    await managedClient.StartAsync(managedClientOptions);
+                    await LongTestDelay();
+                }
+
+                receivedMessages.AssertReceivedCountEquals(2);
+            }
+        }
+
         [TestMethod]
         public async Task Connect_To_Invalid_Server()
         {
@@ -88,38 +181,6 @@ namespace MQTTnet.Tests.Clients.ManagedMqttClient
             }
         }
 
-        [TestMethod]
-        public async Task Expose_Custom_Connection_Error()
-        {
-            using (var testEnvironment = CreateTestEnvironment())
-            {
-                var server = await testEnvironment.StartServer();
-
-                server.ValidatingConnectionAsync += args =>
-                {
-                    args.ReasonCode = MqttConnectReasonCode.BadUserNameOrPassword;
-                    return CompletedTask.Instance;
-                };
-
-                var managedClient = testEnvironment.Factory.CreateManagedMqttClient();
-
-                MqttClientDisconnectedEventArgs disconnectedArgs = null;
-                managedClient.DisconnectedAsync += args =>
-                {
-                    disconnectedArgs = args;
-                    return CompletedTask.Instance;
-                };
-
-                var clientOptions = testEnvironment.Factory.CreateManagedMqttClientOptionsBuilder().WithClientOptions(testEnvironment.CreateDefaultClientOptions()).Build();
-                await managedClient.StartAsync(clientOptions);
-
-                await LongTestDelay();
-
-                Assert.IsNotNull(disconnectedArgs);
-                Assert.AreEqual(MqttClientConnectResultCode.BadUserNameOrPassword, disconnectedArgs.ConnectResult.ResultCode);
-            }
-        }
-
         [TestMethod]
         public async Task ManagedClients_Will_Message_Send()
         {
@@ -163,67 +224,6 @@ namespace MQTTnet.Tests.Clients.ManagedMqttClient
             }
         }
 
-        [TestMethod]
-        public async Task Receive_While_Not_Cleanly_Disconnected()
-        {
-            using (var testEnvironment = CreateTestEnvironment(MqttProtocolVersion.V500))
-            {
-                await testEnvironment.StartServer(o => o.WithPersistentSessions());
-
-                var senderClient = await testEnvironment.ConnectClient();
-
-                // Prepare managed client.
-                var managedClient = testEnvironment.Factory.CreateManagedMqttClient();
-                await managedClient.SubscribeAsync("#");
-                var receivedMessages = testEnvironment.CreateApplicationMessageHandler(managedClient);
-
-                var managedClientOptions = new ManagedMqttClientOptions
-                {
-                    ClientOptions = testEnvironment.Factory.CreateClientOptionsBuilder()
-                        .WithTcpServer("127.0.0.1", testEnvironment.ServerPort)
-                        .WithClientId(nameof(Receive_While_Not_Cleanly_Disconnected) + "_managed")
-                        .WithCleanSession(false)
-                        .Build()
-                };
-
-                await managedClient.StartAsync(managedClientOptions);
-                await LongTestDelay();
-                await LongTestDelay();
-
-                // Send test data.
-                await senderClient.PublishStringAsync("topic1");
-                await LongTestDelay();
-                await LongTestDelay();
-
-                receivedMessages.AssertReceivedCountEquals(1);
-
-                // Stop the managed client but keep session at server (not clean disconnect required).
-                await managedClient.StopAsync(false);
-                await LongTestDelay();
-
-                // Send new messages in the meantime.
-                await senderClient.PublishStringAsync("topic2", qualityOfServiceLevel: MqttQualityOfServiceLevel.ExactlyOnce);
-                await LongTestDelay();
-
-                // Start the managed client, it should receive the new message.
-                await managedClient.StartAsync(managedClientOptions);
-                await LongTestDelay();
-
-                receivedMessages.AssertReceivedCountEquals(2);
-
-                // Stop and start again, no new message should be received.
-                for (var i = 0; i < 3; i++)
-                {
-                    await managedClient.StopAsync(false);
-                    await LongTestDelay();
-                    await managedClient.StartAsync(managedClientOptions);
-                    await LongTestDelay();
-                }
-
-                receivedMessages.AssertReceivedCountEquals(2);
-            }
-        }
-
         [TestMethod]
         public async Task Start_Stop()
         {
@@ -375,7 +375,7 @@ namespace MQTTnet.Tests.Clients.ManagedMqttClient
                 var clientOptions = new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1", testEnvironment.ServerPort);
 
                 var receivedManagedMessages = new List<MqttApplicationMessage>();
-
+                
                 var managedClient = testEnvironment.Factory.CreateManagedMqttClient(testEnvironment.CreateClient());
                 managedClient.ApplicationMessageReceivedAsync += e =>
                 {
@@ -403,7 +403,7 @@ namespace MQTTnet.Tests.Clients.ManagedMqttClient
                 // Make sure that it gets received after subscribing again.
                 await managedClient.SubscribeAsync("topic");
                 await LongTestDelay();
-
+                
                 Assert.AreEqual(2, receivedManagedMessages.Count);
             }
         }
@@ -421,7 +421,7 @@ namespace MQTTnet.Tests.Clients.ManagedMqttClient
                 var receivingClient = await CreateManagedClientAsync(testEnvironment, null, connectionCheckInterval);
                 var sendingClient = await testEnvironment.ConnectClient();
 
-                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", PayloadSegment = new ArraySegment<byte>(new byte[] { 1 }), Retain = true });
+                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", Payload = new byte[] { 1 }, Retain = true });
 
                 var subscribeTime = DateTime.UtcNow;
 
@@ -454,7 +454,7 @@ namespace MQTTnet.Tests.Clients.ManagedMqttClient
                 //wait a bit for the subscription to become established
                 await Task.Delay(500);
 
-                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", PayloadSegment = new ArraySegment<byte>(new byte[] { 1 }), Retain = true });
+                await sendingClient.PublishAsync(new MqttApplicationMessage { Topic = "topic", Payload = new byte[] { 1 }, Retain = true });
 
                 var messages = await SetupReceivingOfMessages(managedClient, 1);
 

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

@@ -9,6 +9,7 @@ using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Client;
 using MQTTnet.Exceptions;
+using MQTTnet.Extensions.Rpc;
 using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
@@ -20,6 +21,38 @@ namespace MQTTnet.Tests.Clients.MqttClient
     [TestClass]
     public sealed class MqttClient_Connection_Tests : BaseTestClass
     {
+        [TestMethod]
+        public async Task Connect_Disconnect_Connect()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                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(InvalidOperationException))]
+        public async Task Connect_Multiple_Times_Should_Fail()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                await testEnvironment.StartServer();
+
+                var clientOptions = testEnvironment.CreateDefaultClientOptions();
+                var client = testEnvironment.CreateClient();
+
+                await client.ConnectAsync(clientOptions);
+                await client.ConnectAsync(clientOptions);
+            }
+        }
+
         [TestMethod]
         [ExpectedException(typeof(MqttCommunicationException))]
         public async Task Connect_To_Invalid_Server_Port_Not_Opened()
@@ -167,38 +200,6 @@ namespace MQTTnet.Tests.Clients.MqttClient
             }
         }
 
-        [TestMethod]
-        public async Task No_Unobserved_Exception()
-        {
-            using (var testEnvironment = CreateTestEnvironment())
-            {
-                testEnvironment.IgnoreClientLogErrors = true;
-
-                var client = testEnvironment.CreateClient();
-                var options = new MqttClientOptionsBuilder().WithTcpServer("127.0.0.1").WithTimeout(TimeSpan.FromSeconds(2)).Build();
-
-                try
-                {
-                    using (var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(0.5)))
-                    {
-                        await client.ConnectAsync(options, timeout.Token);
-                    }
-                }
-                catch (OperationCanceledException)
-                {
-                }
-
-                client.Dispose();
-
-                // These delays and GC calls are required in order to make calling the finalizer reproducible.
-                GC.Collect();
-                GC.WaitForPendingFinalizers();
-                await LongTestDelay();
-                await LongTestDelay();
-                await LongTestDelay();
-            }
-        }
-
         [TestMethod]
         public async Task Return_Non_Success()
         {
@@ -230,25 +231,15 @@ namespace MQTTnet.Tests.Clients.MqttClient
         }
 
         [TestMethod]
-        public async Task Throw_Proper_Exception_When_Not_Connected()
+        [ExpectedException(typeof(MqttClientDisconnectedException))]
+        public async Task Rpc_Client_Not_Connected()
         {
-            try
+            var factory = new MqttFactory();
+            using (var client = factory.CreateMqttClient())
             {
-                var mqttFactory = new MqttFactory();
-                using (var mqttClient = mqttFactory.CreateMqttClient())
-                {
-                    await mqttClient.SubscribeAsync("test", MqttQualityOfServiceLevel.AtLeastOnce);
-                }
+                var rpcClient = factory.CreateMqttRpcClient(client);
+                await rpcClient.ExecuteAsync("aaa", new byte[] { 1, 2, 3 }, MqttQualityOfServiceLevel.AtLeastOnce);
             }
-            catch (MqttCommunicationException exception)
-            {
-                if (exception.Message == "The client is not connected.")
-                {
-                    return;
-                }
-            }
-
-            Assert.Fail();
         }
     }
 }

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

@@ -0,0 +1,59 @@
+// 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.Protocol;
+using MQTTnet.Server;
+
+namespace MQTTnet.Tests.Clients.MqttClient
+{
+    [TestClass]
+    public sealed class MqttClient_Publish_Tests : BaseTestClass
+    {
+        [TestMethod]
+        public async Task Acknowledge_After_Disconnect_Should_Fail()
+        {
+            using (var testEnvironment = CreateTestEnvironment())
+            {
+                var server = await testEnvironment.StartServer();
+
+                var client = await testEnvironment.ConnectClient();
+                await client.SubscribeAsync("TEST", MqttQualityOfServiceLevel.AtLeastOnce);
+
+                var flag = false;
+                
+                client.ApplicationMessageReceivedAsync += async args =>
+                {
+                    try
+                    {
+                        args.AutoAcknowledge = false;
+                        
+                        await client.DisconnectAsync();
+                        await args.AcknowledgeAsync();
+
+                        flag = true;
+                    }
+                    catch (Exception exception)
+                    {
+                        
+                    }
+                };
+
+                await server.InjectApplicationMessageAsync(
+                    new MqttApplicationMessage
+                    {
+                        Topic = "TEST"
+                    });
+
+                SpinWait.SpinUntil(() => flag, TimeSpan.FromSeconds(10));
+                
+                Assert.IsTrue(flag);
+            }
+        }
+    }
+}

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

@@ -17,7 +17,6 @@ using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server;
 using MQTTnet.Tests.Mockups;
 
 // ReSharper disable InconsistentNaming
@@ -70,38 +69,8 @@ namespace MQTTnet.Tests.Clients.MqttClient
                 Assert.IsTrue(success);
             }
         }
+       
 
-        [TestMethod]
-        public async Task Connect_Disconnect_Connect()
-        {
-            using (var testEnvironment = CreateTestEnvironment())
-            {
-                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(InvalidOperationException))]
-        public async Task Connect_Multiple_Times_Should_Fail()
-        {
-            using (var testEnvironment = CreateTestEnvironment())
-            {
-                await testEnvironment.StartServer();
-
-                var clientOptions = testEnvironment.CreateDefaultClientOptions();
-                var client = testEnvironment.CreateClient();
-
-                await client.ConnectAsync(clientOptions);
-                await client.ConnectAsync(clientOptions);
-            }
-        }
 
         [TestMethod]
         public async Task Disconnect_Event_Contains_Exception()
@@ -297,7 +266,7 @@ namespace MQTTnet.Tests.Clients.MqttClient
 
                 Assert.IsNotNull(receivedMessage);
                 Assert.AreEqual("A", receivedMessage.Topic);
-                Assert.AreEqual(null, receivedMessage.PayloadSegment.Array);
+                Assert.AreEqual(null, receivedMessage.Payload);
             }
         }
 
@@ -508,7 +477,7 @@ namespace MQTTnet.Tests.Clients.MqttClient
 
                 client2.ApplicationMessageReceivedAsync += e =>
                 {
-                    client2TopicResults.Add(Encoding.UTF8.GetString(e.ApplicationMessage.PayloadSegment.ToArray()));
+                    client2TopicResults.Add(Encoding.UTF8.GetString(e.ApplicationMessage.Payload));
                     return CompletedTask.Instance;
                 };
 

Source/MQTTnet.Tests/Clients/MqttClientOptionsBuilder_Tests.cs

@@ -10,7 +10,7 @@ using MQTTnet.Client;
 namespace MQTTnet.Tests.Clients
 {
     [TestClass]
-    public class MqttClientOptionsBuilder_Tests
+    public sealed class MqttClientOptionsBuilder_Tests
     {
         [TestMethod]
         public void WithConnectionUri_Credential_Test()

Source/MQTTnet.Tests/Extensions/Rpc_Tests.cs

@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Collections.Generic;
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
@@ -46,34 +45,6 @@ namespace MQTTnet.Tests.Extensions
             }
         }
 
-        [TestMethod]
-        public async Task Execute_Success_Parameters_Propagated_Correctly()
-        {
-            var paramValue = "123";
-            var parameters = new Dictionary<string, object>
-            {
-                { TestParametersTopicGenerationStrategy.ExpectedParamName, "123" }
-            };
-
-            using (var testEnvironment = CreateTestEnvironment())
-            {
-                await testEnvironment.StartServer();
-
-                var responseSender = await testEnvironment.ConnectClient(new MqttClientOptionsBuilder());
-                await responseSender.SubscribeAsync($"MQTTnet.RPC/+/ping/{paramValue}");
-
-                responseSender.ApplicationMessageReceivedAsync += e => responseSender.PublishStringAsync(e.ApplicationMessage.Topic + "/response", "pong");
-
-                using (var rpcClient = await testEnvironment.ConnectRpcClient(new MqttRpcClientOptionsBuilder()
-                           .WithTopicGenerationStrategy(new TestParametersTopicGenerationStrategy()).Build()))
-                {
-                    var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(5), "ping", "", MqttQualityOfServiceLevel.AtMostOnce, parameters);
-
-                    Assert.AreEqual("pong", Encoding.UTF8.GetString(response));
-                }
-            }
-        }
-
         [TestMethod]
         public Task Execute_Success_With_QoS_0()
         {
@@ -164,7 +135,7 @@ namespace MQTTnet.Tests.Extensions
 
                 using (var rpcClient = new MqttRpcClient(requestSender, new MqttRpcClientOptionsBuilder().Build()))
                 {
-                    await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
+                    var response = await rpcClient.ExecuteAsync(TimeSpan.FromSeconds(2), "ping", "", MqttQualityOfServiceLevel.AtMostOnce);
                 }
             }
         }
@@ -251,32 +222,5 @@ namespace MQTTnet.Tests.Extensions
                 };
             }
         }
-
-        class TestParametersTopicGenerationStrategy : IMqttRpcClientTopicGenerationStrategy
-        {
-            internal const string ExpectedParamName = "test_param_name";
-
-            public MqttRpcTopicPair CreateRpcTopics(TopicGenerationContext context)
-            {
-                if (context.Parameters == null)
-                {
-                    throw new InvalidOperationException("Parameters dictionary expected to be not null");
-                }
-
-                if (!context.Parameters.TryGetValue(ExpectedParamName, out var paramValue))
-                {
-                    throw new InvalidOperationException($"Parameter with name {ExpectedParamName} not present");
-                }
-
-                var requestTopic = $"MQTTnet.RPC/{Guid.NewGuid():N}/{context.MethodName}/{paramValue}";
-                var responseTopic = requestTopic + "/response";
-
-                return new MqttRpcTopicPair
-                {
-                    RequestTopic = requestTopic,
-                    ResponseTopic = responseTopic
-                };
-            }
-        }
     }
 }

Source/MQTTnet.Tests/Extensions/WebSocket4Net_Tests.cs

@@ -23,7 +23,7 @@ namespace MQTTnet.Tests.Extensions
 
             using (var client = factory.CreateMqttClient())
             {
-                var options = new MqttClientOptionsBuilder().WithWebSocketServer(o => o.WithUri("ws://a.b/mqtt")).WithTimeout(TimeSpan.FromSeconds(2)).Build();
+                var options = new MqttClientOptionsBuilder().WithWebSocketServer("ws://a.b/mqtt").WithTimeout(TimeSpan.FromSeconds(2)).Build();
                 await client.ConnectAsync(options).ConfigureAwait(false);
             }
         }

Source/MQTTnet.Tests/MQTTnet.Tests.csproj

@@ -1,8 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFrameworks>netcoreapp3.1;net7.0</TargetFrameworks>
-        <TargetFrameworks Condition=" '$(OS)' == 'Windows_NT' ">$(TargetFrameworks);net452;net48</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/MQTTv5/Client_Tests.cs

@@ -273,7 +273,7 @@ namespace MQTTnet.Tests.MQTTv5
                 Assert.AreEqual(applicationMessage.ResponseTopic, receivedMessage.ResponseTopic);
                 Assert.AreEqual(applicationMessage.MessageExpiryInterval, receivedMessage.MessageExpiryInterval);
                 CollectionAssert.AreEqual(applicationMessage.CorrelationData, receivedMessage.CorrelationData);
-                CollectionAssert.AreEqual(applicationMessage.PayloadSegment.ToArray(), receivedMessage.PayloadSegment.ToArray());
+                CollectionAssert.AreEqual(applicationMessage.Payload, receivedMessage.Payload);
                 CollectionAssert.AreEqual(applicationMessage.UserProperties, receivedMessage.UserProperties);
             }
         }

Source/MQTTnet.Tests/MQTTv5/Server_Tests.cs

@@ -10,7 +10,6 @@ using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Internal;
 using MQTTnet.Protocol;
-using MQTTnet.Server;
 
 namespace MQTTnet.Tests.MQTTv5
 {

Source/MQTTnet.Tests/Mockups/TestEnvironment.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
@@ -24,9 +25,9 @@ namespace MQTTnet.Tests.Mockups
     public sealed class TestEnvironment : IDisposable
     {
         readonly List<string> _clientErrors = new List<string>();
-        readonly List<IMqttClient> _clients = new List<IMqttClient>();
+        readonly ConcurrentBag<IMqttClient> _clients = new ConcurrentBag<IMqttClient>();
         readonly List<Exception> _exceptions = new List<Exception>();
-        readonly List<ILowLevelMqttClient> _lowLevelClients = new List<ILowLevelMqttClient>();
+        readonly ConcurrentBag<ILowLevelMqttClient> _lowLevelClients = new ConcurrentBag<ILowLevelMqttClient>();
         readonly MqttProtocolVersion _protocolVersion;
         readonly List<string> _serverErrors = new List<string>();
 
@@ -39,8 +40,6 @@ namespace MQTTnet.Tests.Mockups
             _protocolVersion = protocolVersion;
             TestContext = testContext;
 
-            TaskScheduler.UnobservedTaskException += TrackUnobservedTaskException;
-
             ServerLogger.LogMessagePublished += (s, e) =>
             {
                 if (Debugger.IsAttached)
@@ -217,9 +216,8 @@ namespace MQTTnet.Tests.Mockups
         public IMqttClient CreateClient()
         {
             var logger = EnableLogger ? (IMqttNetLogger)ClientLogger : MqttNetNullLogger.Instance;
-
+            
             var client = Factory.CreateMqttClient(logger);
-
             client.ConnectingAsync += e =>
             {
                 if (TestContext != null)
@@ -234,12 +232,9 @@ namespace MQTTnet.Tests.Mockups
 
                 return CompletedTask.Instance;
             };
-
-            lock (_clients)
-            {
-                _clients.Add(client);
-            }
-
+            
+            _clients.Add(client);
+            
             return client;
         }
 
@@ -250,20 +245,13 @@ namespace MQTTnet.Tests.Mockups
 
         public MqttClientOptionsBuilder CreateDefaultClientOptionsBuilder()
         {
-            return Factory.CreateClientOptionsBuilder()
-                .WithProtocolVersion(_protocolVersion)
-                .WithTcpServer("127.0.0.1", ServerPort)
-                .WithClientId(TestContext.TestName + "_" + Guid.NewGuid());
+            return Factory.CreateClientOptionsBuilder().WithProtocolVersion(_protocolVersion).WithTcpServer("127.0.0.1", ServerPort).WithClientId(TestContext.TestName + "_" + Guid.NewGuid());
         }
 
         public ILowLevelMqttClient CreateLowLevelClient()
         {
             var client = Factory.CreateLowLevelMqttClient(ClientLogger);
-
-            lock (_lowLevelClients)
-            {
-                _lowLevelClients.Add(client);
-            }
+            _lowLevelClients.Add(client);
 
             return client;
         }
@@ -299,68 +287,45 @@ namespace MQTTnet.Tests.Mockups
 
         public void Dispose()
         {
-            try
+            foreach (var mqttClient in _clients)
             {
-                lock (_clients)
-                {
-                    foreach (var mqttClient in _clients)
-                    {
-                        try
-                        {
-                            //mqttClient.DisconnectAsync().GetAwaiter().GetResult();
-                        }
-                        catch
-                        {
-                            // This can happen when the test already disconnected the client.
-                        }
-                        finally
-                        {
-                            mqttClient?.Dispose();
-                        }
-                    }
-
-                    _clients.Clear();
-                }
-
-                lock (_lowLevelClients)
-                {
-                    foreach (var lowLevelMqttClient in _lowLevelClients)
-                    {
-                        lowLevelMqttClient.Dispose();
-                    }
-
-                    _lowLevelClients.Clear();
-                }
-
                 try
                 {
-                    Server?.StopAsync().GetAwaiter().GetResult();
+                    //mqttClient.DisconnectAsync().GetAwaiter().GetResult();
                 }
                 catch
                 {
-                    // This can happen when the test already stopped the server.
+                    // This can happen when the test already disconnected the client.
                 }
                 finally
                 {
-                    Server?.Dispose();
+                    mqttClient?.Dispose();
                 }
+            }
 
-                Server = null;
+            foreach (var lowLevelMqttClient in _lowLevelClients)
+            {
+                lowLevelMqttClient.Dispose();
+            }
 
-                ThrowIfLogErrors();
-
-                GC.Collect();
-                GC.WaitForFullGCComplete();
-                GC.WaitForPendingFinalizers();
-                
-                if (_exceptions.Any())
-                {
-                    throw new Exception($"{_exceptions.Count} exceptions tracked.\r\n" + string.Join(Environment.NewLine, _exceptions));
-                }
+            try
+            {
+                Server?.StopAsync().GetAwaiter().GetResult();
+            }
+            catch
+            {
+                // This can happen when the test already stopped the server.
             }
             finally
             {
-                TaskScheduler.UnobservedTaskException -= TrackUnobservedTaskException;
+                Server?.Dispose();
+            }
+
+            ThrowIfLogErrors();
+
+            if (_exceptions.Any())
+            {
+                throw new Exception($"{_exceptions.Count} exceptions tracked.\r\n" + string.Join(Environment.NewLine, _exceptions));
             }
         }
 
@@ -377,7 +342,7 @@ namespace MQTTnet.Tests.Mockups
 
             var options = optionsBuilder.Build();
             var server = CreateServer(options);
-            await server.StartAsync().ConfigureAwait(false);
+            await server.StartAsync();
 
             // The OS has chosen the port to we have to properly expose it to the tests.
             ServerPort = options.DefaultEndpointOptions.Port;
@@ -405,16 +370,13 @@ namespace MQTTnet.Tests.Mockups
 
         public void ThrowIfLogErrors()
         {
-            if (!IgnoreServerLogErrors)
+            lock (_serverErrors)
             {
-                lock (_serverErrors)
+                if (!IgnoreServerLogErrors && _serverErrors.Count > 0)
                 {
-                    if (_serverErrors.Count > 0)
-                    {
-                        var message = $"Server had {_serverErrors.Count} errors (${string.Join(Environment.NewLine, _serverErrors)}).";
-                        Console.WriteLine(message);
-                        throw new Exception(message);
-                    }
+                    var message = $"Server had {_serverErrors.Count} errors (${string.Join(Environment.NewLine, _serverErrors)}).";
+                    Console.WriteLine(message);
+                    throw new Exception(message);
                 }
             }
 
@@ -434,20 +396,10 @@ namespace MQTTnet.Tests.Mockups
 
         public void TrackException(Exception exception)
         {
-            if (exception == null)
-            {
-                return;
-            }
-
             lock (_exceptions)
             {
                 _exceptions.Add(exception);
             }
         }
-
-        void TrackUnobservedTaskException(object sender, UnobservedTaskExceptionEventArgs e)
-        {
-            TrackException(e.Exception);
-        }
     }
 }

Source/MQTTnet.Tests/MqttApplicationMessageBuilder_Tests.cs

@@ -4,7 +4,6 @@
 
 using System;
 using System.IO;
-using System.Linq;
 using System.Text;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Protocol;
@@ -12,7 +11,7 @@ using MQTTnet.Protocol;
 namespace MQTTnet.Tests
 {
     [TestClass]
-    public sealed class MqttApplicationMessageBuilder_Tests
+    public class MqttApplicationMessageBuilder_Tests
     {
         [TestMethod]
         public void CreateApplicationMessage_TopicOnly()
@@ -30,7 +29,7 @@ namespace MQTTnet.Tests
             Assert.AreEqual("xyz", message.Topic);
             Assert.IsFalse(message.Retain);
             Assert.AreEqual(MqttQualityOfServiceLevel.AtMostOnce, message.QualityOfServiceLevel);
-            Assert.AreEqual(Encoding.UTF8.GetString(message.PayloadSegment.ToArray()), "00:06:00");
+            Assert.AreEqual(Encoding.UTF8.GetString(message.Payload), "00:06:00");
         }
 
         [TestMethod]
@@ -42,7 +41,7 @@ namespace MQTTnet.Tests
             Assert.AreEqual("123", message.Topic);
             Assert.IsFalse(message.Retain);
             Assert.AreEqual(MqttQualityOfServiceLevel.AtMostOnce, message.QualityOfServiceLevel);
-            Assert.AreEqual(Encoding.UTF8.GetString(message.PayloadSegment.ToArray()), "Hello");
+            Assert.AreEqual(Encoding.UTF8.GetString(message.Payload), "Hello");
         }
 
         [TestMethod]

Source/MQTTnet.Tests/MqttApplicationMessageTest.cs

@@ -1,5 +1,3 @@
-#pragma warning disable CS0618 // Type or member is obsolete
-
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 using System;
 using System.Collections.Generic;
@@ -10,7 +8,7 @@ using System.Threading.Tasks;
 namespace MQTTnet.Tests
 {
     [TestClass]
-    public sealed class MqttApplicationMessageTest
+    public class MqttApplicationMessageTest
     {
         [TestMethod]
         public void PayloadSegment()
@@ -19,27 +17,32 @@ namespace MQTTnet.Tests
             Assert.AreEqual(0, message.Payload.Length);
             Assert.AreEqual(0, message.PayloadSegment.Count);
 
-            Assert.IsTrue(ReferenceEquals(message.Payload, message.PayloadSegment.Array));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.Payload));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.PayloadSegment.Array));
 
             message.Payload = new byte[] { 1, 2 };
             Assert.AreEqual(2, message.Payload.Length);
             Assert.AreEqual(2, message.PayloadSegment.Count);
-            Assert.IsTrue(ReferenceEquals(message.Payload, message.PayloadSegment.Array));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.Payload));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.PayloadSegment.Array));
 
             message.Payload = new byte[] { 1, 2, 3 };
             Assert.AreEqual(3, message.Payload.Length);
             Assert.AreEqual(3, message.PayloadSegment.Count);
-            Assert.IsTrue(ReferenceEquals(message.Payload, message.PayloadSegment.Array));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.Payload));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.PayloadSegment.Array));
 
             message.PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3 });
             Assert.AreEqual(3, message.Payload.Length);
             Assert.AreEqual(3, message.PayloadSegment.Count);
-            Assert.IsTrue(ReferenceEquals(message.Payload, message.PayloadSegment.Array));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.Payload));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.PayloadSegment.Array));
 
             message.PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3 }, 1, 1);
             Assert.AreEqual(1, message.Payload.Length);
             Assert.AreEqual(1, message.PayloadSegment.Count);
-            Assert.IsFalse(ReferenceEquals(message.Payload, message.PayloadSegment.Array));
+            Assert.IsTrue(object.ReferenceEquals(message.Payload, message.Payload));
+            Assert.IsFalse(object.ReferenceEquals(message.Payload, message.PayloadSegment.Array));
         }
     }
 }

Source/MQTTnet.Tests/Server/General.cs

@@ -303,7 +303,7 @@ namespace MQTTnet.Tests.Server
                 var server = await testEnvironment.StartServer();
                 server.InterceptingPublishAsync += e =>
                 {
-                    e.ApplicationMessage.PayloadSegment = new ArraySegment<byte>(Encoding.ASCII.GetBytes("extended"));
+                    e.ApplicationMessage.Payload = Encoding.ASCII.GetBytes("extended");
                     return CompletedTask.Instance;
                 };
 
@@ -314,7 +314,7 @@ namespace MQTTnet.Tests.Server
                 var isIntercepted = false;
                 c2.ApplicationMessageReceivedAsync += e =>
                 {
-                    isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(e.ApplicationMessage.PayloadSegment.ToArray()), StringComparison.Ordinal) == 0;
+                    isIntercepted = string.Compare("extended", Encoding.UTF8.GetString(e.ApplicationMessage.Payload), StringComparison.Ordinal) == 0;
                     return CompletedTask.Instance;
                 };
 
@@ -425,7 +425,7 @@ namespace MQTTnet.Tests.Server
                             new MqttApplicationMessage
                             {
                                 Topic = "/test/1",
-                                PayloadSegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes("true")),
+                                Payload = Encoding.UTF8.GetBytes("true"),
                                 QualityOfServiceLevel = MqttQualityOfServiceLevel.ExactlyOnce
                             })
                         {
@@ -780,7 +780,7 @@ namespace MQTTnet.Tests.Server
                 var client1 = await testEnvironment.ConnectClient();
                 client1.ApplicationMessageReceivedAsync += e =>
                 {
-                    receivedBody = e.ApplicationMessage.PayloadSegment.ToArray();
+                    receivedBody = e.ApplicationMessage.Payload;
                     return CompletedTask.Instance;
                 };
 

Source/MQTTnet.Tests/Server/HotSwapCerts_Tests.cs

@@ -1,426 +0,0 @@
-#if !(NET452 || NET461 || NET48)
-using System;
-using System.Collections.Concurrent;
-using System.Diagnostics;
-using System.Linq;
-using System.Net;
-using System.Net.Security;
-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.Protocol;
-using MQTTnet.Server;
-
-namespace MQTTnet.Tests.Server
-{
-    // missing certificate builder api means tests won't work for older frameworks
-
-    [TestClass]
-    public sealed class HotSwapCerts_Tests
-    {
-        static readonly TimeSpan DefaultTimeout = TimeSpan.FromSeconds(10);
-
-        [TestMethod]
-        public async Task ClientCertChangeWithoutServerUpdateFailsReconnect()
-        {
-            using (var server = new ServerTestHarness())
-            using (var client01 = new ClientTestHarness())
-            {
-                server.InstallNewClientCert(client01.GetCurrentClientCert());
-                client01.InstallNewServerCert(server.GetCurrentServerCert());
-
-                await server.StartServer();
-
-                await client01.Connect();
-
-                client01.WaitForConnectOrFail(DefaultTimeout);
-
-                client01.HotSwapClientCert();
-                server.ForceDisconnectAsync(client01).Wait(DefaultTimeout);
-                client01.WaitForDisconnectOrFail(DefaultTimeout);
-
-                client01.WaitForConnectToFail(DefaultTimeout);
-            }
-        }
-
-        [TestMethod]
-        public async Task ClientCertChangeWithServerUpdateAcceptsReconnect()
-        {
-            using (var server = new ServerTestHarness())
-            using (var client01 = new ClientTestHarness())
-            {
-                server.InstallNewClientCert(client01.GetCurrentClientCert());
-                client01.InstallNewServerCert(server.GetCurrentServerCert());
-
-                await server.StartServer();
-
-                await client01.Connect();
-
-                client01.WaitForConnectOrFail(DefaultTimeout);
-
-                client01.HotSwapClientCert();
-                server.ForceDisconnectAsync(client01).Wait(DefaultTimeout);
-                client01.WaitForDisconnectOrFail(DefaultTimeout);
-
-                server.InstallNewClientCert(client01.GetCurrentClientCert());
-
-                client01.WaitForConnectOrFail(DefaultTimeout);
-            }
-        }
-
-        [TestMethod]
-        public async Task ServerCertChangeWithClientCertUpdateAllowsReconnect()
-        {
-            using (var server = new ServerTestHarness())
-            using (var client01 = new ClientTestHarness())
-            {
-                server.InstallNewClientCert(client01.GetCurrentClientCert());
-                client01.InstallNewServerCert(server.GetCurrentServerCert());
-
-                await server.StartServer();
-                await client01.Connect();
-
-                client01.WaitForConnectOrFail(DefaultTimeout);
-                server.HotSwapServerCert();
-
-                server.ForceDisconnectAsync(client01).Wait(DefaultTimeout);
-                client01.WaitForDisconnectOrFail(DefaultTimeout);
-                client01.InstallNewServerCert(server.GetCurrentServerCert());
-
-                client01.WaitForConnectOrFail(DefaultTimeout);
-            }
-        }
-
-        [TestMethod]
-        public async Task ServerCertChangeWithoutClientCertUpdateFailsReconnect()
-        {
-            using (var server = new ServerTestHarness())
-            using (var client01 = new ClientTestHarness())
-            {
-                server.InstallNewClientCert(client01.GetCurrentClientCert());
-                client01.InstallNewServerCert(server.GetCurrentServerCert());
-
-                await server.StartServer();
-                await client01.Connect();
-
-                client01.WaitForConnectOrFail(DefaultTimeout);
-                server.HotSwapServerCert();
-
-                server.ForceDisconnectAsync(client01).Wait(DefaultTimeout);
-                client01.WaitForDisconnectOrFail(DefaultTimeout);
-
-                client01.WaitForConnectToFail(DefaultTimeout);
-            }
-        }
-
-        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(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;
-                }
-            }
-        }
-
-        sealed class ClientTestHarness : IDisposable
-        {
-            readonly HotSwappableClientCertProvider _hotSwapClient = new HotSwappableClientCertProvider();
-
-            IMqttClient _client;
-
-            public string ClientId => _client.Options.ClientId;
-
-            public Task Connect()
-            {
-                return Run_Client_Connection();
-            }
-
-            public void Dispose()
-            {
-                _client.Dispose();
-                _hotSwapClient.Dispose();
-            }
-
-            public X509Certificate2 GetCurrentClientCert()
-            {
-                var result = _hotSwapClient.GetCertificates()[0];
-                return new X509Certificate2(result);
-            }
-
-            public void HotSwapClientCert()
-            {
-                _hotSwapClient.HotSwapCert();
-            }
-
-            public void InstallNewServerCert(X509Certificate2 serverCert)
-            {
-                _hotSwapClient.InstallNewServerCert(serverCert);
-            }
-
-            public void WaitForConnectOrFail(TimeSpan timeout)
-            {
-                Thread.Sleep(100);
-
-                if (!_client.IsConnected)
-                {
-                    _client.ReconnectAsync().Wait(timeout);
-                }
-
-                WaitForConnect(timeout);
-
-                Assert.IsNotNull(_client, "Client was never initialized");
-                Assert.IsTrue(_client.IsConnected, $"Client connection failed after {timeout}");
-            }
-
-            public void WaitForConnectToFail(TimeSpan timeout)
-            {
-                Assert.IsFalse(_client.IsConnected, "Client should be disconnected before waiting for connect.");
-
-                WaitForConnect(timeout);
-
-                Assert.IsNotNull(_client, "Client was never initialized");
-                Assert.IsFalse(_client.IsConnected, "Client connection success but test wanted fail");
-            }
-
-            void WaitForDisconnect(TimeSpan timeout)
-            {
-                var timer = Stopwatch.StartNew();
-                while ((_client == null || _client.IsConnected) && timer.Elapsed < timeout)
-                {
-                    Thread.Sleep(100);
-                }
-            }
-
-            public void WaitForDisconnectOrFail(TimeSpan timeout)
-            {
-                WaitForDisconnect(timeout);
-
-                Assert.IsNotNull(_client, "Client was never initialized");
-                Assert.IsFalse(_client.IsConnected, $"Client connection should have disconnected after {timeout}");
-            }
-
-            async Task Run_Client_Connection()
-            {
-                var optionsBuilder = new MqttClientOptionsBuilder()
-                    .WithTlsOptions(
-                        o => o.WithClientCertificatesProvider(_hotSwapClient)
-                            .WithCertificateValidationHandler(_hotSwapClient.OnCertificateValidation)
-                            .WithSslProtocols(SslProtocols.Tls12))
-                    .WithTcpServer("localhost")
-                    .WithCleanSession()
-                    .WithProtocolVersion(MqttProtocolVersion.V500);
-
-                var mqttClientOptions = optionsBuilder.Build();
-
-                var factory = new MqttFactory();
-                var mqttClient = factory.CreateMqttClient();
-                _client = mqttClient;
-
-                await mqttClient.ConnectAsync(mqttClientOptions);
-            }
-
-            void WaitForConnect(TimeSpan timeout)
-            {
-                var timer = Stopwatch.StartNew();
-                while ((_client == null || !_client.IsConnected) && timer.Elapsed < timeout)
-                {
-                    Thread.Sleep(100);
-                }
-            }
-        }
-
-        sealed class ServerTestHarness : IDisposable
-        {
-            readonly HotSwappableServerCertProvider _hotSwapServer = new HotSwappableServerCertProvider();
-
-            MqttServer _server;
-
-            public void Dispose()
-            {
-                if (_server != null)
-                {
-                    _server.StopAsync().Wait();
-                    _server.Dispose();
-                }
-
-                _hotSwapServer?.Dispose();
-            }
-
-            public Task ForceDisconnectAsync(ClientTestHarness client)
-            {
-                return _server.DisconnectClientAsync(client.ClientId, MqttDisconnectReasonCode.UnspecifiedError);
-            }
-
-            public X509Certificate2 GetCurrentServerCert()
-            {
-                return _hotSwapServer.GetCertificate();
-            }
-
-            public void HotSwapServerCert()
-            {
-                _hotSwapServer.HotSwapCert();
-            }
-
-            public void InstallNewClientCert(X509Certificate2 serverCert)
-            {
-                _hotSwapServer.InstallNewClientCert(serverCert);
-            }
-
-            public Task StartServer()
-            {
-                var mqttFactory = new MqttFactory();
-
-                var mqttServerOptions = new MqttServerOptionsBuilder().WithEncryptionCertificate(_hotSwapServer)
-                    .WithRemoteCertificateValidationCallback(_hotSwapServer.RemoteCertificateValidationCallback)
-                    .WithEncryptedEndpoint()
-                    .Build();
-
-                mqttServerOptions.TlsEndpointOptions.ClientCertificateRequired = true;
-
-                _server = mqttFactory.CreateMqttServer(mqttServerOptions);
-                return _server.StartAsync();
-            }
-        }
-
-        class HotSwappableClientCertProvider : IMqttClientCertificatesProvider, IDisposable
-        {
-            X509Certificate2Collection _certificates;
-            ConcurrentBag<X509Certificate2> _serverCerts = new ConcurrentBag<X509Certificate2>();
-
-            public HotSwappableClientCertProvider()
-            {
-                _certificates = new X509Certificate2Collection(CreateSelfSignedCertificate("1.3.6.1.5.5.7.3.2"));
-            }
-            
-            public void Dispose()
-            {
-                if (_certificates != null)
-                {
-                    foreach (var certs in _certificates)
-                    {
-#if !NET452
-                        certs.Dispose();
-#endif
-                    }
-                }
-            }
-
-            public X509CertificateCollection GetCertificates()
-            {
-                return new X509Certificate2Collection(_certificates);
-            }
-
-            public void HotSwapCert()
-            {
-                _certificates = new X509Certificate2Collection(CreateSelfSignedCertificate("1.3.6.1.5.5.7.3.2"));
-            }
-
-            public void InstallNewServerCert(X509Certificate2 serverCert)
-            {
-                _serverCerts.Add(serverCert);
-            }
-
-            public bool OnCertificateValidation(MqttClientCertificateValidationEventArgs certContext)
-            {
-                var serverCerts = _serverCerts.ToArray();
-
-                var providedCert = certContext.Certificate.GetRawCertData();
-                for (int i = 0, n = serverCerts.Length; i < n; i++)
-                {
-                    var currentcert = serverCerts[i];
-
-                    if (currentcert.RawData.SequenceEqual(providedCert))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-        }
-
-        sealed class HotSwappableServerCertProvider : ICertificateProvider, IDisposable
-        {
-            readonly ConcurrentBag<X509Certificate2> _clientCerts = new ConcurrentBag<X509Certificate2>();
-            X509Certificate2 _certificate;
-
-            public HotSwappableServerCertProvider()
-            {
-                _certificate = CreateSelfSignedCertificate("1.3.6.1.5.5.7.3.1");
-            }
-
-            public void Dispose()
-            {
-#if !NET452
-                _certificate.Dispose();
-#endif
-            }
-
-            public X509Certificate2 GetCertificate()
-            {
-                return _certificate;
-            }
-
-            public void HotSwapCert()
-            {
-                var newCert = CreateSelfSignedCertificate("1.3.6.1.5.5.7.3.1");
-                var oldCert = Interlocked.Exchange(ref _certificate, newCert);
-#if !NET452
-                oldCert.Dispose();
-#endif
-            }
-
-            public void InstallNewClientCert(X509Certificate2 certificate)
-            {
-                _clientCerts.Add(certificate);
-            }
-
-            public bool RemoteCertificateValidationCallback(object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
-            {
-                var serverCerts = _clientCerts.ToArray();
-
-                var providedCert = certificate.GetRawCertData();
-                for (int i = 0, n = serverCerts.Length; i < n; i++)
-                {
-                    var currentCert = serverCerts[i];
-
-                    if (currentCert.RawData.SequenceEqual(providedCert))
-                    {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-        }
-    }
-}
-
-#endif

Source/MQTTnet.Tests/Server/Publishing_Tests.cs

@@ -8,7 +8,6 @@ using MQTTnet.Client;
 using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Protocol;
-using MQTTnet.Server;
 
 namespace MQTTnet.Tests.Server
 {

Source/MQTTnet.Tests/Server/Session_Tests.cs

@@ -283,7 +283,7 @@ namespace MQTTnet.Tests.Server
 
                 server.InterceptingPublishAsync += e =>
                 {
-                    e.ApplicationMessage.PayloadSegment = new ArraySegment<byte>(Encoding.UTF8.GetBytes(e.SessionItems["default_payload"] as string ?? string.Empty));
+                    e.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(e.SessionItems["default_payload"] as string ?? string.Empty);
                     return CompletedTask.Instance;
                 };
 

Source/MQTTnet.Tests/Server/Tls_Tests.cs

@@ -101,7 +101,7 @@ namespace MQTTnet.Tests.Server
                 new MqttApplicationMessage
                 {
                     Topic = "TestTopic1",
-                    PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 })
+                    Payload = new byte[] { 1, 2, 3, 4 }
                 });
 
             await testEnvironment.Server.InjectApplicationMessage(
@@ -109,7 +109,7 @@ namespace MQTTnet.Tests.Server
                     new MqttApplicationMessage
                     {
                         Topic = "TestTopic1",
-                        PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 })
+                        Payload = new byte[] { 1, 2, 3, 4 }
                     }));
 
             certificateProvider.CurrentCertificate = CreateCertificate(secondOid);
@@ -137,7 +137,7 @@ namespace MQTTnet.Tests.Server
                 new MqttApplicationMessage
                 {
                     Topic = "TestTopic2",
-                    PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 })
+                    Payload = new byte[] { 1, 2, 3, 4 }
                 });
 
             await testEnvironment.Server.InjectApplicationMessage(
@@ -145,7 +145,7 @@ namespace MQTTnet.Tests.Server
                     new MqttApplicationMessage
                     {
                         Topic = "TestTopic2",
-                        PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 })
+                        Payload = new byte[] { 1, 2, 3, 4 }
                     }));
 
             // Ensure first client still works
@@ -153,7 +153,7 @@ namespace MQTTnet.Tests.Server
                 new MqttApplicationMessage
                 {
                     Topic = "TestTopic1",
-                    PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 })
+                    Payload = new byte[] { 1, 2, 3, 4 }
                 });
 
             await testEnvironment.Server.InjectApplicationMessage(
@@ -161,7 +161,7 @@ namespace MQTTnet.Tests.Server
                     new MqttApplicationMessage
                     {
                         Topic = "TestTopic1",
-                        PayloadSegment = new ArraySegment<byte>(new byte[] { 1, 2, 3, 4 })
+                        Payload = new byte[] { 1, 2, 3, 4 }
                     }));
 
             await Task.Delay(1000);
@@ -178,10 +178,12 @@ namespace MQTTnet.Tests.Server
             var clientOptionsBuilder = testEnvironment.Factory.CreateClientOptionsBuilder();
             clientOptionsBuilder.WithClientId(Guid.NewGuid().ToString())
                 .WithTcpServer("localhost", 8883)
-                .WithTlsOptions(
-                    o =>
+                .WithTls(
+                    tls =>
                     {
-                        o.WithSslProtocols(SslProtocols.Tls12).WithCertificateValidationHandler(certValidator);
+                        tls.UseTls = true;
+                        tls.SslProtocol = SslProtocols.Tls12;
+                        tls.CertificateValidationHandler = certValidator;
                     });
 
             var clientOptions = clientOptionsBuilder.Build();

Source/MQTTnet/Adapter/IMqttChannelAdapter.cs

@@ -25,6 +25,8 @@ namespace MQTTnet.Adapter
 
         long BytesReceived { get; }
 
+        bool IsReadingPacket { get; }
+
         Task ConnectAsync(CancellationToken cancellationToken);
 
         Task DisconnectAsync(CancellationToken cancellationToken);

Source/MQTTnet/Adapter/IMqttServerAdapter.cs

@@ -14,7 +14,6 @@ namespace MQTTnet.Adapter
         Func<IMqttChannelAdapter, Task> ClientHandler { get; set; }
 
         Task StartAsync(MqttServerOptions options, IMqttNetLogger logger);
-
         Task StopAsync();
     }
 }

Source/MQTTnet/Adapter/MqttChannelAdapter.cs

@@ -26,7 +26,9 @@ namespace MQTTnet.Adapter
         readonly IMqttChannel _channel;
         readonly byte[] _fixedHeaderBuffer = new byte[2];
         readonly MqttNetSourceLogger _logger;
+
         readonly byte[] _singleByteBuffer = new byte[1];
+
         readonly AsyncLock _syncRoot = new AsyncLock();
 
         Statistics _statistics; // mutable struct, don't make readonly!
@@ -45,8 +47,6 @@ namespace MQTTnet.Adapter
             _logger = logger.WithSource(nameof(MqttChannelAdapter));
         }
 
-        public bool AllowPacketFragmentation { get; set; } = true;
-
         public long BytesReceived => Volatile.Read(ref _statistics._bytesReceived);
 
         public long BytesSent => Volatile.Read(ref _statistics._bytesSent);
@@ -55,12 +55,16 @@ namespace MQTTnet.Adapter
 
         public string Endpoint => _channel.Endpoint;
 
+        public bool IsReadingPacket { get; private set; }
+
         public bool IsSecureConnection => _channel.IsSecureConnection;
 
         public MqttPacketFormatterAdapter PacketFormatterAdapter { get; }
 
         public MqttPacketInspector PacketInspector { get; set; }
 
+        public bool AllowPacketFragmentation { get; set; } = true;
+
         public async Task ConnectAsync(CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
@@ -74,30 +78,12 @@ namespace MQTTnet.Adapter
                  * block forever. Even a cancellation token is not supported properly.
                  */
 
+                var connectTask = _channel.ConnectAsync(cancellationToken);
+
                 var timeout = new TaskCompletionSource<object>();
                 using (cancellationToken.Register(() => timeout.TrySetResult(null)))
                 {
-                    var connectTask = Task.Run(
-                        async () =>
-                        {
-                            try
-                            {
-                                await _channel.ConnectAsync(cancellationToken).ConfigureAwait(false);
-                            }
-                            catch
-                            {
-                                // If the timeout is already reached the exception is no longer of interest and
-                                // must be catched. Otherwise it will arrive at the TaskScheduler.UnobservedTaskException.
-                                if (!timeout.Task.IsCompleted)
-                                {
-                                    throw;
-                                }
-                            }
-                        },
-                        CancellationToken.None);
-
                     await Task.WhenAny(connectTask, timeout.Task).ConfigureAwait(false);
-
                     if (timeout.Task.IsCompleted && !connectTask.IsCompleted)
                     {
                         throw new OperationCanceledException("MQTT connect canceled.", cancellationToken);
@@ -218,7 +204,7 @@ namespace MQTTnet.Adapter
                     PacketInspector?.BeginSendPacket(packetBuffer);
 
                     _logger.Verbose("TX ({0} bytes) >>> {1}", packetBuffer.Length, packet);
-
+                    
                     if (packetBuffer.Payload.Count == 0 || !AllowPacketFragmentation)
                     {
                         await _channel.WriteAsync(packetBuffer.Join(), true, cancellationToken).ConfigureAwait(false);
@@ -387,45 +373,53 @@ namespace MQTTnet.Adapter
                 return ReceivedMqttPacket.Empty;
             }
 
-            var fixedHeader = readFixedHeaderResult.FixedHeader;
-            if (fixedHeader.RemainingLength == 0)
+            IsReadingPacket = true;
+            try
             {
-                return new ReceivedMqttPacket(fixedHeader.Flags, EmptyBuffer.ArraySegment, 2);
+                var fixedHeader = readFixedHeaderResult.FixedHeader;
+                if (fixedHeader.RemainingLength == 0)
+                {
+                    return new ReceivedMqttPacket(fixedHeader.Flags, EmptyBuffer.ArraySegment, 2);
+                }
+
+                var bodyLength = fixedHeader.RemainingLength;
+                var body = new byte[bodyLength];
+
+                var bodyOffset = 0;
+                var chunkSize = Math.Min(ReadBufferSize, bodyLength);
+
+                do
+                {
+                    var bytesLeft = body.Length - bodyOffset;
+                    if (chunkSize > bytesLeft)
+                    {
+                        chunkSize = bytesLeft;
+                    }
+
+                    var readBytes = await _channel.ReadAsync(body, bodyOffset, chunkSize, cancellationToken).ConfigureAwait(false);
+
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        return ReceivedMqttPacket.Empty;
+                    }
+
+                    if (readBytes == 0)
+                    {
+                        return ReceivedMqttPacket.Empty;
+                    }
+
+                    bodyOffset += readBytes;
+                } while (bodyOffset < bodyLength);
+
+                PacketInspector?.FillReceiveBuffer(body);
+
+                var bodySegment = new ArraySegment<byte>(body, 0, bodyLength);
+                return new ReceivedMqttPacket(fixedHeader.Flags, bodySegment, fixedHeader.TotalLength);
             }
-
-            var bodyLength = fixedHeader.RemainingLength;
-            var body = new byte[bodyLength];
-
-            var bodyOffset = 0;
-            var chunkSize = Math.Min(ReadBufferSize, bodyLength);
-
-            do
+            finally
             {
-                var bytesLeft = body.Length - bodyOffset;
-                if (chunkSize > bytesLeft)
-                {
-                    chunkSize = bytesLeft;
-                }
-
-                var readBytes = await _channel.ReadAsync(body, bodyOffset, chunkSize, cancellationToken).ConfigureAwait(false);
-
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return ReceivedMqttPacket.Empty;
-                }
-
-                if (readBytes == 0)
-                {
-                    return ReceivedMqttPacket.Empty;
-                }
-
-                bodyOffset += readBytes;
-            } while (bodyOffset < bodyLength);
-
-            PacketInspector?.FillReceiveBuffer(body);
-
-            var bodySegment = new ArraySegment<byte>(body, 0, bodyLength);
-            return new ReceivedMqttPacket(fixedHeader.Flags, bodySegment, fixedHeader.TotalLength);
+                IsReadingPacket = false;
+            }
         }
 
         static bool WrapAndThrowException(Exception exception)

Source/MQTTnet/Client/MqttClient.cs

@@ -140,7 +140,6 @@ namespace MQTTnet.Client
                 if (connectResult.ResultCode != MqttClientConnectResultCode.Success)
                 {
                     _logger.Warning("Connecting failed: {0}", connectResult.ResultCode);
-                    await DisconnectInternal(null, null, connectResult).ConfigureAwait(false);
                     return connectResult;
                 }
 
@@ -238,11 +237,6 @@ namespace MQTTnet.Client
 
         public async Task PingAsync(CancellationToken cancellationToken = default)
         {
-            cancellationToken.ThrowIfCancellationRequested();
-            
-            ThrowIfDisposed();
-            ThrowIfNotConnected();
-
             if (cancellationToken.CanBeCanceled)
             {
                 await Request<MqttPingRespPacket>(MqttPingReqPacket.Instance, cancellationToken).ConfigureAwait(false);
@@ -309,7 +303,6 @@ namespace MQTTnet.Client
                 AuthenticationMethod = Options.AuthenticationMethod,
                 AuthenticationData = data.AuthenticationData,
                 ReasonString = data.ReasonString,
-                ReasonCode = data.ReasonCode,
                 UserProperties = data.UserProperties
             };
 
@@ -328,14 +321,14 @@ namespace MQTTnet.Client
                 MqttTopicValidator.ThrowIfInvalidSubscribe(topicFilter.Topic);
             }
 
-            ThrowIfDisposed();
-            ThrowIfNotConnected();
-            
             if (Options.ValidateFeatures)
             {
                 MqttClientSubscribeOptionsValidator.ThrowIfNotSupported(options, _adapter.PacketFormatterAdapter.ProtocolVersion);
             }
 
+            ThrowIfDisposed();
+            ThrowIfNotConnected();
+
             var subscribePacket = MqttPacketFactories.Subscribe.Create(options);
             subscribePacket.PacketIdentifier = _packetIdentifierProvider.GetNextPacketIdentifier();
 
@@ -447,7 +440,7 @@ namespace MQTTnet.Client
 
                 if (receivedPacket is MqttConnAckPacket connAckPacket)
                 {
-                    result = MqttClientResultFactory.ConnectResult.Create(connAckPacket, channelAdapter.PacketFormatterAdapter.ProtocolVersion);
+                    result = MqttClientResultFactory.ConnectResult.Create(connAckPacket, _adapter.PacketFormatterAdapter.ProtocolVersion);
                 }
                 else if (receivedPacket is MqttAuthPacket)
                 {
@@ -472,10 +465,11 @@ namespace MQTTnet.Client
             // did send a proper ACK packet with a non success response.
             if (options.ThrowOnNonSuccessfulConnectResponse)
             {
+                _logger.Warning(
+                    "Client will now throw an _MqttConnectingFailedException_. This is obsolete and will be removed in the future. Consider setting _ThrowOnNonSuccessfulResponseFromServer=False_ in client options.");
+
                 if (result.ResultCode != MqttClientConnectResultCode.Success)
                 {
-                    _logger.Warning(
-                        "Client will now throw an _MqttConnectingFailedException_. This is obsolete and will be removed in the future. Consider setting _ThrowOnNonSuccessfulResponseFromServer=False_ in client options.");
                     throw new MqttConnectingFailedException($"Connecting with MQTT server failed ({result.ResultCode}).", null, result);
                 }
             }
@@ -519,7 +513,7 @@ namespace MQTTnet.Client
             using (var effectiveCancellationToken = CancellationTokenSource.CreateLinkedTokenSource(backgroundCancellationToken, cancellationToken))
             {
                 _logger.Verbose("Trying to connect with server '{0}'", Options.ChannelOptions);
-                await channelAdapter.ConnectAsync(effectiveCancellationToken.Token).ConfigureAwait(false);
+                await _adapter.ConnectAsync(effectiveCancellationToken.Token).ConfigureAwait(false);
                 _logger.Verbose("Connection with server established");
 
                 _publishPacketReceiverQueue?.Dispose();
@@ -709,15 +703,12 @@ namespace MQTTnet.Client
                         await eventArgs.AcknowledgeAsync(cancellationToken).ConfigureAwait(false);
                     }
                 }
-                catch (ObjectDisposedException)
-                {
-                }
                 catch (OperationCanceledException)
                 {
                 }
                 catch (Exception exception)
                 {
-                    _logger.Error(exception, "Error while handling application message");
+                    _logger.Error(exception, "Error while handling application message.");
                 }
             }
         }
@@ -791,7 +782,7 @@ namespace MQTTnet.Client
         {
             try
             {
-                _logger.Verbose("Start receiving packets");
+                _logger.Verbose("Start receiving packets.");
 
                 while (!cancellationToken.IsCancellationRequested)
                 {
@@ -829,21 +820,20 @@ namespace MQTTnet.Client
                 }
                 else if (exception is MqttCommunicationException)
                 {
-                    _logger.Warning(exception, "Communication error while receiving packets");
+                    _logger.Warning(exception, "Communication error while receiving packets.");
                 }
                 else
                 {
-                    _logger.Error(exception, "Error while receiving packets");
+                    _logger.Error(exception, "Error while receiving packets.");
                 }
 
-                // The packet dispatcher is set to null when the client is being disposed so it may already being gone!
-                _packetDispatcher?.FailAll(exception);
+                _packetDispatcher.FailAll(exception);
 
                 await DisconnectInternal(_packetReceiverTask, exception, null).ConfigureAwait(false);
             }
             finally
             {
-                _logger.Verbose("Stopped receiving packets");
+                _logger.Verbose("Stopped receiving packets.");
             }
         }
 
@@ -865,7 +855,7 @@ namespace MQTTnet.Client
                 }
                 catch (Exception exception)
                 {
-                    _logger.Warning(exception, "Error when sending {0} request packet", requestPacket.GetType().Name);
+                    _logger.Warning(exception, "Error when sending request packet ({0}).", requestPacket.GetType().Name);
                     packetAwaitable.Fail(exception);
                 }
 
@@ -877,7 +867,7 @@ namespace MQTTnet.Client
                 {
                     if (exception is MqttCommunicationTimedOutException)
                     {
-                        _logger.Warning("Timeout while waiting for {0} response packet", typeof(TResponsePacket).Name);
+                        _logger.Warning("Timeout while waiting for response packet ({0}).", typeof(TResponsePacket).Name);
                     }
 
                     throw;
@@ -891,6 +881,7 @@ namespace MQTTnet.Client
 
             _lastPacketSentTimestamp = DateTime.UtcNow;
 
+            //ThrowIfNotConnected();
             return _adapter.SendPacketAsync(packet, cancellationToken);
         }
 
@@ -943,7 +934,7 @@ namespace MQTTnet.Client
                 }
                 catch (Exception exception)
                 {
-                    _logger.Warning(exception, "Error while initiating disconnect");
+                    _logger.Warning(exception, "Error while initiating disconnect.");
                 }
             }
         }
@@ -978,7 +969,7 @@ namespace MQTTnet.Client
                 }
                 else if (packet is MqttPingReqPacket)
                 {
-                    throw new MqttProtocolViolationException("The PINGREQ Packet is sent from a client to the server only.");
+                    throw new MqttProtocolViolationException("The PINGREQ Packet is sent from a Client to the Server only.");
                 }
                 else
                 {
@@ -1000,15 +991,14 @@ namespace MQTTnet.Client
                 }
                 else if (exception is MqttCommunicationException)
                 {
-                    _logger.Warning(exception, "Communication error while receiving packets");
+                    _logger.Warning(exception, "Communication error while receiving packets.");
                 }
                 else
                 {
-                    _logger.Error(exception, "Error while processing received {0} packet", packet.GetType().Name);
+                    _logger.Error(exception, $"Error while processing received packet ({packet.GetType().Name}).");
                 }
 
-                // The packet dispatcher may already be gone due to disconnect etc!
-                _packetDispatcher?.FailAll(exception);
+                _packetDispatcher.FailAll(exception);
 
                 await DisconnectInternal(_packetReceiverTask, exception, null).ConfigureAwait(false);
             }
@@ -1018,7 +1008,7 @@ namespace MQTTnet.Client
         {
             try
             {
-                _logger.Verbose("Start sending keep alive packets");
+                _logger.Verbose("Start sending keep alive packets.");
 
                 var keepAlivePeriod = Options.KeepAlivePeriod;
 
@@ -1056,19 +1046,19 @@ namespace MQTTnet.Client
                 }
                 else if (exception is MqttCommunicationException)
                 {
-                    _logger.Warning(exception, "Communication error while sending/receiving keep alive packets");
+                    _logger.Warning(exception, "Communication error while sending/receiving keep alive packets.");
                 }
                 else
                 {
-                    _logger.Error(exception, "Error exception while sending/receiving keep alive packets");
+                    _logger.Error(exception, "Error exception while sending/receiving keep alive packets.");
                 }
 
                 await DisconnectInternal(_keepAlivePacketsSenderTask, exception, null).ConfigureAwait(false);
             }
             finally
             {
-                _logger.Verbose("Stopped sending keep alive packets");
+                _logger.Verbose("Stopped sending keep alive packets.");
             }
         }
     }
-}
+}

Source/MQTTnet/Client/Options/DefaultMqttCertificatesProvider.cs

@@ -1,36 +0,0 @@
-// 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.Collections.Generic;
-using System.Security.Cryptography.X509Certificates;
-
-namespace MQTTnet.Client
-{
-    public sealed class DefaultMqttCertificatesProvider : IMqttClientCertificatesProvider
-    {
-        readonly X509Certificate2Collection _certificates;
-
-        public DefaultMqttCertificatesProvider(X509Certificate2Collection certificates)
-        {
-            _certificates = certificates;
-        }
-
-        public DefaultMqttCertificatesProvider(IEnumerable<X509Certificate> certificates)
-        {
-            if (certificates != null)
-            {
-                _certificates = new X509Certificate2Collection();
-                foreach (var certificate in certificates)
-                {
-                    _certificates.Add(certificate);
-                }
-            }
-        }
-
-        public X509CertificateCollection GetCertificates()
-        {
-            return _certificates;
-        }
-    }
-}

Source/MQTTnet/Client/Options/IMqttClientCertificatesProvider.cs

@@ -1,11 +0,0 @@
-// 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
-{
-    public interface IMqttClientCertificatesProvider
-    {
-        System.Security.Cryptography.X509Certificates.X509CertificateCollection GetCertificates();
-    }
-}

Source/MQTTnet/Client/Options/MqttClientCertificateValidationEventArgs.cs

@@ -14,14 +14,8 @@ namespace MQTTnet.Client
 
         public X509Chain Chain { get; set; }
 
-        public IMqttClientChannelOptions ClientOptions { get; set; }
-#if NET452 || NET461 || NET48
-        /// <summary>
-        ///     Can be a host string name or an object derived from WebRequest.
-        /// </summary>
-        public object Sender { get; set; }
-#endif
-
         public SslPolicyErrors SslPolicyErrors { get; set; }
+
+        public IMqttClientChannelOptions ClientOptions { get; set; }
     }
-}
+}

Source/MQTTnet/Client/Options/MqttClientOptionsBuilder.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#pragma warning disable CS0612 // Type or member is obsolete
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -17,14 +15,10 @@ namespace MQTTnet.Client
     public sealed class MqttClientOptionsBuilder
     {
         readonly MqttClientOptions _options = new MqttClientOptions();
-
-        [Obsolete] MqttClientWebSocketProxyOptions _proxyOptions;
+        MqttClientWebSocketProxyOptions _proxyOptions;
 
         MqttClientTcpOptions _tcpOptions;
-        MqttClientTlsOptions _tlsOptions;
-
-        [Obsolete] MqttClientOptionsBuilderTlsParameters _tlsParameters;
-
+        MqttClientOptionsBuilderTlsParameters _tlsParameters;
         MqttClientWebSocketOptions _webSocketOptions;
 
         public MqttClientOptions Build()
@@ -34,17 +28,11 @@ namespace MQTTnet.Client
                 throw new InvalidOperationException("A channel must be set.");
             }
 
-            // The user can specify the TCP options with already configured TLS options
-            // or start with TLS settings not knowing which transport will be used (depending
-            // on the order of called methods from the builder).
-            // The builder prefers the explicitly set TLS options!
-            var tlsOptions = _tlsOptions ?? _tcpOptions?.TlsOptions;
-
             if (_tlsParameters != null)
             {
                 if (_tlsParameters?.UseTls == true)
                 {
-                    tlsOptions = new MqttClientTlsOptions
+                    var tlsOptions = new MqttClientTlsOptions
                     {
                         UseTls = true,
                         SslProtocol = _tlsParameters.SslProtocol,
@@ -52,21 +40,26 @@ namespace MQTTnet.Client
                         CertificateValidationHandler = _tlsParameters.CertificateValidationHandler,
                         IgnoreCertificateChainErrors = _tlsParameters.IgnoreCertificateChainErrors,
                         IgnoreCertificateRevocationErrors = _tlsParameters.IgnoreCertificateRevocationErrors,
-                        ClientCertificatesProvider = _tlsParameters.CertificatesProvider,
+#if WINDOWS_UWP
+                        Certificates = _tlsParameters.Certificates?.Select(c => c.ToArray()).ToList(),
+#else
+                        Certificates = _tlsParameters.Certificates?.ToList(),
+#endif
+
 #if NETCOREAPP3_1_OR_GREATER
                         ApplicationProtocols = _tlsParameters.ApplicationProtocols,
 #endif
                     };
-                }
-            }
 
-            if (_tcpOptions != null)
-            {
-                _tcpOptions.TlsOptions = tlsOptions;
-            }
-            else if (_webSocketOptions != null)
-            {
-                _webSocketOptions.TlsOptions = tlsOptions;
+                    if (_tcpOptions != null)
+                    {
+                        _tcpOptions.TlsOptions = tlsOptions;
+                    }
+                    else if (_webSocketOptions != null)
+                    {
+                        _webSocketOptions.TlsOptions = tlsOptions;
+                    }
+                }
             }
 
             if (_proxyOptions != null)
@@ -85,7 +78,17 @@ namespace MQTTnet.Client
 
             return _options;
         }
-
+        
+        /// <summary>
+        /// The client will not throw an exception when the MQTT server responses with a non success ACK packet.
+        /// This will become the default behavior in future versions of the library.
+        /// </summary>
+        public MqttClientOptionsBuilder WithoutThrowOnNonSuccessfulConnectResponse()
+        {
+            _options.ThrowOnNonSuccessfulConnectResponse = false;
+            return this;
+        }
+        
         public MqttClientOptionsBuilder WithAuthentication(string method, byte[] data)
         {
             _options.AuthenticationMethod = method;
@@ -117,7 +120,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        [Obsolete("Use WithTcpServer(... configure) or WithWebSocketServer(... configure) instead.")]
         public MqttClientOptionsBuilder WithConnectionUri(Uri uri)
         {
             if (uri == null)
@@ -134,16 +136,12 @@ namespace MQTTnet.Client
                     break;
 
                 case "mqtts":
-                    WithTcpServer(uri.Host, port)
-                        .WithTlsOptions(
-                            o =>
-                            {
-                            });
+                    WithTcpServer(uri.Host, port).WithTls();
                     break;
 
                 case "ws":
                 case "wss":
-                    WithWebSocketServer(o => o.WithUri(uri.ToString()));
+                    WithWebSocketServer(uri.ToString());
                     break;
 
                 default:
@@ -161,7 +159,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        [Obsolete("Use WithTcpServer(... configure) or WithWebSocketServer(... configure) instead.")]
         public MqttClientOptionsBuilder WithConnectionUri(string uri)
         {
             return WithConnectionUri(new Uri(uri, UriKind.Absolute));
@@ -225,16 +222,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        /// <summary>
-        ///     The client will not throw an exception when the MQTT server responses with a non success ACK packet.
-        ///     This will become the default behavior in future versions of the library.
-        /// </summary>
-        public MqttClientOptionsBuilder WithoutThrowOnNonSuccessfulConnectResponse()
-        {
-            _options.ThrowOnNonSuccessfulConnectResponse = false;
-            return this;
-        }
-
         public MqttClientOptionsBuilder WithProtocolVersion(MqttProtocolVersion value)
         {
             if (value == MqttProtocolVersion.Unknown)
@@ -246,7 +233,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        [Obsolete("Use WithWebSocketServer(... configure) instead.")]
         public MqttClientOptionsBuilder WithProxy(
             string address,
             string username = null,
@@ -268,7 +254,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        [Obsolete("Use WithWebSocketServer(... configure) instead.")]
         public MqttClientOptionsBuilder WithProxy(Action<MqttClientWebSocketProxyOptions> optionsBuilder)
         {
             if (optionsBuilder == null)
@@ -339,20 +324,17 @@ namespace MQTTnet.Client
             return this;
         }
 
-        [Obsolete("Use WithTlsOptions(... configure) instead.")]
         public MqttClientOptionsBuilder WithTls(MqttClientOptionsBuilderTlsParameters parameters)
         {
             _tlsParameters = parameters;
             return this;
         }
 
-        [Obsolete("Use WithTlsOptions(... configure) instead.")]
         public MqttClientOptionsBuilder WithTls()
         {
             return WithTls(new MqttClientOptionsBuilderTlsParameters { UseTls = true });
         }
 
-        [Obsolete("Use WithTlsOptions(... configure) instead.")]
         public MqttClientOptionsBuilder WithTls(Action<MqttClientOptionsBuilderTlsParameters> optionsBuilder)
         {
             if (optionsBuilder == null)
@@ -369,26 +351,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        public MqttClientOptionsBuilder WithTlsOptions(MqttClientTlsOptions tlsOptions)
-        {
-            _tlsOptions = tlsOptions;
-            return this;
-        }
-
-        public MqttClientOptionsBuilder WithTlsOptions(Action<MqttClientTlsOptionsBuilder> configure)
-        {
-            if (configure == null)
-            {
-                throw new ArgumentNullException(nameof(configure));
-            }
-
-            var builder = new MqttClientTlsOptionsBuilder();
-            configure.Invoke(builder);
-
-            _tlsOptions = builder.Build();
-            return this;
-        }
-
         public MqttClientOptionsBuilder WithTopicAliasMaximum(ushort topicAliasMaximum)
         {
             _options.TopicAliasMaximum = topicAliasMaximum;
@@ -420,7 +382,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        [Obsolete("Use WithWebSocketServer(... configure) instead.")]
         public MqttClientOptionsBuilder WithWebSocketServer(string uri, MqttClientOptionsBuilderWebSocketParameters parameters = null)
         {
             _webSocketOptions = new MqttClientWebSocketOptions
@@ -433,21 +394,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        public MqttClientOptionsBuilder WithWebSocketServer(Action<MqttClientWebSocketOptionsBuilder> configure)
-        {
-            if (configure == null)
-            {
-                throw new ArgumentNullException(nameof(configure));
-            }
-
-            var webSocketOptionsBuilder = new MqttClientWebSocketOptionsBuilder();
-            configure.Invoke(webSocketOptionsBuilder);
-
-            _webSocketOptions = webSocketOptionsBuilder.Build();
-            return this;
-        }
-
-        [Obsolete("Use WithWebSocketServer(... configure) instead.")]
         public MqttClientOptionsBuilder WithWebSocketServer(Action<MqttClientWebSocketOptions> optionsBuilder)
         {
             if (optionsBuilder == null)
@@ -479,12 +425,6 @@ namespace MQTTnet.Client
             return this;
         }
 
-        public MqttClientOptionsBuilder WithWillMessageExpiryInterval(uint willMessageExpiryInterval)
-        {
-            _options.WillMessageExpiryInterval = willMessageExpiryInterval;
-            return this;
-        }
-
         public MqttClientOptionsBuilder WithWillPayload(byte[] willPayload)
         {
             _options.WillPayload = willPayload;

Source/MQTTnet/Client/Options/MqttClientOptionsBuilderTlsParameters.cs

@@ -5,14 +5,12 @@
 using System;
 using System.Collections.Generic;
 using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
 
 namespace MQTTnet.Client
 {
-    [Obsolete("Use methods from MqttClientOptionsBuilder instead.")]
     public sealed class MqttClientOptionsBuilderTlsParameters
     {
-        IEnumerable<System.Security.Cryptography.X509Certificates.X509Certificate> _obsoleteCertificates;
-
         public bool UseTls { get; set; }
 
         public Func<MqttClientCertificateValidationEventArgs, bool> CertificateValidationHandler { get; set; }
@@ -26,24 +24,7 @@ namespace MQTTnet.Client
 #if WINDOWS_UWP
         public IEnumerable<IEnumerable<byte>> Certificates { get; set; }
 #else
-        [Obsolete("Use CertificatesProvider instead.")]
-        public IEnumerable<System.Security.Cryptography.X509Certificates.X509Certificate> Certificates
-        {
-            get => _obsoleteCertificates;
-            set
-            {
-                _obsoleteCertificates = value;
-
-                if (value == null)
-                {
-                    CertificatesProvider = null;
-                }
-                else
-                {
-                    CertificatesProvider = new DefaultMqttCertificatesProvider(value);
-                }
-            }
-        }
+        public IEnumerable<X509Certificate> Certificates { get; set; }
 #endif
 
 #if NETCOREAPP3_1_OR_GREATER
@@ -55,7 +36,5 @@ namespace MQTTnet.Client
         public bool IgnoreCertificateChainErrors { get; set; }
 
         public bool IgnoreCertificateRevocationErrors { get; set; }
-
-        public IMqttClientCertificatesProvider CertificatesProvider { get; set; }
     }
 }

Source/MQTTnet/Client/Options/MqttClientOptionsBuilderWebSocketParameters.cs

@@ -2,13 +2,11 @@
 // 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 System.Net;
 
 namespace MQTTnet.Client
 {
-    [Obsolete("Use dedicated methods in MqttClientOptionsBuilder.")]
     public class MqttClientOptionsBuilderWebSocketParameters
     {
         public IDictionary<string, string> RequestHeaders { get; set; }

Source/MQTTnet/Client/Options/MqttClientTcpOptionsExtensions.cs

@@ -17,7 +17,7 @@ namespace MQTTnet.Client
                 return options.Port.Value;
             }
 
-            return !(options.TlsOptions?.UseTls ?? false) ? 1883 : 8883;
+            return !options.TlsOptions.UseTls ? 1883 : 8883;
         }
     }
 }

Source/MQTTnet/Client/Options/MqttClientTlsOptions.cs

@@ -24,13 +24,11 @@ namespace MQTTnet.Client
 
         public X509RevocationMode RevocationMode { get; set; } = X509RevocationMode.Online;
 
-        /// <summary>
-        ///     Gets or sets the provider for certificates.
-        ///     This provider gets called whenever the client wants to connect
-        ///     with the server and requires certificates for authentication.
-        ///     The implementation may return different certificates each time.
-        /// </summary>
-        public IMqttClientCertificatesProvider ClientCertificatesProvider { get; set; }
+#if WINDOWS_UWP
+        public List<byte[]> Certificates { get; set; }
+#else
+        public List<X509Certificate> Certificates { get; set; }
+#endif
 
 #if NETCOREAPP3_1_OR_GREATER
         public List<SslApplicationProtocol> ApplicationProtocols { get; set; }
@@ -50,13 +48,8 @@ namespace MQTTnet.Client
 
 #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*/;
 #endif
-
-#if NET7_0_OR_GREATER
-        public X509Certificate2Collection TrustChain { get; set; }
-#endif
     }
 }

Source/MQTTnet/Client/Options/MqttClientTlsOptionsBuilder.cs

@@ -1,145 +0,0 @@
-// 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.Collections.Generic;
-using System.Security.Authentication;
-using System.Security.Cryptography.X509Certificates;
-#if NETCOREAPP3_1_OR_GREATER
-using System.Net.Security;
-#endif
-
-namespace MQTTnet.Client
-{
-    public sealed class MqttClientTlsOptionsBuilder
-    {
-        readonly MqttClientTlsOptions _tlsOptions = new MqttClientTlsOptions
-        {
-            // If someone used this builder the change is very very high that TLS
-            // should be actually used.
-            UseTls = true
-        };
-
-        public MqttClientTlsOptions Build()
-        {
-            return _tlsOptions;
-        }
-
-        public MqttClientTlsOptionsBuilder UseTls(bool useTls = true)
-        {
-            _tlsOptions.UseTls = useTls;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithAllowUntrustedCertificates(bool allowUntrustedCertificates = true)
-        {
-            _tlsOptions.AllowUntrustedCertificates = allowUntrustedCertificates;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithCertificateValidationHandler(Func<MqttClientCertificateValidationEventArgs, bool> certificateValidationHandler)
-        {
-            if (certificateValidationHandler == null)
-            {
-                throw new ArgumentNullException(nameof(certificateValidationHandler));
-            }
-
-            _tlsOptions.CertificateValidationHandler = certificateValidationHandler;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithClientCertificates(IEnumerable<X509Certificate2> certificates)
-        {
-            if (certificates == null)
-            {
-                throw new ArgumentNullException(nameof(certificates));
-            }
-
-            _tlsOptions.ClientCertificatesProvider = new DefaultMqttCertificatesProvider(certificates);
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithClientCertificates(X509Certificate2Collection certificates)
-        {
-            if (certificates == null)
-            {
-                throw new ArgumentNullException(nameof(certificates));
-            }
-
-            _tlsOptions.ClientCertificatesProvider = new DefaultMqttCertificatesProvider(certificates);
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithClientCertificatesProvider(IMqttClientCertificatesProvider clientCertificatesProvider)
-        {
-            _tlsOptions.ClientCertificatesProvider = clientCertificatesProvider;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithIgnoreCertificateChainErrors(bool ignoreCertificateChainErrors = true)
-        {
-            _tlsOptions.IgnoreCertificateChainErrors = ignoreCertificateChainErrors;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithIgnoreCertificateRevocationErrors(bool ignoreCertificateRevocationErrors = true)
-        {
-            _tlsOptions.IgnoreCertificateRevocationErrors = ignoreCertificateRevocationErrors;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithRevocationMode(X509RevocationMode revocationMode)
-        {
-            _tlsOptions.RevocationMode = revocationMode;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithSslProtocols(SslProtocols sslProtocols)
-        {
-            _tlsOptions.SslProtocol = sslProtocols;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithTargetHost(string targetHost)
-        {
-            _tlsOptions.TargetHost = targetHost;
-            return this;
-        }
-
-#if NETCOREAPP3_1_OR_GREATER
-        public MqttClientTlsOptionsBuilder WithAllowRenegotiation(bool allowRenegotiation = true)
-        {
-            _tlsOptions.AllowRenegotiation = allowRenegotiation;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithApplicationProtocols(List<SslApplicationProtocol> applicationProtocols)
-        {
-            _tlsOptions.ApplicationProtocols = applicationProtocols;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithCipherSuitesPolicy(CipherSuitesPolicy cipherSuitePolicy)
-        {
-            _tlsOptions.CipherSuitesPolicy = cipherSuitePolicy;
-            return this;
-        }
-
-        public MqttClientTlsOptionsBuilder WithCipherSuitesPolicy(EncryptionPolicy encryptionPolicy)
-        {
-            _tlsOptions.EncryptionPolicy = encryptionPolicy;
-            return this;
-        }
-#endif
-
-#if NET7_0_OR_GREATER
-        public MqttClientTlsOptionsBuilder WithTrustChain(X509Certificate2Collection chain)
-        {
-            _tlsOptions.TrustChain = chain;
-            return this;
-        }
-
-#endif
-    }
-}

Source/MQTTnet/Client/Options/MqttClientWebSocketOptionsBuilder.cs

@@ -1,85 +0,0 @@
-// 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.Collections.Generic;
-using System.Net;
-
-namespace MQTTnet.Client
-{
-    public sealed class MqttClientWebSocketOptionsBuilder
-    {
-        readonly MqttClientWebSocketOptions _webSocketOptions = new MqttClientWebSocketOptions();
-
-        public MqttClientWebSocketOptions Build()
-        {
-            return _webSocketOptions;
-        }
-
-        public MqttClientWebSocketOptionsBuilder WithCookieContainer(CookieContainer cookieContainer)
-        {
-            _webSocketOptions.CookieContainer = cookieContainer;
-            return this;
-        }
-
-        public MqttClientWebSocketOptionsBuilder WithCookieContainer(ICredentials credentials)
-        {
-            _webSocketOptions.Credentials = credentials;
-            return this;
-        }
-
-        public MqttClientWebSocketOptionsBuilder WithProxyOptions(MqttClientWebSocketProxyOptions proxyOptions)
-        {
-            _webSocketOptions.ProxyOptions = proxyOptions;
-            return this;
-        }
-
-        public MqttClientWebSocketOptionsBuilder WithProxyOptions(Action<MqttClientWebSocketProxyOptionsBuilder> configure)
-        {
-            if (configure == null)
-            {
-                throw new ArgumentNullException(nameof(configure));
-            }
-
-            var proxyOptionsBuilder = new MqttClientWebSocketProxyOptionsBuilder();
-            configure.Invoke(proxyOptionsBuilder);
-
-            _webSocketOptions.ProxyOptions = proxyOptionsBuilder.Build();
-            return this;
-        }
-
-        public MqttClientWebSocketOptionsBuilder WithRequestHeaders(IDictionary<string, string> requestHeaders)
-        {
-            _webSocketOptions.RequestHeaders = requestHeaders;
-            return this;
-        }
-
-        public MqttClientWebSocketOptionsBuilder WithSubProtocols(ICollection<string> subProtocols)
-        {
-            _webSocketOptions.SubProtocols = subProtocols;
-            return this;
-        }
-
-        public MqttClientWebSocketOptionsBuilder WithUri(string uri)
-        {
-            _webSocketOptions.Uri = uri;
-            return this;
-        }
-
-#if !NETSTANDARD1_3
-        public MqttClientWebSocketOptionsBuilder WithKeepAliveInterval(TimeSpan keepAliveInterval)
-        {
-            _webSocketOptions.KeepAliveInterval = keepAliveInterval;
-            return this;
-        }
-#endif
-#if !WINDOWS_UWP && !NETSTANDARD1_3
-        public MqttClientWebSocketOptionsBuilder WithUseDefaultCredentials(bool useDefaultCredentials = true)
-        {
-            _webSocketOptions.UseDefaultCredentials = useDefaultCredentials;
-            return this;
-        }
-#endif
-    }
-}

Source/MQTTnet/Client/Options/MqttClientWebSocketProxyOptionsBuilder.cs

@@ -1,67 +0,0 @@
-// 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.Collections.Generic;
-using System.Linq;
-
-namespace MQTTnet.Client
-{
-    public sealed class MqttClientWebSocketProxyOptionsBuilder
-    {
-        readonly MqttClientWebSocketProxyOptions _proxyOptions = new MqttClientWebSocketProxyOptions();
-
-        public MqttClientWebSocketProxyOptionsBuilder WithAddress(string address)
-        {
-            _proxyOptions.Address = address;
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptionsBuilder WithUsername(string username)
-        {
-            _proxyOptions.Username = username;
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptionsBuilder WithPassword(string password)
-        {
-            _proxyOptions.Password = password;
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptionsBuilder WithDomain(string domain)
-        {
-            _proxyOptions.Domain = domain;
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptionsBuilder WithBypassOnLocal(bool bypassOnLocal = true)
-        {
-            _proxyOptions.BypassOnLocal = bypassOnLocal;
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptionsBuilder WithBypassList(string[] bypassList)
-        {
-            _proxyOptions.BypassList = bypassList;
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptionsBuilder WithBypassList(IEnumerable<string> bypassList)
-        {
-            _proxyOptions.BypassList = bypassList?.ToArray();
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptionsBuilder WithUseDefaultCredentials(bool useDefaultCredentials = true)
-        {
-            _proxyOptions.UseDefaultCredentials = useDefaultCredentials;
-            return this;
-        }
-        
-        public MqttClientWebSocketProxyOptions Build()
-        {
-            return _proxyOptions;
-        }
-    }
-}

Source/MQTTnet/Client/Receiving/MqttApplicationMessageReceivedEventArgs.cs

@@ -77,7 +77,7 @@ namespace MQTTnet.Client
 
         internal MqttPublishPacket PublishPacket { get; set; }
 
-        public Task AcknowledgeAsync(CancellationToken cancellationToken)
+        public Task AcknowledgeAsync(CancellationToken cancellationToken = default)
         {
             if (_acknowledgeHandler == null)
             {

Source/MQTTnet/Formatter/MqttDisconnectPacketFactory.cs

@@ -5,107 +5,45 @@
 using MQTTnet.Client;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server;
-using MQTTnet.Server.Disconnecting;
 
 namespace MQTTnet.Formatter
 {
     public sealed class MqttDisconnectPacketFactory
     {
-        static readonly MqttDisconnectPacket DefaultNormalDisconnection = new MqttDisconnectPacket
+        readonly MqttDisconnectPacket _normalDisconnection = new MqttDisconnectPacket
         {
-            ReasonCode = MqttDisconnectReasonCode.NormalDisconnection,
-            UserProperties = null,
-            ReasonString = null,
-            ServerReference = null,
-            SessionExpiryInterval = 0
-        };
-
-        static readonly MqttDisconnectPacket DefaultServerShuttingDown = new MqttDisconnectPacket
-        {
-            ReasonCode = MqttDisconnectReasonCode.ServerShuttingDown,
-            UserProperties = null,
-            ReasonString = null,
-            ServerReference = null,
-            SessionExpiryInterval = 0
-        };
-
-        static readonly MqttDisconnectPacket DefaultUnspecifiedError = new MqttDisconnectPacket
-        {
-            ReasonCode = MqttDisconnectReasonCode.UnspecifiedError,
-            UserProperties = null,
-            ReasonString = null,
-            ServerReference = null,
-            SessionExpiryInterval = 0
+            ReasonCode = MqttDisconnectReasonCode.NormalDisconnection
         };
 
         public MqttDisconnectPacket Create(MqttDisconnectReasonCode reasonCode)
         {
             if (reasonCode == MqttDisconnectReasonCode.NormalDisconnection)
             {
-                return DefaultNormalDisconnection;
-            }
-
-            if (reasonCode == MqttDisconnectReasonCode.ServerShuttingDown)
-            {
-                return DefaultServerShuttingDown;
-            }
-
-            if (reasonCode == MqttDisconnectReasonCode.UnspecifiedError)
-            {
-                return DefaultUnspecifiedError;
+                return _normalDisconnection;
             }
 
             return new MqttDisconnectPacket
             {
-                ReasonCode = reasonCode,
-                UserProperties = null,
-                ReasonString = null,
-                ServerReference = null,
-                SessionExpiryInterval = 0
-            };
-        }
-
-        public MqttDisconnectPacket Create(MqttServerStopOptions serverStopOptions)
-        {
-            if (serverStopOptions == null)
-            {
-                return DefaultServerShuttingDown;
-            }
-
-            return Create(serverStopOptions.DefaultClientDisconnectOptions);
-        }
-
-        public MqttDisconnectPacket Create(MqttServerClientDisconnectOptions clientDisconnectOptions)
-        {
-            if (clientDisconnectOptions == null)
-            {
-                return DefaultNormalDisconnection;
-            }
-
-            return new MqttDisconnectPacket
-            {
-                ReasonCode = clientDisconnectOptions.ReasonCode,
-                UserProperties = clientDisconnectOptions.UserProperties,
-                ReasonString = clientDisconnectOptions.ReasonString,
-                ServerReference = clientDisconnectOptions.ServerReference,
-                SessionExpiryInterval = 0 // TODO: Not yet supported!
+                ReasonCode = reasonCode
             };
         }
 
         public MqttDisconnectPacket Create(MqttClientDisconnectOptions clientDisconnectOptions)
         {
+            var packet = new MqttDisconnectPacket();
+
             if (clientDisconnectOptions == null)
             {
-                return DefaultNormalDisconnection;
+                packet.ReasonCode = MqttDisconnectReasonCode.NormalDisconnection;
+            }
+            else
+            {
+                packet.ReasonCode = (MqttDisconnectReasonCode)clientDisconnectOptions.Reason;
+                packet.UserProperties = clientDisconnectOptions.UserProperties;
+                packet.SessionExpiryInterval = clientDisconnectOptions.SessionExpiryInterval;
             }
 
-            return new MqttDisconnectPacket
-            {
-                ReasonCode = (MqttDisconnectReasonCode)clientDisconnectOptions.Reason,
-                UserProperties = clientDisconnectOptions.UserProperties,
-                SessionExpiryInterval = clientDisconnectOptions.SessionExpiryInterval
-            };
+            return packet;
         }
     }
 }

Source/MQTTnet/Implementations/MqttTcpChannel.Uwp.cs

@@ -6,6 +6,8 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Runtime.InteropServices.WindowsRuntime;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
@@ -16,7 +18,6 @@ using Windows.Security.Cryptography.Certificates;
 using MQTTnet.Channel;
 using MQTTnet.Client;
 using MQTTnet.Server;
-using System.Runtime.InteropServices.WindowsRuntime;
 
 namespace MQTTnet.Implementations
 {
@@ -125,19 +126,17 @@ namespace MQTTnet.Implementations
 
         private static Certificate LoadCertificate(IMqttClientChannelOptions options)
         {
-            var certificates = options.TlsOptions?.ClientCertificatesProvider?.GetCertificates();
-
-            if (certificates == null || certificates.Count == 0)
+            if (options.TlsOptions.Certificates == null || !options.TlsOptions.Certificates.Any())
             {
                 return null;
             }
 
-            if (certificates.Count > 1)
+            if (options.TlsOptions.Certificates.Count > 1)
             {
                 throw new NotSupportedException("Only one client certificate is supported when using 'uap10.0'.");
             }
 
-            return new Certificate(certificates[0].Export(X509ContentType.Cert).AsBuffer());
+            return new Certificate(options.TlsOptions.Certificates.First().AsBuffer());
         }
 
         private IEnumerable<ChainValidationResult> ResolveIgnorableServerCertificateErrors()

Source/MQTTnet/Implementations/MqttTcpChannel.cs

@@ -3,6 +3,9 @@
 // See the LICENSE file in the project root for more information.
 
 #if !WINDOWS_UWP
+using MQTTnet.Channel;
+using MQTTnet.Client;
+using MQTTnet.Exceptions;
 using System;
 using System.IO;
 using System.Net.Security;
@@ -11,9 +14,6 @@ using System.Runtime.ExceptionServices;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading;
 using System.Threading.Tasks;
-using MQTTnet.Channel;
-using MQTTnet.Client;
-using MQTTnet.Exceptions;
 using MQTTnet.Internal;
 
 namespace MQTTnet.Implementations
@@ -73,7 +73,7 @@ namespace MQTTnet.Implementations
                 {
                     socket.Bind(_tcpOptions.LocalEndpoint);
                 }
-
+                
                 socket.ReceiveBufferSize = _tcpOptions.BufferSize;
                 socket.SendBufferSize = _tcpOptions.BufferSize;
                 socket.SendTimeout = (int)_clientOptions.Timeout.TotalMilliseconds;
@@ -105,7 +105,7 @@ namespace MQTTnet.Implementations
                     {
                         targetHost = _tcpOptions.Server;
                     }
-
+                    
                     var sslStream = new SslStream(networkStream, false, InternalUserCertificateValidationCallback);
                     try
                     {
@@ -115,31 +115,14 @@ namespace MQTTnet.Implementations
                             ApplicationProtocols = _tcpOptions.TlsOptions.ApplicationProtocols,
                             ClientCertificates = LoadCertificates(),
                             EnabledSslProtocols = _tcpOptions.TlsOptions.SslProtocol,
-                            CertificateRevocationCheckMode = _tcpOptions.TlsOptions.IgnoreCertificateRevocationErrors
-                                ? X509RevocationMode.NoCheck
-                                : _tcpOptions.TlsOptions.RevocationMode,
+                            CertificateRevocationCheckMode =
+ _tcpOptions.TlsOptions.IgnoreCertificateRevocationErrors ? X509RevocationMode.NoCheck : _tcpOptions.TlsOptions.RevocationMode,
                             TargetHost = targetHost,
                             CipherSuitesPolicy = _tcpOptions.TlsOptions.CipherSuitesPolicy,
                             EncryptionPolicy = _tcpOptions.TlsOptions.EncryptionPolicy,
                             AllowRenegotiation = _tcpOptions.TlsOptions.AllowRenegotiation
                         };
 
-#if NET7_0_OR_GREATER
-                        if (_tcpOptions.TlsOptions.TrustChain?.Count > 0)
-                        {
-                            sslOptions.CertificateChainPolicy = new X509ChainPolicy
-                            {
-                                TrustMode = X509ChainTrustMode.CustomRootTrust,
-                                VerificationFlags = X509VerificationFlags.IgnoreEndRevocationUnknown,
-                                RevocationMode = _tcpOptions.TlsOptions.IgnoreCertificateRevocationErrors
-                                    ? X509RevocationMode.NoCheck
-                                    : _tcpOptions.TlsOptions.RevocationMode
-                            };
-
-                            sslOptions.CertificateChainPolicy.CustomTrustStore.AddRange(_tcpOptions.TlsOptions.TrustChain);
-                        }
-#endif
-
                         await sslStream.AuthenticateAsClientAsync(sslOptions, cancellationToken).ConfigureAwait(false);
 #else
                         await sslStream.AuthenticateAsClientAsync(
@@ -315,7 +298,18 @@ namespace MQTTnet.Implementations
 
         X509CertificateCollection LoadCertificates()
         {
-            return _tcpOptions.TlsOptions.ClientCertificatesProvider?.GetCertificates();
+            if (_tcpOptions.TlsOptions.Certificates == null)
+            {
+                return null;
+            }
+
+            var certificates = new X509CertificateCollection();
+            foreach (var certificate in _tcpOptions.TlsOptions.Certificates)
+            {
+                certificates.Add(certificate);
+            }
+
+            return certificates;
         }
     }
 }

Source/MQTTnet/Implementations/MqttWebSocketChannel.cs

@@ -46,13 +46,13 @@ namespace MQTTnet.Implementations
             var uri = _options.Uri;
             if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
             {
-                if (_options.TlsOptions?.UseTls == true)
+                if (_options.TlsOptions?.UseTls == false)
                 {
-                    uri = "wss://" + uri;
+                    uri = "ws://" + uri;
                 }
                 else
                 {
-                    uri = "ws://" + uri;
+                    uri = "wss://" + uri;
                 }
             }
 
@@ -206,12 +206,16 @@ namespace MQTTnet.Implementations
                 clientWebSocket.Options.Cookies = _options.CookieContainer;
             }
 
-            if (_options.TlsOptions?.UseTls == true)
+            if (_options.TlsOptions?.UseTls == true && _options.TlsOptions?.Certificates != null)
             {
-                var certificates = _options.TlsOptions?.ClientCertificatesProvider?.GetCertificates();
-                if (certificates?.Count > 0)
+                clientWebSocket.Options.ClientCertificates = new X509CertificateCollection();
+                foreach (var certificate in _options.TlsOptions.Certificates)
                 {
-                    clientWebSocket.Options.ClientCertificates = certificates;
+#if WINDOWS_UWP
+                    clientWebSocket.Options.ClientCertificates.Add(new X509Certificate(certificate));
+#else
+                    clientWebSocket.Options.ClientCertificates.Add(certificate);
+#endif
                 }
             }
 
@@ -244,20 +248,12 @@ namespace MQTTnet.Implementations
                 throw new NotSupportedException("Remote certificate validation callback is not supported when using 'netstandard2.0'.");
 #elif WINDOWS_UWP
                 throw new NotSupportedException("Remote certificate validation callback is not supported when using 'uap10.0'.");
-#elif NET452 || NET461 || NET48
-                ServicePointManager.ServerCertificateValidationCallback += (sender, certificate, chain, sslPolicyErrors) => 
-                {
-                    var context = new MqttClientCertificateValidationEventArgs
-                    {
-                        Sender = sender,
-                        Certificate = certificate,
-                        Chain = chain,
-                        SslPolicyErrors = sslPolicyErrors,
-                        ClientOptions = _options
-                    };
-
-                    return certificateValidationHandler(context);
-                };
+#elif NET452
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'net452'.");
+#elif NET461
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'net461'.");
+#elif NET48
+                throw new NotSupportedException("Remote certificate validation callback is not supported when using 'net48'.");
 #else
                 clientWebSocket.Options.RemoteCertificateValidationCallback = (sender, certificate, chain, sslPolicyErrors) =>
                 {
@@ -276,4 +272,4 @@ namespace MQTTnet.Implementations
             }
         }
     }
-}
+}

Source/MQTTnet/Internal/MqttPacketBus.cs

@@ -104,22 +104,17 @@ namespace MQTTnet.Internal
             _signal.Dispose();
         }
 
-        public MqttPacketBusItem DropFirstItem(MqttPacketBusPartition partition)
+        public void DropFirstItem(MqttPacketBusPartition partition)
         {
             lock (_syncRoot)
             {
                 var partitionInstance = _partitions[(int)partition];
 
-                if (partitionInstance.Count > 0)
+                if (partitionInstance.Any())
                 {
-                    var firstItem = partitionInstance.First.Value;
                     partitionInstance.RemoveFirst();
-
-                    return firstItem;
                 }
             }
-
-            return null;
         }
 
         public void EnqueueItem(MqttPacketBusItem item, MqttPacketBusPartition partition)

Source/MQTTnet/LowLevelClient/LowLevelMqttClient.cs

@@ -19,6 +19,7 @@ namespace MQTTnet.LowLevelClient
         readonly IMqttClientAdapterFactory _clientAdapterFactory;
         readonly AsyncEvent<InspectMqttPacketEventArgs> _inspectPacketEvent = new AsyncEvent<InspectMqttPacketEventArgs>();
         readonly MqttNetSourceLogger _logger;
+
         readonly IMqttNetLogger _rootLogger;
 
         IMqttChannelAdapter _adapter;

Source/MQTTnet/MQTTnet.csproj.DotSettings

@@ -17,5 +17,4 @@
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=server_005Cmanagement/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=server_005Coptions/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=server_005Cstatus/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=server_005Cstopping/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=server_005Cstorage/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

Source/MQTTnet/MqttFactory.cs

@@ -11,7 +11,6 @@ using MQTTnet.Diagnostics;
 using MQTTnet.Implementations;
 using MQTTnet.LowLevelClient;
 using MQTTnet.Server;
-using MQTTnet.Server.Disconnecting;
 using MqttClient = MQTTnet.Client.MqttClient;
 
 namespace MQTTnet
@@ -176,16 +175,6 @@ namespace MQTTnet
             return new MqttServer(options, serverAdapters, DefaultLogger);
         }
 
-        public MqttServerClientDisconnectOptionsBuilder CreateMqttServerClientDisconnectOptionsBuilder()
-        {
-            return new MqttServerClientDisconnectOptionsBuilder();
-        }
-
-        public MqttServerStopOptionsBuilder CreateMqttServerStopOptionsBuilder()
-        {
-            return new MqttServerStopOptionsBuilder();
-        }
-
         public MqttServerOptionsBuilder CreateServerOptionsBuilder()
         {
             return new MqttServerOptionsBuilder();

Source/MQTTnet/Server/Disconnecting/MqttServerClientDisconnectOptions.cs

@@ -1,33 +0,0 @@
-// 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.Collections.Generic;
-using MQTTnet.Packets;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Server.Disconnecting
-{
-    public sealed class MqttServerClientDisconnectOptions
-    {
-        public MqttDisconnectReasonCode ReasonCode { get; set; } = MqttDisconnectReasonCode.NormalDisconnection;
-
-        /// <summary>
-        ///     The reason string is sent to every client via a DISCONNECT packet.
-        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
-        /// </summary>
-        public string ReasonString { get; set; }
-
-        /// <summary>
-        ///     The server reference is sent to every client via a DISCONNECT packet.
-        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
-        /// </summary>
-        public string ServerReference { get; set; }
-
-        /// <summary>
-        ///     These user properties are sent to every client via a DISCONNECT packet.
-        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
-        /// </summary>
-        public List<MqttUserProperty> UserProperties { get; set; }
-    }
-}

Source/MQTTnet/Server/Disconnecting/MqttServerClientDisconnectOptionsBuilder.cs

@@ -1,55 +0,0 @@
-// 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.Collections.Generic;
-using MQTTnet.Packets;
-using MQTTnet.Protocol;
-
-namespace MQTTnet.Server.Disconnecting
-{
-    public sealed class MqttServerClientDisconnectOptionsBuilder
-    {
-        readonly MqttServerClientDisconnectOptions _options = new MqttServerClientDisconnectOptions();
-
-        public MqttServerClientDisconnectOptions Build()
-        {
-            return _options;
-        }
-
-        public MqttServerClientDisconnectOptionsBuilder WithReasonCode(MqttDisconnectReasonCode value)
-        {
-            _options.ReasonCode = value;
-            return this;
-        }
-
-        public MqttServerClientDisconnectOptionsBuilder WithReasonString(string value)
-        {
-            _options.ReasonString = value;
-            return this;
-        }
-
-        public MqttServerClientDisconnectOptionsBuilder WithServerReference(string value)
-        {
-            _options.ServerReference = value;
-            return this;
-        }
-
-        public MqttServerClientDisconnectOptionsBuilder WithUserProperties(List<MqttUserProperty> value)
-        {
-            _options.UserProperties = value;
-            return this;
-        }
-
-        public MqttServerClientDisconnectOptionsBuilder WithUserProperty(string name, string value)
-        {
-            if (_options.UserProperties == null)
-            {
-                _options.UserProperties = new List<MqttUserProperty>();
-            }
-
-            _options.UserProperties.Add(new MqttUserProperty(name, value));
-            return this;
-        }
-    }
-}

Source/MQTTnet/Server/Events/ApplicationMessageEnqueuedEventArgs.cs

@@ -1,27 +0,0 @@
-// 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;
-
-namespace MQTTnet.Server
-{
-    public sealed class ApplicationMessageEnqueuedEventArgs : EventArgs
-    {
-        public ApplicationMessageEnqueuedEventArgs(string senderClientId, string receiverClientId, MqttApplicationMessage applicationMessage, bool isDropped)
-        {
-            SenderClientId = senderClientId ?? throw new ArgumentNullException( nameof(senderClientId));
-            ReceiverClientId = receiverClientId ?? throw new ArgumentNullException(nameof(receiverClientId));
-            ApplicationMessage = applicationMessage ?? throw new ArgumentNullException(nameof(applicationMessage));
-            IsDropped = isDropped;
-        }
-
-        public string SenderClientId { get; }
-
-        public string ReceiverClientId { get; }
-
-        public bool IsDropped { get; }
-
-        public MqttApplicationMessage ApplicationMessage { get; }
-    }
-}

Source/MQTTnet/Server/Events/QueueMessageOverwrittenEventArgs.cs

@@ -1,22 +0,0 @@
-// 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 MQTTnet.Packets;
-
-namespace MQTTnet.Server
-{
-    public sealed class QueueMessageOverwrittenEventArgs : EventArgs
-    {
-        public QueueMessageOverwrittenEventArgs(string receiverClientId, MqttPacket packet)
-        {
-            ReceiverClientId = receiverClientId ?? throw new ArgumentNullException(nameof(receiverClientId));
-            Packet = packet ?? throw new ArgumentNullException(nameof(packet));
-        }
-
-        public MqttPacket Packet { get; }
-
-        public string ReceiverClientId { get; }
-    }
-}

Source/MQTTnet/Server/Internal/EnqueueDataPacketResult.cs

@@ -1,12 +0,0 @@
-// 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.Server
-{
-    public enum EnqueueDataPacketResult
-    {
-        Enqueued,
-        Dropped
-    }
-}

Source/MQTTnet/Server/Internal/MqttClient.cs

@@ -4,7 +4,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
@@ -15,7 +14,6 @@ using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server.Disconnecting;
 
 namespace MQTTnet.Server
 {
@@ -97,16 +95,15 @@ namespace MQTTnet.Server
             {
                 var cancellationToken = _cancellationToken.Token;
                 IsRunning = true;
-
-                _ = Task.Factory.StartNew(() => SendPacketsLoop(cancellationToken), cancellationToken, TaskCreationOptions.PreferFairness, TaskScheduler.Default)
-                    .ConfigureAwait(false);
+                
+                _ = Task.Factory.StartNew(() => SendPacketsLoop(cancellationToken), cancellationToken, TaskCreationOptions.PreferFairness, TaskScheduler.Default).ConfigureAwait(false);
 
                 await ReceivePackagesLoop(cancellationToken).ConfigureAwait(false);
             }
             finally
             {
                 IsRunning = false;
-
+                
                 Session.DisconnectedTimestamp = DateTime.UtcNow;
 
                 _cancellationToken?.TryCancel();
@@ -144,7 +141,7 @@ namespace MQTTnet.Server
             Statistics.HandleSentPacket(packet);
         }
 
-        public async Task StopAsync(MqttServerClientDisconnectOptions disconnectOptions)
+        public async Task StopAsync(MqttDisconnectReasonCode reason)
         {
             IsRunning = false;
 
@@ -153,20 +150,16 @@ namespace MQTTnet.Server
                 // Sending DISCONNECT packets from the server to the client is only supported when using MQTTv5+.
                 if (ChannelAdapter.PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.V500)
                 {
-                    // From RFC: The Client or Server MAY send a DISCONNECT packet before closing the Network Connection.
-                    // This library does not sent a DISCONNECT packet for a normal disconnection.
-                    // TODO: Maybe adding a configuration option is requested in the future.
-                    if (disconnectOptions != null)
+                    // The Client or Server MAY send a DISCONNECT packet before closing the Network Connection.
+                    // This library does not sent a DISCONNECT packet for a normal disconnection. Maybe adding
+                    // a configuration option is requested in the future.
+                    if (reason != MqttDisconnectReasonCode.NormalDisconnection)
                     {
-                        if (disconnectOptions.ReasonCode != MqttDisconnectReasonCode.NormalDisconnection || disconnectOptions.UserProperties?.Any() == true ||
-                            !string.IsNullOrEmpty(disconnectOptions.ReasonString) || !string.IsNullOrEmpty(disconnectOptions.ServerReference))
-                        {
-                            // Is is very important to send the DISCONNECT packet here BEFORE cancelling the
-                            // token because the entire connection is closed (disposed) as soon as the cancellation
-                            // token is cancelled. To there is no chance that the DISCONNECT packet will ever arrive
-                            // at the client!
-                            await TrySendDisconnectPacket(disconnectOptions).ConfigureAwait(false);
-                        }
+                        // Is is very important to send the DISCONNECT packet here BEFORE cancelling the
+                        // token because the entire connection is closed (disposed) as soon as the cancellation
+                        // token is cancelled. To there is no chance that the DISCONNECT packet will ever arrive
+                        // at the client!
+                        await TrySendDisconnectPacket(reason).ConfigureAwait(false);
                     }
                 }
             }
@@ -226,7 +219,7 @@ namespace MQTTnet.Server
 
             if (dispatchApplicationMessageResult.CloseConnection)
             {
-                await StopAsync(new MqttServerClientDisconnectOptions { ReasonCode = MqttDisconnectReasonCode.UnspecifiedError });
+                await StopAsync(MqttDisconnectReasonCode.UnspecifiedError);
                 return;
             }
 
@@ -557,14 +550,14 @@ namespace MQTTnet.Server
             _cancellationToken?.TryCancel();
         }
 
-        async Task TrySendDisconnectPacket(MqttServerClientDisconnectOptions options)
+        async Task TrySendDisconnectPacket(MqttDisconnectReasonCode reasonCode)
         {
             try
             {
                 // This also indicates that it was tried at least!
                 _disconnectPacketSent = true;
 
-                var disconnectPacket = MqttPacketFactories.Disconnect.Create(options);
+                var disconnectPacket = MqttPacketFactories.Disconnect.Create(reasonCode);
 
                 using (var timeout = new CancellationTokenSource(_serverOptions.DefaultCommunicationTimeout))
                 {
@@ -573,7 +566,7 @@ namespace MQTTnet.Server
             }
             catch (Exception exception)
             {
-                _logger.Warning(exception, "Client '{0}': Error while sending DISCONNECT packet (ReasonCode = {1})", Id, options.ReasonCode);
+                _logger.Warning(exception, "Client '{0}': Error while sending DISCONNECT packet (ReasonCode = {1})", Id, reasonCode);
             }
         }
     }

Source/MQTTnet/Server/Internal/MqttClientSessionsManager.cs

@@ -16,7 +16,6 @@ using MQTTnet.Formatter;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server.Disconnecting;
 
 namespace MQTTnet.Server
 {
@@ -33,11 +32,11 @@ namespace MQTTnet.Server
         readonly MqttRetainedMessagesManager _retainedMessagesManager;
         readonly IMqttNetLogger _rootLogger;
 
-        readonly ReaderWriterLockSlim _sessionsManagementLock = new ReaderWriterLockSlim();
-
         // The _sessions dictionary contains all session, the _subscriberSessions hash set contains subscriber sessions only.
         // See the MqttSubscription object for a detailed explanation.
         readonly MqttSessionsStorage _sessionsStorage = new MqttSessionsStorage();
+
+        readonly ReaderWriterLockSlim _sessionsManagementLock = new ReaderWriterLockSlim();
         readonly HashSet<MqttSession> _subscriberSessions = new HashSet<MqttSession>();
 
         public MqttClientSessionsManager(
@@ -59,13 +58,8 @@ namespace MQTTnet.Server
             _eventContainer = eventContainer ?? throw new ArgumentNullException(nameof(eventContainer));
         }
 
-        public async Task CloseAllConnections(MqttServerClientDisconnectOptions options)
+        public async Task CloseAllConnections()
         {
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-
             List<MqttClient> connections;
             lock (_clients)
             {
@@ -75,7 +69,7 @@ namespace MQTTnet.Server
 
             foreach (var connection in connections)
             {
-                await connection.StopAsync(options).ConfigureAwait(false);
+                await connection.StopAsync(MqttDisconnectReasonCode.NormalDisconnection).ConfigureAwait(false);
             }
         }
 
@@ -107,7 +101,7 @@ namespace MQTTnet.Server
             {
                 if (connection != null)
                 {
-                    await connection.StopAsync(new MqttServerClientDisconnectOptions { ReasonCode = MqttDisconnectReasonCode.NormalDisconnection }).ConfigureAwait(false);
+                    await connection.StopAsync(MqttDisconnectReasonCode.NormalDisconnection).ConfigureAwait(false);
                 }
             }
             catch (Exception exception)
@@ -210,7 +204,7 @@ namespace MQTTnet.Server
                         {
                             continue;
                         }
-
+                        
                         if (_eventContainer.InterceptingClientEnqueueEvent.HasHandlers)
                         {
                             var eventArgs = new InterceptingClientApplicationMessageEnqueueEventArgs(senderId, session.Id, applicationMessage);
@@ -244,14 +238,7 @@ namespace MQTTnet.Server
 
                         matchingSubscribersCount++;
 
-                        var result = session.EnqueueDataPacket(new MqttPacketBusItem(publishPacketCopy));
-
-                        if (_eventContainer.ApplicationMessageEnqueuedOrDroppedEvent.HasHandlers)
-                        {
-                            var eventArgs = new ApplicationMessageEnqueuedEventArgs(senderId, session.Id, applicationMessage, result == EnqueueDataPacketResult.Dropped);
-                            await _eventContainer.ApplicationMessageEnqueuedOrDroppedEvent.InvokeAsync(eventArgs).ConfigureAwait(false);
-                        }
-
+                        session.EnqueueDataPacket(new MqttPacketBusItem(publishPacketCopy));
                         _logger.Verbose("Client '{0}': Queued PUBLISH packet with topic '{1}'", session.Id, applicationMessage.Topic);
                     }
 
@@ -379,8 +366,7 @@ namespace MQTTnet.Server
 
                 if (_eventContainer.ClientConnectedEvent.HasHandlers)
                 {
-                    var eventArgs = new ClientConnectedEventArgs(
-                        connectPacket,
+                    var eventArgs = new ClientConnectedEventArgs(connectPacket,
                         channelAdapter.PacketFormatterAdapter.ProtocolVersion,
                         channelAdapter.Endpoint,
                         client.Session.Items);
@@ -609,13 +595,13 @@ namespace MQTTnet.Server
                             session.IsPersistent = sessionShouldPersist;
                             session.DisconnectedTimestamp = null;
                             session.Recover();
-
+                            
                             connAckPacket.IsSessionPresent = true;
                         }
                     }
 
                     _sessionsStorage.UpdateSession(connectPacket.ClientId, session);
-
+                    
                     // Create a new client (always required).
                     lock (_clients)
                     {
@@ -645,8 +631,7 @@ namespace MQTTnet.Server
 
                 if (oldClient != null)
                 {
-                    // TODO: Consider event here for session takeover to allow manipulation of user properties etc.
-                    await oldClient.StopAsync(new MqttServerClientDisconnectOptions { ReasonCode = MqttDisconnectReasonCode.SessionTakenOver }).ConfigureAwait(false);
+                    await oldClient.StopAsync(MqttDisconnectReasonCode.SessionTakenOver).ConfigureAwait(false);
 
                     if (_eventContainer.ClientDisconnectedEvent.HasHandlers)
                     {
@@ -749,4 +734,4 @@ namespace MQTTnet.Server
             return eventArgs;
         }
     }
-}
+}

Source/MQTTnet/Server/Internal/MqttClientStatistics.cs

@@ -92,7 +92,7 @@ namespace MQTTnet.Server
             }
         }
 
-        struct Statistics
+        private struct Statistics
         {
             public long _receivedPacketsCount;
             public long _sentPacketsCount;

Source/MQTTnet/Server/Internal/MqttServerEventContainer.cs

@@ -22,10 +22,6 @@ namespace MQTTnet.Server
         public AsyncEvent<ClientUnsubscribedTopicEventArgs> ClientUnsubscribedTopicEvent { get; } = new AsyncEvent<ClientUnsubscribedTopicEventArgs>();
 
         public AsyncEvent<InterceptingClientApplicationMessageEnqueueEventArgs> InterceptingClientEnqueueEvent { get; } = new AsyncEvent<InterceptingClientApplicationMessageEnqueueEventArgs>();
-        
-        public AsyncEvent<ApplicationMessageEnqueuedEventArgs> ApplicationMessageEnqueuedOrDroppedEvent { get; } = new AsyncEvent<ApplicationMessageEnqueuedEventArgs>();
-
-        public AsyncEvent<QueueMessageOverwrittenEventArgs> QueuedApplicationMessageOverwrittenEvent { get; } = new AsyncEvent<QueueMessageOverwrittenEventArgs>();
 
         public AsyncEvent<InterceptingPacketEventArgs> InterceptingInboundPacketEvent { get; } = new AsyncEvent<InterceptingPacketEventArgs>();
 

Source/MQTTnet/Server/Internal/MqttServerKeepAliveMonitor.cs

@@ -8,20 +8,11 @@ using System.Threading.Tasks;
 using MQTTnet.Diagnostics;
 using MQTTnet.Internal;
 using MQTTnet.Protocol;
-using MQTTnet.Server.Disconnecting;
 
 namespace MQTTnet.Server
 {
     public sealed class MqttServerKeepAliveMonitor
     {
-        static readonly MqttServerClientDisconnectOptions DefaultDisconnectOptions = new MqttServerClientDisconnectOptions
-        {
-            ReasonCode = MqttDisconnectReasonCode.KeepAliveTimeout,
-            UserProperties = null,
-            ReasonString = null,
-            ServerReference = null
-        };
-
         readonly MqttNetSourceLogger _logger;
         readonly MqttServerOptions _options;
         readonly MqttClientSessionsManager _sessionsManager;
@@ -52,7 +43,7 @@ namespace MQTTnet.Server
         {
             try
             {
-                _logger.Info("Starting keep alive monitor");
+                _logger.Info("Starting keep alive monitor.");
 
                 while (!cancellationToken.IsCancellationRequested)
                 {
@@ -65,11 +56,11 @@ namespace MQTTnet.Server
             }
             catch (Exception exception)
             {
-                _logger.Error(exception, "Unhandled exception while checking keep alive timeouts");
+                _logger.Error(exception, "Unhandled exception while checking keep alive timeouts.");
             }
             finally
             {
-                _logger.Verbose("Stopped checking keep alive timeout");
+                _logger.Verbose("Stopped checking keep alive timeout.");
             }
         }
 
@@ -107,6 +98,13 @@ namespace MQTTnet.Server
                     return;
                 }
 
+                if (connection.ChannelAdapter.IsReadingPacket)
+                {
+                    // The connection is currently reading a (large) packet. So it is obviously 
+                    // doing something and thus "connected".
+                    return;
+                }
+
                 // Values described here: [MQTT-3.1.2-24].
                 // If the client sends 5 sec. the server will allow up to 7.5 seconds.
                 // If the client sends 1 sec. the server will allow up to 1.5 seconds.
@@ -119,18 +117,18 @@ namespace MQTTnet.Server
                     return;
                 }
 
-                _logger.Warning("Client '{0}': Did not receive any packet or keep alive signal", connection.Id);
+                _logger.Warning("Client '{0}': Did not receive any packet or keep alive signal.", connection.Id);
 
                 // Execute the disconnection in background so that the keep alive monitor can continue
                 // with checking other connections.
                 // We do not need to wait for the task so no await is needed.
                 // Also the internal state of the connection must be swapped to "Finalizing" because the
                 // next iteration of the keep alive timer happens.
-                _ = connection.StopAsync(DefaultDisconnectOptions);
+                var _ = connection.StopAsync(MqttDisconnectReasonCode.KeepAliveTimeout);
             }
             catch (Exception exception)
             {
-                _logger.Error(exception, "Client {0}: Unhandled exception while checking keep alive timeouts", connection.Id);
+                _logger.Error(exception, "Client {0}: Unhandled exception while checking keep alive timeouts.", connection.Id);
             }
         }
 

Source/MQTTnet/Server/Internal/MqttSession.cs

@@ -18,7 +18,6 @@ namespace MQTTnet.Server
     public sealed class MqttSession : IDisposable
     {
         readonly MqttClientSessionsManager _clientSessionsManager;
-        readonly MqttServerEventContainer _eventContainer;
         readonly MqttPacketBus _packetBus = new MqttPacketBus();
         readonly MqttPacketIdentifierProvider _packetIdentifierProvider = new MqttPacketIdentifierProvider();
 
@@ -45,7 +44,6 @@ namespace MQTTnet.Server
             _connectPacket = connectPacket ?? throw new ArgumentNullException(nameof(connectPacket));
             _serverOptions = serverOptions ?? throw new ArgumentNullException(nameof(serverOptions));
             _clientSessionsManager = clientSessionsManager ?? throw new ArgumentNullException(nameof(clientSessionsManager));
-            _eventContainer = eventContainer ?? throw new ArgumentNullException(nameof(eventContainer));
 
             _subscriptionsManager = new MqttClientSubscriptionsManager(this, eventContainer, retainedMessagesManager, clientSessionsManager);
         }
@@ -119,25 +117,20 @@ namespace MQTTnet.Server
             _packetBus.EnqueueItem(packetBusItem, MqttPacketBusPartition.Control);
         }
 
-        public EnqueueDataPacketResult EnqueueDataPacket(MqttPacketBusItem packetBusItem)
+        public void EnqueueDataPacket(MqttPacketBusItem packetBusItem)
         {
             if (_packetBus.ItemsCount(MqttPacketBusPartition.Data) >= _serverOptions.MaxPendingMessagesPerClient)
             {
                 if (_serverOptions.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropNewMessage)
                 {
-                    return EnqueueDataPacketResult.Dropped;
+                    return;
                 }
 
                 if (_serverOptions.PendingMessagesOverflowStrategy == MqttPendingMessagesOverflowStrategy.DropOldestQueuedMessage)
                 {
                     // Only drop from the data partition. Dropping from control partition might break the connection
                     // because the client does not receive PINGREQ packets etc. any longer.
-                    var firstItem = _packetBus.DropFirstItem(MqttPacketBusPartition.Data);
-                    if (firstItem != null && _eventContainer.QueuedApplicationMessageOverwrittenEvent.HasHandlers)
-                    {
-                        var eventArgs = new QueueMessageOverwrittenEventArgs(Id, firstItem.Packet);
-                        _eventContainer.QueuedApplicationMessageOverwrittenEvent.InvokeAsync(eventArgs).ConfigureAwait(false);
-                    }
+                    _packetBus.DropFirstItem(MqttPacketBusPartition.Data);
                 }
             }
 
@@ -154,7 +147,6 @@ namespace MQTTnet.Server
             }
 
             _packetBus.EnqueueItem(packetBusItem, MqttPacketBusPartition.Data);
-            return EnqueueDataPacketResult.Enqueued;
         }
 
         public void EnqueueHealthPacket(MqttPacketBusItem packetBusItem)

Source/MQTTnet/Server/MqttServer.cs

@@ -14,7 +14,6 @@ using MQTTnet.Diagnostics;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server.Disconnecting;
 
 namespace MQTTnet.Server
 {
@@ -30,7 +29,6 @@ namespace MQTTnet.Server
         readonly IMqttNetLogger _rootLogger;
 
         CancellationTokenSource _cancellationTokenSource;
-        bool _isStopping;
 
         public MqttServer(MqttServerOptions options, IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
         {
@@ -51,12 +49,6 @@ namespace MQTTnet.Server
             _keepAliveMonitor = new MqttServerKeepAliveMonitor(options, _clientSessionsManager, _rootLogger);
         }
 
-        public event Func<ApplicationMessageEnqueuedEventArgs, Task> ApplicationMessageEnqueuedOrDroppedAsync
-        {
-            add => _eventContainer.ApplicationMessageEnqueuedOrDroppedEvent.AddHandler(value);
-            remove => _eventContainer.ApplicationMessageEnqueuedOrDroppedEvent.RemoveHandler(value);
-        }
-
         public event Func<ApplicationMessageNotConsumedEventArgs, Task> ApplicationMessageNotConsumedAsync
         {
             add => _eventContainer.ApplicationMessageNotConsumedEvent.AddHandler(value);
@@ -141,12 +133,6 @@ namespace MQTTnet.Server
             remove => _eventContainer.PreparingSessionEvent.RemoveHandler(value);
         }
 
-        public event Func<QueueMessageOverwrittenEventArgs, Task> QueuedApplicationMessageOverwrittenAsync
-        {
-            add => _eventContainer.QueuedApplicationMessageOverwrittenEvent.AddHandler(value);
-            remove => _eventContainer.QueuedApplicationMessageOverwrittenEvent.RemoveHandler(value);
-        }
-
         public event Func<RetainedMessageChangedEventArgs, Task> RetainedMessageChangedAsync
         {
             add => _eventContainer.RetainedMessageChangedEvent.AddHandler(value);
@@ -183,13 +169,6 @@ namespace MQTTnet.Server
             remove => _eventContainer.ValidatingConnectionEvent.RemoveHandler(value);
         }
 
-        /// <summary>
-        ///     Gets or sets whether the server will accept new connections.
-        ///     If not, the server will close the connection without any notification (DISCONNECT packet).
-        ///     This feature can be used when the server is shutting down.
-        /// </summary>
-        public bool AcceptNewConnections { get; set; } = true;
-
         public bool IsStarted => _cancellationTokenSource != null;
 
         /// <summary>
@@ -205,21 +184,16 @@ namespace MQTTnet.Server
             return _retainedMessagesManager?.ClearMessages() ?? CompletedTask.Instance;
         }
 
-        public Task DisconnectClientAsync(string id, MqttServerClientDisconnectOptions options)
+        public Task DisconnectClientAsync(string id, MqttDisconnectReasonCode reasonCode)
         {
             if (id == null)
             {
                 throw new ArgumentNullException(nameof(id));
             }
 
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-
             ThrowIfNotStarted();
 
-            return _clientSessionsManager.GetClient(id).StopAsync(options);
+            return _clientSessionsManager.GetClient(id).StopAsync(reasonCode);
         }
 
         public Task<IList<MqttClientStatus>> GetClientsAsync()
@@ -229,6 +203,13 @@ namespace MQTTnet.Server
             return _clientSessionsManager.GetClientsStatus();
         }
 
+        public Task<IList<MqttApplicationMessage>> GetRetainedMessagesAsync()
+        {
+            ThrowIfNotStarted();
+
+            return _retainedMessagesManager.GetMessages();
+        }
+
         public Task<MqttApplicationMessage> GetRetainedMessageAsync(string topic)
         {
             if (topic == null)
@@ -241,13 +222,6 @@ namespace MQTTnet.Server
             return _retainedMessagesManager.GetMessage(topic);
         }
 
-        public Task<IList<MqttApplicationMessage>> GetRetainedMessagesAsync()
-        {
-            ThrowIfNotStarted();
-
-            return _retainedMessagesManager.GetMessages();
-        }
-
         public Task<IList<MqttSessionStatus>> GetSessionsAsync()
         {
             ThrowIfNotStarted();
@@ -255,7 +229,13 @@ namespace MQTTnet.Server
             return _clientSessionsManager.GetSessionsStatus();
         }
 
+        [Obsolete("Use InjectApplicationMessageAsync instead.")]
         public Task InjectApplicationMessage(InjectedMqttApplicationMessage injectedApplicationMessage, CancellationToken cancellationToken = default)
+        {
+            return InjectApplicationMessageAsync(injectedApplicationMessage, cancellationToken);
+        }
+        
+        public Task InjectApplicationMessageAsync(InjectedMqttApplicationMessage injectedApplicationMessage, CancellationToken cancellationToken = default)
         {
             if (injectedApplicationMessage == null)
             {
@@ -273,7 +253,7 @@ namespace MQTTnet.Server
 
             if (string.IsNullOrEmpty(injectedApplicationMessage.ApplicationMessage.Topic))
             {
-                throw new NotSupportedException("Injected application messages must contain a topic (topic alias is not supported)");
+                throw new NotSupportedException("Injected application messages must contain a topic. Topic alias is not supported.");
             }
 
             var sessionItems = injectedApplicationMessage.CustomSessionItems ?? ServerSessionItems;
@@ -289,8 +269,6 @@ namespace MQTTnet.Server
         {
             ThrowIfStarted();
 
-            _isStopping = false;
-            
             _cancellationTokenSource = new CancellationTokenSource();
             var cancellationToken = _cancellationTokenSource.Token;
 
@@ -306,16 +284,11 @@ namespace MQTTnet.Server
 
             await _eventContainer.StartedEvent.InvokeAsync(EventArgs.Empty).ConfigureAwait(false);
 
-            _logger.Info("Started");
+            _logger.Info("Started.");
         }
 
-        public async Task StopAsync(MqttServerStopOptions options)
+        public async Task StopAsync()
         {
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
-
             try
             {
                 if (_cancellationTokenSource == null)
@@ -323,11 +296,9 @@ namespace MQTTnet.Server
                     return;
                 }
 
-                _isStopping = true;
-
                 _cancellationTokenSource.Cancel(false);
 
-                await _clientSessionsManager.CloseAllConnections(options.DefaultClientDisconnectOptions).ConfigureAwait(false);
+                await _clientSessionsManager.CloseAllConnections().ConfigureAwait(false);
 
                 foreach (var adapter in _adapters)
                 {
@@ -343,7 +314,7 @@ namespace MQTTnet.Server
 
             await _eventContainer.StoppedEvent.InvokeAsync(EventArgs.Empty).ConfigureAwait(false);
 
-            _logger.Info("Stopped");
+            _logger.Info("Stopped.");
         }
 
         public Task SubscribeAsync(string clientId, ICollection<MqttTopicFilter> topicFilters)
@@ -397,14 +368,14 @@ namespace MQTTnet.Server
             ThrowIfDisposed();
             ThrowIfNotStarted();
 
-            return _retainedMessagesManager?.UpdateMessage(string.Empty, retainedMessage);
+            return _retainedMessagesManager?.UpdateMessage(null, retainedMessage);
         }
 
         protected override void Dispose(bool disposing)
         {
             if (disposing)
             {
-                StopAsync(new MqttServerStopOptions()).GetAwaiter().GetResult();
+                StopAsync().GetAwaiter().GetResult();
 
                 foreach (var adapter in _adapters)
                 {
@@ -417,11 +388,6 @@ namespace MQTTnet.Server
 
         Task OnHandleClient(IMqttChannelAdapter channelAdapter, CancellationToken cancellationToken)
         {
-            if (_isStopping || !AcceptNewConnections)
-            {
-                return CompletedTask.Instance;
-            }
-
             return _clientSessionsManager.HandleClientConnectionAsync(channelAdapter, cancellationToken);
         }
 

Source/MQTTnet/Server/MqttServerExtensions.cs

@@ -8,23 +8,38 @@ using System.Threading.Tasks;
 using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
-using MQTTnet.Server.Disconnecting;
 
 namespace MQTTnet.Server
 {
     public static class MqttServerExtensions
     {
-        public static Task DisconnectClientAsync(this MqttServer server, string id, MqttDisconnectReasonCode reasonCode = MqttDisconnectReasonCode.NormalDisconnection)
+        [Obsolete("Use InjectApplicationMessageAsync instead.")]
+        public static Task InjectApplicationMessage(
+            this MqttServer server,
+            string topic,
+            string payload = null,
+            MqttQualityOfServiceLevel qualityOfServiceLevel = MqttQualityOfServiceLevel.AtMostOnce,
+            bool retain = false)
+        {
+            return InjectApplicationMessageAsync(server, topic, payload, qualityOfServiceLevel, retain);
+        }
+
+        public static Task InjectApplicationMessageAsync(this MqttServer server, MqttApplicationMessage applicationMessage)
         {
             if (server == null)
             {
                 throw new ArgumentNullException(nameof(server));
             }
 
-            return server.DisconnectClientAsync(id, new MqttServerClientDisconnectOptions { ReasonCode = reasonCode });
+            if (applicationMessage == null)
+            {
+                throw new ArgumentNullException(nameof(applicationMessage));
+            }
+
+            return server.InjectApplicationMessageAsync(new InjectedMqttApplicationMessage(applicationMessage));
         }
 
-        public static Task InjectApplicationMessage(
+        public static Task InjectApplicationMessageAsync(
             this MqttServer server,
             string topic,
             string payload = null,
@@ -47,7 +62,7 @@ namespace MQTTnet.Server
                 payloadBuffer = Encoding.UTF8.GetBytes(stringPayload);
             }
 
-            return server.InjectApplicationMessage(
+            return server.InjectApplicationMessageAsync(
                 new InjectedMqttApplicationMessage(
                     new MqttApplicationMessage
                     {
@@ -58,16 +73,6 @@ namespace MQTTnet.Server
                     }));
         }
 
-        public static Task StopAsync(this MqttServer server)
-        {
-            if (server == null)
-            {
-                throw new ArgumentNullException(nameof(server));
-            }
-
-            return server.StopAsync(new MqttServerStopOptions());
-        }
-
         public static Task SubscribeAsync(this MqttServer server, string clientId, params MqttTopicFilter[] topicFilters)
         {
             if (server == null)

Source/MQTTnet/Server/Options/MqttServerKeepAliveOptions.cs

@@ -1,21 +0,0 @@
-// 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;
-
-namespace MQTTnet.Server
-{
-    public sealed class MqttServerKeepAliveOptions
-    {
-        /// <summary>
-        ///     When this mode is enabled the MQTT server will not close a connection when the
-        ///     client is currently sending a (large) payload. This may lead to "dead" connections
-        ///     When this mode is disabled the MQTT server will disconnect a client when the keep
-        ///     alive timeout is reached even if the client is currently sending a (large) payload.
-        /// </summary>
-        public bool DisconnectClientWhenReadingPayload { get; set; }
-
-        public TimeSpan MonitorInterval { get; set; } = TimeSpan.FromMilliseconds(500);
-    }
-}

Source/MQTTnet/Server/Options/MqttServerOptions.cs

@@ -9,19 +9,12 @@ namespace MQTTnet.Server
     public sealed class MqttServerOptions
     {
         public TimeSpan DefaultCommunicationTimeout { get; set; } = TimeSpan.FromSeconds(100);
-
+        
         public MqttServerTcpEndpointOptions DefaultEndpointOptions { get; } = new MqttServerTcpEndpointOptions();
 
         public bool EnablePersistentSessions { get; set; }
 
-        [Obsolete("Use KeepAliveOptions instead.")]
-        public TimeSpan KeepAliveMonitorInterval
-        {
-            get => KeepAliveOptions.MonitorInterval;
-            set => KeepAliveOptions.MonitorInterval = value;
-        }
-
-        public MqttServerKeepAliveOptions KeepAliveOptions { get; } = new MqttServerKeepAliveOptions();
+        public TimeSpan KeepAliveMonitorInterval { get; set; } = TimeSpan.FromMilliseconds(500);
 
         public int MaxPendingMessagesPerClient { get; set; } = 250;
 

Source/MQTTnet/Server/Status/MqttClientStatus.cs

@@ -5,7 +5,7 @@
 using System;
 using System.Threading.Tasks;
 using MQTTnet.Formatter;
-using MQTTnet.Server.Disconnecting;
+using MQTTnet.Protocol;
 
 namespace MQTTnet.Server
 {
@@ -18,46 +18,41 @@ namespace MQTTnet.Server
             _client = client ?? throw new ArgumentNullException(nameof(client));
         }
 
-        public long BytesReceived => _client.ChannelAdapter.BytesReceived;
-
-        public long BytesSent => _client.ChannelAdapter.BytesSent;
-
-        public DateTime ConnectedTimestamp => _client.Statistics.ConnectedTimestamp;
-
-        public string Endpoint => _client.Endpoint;
-
         /// <summary>
-        ///     Gets or sets the client identifier.
-        ///     Hint: This identifier needs to be unique over all used clients / devices on the broker to avoid connection issues.
+        /// Gets or sets the client identifier.
+        /// Hint: This identifier needs to be unique over all used clients / devices on the broker to avoid connection issues.
         /// </summary>
         public string Id => _client.Id;
 
-        public DateTime LastNonKeepAlivePacketReceivedTimestamp => _client.Statistics.LastNonKeepAlivePacketReceivedTimestamp;
+        public string Endpoint => _client.Endpoint;
+
+        public MqttProtocolVersion ProtocolVersion => _client.ChannelAdapter.PacketFormatterAdapter.ProtocolVersion;
+
+        public DateTime ConnectedTimestamp => _client.Statistics.ConnectedTimestamp;
 
         public DateTime LastPacketReceivedTimestamp => _client.Statistics.LastPacketReceivedTimestamp;
 
         public DateTime LastPacketSentTimestamp => _client.Statistics.LastPacketSentTimestamp;
 
-        public MqttProtocolVersion ProtocolVersion => _client.ChannelAdapter.PacketFormatterAdapter.ProtocolVersion;
+        public DateTime LastNonKeepAlivePacketReceivedTimestamp => _client.Statistics.LastNonKeepAlivePacketReceivedTimestamp;
 
         public long ReceivedApplicationMessagesCount => _client.Statistics.ReceivedApplicationMessagesCount;
 
-        public long ReceivedPacketsCount => _client.Statistics.ReceivedPacketsCount;
-
         public long SentApplicationMessagesCount => _client.Statistics.SentApplicationMessagesCount;
 
+        public long ReceivedPacketsCount => _client.Statistics.ReceivedPacketsCount;
+
         public long SentPacketsCount => _client.Statistics.SentPacketsCount;
 
         public MqttSessionStatus Session { get; set; }
 
-        public Task DisconnectAsync(MqttServerClientDisconnectOptions options)
-        {
-            if (options == null)
-            {
-                throw new ArgumentNullException(nameof(options));
-            }
+        public long BytesSent => _client.ChannelAdapter.BytesSent;
 
-            return _client.StopAsync(options);
+        public long BytesReceived => _client.ChannelAdapter.BytesReceived;
+        
+        public Task DisconnectAsync()
+        {
+            return _client.StopAsync(MqttDisconnectReasonCode.NormalDisconnection);
         }
 
         public void ResetStatistics()
@@ -65,4 +60,4 @@ namespace MQTTnet.Server
             _client.ResetStatistics();
         }
     }
-}
+}

Source/MQTTnet/Server/Status/MqttClientStatusExtensions.cs

@@ -1,32 +0,0 @@
-// 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.Tasks;
-using MQTTnet.Protocol;
-using MQTTnet.Server.Disconnecting;
-
-namespace MQTTnet.Server
-{
-    public static class MqttClientStatusExtensions
-    {
-        static readonly MqttServerClientDisconnectOptions DefaultDisconnectOptions = new MqttServerClientDisconnectOptions
-        {
-            ReasonCode = MqttDisconnectReasonCode.NormalDisconnection,
-            ReasonString = null,
-            UserProperties = null,
-            ServerReference = null
-        };
-
-        public static Task DisconnectAsync(this MqttClientStatus clientStatus)
-        {
-            if (clientStatus == null)
-            {
-                throw new ArgumentNullException(nameof(clientStatus));
-            }
-
-            return clientStatus.DisconnectAsync(DefaultDisconnectOptions);
-        }
-    }
-}

Source/MQTTnet/Server/Stopping/MqttServerStopOptions.cs

@@ -1,24 +0,0 @@
-// 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.Protocol;
-using MQTTnet.Server.Disconnecting;
-
-namespace MQTTnet.Server
-{
-    public sealed class MqttServerStopOptions
-    {
-        /// <summary>
-        ///     These disconnect options are sent to every connected client via a DISCONNECT packet.
-        ///     <remarks>MQTT 5.0.0+ feature.</remarks>
-        /// </summary>
-        public MqttServerClientDisconnectOptions DefaultClientDisconnectOptions { get; set; } = new MqttServerClientDisconnectOptions
-        {
-            ReasonCode = MqttDisconnectReasonCode.ServerShuttingDown,
-            UserProperties = null,
-            ReasonString = null,
-            ServerReference = null
-        };
-    }
-}

Source/MQTTnet/Server/Stopping/MqttServerStopOptionsBuilder.cs

@@ -1,39 +0,0 @@
-// 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 MQTTnet.Server.Disconnecting;
-
-namespace MQTTnet.Server
-{
-    public sealed class MqttServerStopOptionsBuilder
-    {
-        readonly MqttServerStopOptions _options = new MqttServerStopOptions();
-
-        public MqttServerStopOptionsBuilder WithDefaultClientDisconnectOptions(MqttServerClientDisconnectOptions value)
-        {
-            _options.DefaultClientDisconnectOptions = value;
-            return this;
-        }
-        
-        public MqttServerStopOptionsBuilder WithDefaultClientDisconnectOptions(Action<MqttServerClientDisconnectOptionsBuilder> builder)
-        {
-            if (builder == null)
-            {
-                throw new ArgumentNullException(nameof(builder));
-            }
-
-            var optionsBuilder = new MqttServerClientDisconnectOptionsBuilder();
-            builder.Invoke(optionsBuilder);
-            
-            _options.DefaultClientDisconnectOptions = optionsBuilder.Build();
-            return this;
-        }
-        
-        public MqttServerStopOptions Build()
-        {
-            return _options;
-        }
-    }
-}