Removed 3rd-Party libraries.

Build/MQTTnet.nuspec

@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>MQTTnet</id>
-    <version>2.5.2</version>
+    <version>2.5.3</version>
     <authors>Christian Kratky</authors>
     <owners>Christian Kratky</owners>
     <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
@@ -10,7 +10,9 @@
     <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>MQTTnet is a high performance .NET library for MQTT based communication. It provides a MQTT client and a MQTT server (broker).</description>
-    <releaseNotes>* [Core] Refactored trace messages.
+    <releaseNotes>* [Core] Removed all dependencies to other libraries (BREAKING CHANGE!).
+* [Core] Updated SDK libraries.
+* [Client] Fixed broken support for WebSocketSecure connections (Thanks to @StAI).
     </releaseNotes>
     <copyright>Copyright Christian Kratky 2016-2017</copyright>
     <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin</tags> 
@@ -18,43 +20,26 @@
 
       <group targetFramework="netstandard1.3">
         <dependency id="NETStandard.Library" version="1.3.0" />
-        <dependency id="Microsoft.Extensions.DependencyInjection" version="1.0.2" />
-        <dependency id="Microsoft.Extensions.Logging" version="1.0.2" />
-        <dependency id="Microsoft.Extensions.Options" version="1.0.2" />
         <dependency id="System.Net.Security" version="4.3.2" />
         <dependency id="System.Net.WebSockets" version="4.3.0" />
-        <dependency id="System.Net.WebSockets.Client" version="4.3.1" />
-        <dependency id="System.Threading.Thread" version="4.3.0" />
+        <dependency id="System.Net.WebSockets.Client" version="4.3.1" />      
       </group>
 
       <group targetFramework="netstandard2.0">
         <dependency id="NETStandard.Library" version="2.0.0" />
-        <dependency id="Microsoft.Extensions.DependencyInjection" version="2.0.0" />
-        <dependency id="Microsoft.Extensions.Logging" version="2.0.0" />
-        <dependency id="Microsoft.Extensions.Options" version="2.0.0" />
         <dependency id="System.Net.Security" version="4.3.2" />
         <dependency id="System.Net.WebSockets" version="4.3.0" />
         <dependency id="System.Net.WebSockets.Client" version="4.3.1" />
-        <dependency id="System.Threading.Thread" version="4.3.0" />
       </group>
       
       <group targetFramework="uap10.0">
-        <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="5.4.0" />
-        <dependency id="Microsoft.Extensions.DependencyInjection" version="1.1.1" />
-        <dependency id="Microsoft.Extensions.Logging" version="1.1.2" />
-        <dependency id="Microsoft.Extensions.Options" version="1.1.2" />
+        <dependency id="Microsoft.NETCore.UniversalWindowsPlatform" version="5.4.1" />
       </group>
         
       <group targetFramework="net452">
-        <dependency id="Microsoft.Extensions.DependencyInjection" version="1.0.2" />
-        <dependency id="Microsoft.Extensions.Logging" version="1.0.2" />
-        <dependency id="Microsoft.Extensions.Options" version="1.0.2" />
       </group>
 
       <group targetFramework="net461">
-        <dependency id="Microsoft.Extensions.DependencyInjection" version="2.0.0" />
-        <dependency id="Microsoft.Extensions.Logging" version="2.0.0" />
-        <dependency id="Microsoft.Extensions.Options" version="2.0.0" />
       </group>
 
     </dependencies>

Frameworks/MQTTnet.AspnetCore/MqttHostedServer.cs

@@ -2,29 +2,27 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.Extensions.Hosting;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Server;
 
 namespace MQTTnet.AspNetCore
 {
     public class MqttHostedServer : MqttServer, IHostedService
     {
+        private readonly MqttServerOptions _options;
+
         public MqttHostedServer(
-            IOptions<MqttServerOptions> options,
+            MqttServerOptions options,
             IEnumerable<IMqttServerAdapter> adapters,
-            ILogger<MqttServer> logger, 
-            MqttClientSessionsManager clientSessionsManager,
-            IMqttClientRetainedMessageManager clientRetainedMessageManager
-            ) 
-            : base(options, adapters, logger, clientSessionsManager, clientRetainedMessageManager)
+            IMqttNetLogger logger) : base(adapters, logger)
         {
+            _options = options;
         }
 
         public Task StartAsync(CancellationToken cancellationToken)
         {
-            return StartAsync();
+            return StartAsync(_options);
         }
 
         public Task StopAsync(CancellationToken cancellationToken)

Frameworks/MQTTnet.AspnetCore/MqttWebSocketServerAdapter.cs

@@ -2,19 +2,14 @@
 using System.Net.WebSockets;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
 using MQTTnet.Core.Server;
 
 namespace MQTTnet.AspNetCore
 {
     public class MqttWebSocketServerAdapter : IMqttServerAdapter, IDisposable
     {
-        private readonly IMqttCommunicationAdapterFactory _mqttCommunicationAdapterFactory;
-
-        public MqttWebSocketServerAdapter(IMqttCommunicationAdapterFactory mqttCommunicationAdapterFactory)
-        {
-            _mqttCommunicationAdapterFactory = mqttCommunicationAdapterFactory ?? throw new ArgumentNullException(nameof(mqttCommunicationAdapterFactory));
-        }
-
         public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
 
         public Task StartAsync(MqttServerOptions options)
@@ -32,7 +27,7 @@ namespace MQTTnet.AspNetCore
             if (webSocket == null) throw new ArgumentNullException(nameof(webSocket));
 
             var channel = new MqttWebSocketServerChannel(webSocket);
-            var clientAdapter = _mqttCommunicationAdapterFactory.CreateServerCommunicationAdapter(channel);
+            var clientAdapter = new MqttChannelAdapter(channel, new MqttPacketSerializer(), new MqttNetLogger());
 
             var eventArgs = new MqttServerAdapterClientAcceptedEventArgs(clientAdapter);
             ClientAccepted?.Invoke(this, eventArgs);

Frameworks/MQTTnet.AspnetCore/MqttWebSocketServerChannel.cs

@@ -8,7 +8,7 @@ using MQTTnet.Implementations;
 
 namespace MQTTnet.AspNetCore
 {
-    public class MqttWebSocketServerChannel : IMqttCommunicationChannel, IDisposable
+    public class MqttWebSocketServerChannel : IMqttChannel, IDisposable
     {
         private WebSocket _webSocket;
 

Frameworks/MQTTnet.AspnetCore/ServiceCollectionExtensions.cs

@@ -9,8 +9,6 @@ namespace MQTTnet.AspNetCore
     {
         public static IServiceCollection AddHostedMqttServer(this IServiceCollection services)
         {
-            services.AddMqttServerServices();
-
             services.AddSingleton<IHostedService>(s => s.GetService<MqttHostedServer>());
             services.AddSingleton<IMqttServer>(s => s.GetService<MqttHostedServer>());
             services.AddSingleton<MqttHostedServer>();

Frameworks/MQTTnet.NetStandard/Diagnostics/MqttNetConsoleTrace.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Text;
+using MQTTnet.Core.Diagnostics;
+
+namespace MQTTnet.Diagnostics
+{
+    public static class MqttNetConsoleTrace
+    {
+        private static readonly object Lock = new object();
+
+        public static void ForwardToConsole()
+        {
+            MqttNetGlobalLog.LogMessagePublished -= PrintToConsole;
+            MqttNetGlobalLog.LogMessagePublished += PrintToConsole;
+        }
+
+        private static void PrintToConsole(object sender, MqttNetLogMessagePublishedEventArgs e)
+        {
+            var output = new StringBuilder();
+            output.AppendLine($">> [{e.TraceMessage.Timestamp:O}] [{e.TraceMessage.ThreadId}] [{e.TraceMessage.Source}] [{e.TraceMessage.Level}]: {e.TraceMessage.Message}");
+            if (e.TraceMessage.Exception != null)
+            {
+                output.AppendLine(e.TraceMessage.Exception.ToString());
+            }
+
+            lock (Lock)
+            {
+                var backupColor = Console.ForegroundColor;
+                switch (e.TraceMessage.Level)
+                {
+                    case MqttNetLogLevel.Error:
+                        Console.ForegroundColor = ConsoleColor.Red;
+                        break;
+                    case MqttNetLogLevel.Warning:
+                        Console.ForegroundColor = ConsoleColor.Yellow;
+                        break;
+                    case MqttNetLogLevel.Info:
+                        Console.ForegroundColor = ConsoleColor.Green;
+                        break;
+                    case MqttNetLogLevel.Verbose:
+                        Console.ForegroundColor = ConsoleColor.Gray;
+                        break;
+                }
+
+                Console.Write(output);
+                Console.ForegroundColor = backupColor;
+            }
+        }
+    }
+}

Frameworks/MQTTnet.NetStandard/Implementations/MqttClientAdapterFactory.cs

@@ -0,0 +1,26 @@
+using System;
+using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Client;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
+
+namespace MQTTnet.Implementations
+{
+    public class MqttClientAdapterFactory : IMqttClientAdapterFactory
+    {
+        public IMqttChannelAdapter CreateClientAdapter(IMqttClientChannelOptions options, IMqttNetLogger logger)
+        {
+            if (options == null) throw new ArgumentNullException(nameof(options));
+
+            switch (options)
+            {
+                case MqttClientTcpOptions tcpOptions:
+                    return new MqttChannelAdapter(new MqttTcpChannel(tcpOptions), new MqttPacketSerializer(), logger);
+                case MqttClientWebSocketOptions webSocketOptions:
+                    return new MqttChannelAdapter(new MqttWebSocketChannel(webSocketOptions), new MqttPacketSerializer(), logger);
+                default:
+                    throw new NotSupportedException();
+            }
+        }
+    }
+}

Frameworks/MQTTnet.NetStandard/Implementations/MqttServerAdapter.Uwp.cs

@@ -4,20 +4,19 @@ using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Server;
 using Windows.Networking.Sockets;
-using Microsoft.Extensions.Logging;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
 
 namespace MQTTnet.Implementations
 {
     public class MqttServerAdapter : IMqttServerAdapter, IDisposable
     {
-        private readonly ILogger<MqttServerAdapter> _logger;
-        private readonly IMqttCommunicationAdapterFactory _communicationAdapterFactory;
+        private readonly IMqttNetLogger _logger;
         private StreamSocketListener _defaultEndpointSocket;
 
-        public MqttServerAdapter(ILogger<MqttServerAdapter> logger, IMqttCommunicationAdapterFactory communicationAdapterFactory)
+        public MqttServerAdapter(IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _communicationAdapterFactory = communicationAdapterFactory ?? throw new ArgumentNullException(nameof(communicationAdapterFactory));
         }
 
         public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
@@ -63,12 +62,12 @@ namespace MQTTnet.Implementations
         {
             try
             {
-                var clientAdapter = _communicationAdapterFactory.CreateServerCommunicationAdapter(new MqttTcpChannel(args.Socket));
+                var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(args.Socket), new MqttPacketSerializer(), _logger);
                 ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Error while accepting connection at default endpoint.");
+                _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
             }
         }
     }

Frameworks/MQTTnet.NetStandard/Implementations/MqttServerAdapter.cs

@@ -9,24 +9,23 @@ using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Server;
-using Microsoft.Extensions.Logging;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.Serializer;
 
 namespace MQTTnet.Implementations
 {
     public class MqttServerAdapter : IMqttServerAdapter, IDisposable
     {
-        private readonly ILogger<MqttServerAdapter> _logger;
-        private readonly IMqttCommunicationAdapterFactory _communicationAdapterFactory;
+        private readonly IMqttNetLogger _logger;
 
         private CancellationTokenSource _cancellationTokenSource;
         private Socket _defaultEndpointSocket;
         private Socket _tlsEndpointSocket;
         private X509Certificate2 _tlsCertificate;
 
-        public MqttServerAdapter(ILogger<MqttServerAdapter> logger, IMqttCommunicationAdapterFactory communicationAdapterFactory)
+        public MqttServerAdapter(IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _communicationAdapterFactory = communicationAdapterFactory ?? throw new ArgumentNullException(nameof(communicationAdapterFactory));
         }
 
         public event EventHandler<MqttServerAdapterClientAcceptedEventArgs> ClientAccepted;
@@ -103,12 +102,12 @@ namespace MQTTnet.Implementations
 #else
                     var clientSocket = await _defaultEndpointSocket.AcceptAsync().ConfigureAwait(false);
 #endif
-                    var clientAdapter = _communicationAdapterFactory.CreateServerCommunicationAdapter(new MqttTcpChannel(clientSocket, null));
+                    var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, null), new MqttPacketSerializer(), _logger);
                     ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
                 }
                 catch (Exception exception)
                 {
-                    _logger.LogError(new EventId(), exception, "Error while accepting connection at default endpoint.");
+                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at default endpoint.");
 
                     //excessive CPU consumed if in endless loop of socket errors
                     await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);
@@ -131,12 +130,12 @@ namespace MQTTnet.Implementations
                     var sslStream = new SslStream(new NetworkStream(clientSocket));
                     await sslStream.AuthenticateAsServerAsync(_tlsCertificate, false, SslProtocols.Tls12, false).ConfigureAwait(false);
 
-                    var clientAdapter = _communicationAdapterFactory.CreateServerCommunicationAdapter(new MqttTcpChannel(clientSocket, sslStream));
+                    var clientAdapter = new MqttChannelAdapter(new MqttTcpChannel(clientSocket, sslStream), new MqttPacketSerializer(), _logger);
                     ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(clientAdapter));
                 }
                 catch (Exception exception)
                 {
-                    _logger.LogError(new EventId(), exception, "Error while accepting connection at TLS endpoint.");
+                    _logger.Error<MqttServerAdapter>(exception, "Error while accepting connection at TLS endpoint.");
 
                     //excessive CPU consumed if in endless loop of socket errors
                     await Task.Delay(TimeSpan.FromSeconds(1), cancellationToken).ConfigureAwait(false);

Frameworks/MQTTnet.NetStandard/Implementations/MqttTcpChannel.Uwp.cs

@@ -13,7 +13,7 @@ using MQTTnet.Core.Client;
 
 namespace MQTTnet.Implementations
 {
-    public sealed class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
+    public sealed class MqttTcpChannel : IMqttChannel, IDisposable
     {
         private readonly MqttClientTcpOptions _options;
         private StreamSocket _socket;

Frameworks/MQTTnet.NetStandard/Implementations/MqttTcpChannel.cs

@@ -12,7 +12,7 @@ using System.Linq;
 
 namespace MQTTnet.Implementations
 {
-    public sealed class MqttTcpChannel : IMqttCommunicationChannel, IDisposable
+    public sealed class MqttTcpChannel : IMqttChannel, IDisposable
     {
         private readonly MqttClientTcpOptions _options;
 

Frameworks/MQTTnet.NetStandard/Implementations/MqttWebSocketChannel.cs

@@ -9,7 +9,7 @@ using System.Threading.Tasks;
 
 namespace MQTTnet.Implementations
 {
-    public sealed class MqttWebSocketChannel : IMqttCommunicationChannel, IDisposable
+    public sealed class MqttWebSocketChannel : IMqttChannel, IDisposable
     {
         // ReSharper disable once MemberCanBePrivate.Global
         // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
@@ -29,9 +29,16 @@ namespace MQTTnet.Implementations
         public async Task ConnectAsync()
         {
             var uri = _options.Uri;
-            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase))
+            if (!uri.StartsWith("ws://", StringComparison.OrdinalIgnoreCase) && !uri.StartsWith("wss://", StringComparison.OrdinalIgnoreCase))
             {
-                uri = "ws://" + uri;
+                if (!_options.TlsOptions.UseTls)
+                {
+                    uri = "ws://" + uri;
+                }
+                else
+                {
+                    uri = "wss://" + uri;
+                }
             }
 
             _webSocket = new ClientWebSocket();

Frameworks/MQTTnet.NetStandard/MQTTnet.Netstandard.csproj

@@ -4,8 +4,10 @@
     <TargetFrameworks>netstandard1.3;netstandard2.0;net452;net461;uap10.0</TargetFrameworks>
     <AssemblyName>MQTTnet</AssemblyName>
     <RootNamespace>MQTTnet</RootNamespace>
-    <AssemblyVersion>2.5.2.0</AssemblyVersion>
-    <FileVersion>2.5.2.0</FileVersion>
+    <GeneratePackageOnBuild>False</GeneratePackageOnBuild>
+    <DebugType>Full</DebugType>
+    <AssemblyVersion>2.5.3.0</AssemblyVersion>
+    <FileVersion>2.5.3.0</FileVersion>
     <Version>0.0.0.0</Version>
     <Company />
     <Product />
@@ -31,9 +33,6 @@
 
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" />
 
-  <ItemGroup>
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\..\MQTTnet.Core\MQTTnet.Core.csproj" />
   </ItemGroup>
@@ -42,36 +41,22 @@
     <PackageReference Include="System.Net.Security" Version="4.3.2" />
     <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
     <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
-    <PackageReference Include="System.Threading.Thread" Version="4.3.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="2.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Options" Version="2.0.0" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='netstandard1.3'">
     <PackageReference Include="System.Net.Security" Version="4.3.2" />
     <PackageReference Include="System.Net.WebSockets" Version="4.3.0" />
     <PackageReference Include="System.Net.WebSockets.Client" Version="4.3.1" />
-    <PackageReference Include="System.Threading.Thread" Version="4.3.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="1.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="1.0.2" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='uap10.0'">
-    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="5.4.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="1.1.1" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="1.1.2" />
+    <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform" Version="5.4.1" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='net452'">
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="1.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="1.0.2" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)'=='net461'">
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Logging" Version="2.0.0" />
-    <PackageReference Include="Microsoft.Extensions.Options" Version="2.0.0" />
   </ItemGroup>
 
 </Project>

Frameworks/MQTTnet.NetStandard/MqttFactory.cs

@@ -1,130 +1,52 @@
 using System;
+using System.Collections.Generic;
 using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Client;
-using MQTTnet.Core.Serializer;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Options;
 using MQTTnet.Implementations;
 using MQTTnet.Core.ManagedClient;
 using MQTTnet.Core.Server;
-using MQTTnet.Core.Channel;
+using MQTTnet.Core.Diagnostics;
 
 namespace MQTTnet
 {
-    public class MqttFactory : IMqttCommunicationAdapterFactory, IMqttClientSesssionFactory, IMqttClientFactory, IMqttServerFactory
+    public class MqttFactory : IMqttClientFactory, IMqttServerFactory
     {
-        private readonly IServiceProvider _serviceProvider;
-
-        public MqttFactory()
-            : this(BuildServiceProvider())
-        {
-        }
-
-        public MqttFactory(IServiceProvider serviceProvider)
-        {
-            _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
-        }
-
-        public ILoggerFactory GetLoggerFactory()
-        {
-            return _serviceProvider.GetRequiredService<ILoggerFactory>();
-        }
-
-        public IMqttCommunicationAdapter CreateClientCommunicationAdapter(IMqttClientOptions options)
-        {
-            var logger = _serviceProvider.GetRequiredService<ILogger<MqttChannelCommunicationAdapter>>();
-            return new MqttChannelCommunicationAdapter(CreateCommunicationChannel(options.ChannelOptions), CreateSerializer(options.ProtocolVersion), logger);
-        }
-
-        public IMqttCommunicationAdapter CreateServerCommunicationAdapter(IMqttCommunicationChannel channel)
-        {
-            var serializer = _serviceProvider.GetRequiredService<IMqttPacketSerializer>();
-            var logger = _serviceProvider.GetRequiredService<ILogger<MqttChannelCommunicationAdapter>>();
-            return new MqttChannelCommunicationAdapter(channel, serializer, logger);
-        }
-
-        public IMqttCommunicationChannel CreateCommunicationChannel(IMqttClientChannelOptions options)
-        {
-            if (options == null) throw new ArgumentNullException(nameof(options));
-
-            switch (options)
-            {
-                case MqttClientTcpOptions tcpOptions:
-                    return CreateTcpChannel(tcpOptions);
-                case MqttClientWebSocketOptions webSocketOptions:
-                    return CreateWebSocketChannel(webSocketOptions);
-                default:
-                    throw new NotSupportedException();
-            }
-        }
-
-        public MqttTcpChannel CreateTcpChannel(MqttClientTcpOptions tcpOptions)
+        public IMqttClient CreateMqttClient()
         {
-            return new MqttTcpChannel(tcpOptions);
+            return CreateMqttClient(new MqttNetLogger());
         }
 
-        public MqttWebSocketChannel CreateWebSocketChannel(MqttClientWebSocketOptions webSocketOptions)
+        public IMqttClient CreateMqttClient(IMqttNetLogger logger)
         {
-            return new MqttWebSocketChannel(webSocketOptions);
-        }
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
 
-        public MqttPacketSerializer CreateSerializer(MqttProtocolVersion protocolVersion)
-        {
-            return new MqttPacketSerializer
-            {
-                ProtocolVersion = protocolVersion
-            };
+            return new MqttClient(new MqttClientAdapterFactory(), logger);
         }
 
-        public MqttClientSession CreateClientSession(string clientId, MqttClientSessionsManager clientSessionsManager)
+        public IManagedMqttClient CreateManagedMqttClient()
         {
-            return new MqttClientSession(
-                clientId,
-                _serviceProvider.GetRequiredService<IOptions<MqttServerOptions>>(),
-                clientSessionsManager,
-                _serviceProvider.GetRequiredService<MqttClientSubscriptionsManager>(),
-                _serviceProvider.GetRequiredService<ILogger<MqttClientSession>>(),
-                _serviceProvider.GetRequiredService<ILogger<MqttClientPendingMessagesQueue>>());
+            return new ManagedMqttClient(CreateMqttClient(), new MqttNetLogger());
         }
 
-        public IMqttClient CreateMqttClient()
+        public IManagedMqttClient CreateManagedMqttClient(IMqttNetLogger logger)
         {
-            return _serviceProvider.GetRequiredService<IMqttClient>();
-        }
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
 
-        public IManagedMqttClient CreateManagedMqttClient()
-        {
-            return _serviceProvider.GetRequiredService<IManagedMqttClient>();
+            return new ManagedMqttClient(CreateMqttClient(), logger);
         }
 
         public IMqttServer CreateMqttServer()
         {
-            return _serviceProvider.GetRequiredService<IMqttServer>();
-        }
-
-        public IMqttServer CreateMqttServer(Action<MqttServerOptions> configure)
-        {
-            if (configure == null) throw new ArgumentNullException(nameof(configure));
-
-            var options = _serviceProvider.GetRequiredService<IOptions<MqttServerOptions>>();
-            configure(options.Value);
-
-            return _serviceProvider.GetRequiredService<IMqttServer>();
+            var logger = new MqttNetLogger();
+            return CreateMqttServer(new List<IMqttServerAdapter> { new MqttServerAdapter(logger) }, logger);
         }
 
-        private static IServiceProvider BuildServiceProvider()
+        public IMqttServer CreateMqttServer(IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
         {
-            var serviceProvider = new ServiceCollection()
-                .AddMqttClient()
-                .AddMqttServer()
-                .AddLogging()
-                .BuildServiceProvider();
-
-            serviceProvider.GetRequiredService<ILoggerFactory>()
-                .AddMqttTrace();
+            if (adapters == null) throw new ArgumentNullException(nameof(adapters));
+            if (logger == null) throw new ArgumentNullException(nameof(logger));
 
-            return serviceProvider;
+            return new MqttServer(adapters, logger);
         }
     }
 }

Frameworks/MQTTnet.NetStandard/ServiceCollectionExtensions.cs

@@ -1,70 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Client;
-using MQTTnet.Core.ManagedClient;
-using MQTTnet.Core.Serializer;
-using MQTTnet.Core.Server;
-using MQTTnet.Implementations;
-using System;
-using Microsoft.Extensions.Logging;
-using MQTTnet.Core.Diagnostics;
-
-namespace MQTTnet
-{
-    public static class ServiceCollectionExtensions
-    {
-        public static IServiceCollection AddMqttServer(this IServiceCollection services)
-        {
-            services.AddMqttServerServices();
-            
-            services.AddSingleton<IMqttServer>(s => s.GetService<MqttServer>());
-            services.AddSingleton<MqttServer>();
-
-            return services;
-        }
-
-        public static IServiceCollection AddMqttServerServices(this IServiceCollection services)
-        {
-            services.AddOptions();
-            services.AddSingleton<MqttFactory>();
-            services.AddSingleton<IMqttCommunicationAdapterFactory>(s => s.GetService<MqttFactory>());
-            services.AddSingleton<IMqttClientSesssionFactory>(s => s.GetService<MqttFactory>());
-
-            services.AddTransient<IMqttServerAdapter, MqttServerAdapter>();
-            services.AddTransient<IMqttPacketSerializer, MqttPacketSerializer>();
-
-            services.AddSingleton<MqttClientSessionsManager>();
-            services.AddTransient<MqttClientSubscriptionsManager>();
-            services.AddSingleton<IMqttClientRetainedMessageManager, MqttClientRetainedMessagesManager>();
-            return services;
-        }
-
-        public static IServiceCollection AddMqttServer(this IServiceCollection services, Action<MqttServerOptions> configureOptions)
-        {
-            return services
-                .AddMqttServer()
-                .Configure(configureOptions);
-        }
-
-        public static IServiceCollection AddMqttClient(this IServiceCollection services)
-        {
-            services.AddSingleton<MqttFactory>();
-            services.AddSingleton<IMqttCommunicationAdapterFactory>(s => s.GetService<MqttFactory>());
-
-            services.AddTransient<IMqttClient, MqttClient>();
-            services.AddTransient<MqttClient>();
-            services.AddTransient<IManagedMqttClient, ManagedMqttClient>();
-            services.AddTransient<ManagedMqttClient>();
-            services.AddTransient<IMqttPacketSerializer, MqttPacketSerializer>();
-            services.AddTransient<MqttPacketDispatcher>();
-
-            return services;
-        }
-
-        public static ILoggerFactory AddMqttTrace(this ILoggerFactory factory)
-        {
-            factory.AddProvider(new MqttNetTrace());
-            return factory;
-        }
-    }
-}

MQTTnet.Core/Adapter/IMqttCommunicationAdapter.cs → MQTTnet.Core/Adapter/IMqttChannelAdapter.cs

@@ -7,7 +7,7 @@ using MQTTnet.Core.Serializer;
 
 namespace MQTTnet.Core.Adapter
 {
-    public interface IMqttCommunicationAdapter
+    public interface IMqttChannelAdapter
     {
         IMqttPacketSerializer PacketSerializer { get; }
 

MQTTnet.Core/Adapter/IMqttCommunicationAdapterFactory.cs

@@ -1,12 +0,0 @@
-using MQTTnet.Core.Client;
-using MQTTnet.Core.Channel;
-
-namespace MQTTnet.Core.Adapter
-{
-    public interface IMqttCommunicationAdapterFactory
-    {
-        IMqttCommunicationAdapter CreateClientCommunicationAdapter(IMqttClientOptions options);
-
-        IMqttCommunicationAdapter CreateServerCommunicationAdapter(IMqttCommunicationChannel channel);
-    }
-}

MQTTnet.Core/Adapter/MqttChannelCommunicationAdapter.cs → MQTTnet.Core/Adapter/MqttChannelAdapter.cs

@@ -5,23 +5,23 @@ using System.Runtime.InteropServices;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Channel;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Serializer;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Adapter
 {
-    public class MqttChannelCommunicationAdapter : IMqttCommunicationAdapter
+    public class MqttChannelAdapter : IMqttChannelAdapter
     {
         private const uint ErrorOperationAborted = 0x800703E3;
 
         private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
-        private readonly ILogger<MqttChannelCommunicationAdapter> _logger;
-        private readonly IMqttCommunicationChannel _channel;
+        private readonly IMqttNetLogger _logger;
+        private readonly IMqttChannel _channel;
 
-        public MqttChannelCommunicationAdapter(IMqttCommunicationChannel channel, IMqttPacketSerializer serializer, ILogger<MqttChannelCommunicationAdapter> logger)
+        public MqttChannelAdapter(IMqttChannel channel, IMqttPacketSerializer serializer, IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _channel = channel ?? throw new ArgumentNullException(nameof(channel));
@@ -32,14 +32,14 @@ namespace MQTTnet.Core.Adapter
 
         public async Task ConnectAsync(TimeSpan timeout)
         {
-            _logger.LogInformation("Connecting [Timeout={0}]", timeout);
+            _logger.Info<MqttChannelAdapter>("Connecting [Timeout={0}]", timeout);
 
             await ExecuteAndWrapExceptionAsync(() => _channel.ConnectAsync().TimeoutAfter(timeout));
         }
 
         public async Task DisconnectAsync(TimeSpan timeout)
         {
-            _logger.LogInformation("Disconnecting [Timeout={0}]", timeout);
+            _logger.Info<MqttChannelAdapter>("Disconnecting [Timeout={0}]", timeout);
 
             await ExecuteAndWrapExceptionAsync(() => _channel.DisconnectAsync().TimeoutAfter(timeout));
         }
@@ -58,7 +58,7 @@ namespace MQTTnet.Core.Adapter
                             continue;
                         }
 
-                        _logger.LogInformation("TX >>> {0} [Timeout={1}]", packet, timeout);
+                        _logger.Trace<MqttChannelAdapter>("TX >>> {0} [Timeout={1}]", packet, timeout);
 
                         var writeBuffer = PacketSerializer.Serialize(packet);
                         await _channel.SendStream.WriteAsync(writeBuffer, 0, writeBuffer.Length, cancellationToken).ConfigureAwait(false);
@@ -108,7 +108,7 @@ namespace MQTTnet.Core.Adapter
                         throw new MqttProtocolViolationException("Received malformed packet.");
                     }
 
-                    _logger.LogInformation("RX <<< {0}", packet);
+                    _logger.Trace<MqttChannelAdapter>("RX <<< {0}", packet);
                 }
                 finally
                 {

MQTTnet.Core/Adapter/MqttCommunicationAdapterExtensions.cs → MQTTnet.Core/Adapter/MqttChannelAdapterExtensions.cs

@@ -5,9 +5,9 @@ using MQTTnet.Core.Packets;
 
 namespace MQTTnet.Core.Adapter
 {
-    public static class MqttCommunicationAdapterExtensions
+    public static class MqttChannelAdapterExtensions
     {
-        public static Task SendPacketsAsync(this IMqttCommunicationAdapter adapter, TimeSpan timeout, CancellationToken cancellationToken, params MqttBasePacket[] packets)
+        public static Task SendPacketsAsync(this IMqttChannelAdapter adapter, TimeSpan timeout, CancellationToken cancellationToken, params MqttBasePacket[] packets)
         {
             if (adapter == null) throw new ArgumentNullException(nameof(adapter));
 

MQTTnet.Core/Adapter/MqttServerAdapterClientAcceptedEventArgs.cs

@@ -5,12 +5,12 @@ namespace MQTTnet.Core.Adapter
 {
     public class MqttServerAdapterClientAcceptedEventArgs : EventArgs
     {
-        public MqttServerAdapterClientAcceptedEventArgs(IMqttCommunicationAdapter client)
+        public MqttServerAdapterClientAcceptedEventArgs(IMqttChannelAdapter client)
         {
             Client = client ?? throw new ArgumentNullException(nameof(client));
         }
 
-        public IMqttCommunicationAdapter Client { get; }
+        public IMqttChannelAdapter Client { get; }
 
         public Task SessionTask { get; set; }
     }

MQTTnet.Core/Channel/IMqttCommunicationChannel.cs → MQTTnet.Core/Channel/IMqttChannel.cs

@@ -3,7 +3,7 @@ using System.IO;
 
 namespace MQTTnet.Core.Channel
 {
-    public interface IMqttCommunicationChannel
+    public interface IMqttChannel
     {
         Stream SendStream { get; }
         Stream ReceiveStream { get; }

MQTTnet.Core/Client/IMqttClientAdapterFactory.cs

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

MQTTnet.Core/Client/IMqttClientFactory.cs

@@ -1,4 +1,5 @@
-using MQTTnet.Core.ManagedClient;
+using MQTTnet.Core.Diagnostics;
+using MQTTnet.Core.ManagedClient;
 
 namespace MQTTnet.Core.Client
 {
@@ -6,6 +7,10 @@ namespace MQTTnet.Core.Client
     {
         IMqttClient CreateMqttClient();
 
+        IMqttClient CreateMqttClient(IMqttNetLogger logger);
+        
         IManagedMqttClient CreateManagedMqttClient();
+
+        IManagedMqttClient CreateManagedMqttClient(IMqttNetLogger logger);
     }
 }

MQTTnet.Core/Client/IMqttClientOptions.cs

@@ -7,10 +7,6 @@ namespace MQTTnet.Core.Client
     {
         string ClientId { get; }
 
-        /// <summary>
-        /// The LogId is used to create a scope to correlate logging. If no value is provided the ClientId is used instead 
-        /// </summary>
-        string LogId { get; }
         IMqttClientCredentials Credentials { get; }
         bool CleanSession { get; }
         MqttApplicationMessage WillMessage { get; }

MQTTnet.Core/Client/MqttClient.cs

@@ -4,33 +4,34 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Client
 {
     public class MqttClient : IMqttClient
     {
         private readonly HashSet<ushort> _unacknowledgedPublishPackets = new HashSet<ushort>();
+
+        private readonly IMqttClientAdapterFactory _adapterFactory;
         private readonly MqttPacketDispatcher _packetDispatcher;
-        private readonly IMqttCommunicationAdapterFactory _communicationAdapterFactory;
-        private readonly ILogger<MqttClient> _logger;
+        private readonly IMqttNetLogger _logger;
 
         private IMqttClientOptions _options;
         private bool _isReceivingPackets;
         private int _latestPacketIdentifier;
         private CancellationTokenSource _cancellationTokenSource;
-        private IMqttCommunicationAdapter _adapter;
-        private IDisposable _scopeHandle;
+        private IMqttChannelAdapter _adapter;
 
-        public MqttClient(IMqttCommunicationAdapterFactory communicationAdapterFactory, ILogger<MqttClient> logger, MqttPacketDispatcher packetDispatcher)
+        public MqttClient(IMqttClientAdapterFactory channelFactory, IMqttNetLogger logger)
         {
-            _communicationAdapterFactory = communicationAdapterFactory ?? throw new ArgumentNullException(nameof(communicationAdapterFactory));
+            _adapterFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _packetDispatcher = packetDispatcher ?? throw new ArgumentNullException(nameof(packetDispatcher));
+            
+            _packetDispatcher = new MqttPacketDispatcher(logger);
         }
 
         public event EventHandler<MqttClientConnectedEventArgs> Connected;
@@ -53,17 +54,16 @@ namespace MQTTnet.Core.Client
                 _latestPacketIdentifier = 0;
                 _packetDispatcher.Reset();
 
-                _adapter = _communicationAdapterFactory.CreateClientCommunicationAdapter(options);
-
-                _scopeHandle = _logger.BeginScope(options.LogId ?? options.ClientId);
-                _logger.LogTrace("Trying to connect with server.");
+                _adapter = _adapterFactory.CreateClientAdapter(options.ChannelOptions, _logger);
+                
+                _logger.Trace<MqttClient>("Trying to connect with server.");
                 await _adapter.ConnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
-                _logger.LogTrace("Connection with server established.");
+                _logger.Trace<MqttClient>("Connection with server established.");
 
                 await StartReceivingPacketsAsync(_cancellationTokenSource.Token).ConfigureAwait(false);
                 var connectResponse = await AuthenticateAsync(options.WillMessage).ConfigureAwait(false);
 
-                _logger.LogTrace("MQTT connection with server established.");
+                _logger.Trace<MqttClient>("MQTT connection with server established.");
 
                 if (_options.KeepAlivePeriod != TimeSpan.Zero)
                 {
@@ -76,7 +76,7 @@ namespace MQTTnet.Core.Client
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Error while connecting with server.");
+                _logger.Error<MqttClient>(exception, "Error while connecting with server.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
                 throw;
             }
@@ -215,8 +215,6 @@ namespace MQTTnet.Core.Client
 
         private async Task DisconnectInternalAsync()
         {
-            _scopeHandle?.Dispose();
-
             var clientWasConnected = IsConnected;
             IsConnected = false;
 
@@ -233,15 +231,15 @@ namespace MQTTnet.Core.Client
             try
             {
                 await _adapter.DisconnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
-                _logger.LogInformation("Disconnected from adapter.");
+                _logger.Info<MqttClient>("Disconnected from adapter.");
             }
             catch (Exception exception)
             {
-                _logger.LogWarning(new EventId(), exception, "Error while disconnecting from adapter.");
+                _logger.Warning<MqttClient>(exception, "Error while disconnecting from adapter.");
             }
             finally
             {
-                _logger.LogInformation("Disconnected.");
+                _logger.Info<MqttClient>("Disconnected.");
                 Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected));
             }
         }
@@ -250,7 +248,7 @@ namespace MQTTnet.Core.Client
         {
             try
             {
-                _logger.LogInformation("Received <<< {0}", packet);
+                _logger.Info<MqttClient>("Received <<< {0}", packet);
 
                 if (packet is MqttPingReqPacket)
                 {
@@ -280,7 +278,7 @@ namespace MQTTnet.Core.Client
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while processing received packet.");
+                _logger.Error<MqttClient>(exception, "Unhandled exception while processing received packet.");
             }
         }
 
@@ -293,7 +291,7 @@ namespace MQTTnet.Core.Client
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while handling application message.");
+                _logger.Error<MqttClient>(exception, "Unhandled exception while handling application message.");
             }
         }
 
@@ -357,7 +355,7 @@ namespace MQTTnet.Core.Client
 
         private async Task SendKeepAliveMessagesAsync(CancellationToken cancellationToken)
         {
-            _logger.LogInformation("Start sending keep alive packets.");
+            _logger.Info<MqttClient>("Start sending keep alive packets.");
 
             try
             {
@@ -388,23 +386,23 @@ namespace MQTTnet.Core.Client
                     return;
                 }
 
-                _logger.LogWarning(new EventId(), exception, "MQTT communication exception while sending/receiving keep alive packets.");
+                _logger.Warning<MqttClient>(exception, "MQTT communication exception while sending/receiving keep alive packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                _logger.LogWarning(new EventId(), exception, "Unhandled exception while sending/receiving keep alive packets.");
+                _logger.Warning<MqttClient>(exception, "Unhandled exception while sending/receiving keep alive packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             finally
             {
-                _logger.LogInformation("Stopped sending keep alive packets.");
+                _logger.Info<MqttClient>("Stopped sending keep alive packets.");
             }
         }
 
         private async Task ReceivePacketsAsync(CancellationToken cancellationToken)
         {
-            _logger.LogInformation("Start receiving packets.");
+            _logger.Info<MqttClient>("Start receiving packets.");
 
             try
             {
@@ -438,17 +436,17 @@ namespace MQTTnet.Core.Client
                     return;
                 }
 
-                _logger.LogWarning(new EventId(), exception, "MQTT communication exception while receiving packets.");
+                _logger.Warning<MqttClient>(exception, "MQTT communication exception while receiving packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while receiving packets.");
+                _logger.Error<MqttClient>(exception, "Unhandled exception while receiving packets.");
                 await DisconnectInternalAsync().ConfigureAwait(false);
             }
             finally
             {
-                _logger.LogInformation(nameof(MqttClient), "Stopped receiving packets.");
+                _logger.Info<MqttClient>("Stopped receiving packets.");
             }
         }
 

MQTTnet.Core/Client/MqttClientOptions.cs

@@ -9,9 +9,6 @@ namespace MQTTnet.Core.Client
 
         public string ClientId { get; set; } = Guid.NewGuid().ToString("N");
 
-        /// <inheritdoc />
-        public string LogId { get; set; }
-
         public bool CleanSession { get; set; } = true;
 
         public IMqttClientCredentials Credentials { get; set; } = new MqttClientCredentials();

MQTTnet.Core/Client/MqttClientOptionsBuilder.cs

@@ -12,12 +12,6 @@ namespace MQTTnet.Core.Client
 
         private MqttClientTlsOptions _tlsOptions;
 
-        public MqttClientOptionsBuilder WithLogId(string value)
-        {
-            _options.LogId = value;
-            return this;
-        }
-
         public MqttClientOptionsBuilder WithProtocolVersion(MqttProtocolVersion value)
         {
             _options.ProtocolVersion = value;

MQTTnet.Core/Client/MqttPacketDispatcher.cs

@@ -1,10 +1,10 @@
 using System;
 using System.Collections.Concurrent;
 using System.Threading.Tasks;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Client
 {
@@ -12,9 +12,9 @@ namespace MQTTnet.Core.Client
     {
         private readonly ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>> _packetByResponseType = new ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>>();
         private readonly ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>> _packetByResponseTypeAndIdentifier = new ConcurrentDictionary<Type, ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>>();
-        private readonly ILogger<MqttPacketDispatcher> _logger;
+        private readonly IMqttNetLogger _logger;
 
-        public MqttPacketDispatcher(ILogger<MqttPacketDispatcher> logger)
+        public MqttPacketDispatcher(IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
         }
@@ -30,7 +30,7 @@ namespace MQTTnet.Core.Client
             }
             catch (MqttCommunicationTimedOutException)
             {
-                _logger.LogWarning("Timeout while waiting for packet of type '{0}'.", responseType.Name);
+                _logger.Warning<MqttPacketDispatcher>("Timeout while waiting for packet of type '{0}'.", responseType.Name);
                 throw;
             }
             finally

MQTTnet.Core/Diagnostics/IMqttNetLogger.cs

@@ -0,0 +1,21 @@
+using System;
+
+namespace MQTTnet.Core.Diagnostics
+{
+    public interface IMqttNetLogger
+    {
+        event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
+
+        void Trace<TSource>(string message, params object[] parameters);
+
+        void Info<TSource>(string message, params object[] parameters);
+
+        void Warning<TSource>(Exception exception, string message, params object[] parameters);
+
+        void Warning<TSource>(string message, params object[] parameters);
+
+        void Error<TSource>(Exception exception, string message, params object[] parameters);
+
+        void Error<TSource>(string message, params object[] parameters);
+    }
+}

MQTTnet.Core/Diagnostics/MqttNetGlobalLog.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace MQTTnet.Core.Diagnostics
+{
+    public static class MqttNetGlobalLog
+    {
+        public static event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
+
+        public static bool HasListeners => LogMessagePublished != null;
+
+        public static void Publish(MqttNetLogMessage logMessage)
+        {
+            if (logMessage == null) throw new ArgumentNullException(nameof(logMessage));
+
+            LogMessagePublished?.Invoke(null, new MqttNetLogMessagePublishedEventArgs(logMessage));
+        }
+    }
+}

MQTTnet.Core/Diagnostics/MqttNetLogLevel.cs

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

MQTTnet.Core/Diagnostics/MqttTraceMessage.cs → MQTTnet.Core/Diagnostics/MqttNetLogMessage.cs

@@ -1,12 +1,12 @@
 using System;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Diagnostics
 {
-    public sealed class MqttNetTraceMessage
+    public sealed class MqttNetLogMessage
     {
-        public MqttNetTraceMessage(DateTime timestamp, int threadId, string source, LogLevel level, string message, Exception exception)
+        public MqttNetLogMessage(string logId, DateTime timestamp, int threadId, string source, MqttNetLogLevel level, string message, Exception exception)
         {
+            LogId = logId;
             Timestamp = timestamp;
             ThreadId = threadId;
             Source = source;
@@ -15,13 +15,15 @@ namespace MQTTnet.Core.Diagnostics
             Exception = exception;
         }
 
+        public string LogId { get; }
+
         public DateTime Timestamp { get; }
 
         public int ThreadId { get; }
 
         public string Source { get; }
 
-        public LogLevel Level { get; }
+        public MqttNetLogLevel Level { get; }
 
         public string Message { get; }
 

MQTTnet.Core/Diagnostics/MqttNetLogMessagePublishedEventArgs.cs

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

MQTTnet.Core/Diagnostics/MqttNetLogger.cs

@@ -1,52 +1,73 @@
 using System;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Diagnostics
 {
-    public class MqttNetLogger : ILogger
+    public class MqttNetLogger : IMqttNetLogger
     {
-        private readonly string _categoryName;
-        private readonly MqttNetTrace _mqttNetTrace;
+        private readonly string _logId;
 
-        public MqttNetLogger(string categoryName, MqttNetTrace mqttNetTrace)
+        public MqttNetLogger(string logId = null)
         {
-            _categoryName = categoryName;
-            _mqttNetTrace = mqttNetTrace;
+            _logId = logId;
         }
+        
+        public event EventHandler<MqttNetLogMessagePublishedEventArgs> LogMessagePublished;
 
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
+        public void Trace<TSource>(string message, params object[] parameters)
         {
-            if (formatter == null)
-            {
-                throw new ArgumentNullException(nameof(formatter));
-            }
+            Publish<TSource>(MqttNetLogLevel.Verbose, null, message, parameters);
+        }
 
-            if (!MqttNetTrace.HasListeners)
-            {
-                return;
-            }
+        public void Info<TSource>(string message, params object[] parameters)
+        {
+            Publish<TSource>(MqttNetLogLevel.Info, null, message, parameters);
+        }
+
+        public void Warning<TSource>(Exception exception, string message, params object[] parameters)
+        {
+            Publish<TSource>(MqttNetLogLevel.Warning, exception, message, parameters);
+        }
 
-            var message = formatter(state, exception);
-            var traceMessage = new MqttNetTraceMessage(DateTime.Now, Environment.CurrentManagedThreadId, _categoryName, logLevel, message, exception);
-            _mqttNetTrace.Publish(traceMessage);
+        public void Warning<TSource>(string message, params object[] parameters)
+        {
+            Warning<TSource>(null, message, parameters);
         }
 
-        public bool IsEnabled(LogLevel logLevel)
+        public void Error<TSource>(Exception exception, string message, params object[] parameters)
         {
-            return MqttNetTrace.HasListeners;
+            Publish<TSource>(MqttNetLogLevel.Error, exception, message, parameters);
         }
 
-        //not supported: async local requires netstandard1.3
-        //for implementation see https://github.com/aspnet/Logging/blob/dev/src/Microsoft.Extensions.Logging.Console/ConsoleLogScope.cs
-        public IDisposable BeginScope<TState>(TState state)
+        public void Error<TSource>(string message, params object[] parameters)
         {
-            return new DisposableScope();
+            Warning<TSource>(null, message, parameters);
         }
 
-        private class DisposableScope : IDisposable
+        private void Publish<TSource>(MqttNetLogLevel logLevel, Exception exception, string message, object[] parameters)
         {
-            public void Dispose()
+            var hasLocalListeners = LogMessagePublished != null;
+            var hasGlobalListeners = MqttNetGlobalLog.HasListeners;
+
+            if (!hasLocalListeners && !hasGlobalListeners)
+            {
+                return;
+            }
+
+            if (parameters.Length > 0)
+            {
+                message = string.Format(message, parameters);
+            }
+
+            var traceMessage = new MqttNetLogMessage(_logId, DateTime.Now, Environment.CurrentManagedThreadId, typeof(TSource).Name, logLevel, message, exception);
+
+            if (hasGlobalListeners)
+            {
+                MqttNetGlobalLog.Publish(traceMessage);
+            }
+
+            if (hasLocalListeners)
             {
+                LogMessagePublished?.Invoke(this, new MqttNetLogMessagePublishedEventArgs(traceMessage));
             }
         }
     }

MQTTnet.Core/Diagnostics/MqttNetTrace.cs

@@ -1,35 +0,0 @@
-using System;
-using System.Collections.Concurrent;
-using Microsoft.Extensions.Logging;
-
-namespace MQTTnet.Core.Diagnostics
-{
-    public class MqttNetTrace : ILoggerProvider
-    {
-        private readonly ConcurrentDictionary<string, MqttNetLogger> _loggers = new ConcurrentDictionary<string, MqttNetLogger>();
-
-        public static event EventHandler<MqttNetTraceMessagePublishedEventArgs> TraceMessagePublished;
-
-        public static bool HasListeners => TraceMessagePublished != null;
-
-        public void Publish(MqttNetTraceMessage traceMessage)
-        {
-            TraceMessagePublished?.Invoke(this, new MqttNetTraceMessagePublishedEventArgs(traceMessage));
-        }
-
-        public void Dispose()
-        {
-            TraceMessagePublished = null;
-        }
-
-        public ILogger CreateLogger(string categoryName)
-        {
-            return _loggers.GetOrAdd(categoryName, CreateLoggerImplementation);
-        }
-
-        private MqttNetLogger CreateLoggerImplementation(string categoryName)
-        {
-            return new MqttNetLogger(categoryName, this);
-        }
-    }
-}

MQTTnet.Core/Diagnostics/MqttNetTraceMessagePublishedEventArgs.cs

@@ -1,14 +0,0 @@
-using System;
-
-namespace MQTTnet.Core.Diagnostics
-{
-    public sealed class MqttNetTraceMessagePublishedEventArgs : EventArgs
-    {
-        public MqttNetTraceMessagePublishedEventArgs(MqttNetTraceMessage traceMessage)
-        {
-            TraceMessage = traceMessage ?? throw new ArgumentNullException(nameof(traceMessage));
-        }
-
-        public MqttNetTraceMessage TraceMessage { get; }
-    }
-}

MQTTnet.Core/MQTTnet.Core.csproj

@@ -17,15 +17,9 @@
     <PackageIconUrl></PackageIconUrl>
     <RepositoryUrl></RepositoryUrl>
     <PackageTags></PackageTags>
-    <FileVersion>2.5.2.0</FileVersion>
-    <AssemblyVersion>2.5.2.0</AssemblyVersion>
+    <FileVersion>2.5.3.0</FileVersion>
+    <AssemblyVersion>2.5.3.0</AssemblyVersion>
     <PackageLicenseUrl></PackageLicenseUrl>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="1.0.2" />
-    <PackageReference Include="Microsoft.Extensions.Options" Version="1.0.2" />
-    <PackageReference Include="System.Threading" Version="4.3.0" />
-  </ItemGroup>
-
 </Project>

MQTTnet.Core/ManagedClient/ManagedMqttClient.cs

@@ -5,9 +5,9 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Client;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Protocol;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.ManagedClient
 {
@@ -18,7 +18,7 @@ namespace MQTTnet.Core.ManagedClient
         private readonly HashSet<TopicFilter> _subscriptions = new HashSet<TopicFilter>();
 
         private readonly IMqttClient _mqttClient;
-        private readonly ILogger<ManagedMqttClient> _logger;
+        private readonly IMqttNetLogger _logger;
 
         private CancellationTokenSource _connectionCancellationToken;
         private CancellationTokenSource _publishingCancellationToken;
@@ -26,7 +26,7 @@ namespace MQTTnet.Core.ManagedClient
         private IManagedMqttClientOptions _options;
         private bool _subscriptionsNotPushed;
         
-        public ManagedMqttClient(ILogger<ManagedMqttClient> logger, IMqttClient mqttClient)
+        public ManagedMqttClient(IMqttClient mqttClient, IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _mqttClient = mqttClient ?? throw new ArgumentNullException(nameof(mqttClient));
@@ -52,10 +52,7 @@ namespace MQTTnet.Core.ManagedClient
                 throw new NotSupportedException("The managed client does not support existing sessions.");
             }
 
-            if (_connectionCancellationToken != null)
-            {
-                throw new InvalidOperationException("The managed client is already started.");
-            }
+            if (_connectionCancellationToken != null) throw new InvalidOperationException("The managed client is already started.");
 
             _options = options;
             await _storageManager.SetStorageAsync(_options.Storage).ConfigureAwait(false);
@@ -72,10 +69,10 @@ namespace MQTTnet.Core.ManagedClient
             _connectionCancellationToken = new CancellationTokenSource();
             
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Factory.StartNew(() => MaintainConnectionAsync(_connectionCancellationToken.Token), _connectionCancellationToken.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default).ConfigureAwait(false);
+            Task.Run(async () => await MaintainConnectionAsync(_connectionCancellationToken.Token), _connectionCancellationToken.Token).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
 
-            _logger.LogInformation("Started");
+            _logger.Info<ManagedMqttClient>("Started");
         }
 
         public Task StopAsync()
@@ -83,6 +80,9 @@ namespace MQTTnet.Core.ManagedClient
             _connectionCancellationToken?.Cancel(false);
             _connectionCancellationToken = null;
 
+            _publishingCancellationToken?.Cancel(false);
+            _publishingCancellationToken = null;
+
             while (_messageQueue.Any())
             {
                 _messageQueue.Take();
@@ -159,7 +159,7 @@ namespace MQTTnet.Core.ManagedClient
                         _publishingCancellationToken = new CancellationTokenSource();
 
 #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-                        Task.Factory.StartNew(() => PublishQueuedMessagesAsync(_publishingCancellationToken.Token), _publishingCancellationToken.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default).ConfigureAwait(false);
+                        Task.Run(async () => await PublishQueuedMessagesAsync(_publishingCancellationToken.Token), _publishingCancellationToken.Token).ConfigureAwait(false);
 #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
 
                         continue;
@@ -167,7 +167,7 @@ namespace MQTTnet.Core.ManagedClient
 
                     if (connectionState == ReconnectionResult.StillConnected)
                     {
-                        await Task.Delay(100, _connectionCancellationToken.Token).ConfigureAwait(false); // Consider using the _Disconnected_ event here. (TaskCompletionSource)
+                        await Task.Delay(TimeSpan.FromSeconds(1), _connectionCancellationToken.Token).ConfigureAwait(false);
                     }
                 }
             }
@@ -176,16 +176,16 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (MqttCommunicationException exception)
             {
-                _logger.LogWarning(new EventId(), exception, "Communication exception while maintaining connection.");
+                _logger.Warning<ManagedMqttClient>(exception, "Communication exception while maintaining connection.");
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while maintaining connection.");
+                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while maintaining connection.");
             }
             finally
             {
                 await _mqttClient.DisconnectAsync().ConfigureAwait(false);
-                _logger.LogInformation("Stopped");
+                _logger.Info<ManagedMqttClient>("Stopped");
             }
         }
 
@@ -215,7 +215,7 @@ namespace MQTTnet.Core.ManagedClient
             }
             finally
             {
-                _logger.LogInformation("Stopped publishing messages");
+                _logger.Info<ManagedMqttClient>("Stopped publishing messages");
             }
         }
 
@@ -227,7 +227,7 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (MqttCommunicationException exception)
             {
-                _logger.LogWarning(new EventId(), exception, "Publishing application message failed.");
+                _logger.Warning<ManagedMqttClient>(exception, "Publishing application message failed.");
 
                 if (message.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
                 {
@@ -236,13 +236,13 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while publishing queued application message.");
+                _logger.Error<ManagedMqttClient>(exception, "Unhandled exception while publishing queued application message.");
             }
         }
 
         private async Task PushSubscriptionsAsync()
         {
-            _logger.LogInformation(nameof(ManagedMqttClient), "Synchronizing subscriptions");
+            _logger.Info<ManagedMqttClient>(nameof(ManagedMqttClient), "Synchronizing subscriptions");
 
             List<TopicFilter> subscriptions;
             lock (_subscriptions)
@@ -262,7 +262,7 @@ namespace MQTTnet.Core.ManagedClient
             }
             catch (Exception exception)
             {
-                _logger.LogWarning(new EventId(), exception, "Synchronizing subscriptions failed");
+                _logger.Warning<ManagedMqttClient>(exception, "Synchronizing subscriptions failed");
                 _subscriptionsNotPushed = true;
             }
         }

MQTTnet.Core/Server/IMqttClientRetainedMessageManager.cs

@@ -1,15 +0,0 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using MQTTnet.Core.Packets;
-
-namespace MQTTnet.Core.Server
-{
-    public interface IMqttClientRetainedMessageManager
-    {
-        Task LoadMessagesAsync();
-
-        Task HandleMessageAsync(string clientId, MqttApplicationMessage applicationMessage);
-
-        Task<List<MqttApplicationMessage>> GetSubscribedMessagesAsync(MqttSubscribePacket subscribePacket);
-    }
-}

MQTTnet.Core/Server/IMqttClientSesssionFactory.cs

@@ -1,7 +0,0 @@
-namespace MQTTnet.Core.Server
-{
-    public interface IMqttClientSesssionFactory
-    {
-        MqttClientSession CreateClientSession(string sessionId, MqttClientSessionsManager mqttClientSessionsManager);
-    }
-}

MQTTnet.Core/Server/IMqttServer.cs

@@ -12,7 +12,7 @@ namespace MQTTnet.Core.Server
 
         Task<IList<ConnectedMqttClient>> GetConnectedClientsAsync();
 
-        Task StartAsync();
+        Task StartAsync(MqttServerOptions options);
         Task StopAsync();
     }
 }

MQTTnet.Core/Server/IMqttServerFactory.cs

@@ -1,4 +1,6 @@
-using System;
+using System.Collections.Generic;
+using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
 
 namespace MQTTnet.Core.Server
 {
@@ -6,6 +8,6 @@ namespace MQTTnet.Core.Server
     {
         IMqttServer CreateMqttServer();
 
-        IMqttServer CreateMqttServer(Action<MqttServerOptions> configure);
+        IMqttServer CreateMqttServer(IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger);
     }
 }

MQTTnet.Core/Server/MqttClientPendingMessagesQueue.cs

@@ -3,10 +3,10 @@ using System.Collections.Concurrent;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.Core.Server
 {
@@ -15,16 +15,16 @@ namespace MQTTnet.Core.Server
         private readonly BlockingCollection<MqttPublishPacket> _pendingPublishPackets = new BlockingCollection<MqttPublishPacket>();
         private readonly MqttServerOptions _options;
         private readonly MqttClientSession _session;
-        private readonly ILogger<MqttClientPendingMessagesQueue> _logger;
+        private readonly IMqttNetLogger _logger;
 
-        public MqttClientPendingMessagesQueue(MqttServerOptions options, MqttClientSession session, ILogger<MqttClientPendingMessagesQueue> logger)
+        public MqttClientPendingMessagesQueue(MqttServerOptions options, MqttClientSession session, IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
             _session = session ?? throw new ArgumentNullException(nameof(session));
             _options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
-        public void Start(IMqttCommunicationAdapter adapter, CancellationToken cancellationToken)
+        public void Start(IMqttChannelAdapter adapter, CancellationToken cancellationToken)
         {
             if (adapter == null) throw new ArgumentNullException(nameof(adapter));
 
@@ -41,10 +41,10 @@ namespace MQTTnet.Core.Server
             if (publishPacket == null) throw new ArgumentNullException(nameof(publishPacket));
 
             _pendingPublishPackets.Add(publishPacket);
-            _logger.LogTrace("Enqueued packet (ClientId: {0}).", _session.ClientId);
+            _logger.Trace<MqttClientPendingMessagesQueue>("Enqueued packet (ClientId: {0}).", _session.ClientId);
         }
 
-        private async Task SendPendingPublishPacketsAsync(IMqttCommunicationAdapter adapter, CancellationToken cancellationToken)
+        private async Task SendPendingPublishPacketsAsync(IMqttChannelAdapter adapter, CancellationToken cancellationToken)
         {
             try
             {
@@ -58,11 +58,11 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while sending enqueued packet (ClientId: {0}).", _session.ClientId);
+                _logger.Error<MqttClientPendingMessagesQueue>(exception, "Unhandled exception while sending enqueued packet (ClientId: {0}).", _session.ClientId);
             }
         }
 
-        private async Task SendPendingPublishPacketAsync(IMqttCommunicationAdapter adapter, CancellationToken cancellationToken)
+        private async Task SendPendingPublishPacketAsync(IMqttChannelAdapter adapter, CancellationToken cancellationToken)
         {
             MqttPublishPacket packet = null;
             try
@@ -70,24 +70,24 @@ namespace MQTTnet.Core.Server
                 packet = _pendingPublishPackets.Take(cancellationToken);
                 await adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, packet).ConfigureAwait(false);
 
-                _logger.LogTrace("Enqueued packet sent (ClientId: {0}).", _session.ClientId);
+                _logger.Trace<MqttClientPendingMessagesQueue>("Enqueued packet sent (ClientId: {0}).", _session.ClientId);
             }
             catch (Exception exception)
             {
                 if (exception is MqttCommunicationTimedOutException)
                 {
-                    _logger.LogWarning(new EventId(), exception, "Sending publish packet failed due to timeout (ClientId: {0}).", _session.ClientId);
+                    _logger.Warning<MqttClientPendingMessagesQueue>(exception, "Sending publish packet failed due to timeout (ClientId: {0}).", _session.ClientId);
                 }
                 else if (exception is MqttCommunicationException)
                 {
-                    _logger.LogWarning(new EventId(), exception, "Sending publish packet failed due to communication exception (ClientId: {0}).", _session.ClientId);
+                    _logger.Warning<MqttClientPendingMessagesQueue>(exception, "Sending publish packet failed due to communication exception (ClientId: {0}).", _session.ClientId);
                 }
                 else if (exception is OperationCanceledException)
                 {
                 }
                 else
                 {
-                    _logger.LogError(new EventId(), exception, "Sending publish packet failed (ClientId: {0}).", _session.ClientId);
+                    _logger.Error<MqttClientPendingMessagesQueue>(exception, "Sending publish packet failed (ClientId: {0}).", _session.ClientId);
                 }
 
                 if (packet != null && packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)

MQTTnet.Core/Server/MqttClientSession.cs

@@ -3,13 +3,12 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
 using MQTTnet.Core.Serializer;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 
 namespace MQTTnet.Core.Server
 {
@@ -21,28 +20,27 @@ namespace MQTTnet.Core.Server
         private readonly MqttClientSessionsManager _sessionsManager;
         private readonly MqttClientPendingMessagesQueue _pendingMessagesQueue;
         private readonly MqttServerOptions _options;
-        private readonly ILogger<MqttClientSession> _logger;
+        private readonly IMqttNetLogger _logger;
 
-        private IMqttCommunicationAdapter _adapter;
+        private IMqttChannelAdapter _adapter;
         private CancellationTokenSource _cancellationTokenSource;
         private MqttApplicationMessage _willMessage;
 
         public MqttClientSession(
             string clientId,
-            IOptions<MqttServerOptions> options,
+            MqttServerOptions options,
             MqttClientSessionsManager sessionsManager,
-            MqttClientSubscriptionsManager subscriptionsManager,
-            ILogger<MqttClientSession> logger,
-            ILogger<MqttClientPendingMessagesQueue> messageQueueLogger)
+            IMqttNetLogger logger)
         {
             _sessionsManager = sessionsManager ?? throw new ArgumentNullException(nameof(sessionsManager));
-            _subscriptionsManager = subscriptionsManager ?? throw new ArgumentNullException(nameof(subscriptionsManager));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
 
             ClientId = clientId;
 
-            _options = options.Value;
-            _pendingMessagesQueue = new MqttClientPendingMessagesQueue(_options, this, messageQueueLogger);
+            _options = options;
+
+            _subscriptionsManager = new MqttClientSubscriptionsManager(_options);
+            _pendingMessagesQueue = new MqttClientPendingMessagesQueue(_options, this, _logger);
         }
 
         public string ClientId { get; }
@@ -51,7 +49,7 @@ namespace MQTTnet.Core.Server
 
         public bool IsConnected => _adapter != null;
 
-        public async Task RunAsync(MqttApplicationMessage willMessage, IMqttCommunicationAdapter adapter)
+        public async Task RunAsync(MqttApplicationMessage willMessage, IMqttChannelAdapter adapter)
         {
             if (adapter == null) throw new ArgumentNullException(nameof(adapter));
 
@@ -71,11 +69,11 @@ namespace MQTTnet.Core.Server
             }
             catch (MqttCommunicationException exception)
             {
-                _logger.LogWarning(new EventId(), exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
+                _logger.Warning<MqttClientSession>(exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
+                _logger.Error<MqttClientSession>(exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
             }
         }
 
@@ -93,7 +91,7 @@ namespace MQTTnet.Core.Server
                     _adapter = null;
                 }
 
-                _logger.LogInformation("Client '{0}': Session stopped.", ClientId);
+                _logger.Info<MqttClientSession>("Client '{0}': Session stopped.", ClientId);
             }
             finally
             {
@@ -120,7 +118,7 @@ namespace MQTTnet.Core.Server
             _pendingMessagesQueue.Enqueue(publishPacket);
         }
 
-        private async Task ReceivePacketsAsync(IMqttCommunicationAdapter adapter, CancellationToken cancellationToken)
+        private async Task ReceivePacketsAsync(IMqttChannelAdapter adapter, CancellationToken cancellationToken)
         {
             try
             {
@@ -135,17 +133,17 @@ namespace MQTTnet.Core.Server
             }
             catch (MqttCommunicationException exception)
             {
-                _logger.LogWarning(new EventId(), exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
+                _logger.Warning<MqttClientSession>(exception, "Client '{0}': Communication exception while processing client packets.", ClientId);
                 await StopAsync();
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
+                _logger.Error<MqttClientSession>(exception, "Client '{0}': Unhandled exception while processing client packets.", ClientId);
                 await StopAsync();
             }
         }
 
-        private Task ProcessReceivedPacketAsync(IMqttCommunicationAdapter adapter, MqttBasePacket packet, CancellationToken cancellationToken)
+        private Task ProcessReceivedPacketAsync(IMqttChannelAdapter adapter, MqttBasePacket packet, CancellationToken cancellationToken)
         {
             if (packet is MqttPingReqPacket)
             {
@@ -188,11 +186,11 @@ namespace MQTTnet.Core.Server
                 return StopAsync();
             }
 
-            _logger.LogWarning("Client '{0}': Received not supported packet ({1}). Closing connection.", ClientId, packet);
+            _logger.Warning<MqttClientSession>("Client '{0}': Received not supported packet ({1}). Closing connection.", ClientId, packet);
             return StopAsync();            
         }
 
-        private async Task HandleIncomingSubscribePacketAsync(IMqttCommunicationAdapter adapter, MqttSubscribePacket subscribePacket, CancellationToken cancellationToken)
+        private async Task HandleIncomingSubscribePacketAsync(IMqttChannelAdapter adapter, MqttSubscribePacket subscribePacket, CancellationToken cancellationToken)
         {
             var subscribeResult = _subscriptionsManager.Subscribe(subscribePacket, ClientId);
 
@@ -215,7 +213,7 @@ namespace MQTTnet.Core.Server
             }
         }
 
-        private async Task HandleIncomingPublishPacketAsync(IMqttCommunicationAdapter adapter, MqttPublishPacket publishPacket, CancellationToken cancellationToken)
+        private async Task HandleIncomingPublishPacketAsync(IMqttChannelAdapter adapter, MqttPublishPacket publishPacket, CancellationToken cancellationToken)
         {
             var applicationMessage = publishPacket.ToApplicationMessage();
 
@@ -255,7 +253,7 @@ namespace MQTTnet.Core.Server
             }
         }
 
-        private Task HandleIncomingPubRelPacketAsync(IMqttCommunicationAdapter adapter, MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
+        private Task HandleIncomingPubRelPacketAsync(IMqttChannelAdapter adapter, MqttPubRelPacket pubRelPacket, CancellationToken cancellationToken)
         {
             lock (_unacknowledgedPublishPackets)
             {

MQTTnet.Core/Server/MqttClientSessionsManager.cs

@@ -4,13 +4,12 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
 using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
 using MQTTnet.Core.Serializer;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 
 namespace MQTTnet.Core.Server
 {
@@ -20,27 +19,21 @@ namespace MQTTnet.Core.Server
         private readonly SemaphoreSlim _sessionsSemaphore = new SemaphoreSlim(1, 1);
 
         private readonly MqttServerOptions _options;
-        private readonly ILogger<MqttClientSessionsManager> _logger;
-        private readonly IMqttClientSesssionFactory _clientSesssionFactory;
-        private readonly IMqttClientRetainedMessageManager _clientRetainedMessageManager;
-
-        public MqttClientSessionsManager(
-            IOptions<MqttServerOptions> options,
-            ILogger<MqttClientSessionsManager> logger,
-            IMqttClientSesssionFactory clientSesssionFactory,
-            IMqttClientRetainedMessageManager clientRetainedMessageManager)
+        private readonly MqttRetainedMessagesManager _retainedMessagesManager;
+        private readonly IMqttNetLogger _logger;
+
+        public MqttClientSessionsManager(MqttServerOptions options, MqttRetainedMessagesManager retainedMessagesManager, IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _options = options.Value ?? throw new ArgumentNullException(nameof(options));
-            _clientSesssionFactory = clientSesssionFactory ?? throw new ArgumentNullException(nameof(clientSesssionFactory));
-            _clientRetainedMessageManager = clientRetainedMessageManager ?? throw new ArgumentNullException(nameof(clientRetainedMessageManager));
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+            _retainedMessagesManager = retainedMessagesManager ?? throw new ArgumentNullException(nameof(retainedMessagesManager));
         }
 
         public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
         public event EventHandler<MqttClientDisconnectedEventArgs> ClientDisconnected;
         public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
 
-        public async Task RunClientSessionAsync(IMqttCommunicationAdapter clientAdapter, CancellationToken cancellationToken)
+        public async Task RunClientSessionAsync(IMqttChannelAdapter clientAdapter, CancellationToken cancellationToken)
         {
             var clientId = string.Empty;
             try
@@ -80,14 +73,11 @@ namespace MQTTnet.Core.Server
                     ProtocolVersion = clientAdapter.PacketSerializer.ProtocolVersion
                 }));
 
-                using (_logger.BeginScope(clientId))
-                {
-                    await clientSession.Session.RunAsync(connectPacket.WillMessage, clientAdapter).ConfigureAwait(false);
-                }
+                await clientSession.Session.RunAsync(connectPacket.WillMessage, clientAdapter).ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, exception.Message);
+                _logger.Error<MqttClientSessionsManager>(exception, exception.Message);
             }
             finally
             {
@@ -157,7 +147,7 @@ namespace MQTTnet.Core.Server
 
                 if (applicationMessage.Retain)
                 {
-                    await _clientRetainedMessageManager.HandleMessageAsync(senderClientSession?.ClientId, applicationMessage).ConfigureAwait(false);
+                    await _retainedMessagesManager.HandleMessageAsync(senderClientSession?.ClientId, applicationMessage).ConfigureAwait(false);
                 }
 
                 var eventArgs = new MqttApplicationMessageReceivedEventArgs(senderClientSession?.ClientId, applicationMessage);
@@ -165,7 +155,7 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Error while processing application message");
+                _logger.Error<MqttClientSessionsManager>(exception, "Error while processing application message");
             }
 
             lock (_sessions)
@@ -179,7 +169,7 @@ namespace MQTTnet.Core.Server
 
         public Task<List<MqttApplicationMessage>> GetRetainedMessagesAsync(MqttSubscribePacket subscribePacket)
         {
-            return _clientRetainedMessageManager.GetSubscribedMessagesAsync(subscribePacket);
+            return _retainedMessagesManager.GetSubscribedMessagesAsync(subscribePacket);
         }
 
         private MqttConnectReturnCode ValidateConnection(MqttConnectPacket connectPacket)
@@ -206,11 +196,11 @@ namespace MQTTnet.Core.Server
                         await clientSession.StopAsync();
                         clientSession = null;
 
-                        _logger.LogTrace("Stopped existing session of client '{0}'.", connectPacket.ClientId);
+                        _logger.Trace<MqttClientSessionsManager>("Stopped existing session of client '{0}'.", connectPacket.ClientId);
                     }
                     else
                     {
-                        _logger.LogTrace("Reusing existing session of client '{0}'.", connectPacket.ClientId);
+                        _logger.Trace<MqttClientSessionsManager>("Reusing existing session of client '{0}'.", connectPacket.ClientId);
                     }
                 }
 
@@ -219,10 +209,10 @@ namespace MQTTnet.Core.Server
                 {
                     isExistingSession = false;
 
-                    clientSession = _clientSesssionFactory.CreateClientSession(connectPacket.ClientId, this);
+                    clientSession = new MqttClientSession(connectPacket.ClientId, _options, this, _logger);
                     _sessions[connectPacket.ClientId] = clientSession;
 
-                    _logger.LogTrace("Created a new session for client '{0}'.", connectPacket.ClientId);
+                    _logger.Trace<MqttClientSessionsManager>("Created a new session for client '{0}'.", connectPacket.ClientId);
                 }
 
                 return new GetOrCreateClientSessionResult { IsExistingSession = isExistingSession, Session = clientSession };

MQTTnet.Core/Server/MqttClientSubscriptionsManager.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using Microsoft.Extensions.Options;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
 
@@ -11,9 +10,9 @@ namespace MQTTnet.Core.Server
         private readonly Dictionary<string, MqttQualityOfServiceLevel> _subscriptions = new Dictionary<string, MqttQualityOfServiceLevel>();
         private readonly MqttServerOptions _options;
 
-        public MqttClientSubscriptionsManager(IOptions<MqttServerOptions> options)
+        public MqttClientSubscriptionsManager(MqttServerOptions options)
         {
-            _options = options?.Value ?? throw new ArgumentNullException(nameof(options));
+            _options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
         public MqttClientSubscribeResult Subscribe(MqttSubscribePacket subscribePacket, string clientId)

MQTTnet.Core/Server/MqttClientRetainedMessagesManager.cs → MQTTnet.Core/Server/MqttRetainedMessagesManager.cs

@@ -4,22 +4,21 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Packets;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
+using MQTTnet.Core.Diagnostics;
 
 namespace MQTTnet.Core.Server
 {
-    public sealed class MqttClientRetainedMessagesManager : IMqttClientRetainedMessageManager
+    public sealed class MqttRetainedMessagesManager
     {
         private readonly Dictionary<string, MqttApplicationMessage> _retainedMessages = new Dictionary<string, MqttApplicationMessage>();
         private readonly SemaphoreSlim _gate = new SemaphoreSlim(1, 1);
-        private readonly ILogger<MqttClientRetainedMessagesManager> _logger;
+        private readonly IMqttNetLogger _logger;
         private readonly MqttServerOptions _options;
 
-        public MqttClientRetainedMessagesManager(IOptions<MqttServerOptions> options, ILogger<MqttClientRetainedMessagesManager> logger)
+        public MqttRetainedMessagesManager(MqttServerOptions options, IMqttNetLogger logger)
         {
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _options = options.Value ?? throw new ArgumentNullException(nameof(options));
+            _options = options ?? throw new ArgumentNullException(nameof(options));
         }
 
         public async Task LoadMessagesAsync()
@@ -42,7 +41,7 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while loading retained messages.");
+                _logger.Error<MqttRetainedMessagesManager>(exception, "Unhandled exception while loading retained messages.");
             }
             finally
             {
@@ -61,7 +60,7 @@ namespace MQTTnet.Core.Server
             }
             catch (Exception exception)
             {
-                _logger.LogError(new EventId(), exception, "Unhandled exception while handling retained messages.");
+                _logger.Error<MqttRetainedMessagesManager>(exception, "Unhandled exception while handling retained messages.");
             }
             finally
             {
@@ -110,7 +109,7 @@ namespace MQTTnet.Core.Server
             if (applicationMessage.Payload?.Any() == false)
             {
                 saveIsRequired = _retainedMessages.Remove(applicationMessage.Topic);
-                _logger.LogInformation("Client '{0}' cleared retained message for topic '{1}'.", clientId, applicationMessage.Topic);
+                _logger.Info<MqttRetainedMessagesManager>("Client '{0}' cleared retained message for topic '{1}'.", clientId, applicationMessage.Topic);
             }
             else
             {
@@ -129,12 +128,12 @@ namespace MQTTnet.Core.Server
                     }
                 }
 
-                _logger.LogInformation("Client '{0}' set retained message for topic '{1}'.", clientId, applicationMessage.Topic);
+                _logger.Info<MqttRetainedMessagesManager>("Client '{0}' set retained message for topic '{1}'.", clientId, applicationMessage.Topic);
             }
 
             if (!saveIsRequired)
             {
-                _logger.LogTrace("Skipped saving retained messages because no changes were detected.");
+                _logger.Trace<MqttRetainedMessagesManager>("Skipped saving retained messages because no changes were detected.");
             }
 
             if (saveIsRequired && _options.Storage != null)

MQTTnet.Core/Server/MqttServer.cs

@@ -3,33 +3,24 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Options;
 using System.Linq;
+using MQTTnet.Core.Diagnostics;
 
 namespace MQTTnet.Core.Server
 {
     public class MqttServer : IMqttServer
     {
-        private readonly IMqttClientRetainedMessageManager _clientRetainedMessageManager;
-        private readonly ILogger<MqttServer> _logger;
-        private readonly MqttClientSessionsManager _clientSessionsManager;
         private readonly ICollection<IMqttServerAdapter> _adapters;
-        private readonly MqttServerOptions _options;
+        private readonly IMqttNetLogger _logger;
 
+        private MqttClientSessionsManager _clientSessionsManager;
+        private MqttRetainedMessagesManager _retainedMessagesManager;
         private CancellationTokenSource _cancellationTokenSource;
+        private MqttServerOptions _options;
 
-        public MqttServer(
-            IOptions<MqttServerOptions> options,
-            IEnumerable<IMqttServerAdapter> adapters,
-            ILogger<MqttServer> logger,
-            MqttClientSessionsManager clientSessionsManager,
-            IMqttClientRetainedMessageManager clientRetainedMessageManager)
+        public MqttServer(IEnumerable<IMqttServerAdapter> adapters, IMqttNetLogger logger)
         {
-            _options = options.Value ?? throw new ArgumentNullException(nameof(options));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            _clientSessionsManager = clientSessionsManager ?? throw new ArgumentNullException(nameof(clientSessionsManager));
-            _clientRetainedMessageManager = clientRetainedMessageManager ?? throw new ArgumentNullException(nameof(clientRetainedMessageManager));
 
             if (adapters == null)
             {
@@ -37,15 +28,6 @@ namespace MQTTnet.Core.Server
             }
 
             _adapters = adapters.ToList();
-
-            _clientSessionsManager.ApplicationMessageReceived += (s, e) => ApplicationMessageReceived?.Invoke(s, e);
-            _clientSessionsManager.ClientConnected += OnClientConnected;
-            _clientSessionsManager.ClientDisconnected += OnClientDisconnected;
-        }
-
-        public Task<IList<ConnectedMqttClient>> GetConnectedClientsAsync()
-        {
-            return _clientSessionsManager.GetConnectedClientsAsync();
         }
 
         public event EventHandler<MqttServerStartedEventArgs> Started;
@@ -53,14 +35,16 @@ namespace MQTTnet.Core.Server
         public event EventHandler<MqttClientDisconnectedEventArgs> ClientDisconnected;
         public event EventHandler<MqttApplicationMessageReceivedEventArgs> ApplicationMessageReceived;
 
+        public Task<IList<ConnectedMqttClient>> GetConnectedClientsAsync()
+        {
+            return _clientSessionsManager.GetConnectedClientsAsync();
+        }
+
         public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
         {
             if (applicationMessages == null) throw new ArgumentNullException(nameof(applicationMessages));
 
-            if (_cancellationTokenSource == null)
-            {
-                throw new InvalidOperationException("The server is not started.");
-            }
+            if (_cancellationTokenSource == null) throw new InvalidOperationException("The server is not started.");
 
             foreach (var applicationMessage in applicationMessages)
             {
@@ -68,13 +52,21 @@ namespace MQTTnet.Core.Server
             }
         }
 
-        public async Task StartAsync()
+        public async Task StartAsync(MqttServerOptions options)
         {
-            if (_cancellationTokenSource != null) throw new InvalidOperationException("The MQTT server is already started.");
+            _options = options ?? throw new ArgumentNullException(nameof(options));
+
+            if (_cancellationTokenSource != null) throw new InvalidOperationException("The server is already started.");
 
             _cancellationTokenSource = new CancellationTokenSource();
+            _retainedMessagesManager = new MqttRetainedMessagesManager(_options, _logger);
 
-            await _clientRetainedMessageManager.LoadMessagesAsync();
+            _clientSessionsManager = new MqttClientSessionsManager(_options, _retainedMessagesManager, _logger);
+            _clientSessionsManager.ApplicationMessageReceived += OnApplicationMessageReceived;
+            _clientSessionsManager.ClientConnected += OnClientConnected;
+            _clientSessionsManager.ClientDisconnected += OnClientDisconnected;
+
+            await _retainedMessagesManager.LoadMessagesAsync();
 
             foreach (var adapter in _adapters)
             {
@@ -82,26 +74,48 @@ namespace MQTTnet.Core.Server
                 await adapter.StartAsync(_options);
             }
 
-            _logger.LogInformation("Started.");
+            _logger.Info<MqttServer>("Started.");
 
             Started?.Invoke(this, new MqttServerStartedEventArgs());
         }
 
         public async Task StopAsync()
         {
-            _cancellationTokenSource?.Cancel(false);
-            _cancellationTokenSource?.Dispose();
-            _cancellationTokenSource = null;
-
-            foreach (var adapter in _adapters)
+            try
             {
-                adapter.ClientAccepted -= OnClientAccepted;
-                await adapter.StopAsync();
+                if (_cancellationTokenSource == null)
+                {
+                    return;
+                }
+
+                _cancellationTokenSource.Cancel(false);
+                _cancellationTokenSource.Dispose();
+
+                foreach (var adapter in _adapters)
+                {
+                    adapter.ClientAccepted -= OnClientAccepted;
+                    await adapter.StopAsync();
+                }
+
+                await _clientSessionsManager.StopAsync();
+
+                _logger.Info<MqttServer>("Stopped.");
             }
+            finally
+            {
+                _cancellationTokenSource = null;
 
-            await _clientSessionsManager.StopAsync();
+                _retainedMessagesManager = null;
 
-            _logger.LogInformation("Stopped.");
+                if (_clientSessionsManager != null)
+                {
+                    _clientSessionsManager.ApplicationMessageReceived -= OnApplicationMessageReceived;
+                    _clientSessionsManager.ClientConnected -= OnClientConnected;
+                    _clientSessionsManager.ClientDisconnected -= OnClientDisconnected;
+                }
+
+                _clientSessionsManager = null;
+            }
         }
 
         private void OnClientAccepted(object sender, MqttServerAdapterClientAcceptedEventArgs eventArgs)
@@ -111,14 +125,19 @@ namespace MQTTnet.Core.Server
 
         private void OnClientConnected(object sender, MqttClientConnectedEventArgs eventArgs)
         {
-            _logger.LogInformation("Client '{0}': Connected.", eventArgs.Client.ClientId);
+            _logger.Info<MqttServer>("Client '{0}': Connected.", eventArgs.Client.ClientId);
             ClientConnected?.Invoke(this, eventArgs);
         }
 
         private void OnClientDisconnected(object sender, MqttClientDisconnectedEventArgs eventArgs)
         {
-            _logger.LogInformation("Client '{0}': Disconnected.", eventArgs.Client.ClientId);
+            _logger.Info<MqttServer>("Client '{0}': Disconnected.", eventArgs.Client.ClientId);
             ClientDisconnected?.Invoke(this, eventArgs);
         }
+
+        private void OnApplicationMessageReceived(object sender, MqttApplicationMessageReceivedEventArgs e)
+        {
+            ApplicationMessageReceived?.Invoke(this, e);
+        }
     }
 }

Tests/MQTTnet.Core.Tests/MQTTnet.Core.Tests.csproj

@@ -9,7 +9,7 @@
   <ItemGroup>
     <PackageReference Include="MSTest.TestAdapter" Version="1.2.0" />
     <PackageReference Include="MSTest.TestFramework" Version="1.2.0" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.3.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.5.0" />
   </ItemGroup>
 
   <ItemGroup>

Tests/MQTTnet.Core.Tests/MqttLoggerProviderTest.cs

@@ -1,51 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading.Tasks;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Core.Diagnostics;
-
-namespace MQTTnet.Core.Tests
-{
-    [TestClass]
-    public class MqttLoggerProviderTest
-    {
-        [TestMethod]
-        public void TestLoggerCallback()
-        {
-            var serviceCollection = new ServiceCollection();
-            serviceCollection.AddLogging();
-
-            var serviceProvider = serviceCollection.BuildServiceProvider();
-            using ((IDisposable)serviceProvider)
-            {
-                var loggerFactory = serviceProvider.GetRequiredService<ILoggerFactory>();
-
-                loggerFactory.AddMqttTrace();
-
-                var expectedMsg = "Hello World!";
-                MqttNetTraceMessage msg = null;
-
-                MqttNetTrace.TraceMessagePublished += (sender, args) =>
-                {
-                    msg = args.TraceMessage;
-                };
-
-                var logger = loggerFactory.CreateLogger<MqttLoggerProviderTest>();
-
-                logger.LogInformation(expectedMsg);
-
-                Assert.AreEqual(expectedMsg, msg.Message);
-
-                var expectedException = new Exception("bad stuff");
-
-                logger.LogError(new EventId(), expectedException, expectedException.Message);
-                
-                Assert.AreEqual(expectedException, msg.Exception);
-                Assert.AreEqual(expectedException.Message, msg.Message);
-            }
-        }
-    }
-}

Tests/MQTTnet.Core.Tests/MqttServerTests.cs

@@ -1,16 +1,12 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
-using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Client;
+using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Protocol;
 using MQTTnet.Core.Server;
-using Microsoft.Extensions.DependencyInjection;
-using MQTTnet.Core.Internal;
-using MQTTnet.Core.Packets;
 
 namespace MQTTnet.Core.Tests
 {
@@ -54,18 +50,12 @@ namespace MQTTnet.Core.Tests
         public async Task MqttServer_WillMessage()
         {
             var serverAdapter = new TestMqttServerAdapter();
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
-
-            var s = new MqttFactory(services).CreateMqttServer();
             var receivedMessagesCount = 0;
             try
             {
-                await s.StartAsync();
+                await s.StartAsync(new MqttServerOptions());
 
                 var willMessage = new MqttApplicationMessageBuilder().WithTopic("My/last/will").WithAtMostOnceQoS().Build();
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
@@ -92,19 +82,13 @@ namespace MQTTnet.Core.Tests
         public async Task MqttServer_Unsubscribe()
         {
             var serverAdapter = new TestMqttServerAdapter();
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
-
-            var s = new MqttFactory(services).CreateMqttServer();
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
             var receivedMessagesCount = 0;
 
             try
             {
-                await s.StartAsync();
+                await s.StartAsync(new MqttServerOptions());
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
                 var c2 = await serverAdapter.ConnectTestClient(s, "c2");
@@ -140,18 +124,12 @@ namespace MQTTnet.Core.Tests
         public async Task MqttServer_Publish()
         {
             var serverAdapter = new TestMqttServerAdapter();
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
-
-            var s = new MqttFactory(services).CreateMqttServer();
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
             var receivedMessagesCount = 0;
 
             try
             {
-                await s.StartAsync();
+                await s.StartAsync(new MqttServerOptions());
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
 
@@ -167,7 +145,7 @@ namespace MQTTnet.Core.Tests
             {
                 await s.StopAsync();
             }
-            
+
             Assert.AreEqual(1, receivedMessagesCount);
         }
 
@@ -175,18 +153,13 @@ namespace MQTTnet.Core.Tests
         public async Task MqttServer_NoRetainedMessage()
         {
             var serverAdapter = new TestMqttServerAdapter();
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
-            var s = new MqttFactory(services).CreateMqttServer();
             var receivedMessagesCount = 0;
 
             try
             {
-                await s.StartAsync();
+                await s.StartAsync(new MqttServerOptions());
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).Build());
@@ -194,7 +167,7 @@ namespace MQTTnet.Core.Tests
 
                 var c2 = await serverAdapter.ConnectTestClient(s, "c2");
                 c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
-                await c2.SubscribeAsync(new TopicFilter("retained", MqttQualityOfServiceLevel.AtMostOnce));
+                await c2.SubscribeAsync(new TopicFilter("retained"));
 
                 await Task.Delay(500);
             }
@@ -210,28 +183,23 @@ namespace MQTTnet.Core.Tests
         public async Task MqttServer_RetainedMessage()
         {
             var serverAdapter = new TestMqttServerAdapter();
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
-
-            var s = new MqttFactory(services).CreateMqttServer();
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
             var receivedMessagesCount = 0;
             try
             {
-                await s.StartAsync();
+                await s.StartAsync(new MqttServerOptions());
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
                 await c1.DisconnectAsync();
 
-                await services.WaitForRetainedMessage("retained").TimeoutAfter(TimeSpan.FromSeconds(5));
+                await Task.Delay(TimeSpan.FromSeconds(2));
+                // TODO: Find another way to wait for the retained components.
 
                 var c2 = await serverAdapter.ConnectTestClient(s, "c2");
                 c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
-                await c2.SubscribeAsync(new TopicFilter("retained", MqttQualityOfServiceLevel.AtMostOnce));
+                await c2.SubscribeAsync(new TopicFilter("retained"));
 
                 await Task.Delay(500);
             }
@@ -239,7 +207,7 @@ namespace MQTTnet.Core.Tests
             {
                 await s.StopAsync();
             }
-            
+
             Assert.AreEqual(1, receivedMessagesCount);
         }
 
@@ -247,17 +215,12 @@ namespace MQTTnet.Core.Tests
         public async Task MqttServer_ClearRetainedMessage()
         {
             var serverAdapter = new TestMqttServerAdapter();
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
-            var s = new MqttFactory(services).CreateMqttServer();
             var receivedMessagesCount = 0;
             try
             {
-                await s.StartAsync();
+                await s.StartAsync(new MqttServerOptions());
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
@@ -284,18 +247,13 @@ namespace MQTTnet.Core.Tests
         {
             var storage = new TestStorage();
             var serverAdapter = new TestMqttServerAdapter();
-
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
-
-            var s = new MqttFactory(services).CreateMqttServer(options => options.Storage = storage);
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
             try
             {
-                await s.StartAsync();
+                var options = new MqttServerOptions { Storage = storage };
+
+                await s.StartAsync(options);
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
                 await c1.PublishAsync(new MqttApplicationMessageBuilder().WithTopic("retained").WithPayload(new byte[3]).WithRetainFlag().Build());
@@ -306,18 +264,20 @@ namespace MQTTnet.Core.Tests
                 await s.StopAsync();
             }
 
-            await services.WaitForRetainedMessage("retained").TimeoutAfter(TimeSpan.FromSeconds(5));
+            await Task.Delay(TimeSpan.FromSeconds(2));
+            // TODO: Find another way to wait for the retained components.
 
-            s = new MqttFactory(services).CreateMqttServer(options => options.Storage = storage);
+            s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
             var receivedMessagesCount = 0;
             try
             {
-                await s.StartAsync();
+                var options = new MqttServerOptions { Storage = storage };
+                await s.StartAsync(options);
 
                 var c2 = await serverAdapter.ConnectTestClient(s, "c2");
                 c2.ApplicationMessageReceived += (_, __) => receivedMessagesCount++;
-                await c2.SubscribeAsync(new TopicFilter("retained", MqttQualityOfServiceLevel.AtMostOnce));
+                await c2.SubscribeAsync(new TopicFilter("retained"));
 
                 await Task.Delay(500);
             }
@@ -338,16 +298,13 @@ namespace MQTTnet.Core.Tests
             }
 
             var serverAdapter = new TestMqttServerAdapter();
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
-
-            var s = new MqttFactory(services).CreateMqttServer(options => options.ApplicationMessageInterceptor = Interceptor);
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
+            
             try
             {
-                await s.StartAsync();
+                var options = new MqttServerOptions { ApplicationMessageInterceptor = Interceptor };
+
+                await s.StartAsync(options);
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
                 var c2 = await serverAdapter.ConnectTestClient(s, "c2");
@@ -397,17 +354,12 @@ namespace MQTTnet.Core.Tests
             int expectedReceivedMessagesCount)
         {
             var serverAdapter = new TestMqttServerAdapter();
-            var services = new ServiceCollection()
-                .AddMqttServer()
-                .AddLogging()
-                .AddSingleton<IMqttServerAdapter>(serverAdapter)
-                .BuildServiceProvider();
+            var s = new MqttFactory().CreateMqttServer(new[] { serverAdapter }, new MqttNetLogger());
 
-            var s = services.GetRequiredService<IMqttServer>();
             var receivedMessagesCount = 0;
             try
             {
-                await s.StartAsync();
+                await s.StartAsync(new MqttServerOptions());
 
                 var c1 = await serverAdapter.ConnectTestClient(s, "c1");
                 var c2 = await serverAdapter.ConnectTestClient(s, "c2");
@@ -426,29 +378,8 @@ namespace MQTTnet.Core.Tests
             {
                 await s.StopAsync();
             }
-            
-            Assert.AreEqual(expectedReceivedMessagesCount, receivedMessagesCount);
-        }
-    }
 
-    public static class TestExtensions
-    {
-        public static async Task WaitForRetainedMessage(this IServiceProvider services, string topic)
-        {
-            var retainMessagemanager = services.GetRequiredService<IMqttClientRetainedMessageManager>();
-            
-            var subscribe = new MqttSubscribePacket()
-            {
-                TopicFilters = new List<TopicFilter>()
-                {
-                    new TopicFilter(topic, MqttQualityOfServiceLevel.AtMostOnce)
-                }
-            };
-
-            while (!(await retainMessagemanager.GetSubscribedMessagesAsync(subscribe)).Any())
-            {
-                await Task.Delay(TimeSpan.FromMilliseconds(10));
-            }
+            Assert.AreEqual(expectedReceivedMessagesCount, receivedMessagesCount);
         }
     }
 }

Tests/MQTTnet.Core.Tests/MqttSubscriptionsManagerTests.cs

@@ -1,5 +1,4 @@
-using Microsoft.Extensions.Options;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Protocol;
 using MQTTnet.Core.Server;
@@ -12,7 +11,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeSingleSuccess()
         {
-            var sm = new MqttClientSubscriptionsManager(new OptionsWrapper<MqttServerOptions>(new MqttServerOptions()));
+            var sm = new MqttClientSubscriptionsManager(new MqttServerOptions());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilter("A/B/C"));
@@ -31,7 +30,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeSingleNoSuccess()
         {
-            var sm = new MqttClientSubscriptionsManager(new OptionsWrapper<MqttServerOptions>(new MqttServerOptions()));
+            var sm = new MqttClientSubscriptionsManager(new MqttServerOptions());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilter("A/B/C"));
@@ -50,7 +49,7 @@ namespace MQTTnet.Core.Tests
         [TestMethod]
         public void MqttSubscriptionsManager_SubscribeAndUnsubscribeSingle()
         {
-            var sm = new MqttClientSubscriptionsManager(new OptionsWrapper<MqttServerOptions>(new MqttServerOptions()));
+            var sm = new MqttClientSubscriptionsManager(new MqttServerOptions());
 
             var sp = new MqttSubscribePacket();
             sp.TopicFilters.Add(new TopicFilter("A/B/C"));

Tests/MQTTnet.Core.Tests/ServiceCollectionTest.cs

@@ -1,30 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.VisualStudio.TestTools.UnitTesting;
-
-namespace MQTTnet.Core.Tests
-{
-    [TestClass]
-    public class ServiceCollectionTest
-    {
-        [TestMethod]
-        public void TestCanConstructAllServices()
-        {
-            var services = new ServiceCollection()
-                .AddLogging()
-                .AddMqttServer()
-                .AddMqttClient();
-
-            var serviceProvider = services
-                .BuildServiceProvider();
-
-            foreach (var service in services)
-            {
-                if (service.ServiceType.IsGenericType)
-                {
-                    continue;
-                }
-                serviceProvider.GetRequiredService(service.ServiceType);
-            }
-        }
-    }
-}

Tests/MQTTnet.Core.Tests/TestClientSessionFactory.cs

@@ -1,14 +0,0 @@
-using System;
-using MQTTnet.Core.Server;
-
-namespace MQTTnet.Core.Tests
-{
-    public class TestClientSessionFactory : IMqttClientSesssionFactory
-    {
-        public MqttClientSession CreateClientSession(string clientId, MqttClientSessionsManager mqttClientSessionsManager)
-        {
-            throw new NotImplementedException();
-            //return new MqttClientSession(clientId, mqttClientSessionsManager, new TestLogger<MqttClientSession>(), new TestLogger<MqttClientPendingMessagesQueue>());
-        }
-    }
-}

Tests/MQTTnet.Core.Tests/TestLogger.cs

@@ -1,26 +0,0 @@
-using Microsoft.Extensions.Logging;
-using System;
-
-namespace MQTTnet.Core.Tests
-{
-    public class TestLogger<T> : IDisposable, ILogger<T>
-    {
-        public IDisposable BeginScope<TState>(TState state)
-        {
-            return this;
-        }
-
-        public bool IsEnabled(LogLevel logLevel)
-        {
-            return true;
-        }
-
-        public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
-        {
-        }
-
-        public void Dispose()
-        {
-        }
-    }
-}

Tests/MQTTnet.Core.Tests/TestMqttCommunicationAdapter.cs

@@ -9,7 +9,7 @@ using MQTTnet.Core.Serializer;
 
 namespace MQTTnet.Core.Tests
 {
-    public class TestMqttCommunicationAdapter : IMqttCommunicationAdapter
+    public class TestMqttCommunicationAdapter : IMqttChannelAdapter
     {
         private readonly BlockingCollection<MqttBasePacket> _incomingPackets = new BlockingCollection<MqttBasePacket>();
 

Tests/MQTTnet.Core.Tests/TestMqttCommunicationAdapterFactory.cs

@@ -1,24 +1,19 @@
 using MQTTnet.Core.Adapter;
-using MQTTnet.Core.Channel;
 using MQTTnet.Core.Client;
+using MQTTnet.Core.Diagnostics;
 
 namespace MQTTnet.Core.Tests
 {
-    public class TestMqttCommunicationAdapterFactory : IMqttCommunicationAdapterFactory
+    public class TestMqttCommunicationAdapterFactory : IMqttClientAdapterFactory
     {
-        private readonly IMqttCommunicationAdapter _adapter;
+        private readonly IMqttChannelAdapter _adapter;
 
-        public TestMqttCommunicationAdapterFactory(IMqttCommunicationAdapter adapter)
+        public TestMqttCommunicationAdapterFactory(IMqttChannelAdapter adapter)
         {
             _adapter = adapter;
         }
-
-        public IMqttCommunicationAdapter CreateClientCommunicationAdapter(IMqttClientOptions options)
-        {
-            return _adapter;
-        }
-
-        public IMqttCommunicationAdapter CreateServerCommunicationAdapter(IMqttCommunicationChannel channel)
+        
+        public IMqttChannelAdapter CreateClientAdapter(IMqttClientChannelOptions options, IMqttNetLogger logger)
         {
             return _adapter;
         }

Tests/MQTTnet.Core.Tests/TestMqttServerAdapter.cs

@@ -3,6 +3,7 @@ using System.Threading.Tasks;
 using MQTTnet.Core.Adapter;
 using MQTTnet.Core.Server;
 using MQTTnet.Core.Client;
+using MQTTnet.Core.Diagnostics;
 
 namespace MQTTnet.Core.Tests
 {
@@ -19,8 +20,7 @@ namespace MQTTnet.Core.Tests
 
             var client = new MqttClient(
                 new TestMqttCommunicationAdapterFactory(adapterA),
-                new TestLogger<MqttClient>(), 
-                new MqttPacketDispatcher(new TestLogger<MqttPacketDispatcher>()));
+                new MqttNetLogger());
 
             var connected = WaitForClientToConnect(server, clientId);
 
@@ -57,7 +57,7 @@ namespace MQTTnet.Core.Tests
             return tcs.Task;
         }
 
-        private void FireClientAcceptedEvent(IMqttCommunicationAdapter adapter)
+        private void FireClientAcceptedEvent(IMqttChannelAdapter adapter)
         {
             ClientAccepted?.Invoke(this, new MqttServerAdapterClientAcceptedEventArgs(adapter));
         }

Tests/MQTTnet.TestApp.NetCore/ClientTest.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Text;
 using System.Threading.Tasks;
-using Microsoft.Extensions.Logging;
 using MQTTnet.Core;
 using MQTTnet.Core.Client;
 
@@ -28,8 +27,7 @@ namespace MQTTnet.TestApp.NetCore
                 };
 
                 var factory = new MqttFactory();
-                factory.GetLoggerFactory().AddConsole();
-
+                
                 var client = factory.CreateMqttClient();
 
                 client.ApplicationMessageReceived += (s, e) =>

Tests/MQTTnet.TestApp.NetCore/MQTTnet.TestApp.NetCore.csproj

@@ -14,10 +14,4 @@
     <ProjectReference Include="..\..\Frameworks\MQTTnet.Netstandard\MQTTnet.NetStandard.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Console">
-      <Version>1.1.2</Version>
-    </PackageReference>
-  </ItemGroup>
-
 </Project>

Tests/MQTTnet.TestApp.NetCore/ManagedClientTest.cs

@@ -4,8 +4,6 @@ using MQTTnet.Core;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.ManagedClient;
 using MQTTnet.Core.Protocol;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 using System.IO;
 using Newtonsoft.Json;
 using System.Collections.Generic;
@@ -16,14 +14,6 @@ namespace MQTTnet.TestApp.NetCore
     {
         public static async Task RunAsync()
         {
-            var services = new ServiceCollection()
-                   .AddMqttClient()
-                   .AddLogging()
-                   .BuildServiceProvider();
-
-            services.GetService<ILoggerFactory>()
-                .AddConsole();
-
             var ms = new ClientRetainedMessageHandler();
             
             var options = new ManagedMqttClientOptions
@@ -44,7 +34,7 @@ namespace MQTTnet.TestApp.NetCore
 
             try
             {
-                var managedClient = services.GetRequiredService<ManagedMqttClient>();
+                var managedClient = new MqttFactory().CreateManagedMqttClient();
                 managedClient.ApplicationMessageReceived += (s, e) =>
                 {
                     Console.WriteLine(">> RECEIVED: " + e.ApplicationMessage.Topic);

Tests/MQTTnet.TestApp.NetCore/PerformanceTest.cs

@@ -1,9 +1,6 @@
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
-using MQTTnet.Core;
+using MQTTnet.Core;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Protocol;
-using MQTTnet.Core.Server;
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -11,6 +8,7 @@ using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using MQTTnet.Core.Server;
 
 namespace MQTTnet.TestApp.NetCore
 {
@@ -18,46 +16,21 @@ namespace MQTTnet.TestApp.NetCore
     {
         public static async Task RunAsync()
         {
-            var services = new ServiceCollection()
-                .AddMqttServer(options =>
-                {
-
-                    options.ConnectionValidator = p =>
-                    {
-                        if (p.ClientId == "SpecialClient")
-                        {
-                            if (p.Username != "USER" || p.Password != "PASS")
-                            {
-                                return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
-                            }
-                        }
-
-                        return MqttConnectReturnCode.ConnectionAccepted;
-                    };
-
-                    options.DefaultCommunicationTimeout = TimeSpan.FromMinutes(10);
-                })
-                .AddMqttClient()
-                .AddLogging()
-                .BuildServiceProvider();
-
-            //services.GetService<ILoggerFactory>().AddConsole(LogLevel.Warning, true);
-
             Console.WriteLine("Press 'c' for concurrent sends. Otherwise in one batch.");
             var concurrent = Console.ReadKey(true).KeyChar == 'c';
 
-            var server = Task.Factory.StartNew(() => RunServerAsync(services), TaskCreationOptions.LongRunning);
-            var client = Task.Factory.StartNew(() => RunClientAsync(2000, TimeSpan.FromMilliseconds(10), services, concurrent), TaskCreationOptions.LongRunning);
+            var server = Task.Factory.StartNew(async () => await RunServerAsync(), TaskCreationOptions.LongRunning);
+            var client = Task.Factory.StartNew(async () => await RunClientAsync(2000, TimeSpan.FromMilliseconds(10), concurrent), TaskCreationOptions.LongRunning);
 
             await Task.WhenAll(server, client).ConfigureAwait(false);
         }
 
-        private static Task RunClientsAsync(int msgChunkSize, TimeSpan interval, IServiceProvider serviceProvider, bool concurrent)
+        private static Task RunClientsAsync(int msgChunkSize, TimeSpan interval, bool concurrent)
         {
-            return Task.WhenAll(Enumerable.Range(0, 3).Select(i => Task.Run(() => RunClientAsync(msgChunkSize, interval, serviceProvider, concurrent))));
+            return Task.WhenAll(Enumerable.Range(0, 3).Select(i => Task.Run(() => RunClientAsync(msgChunkSize, interval, concurrent))));
         }
 
-        private static async Task RunClientAsync(int msgChunkSize, TimeSpan interval, IServiceProvider serviceProvider, bool concurrent)
+        private static async Task RunClientAsync(int msgChunkSize, TimeSpan interval, bool concurrent)
         {
             try
             {
@@ -69,7 +42,7 @@ namespace MQTTnet.TestApp.NetCore
                     CommunicationTimeout = TimeSpan.FromMinutes(10)
                 };
 
-                var client = serviceProvider.GetRequiredService<IMqttClient>();
+                var client = new MqttFactory().CreateMqttClient();
 
                 client.Connected += async (s, e) =>
                 {
@@ -77,7 +50,7 @@ namespace MQTTnet.TestApp.NetCore
 
                     await client.SubscribeAsync(new List<TopicFilter>
                     {
-                        new TopicFilter("#", MqttQualityOfServiceLevel.AtMostOnce)
+                        new TopicFilter("#")
                     });
 
                     Console.WriteLine("### SUBSCRIBED ###");
@@ -120,7 +93,6 @@ namespace MQTTnet.TestApp.NetCore
                 stopwatch.Stop();
                 Console.WriteLine($"Sent 10.000 messages within {stopwatch.ElapsedMilliseconds} ms ({stopwatch.ElapsedMilliseconds / (float)testMessageCount} ms / message).");
 
-
                 var messages = new[] { message };
                 var sentMessagesCount = 0;
 
@@ -158,9 +130,7 @@ namespace MQTTnet.TestApp.NetCore
                         msgCount += msgs.Count;
                         //send multiple
                     }
-
-
-
+                    
                     var now = DateTime.Now;
                     if (last < now - TimeSpan.FromSeconds(1))
                     {
@@ -194,11 +164,12 @@ namespace MQTTnet.TestApp.NetCore
             return Task.Run(() => client.PublishAsync(applicationMessage));
         }
 
-        private static async Task RunServerAsync(IServiceProvider serviceProvider)
+        private static async Task RunServerAsync()
         {
             try
             {
-                var mqttServer = serviceProvider.GetRequiredService<IMqttServer>();
+                var mqttServer = new MqttFactory().CreateMqttServer();
+
                 var msgs = 0;
                 var stopwatch = Stopwatch.StartNew();
                 mqttServer.ApplicationMessageReceived += (sender, args) =>
@@ -211,7 +182,7 @@ namespace MQTTnet.TestApp.NetCore
                         stopwatch.Restart();
                     }
                 };
-                await mqttServer.StartAsync();
+                await mqttServer.StartAsync(new MqttServerOptions());
 
                 Console.WriteLine("Press any key to exit.");
                 Console.ReadLine();

Tests/MQTTnet.TestApp.NetCore/Program.cs

@@ -7,7 +7,6 @@ using System.IO;
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
-using Microsoft.Extensions.Logging;
 
 namespace MQTTnet.TestApp.NetCore
 {
@@ -70,8 +69,6 @@ namespace MQTTnet.TestApp.NetCore
 
             {
                 var factory = new MqttFactory();
-                factory.GetLoggerFactory().AddConsole();
-
                 var client = factory.CreateMqttClient();
             }
         }

Tests/MQTTnet.TestApp.NetCore/ServerTest.cs

@@ -3,24 +3,21 @@ using System.Text;
 using System.Threading.Tasks;
 using MQTTnet.Core.Protocol;
 using MQTTnet.Core.Server;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.TestApp.NetCore
 {
     public static class ServerTest
     {
-        public static Task RunAsync()
+        public static async Task RunAsync()
         {
             try
             {
-                var services = new ServiceCollection()
-                    .AddMqttServer()
-                    .AddLogging();
+                MqttNetConsoleTrace.ForwardToConsole();
 
-                services.Configure<MqttServerOptions>(options =>
+                var options = new MqttServerOptions
                 {
-                    options.ConnectionValidator = p =>
+                    ConnectionValidator = p =>
                     {
                         if (p.ClientId == "SpecialClient")
                         {
@@ -31,22 +28,19 @@ namespace MQTTnet.TestApp.NetCore
                         }
 
                         return MqttConnectReturnCode.ConnectionAccepted;
-                    };
+                    },
 
-                    options.Storage = new RetainedMessageHandler();
-
-                    // Extend the timestamp for all messages from clients.
-                    options.ApplicationMessageInterceptor = context =>
+                    Storage = new RetainedMessageHandler(),
+                    ApplicationMessageInterceptor = context =>
                     {
                         if (MqttTopicFilterComparer.IsMatch(context.ApplicationMessage.Topic, "/myTopic/WithTimestamp/#"))
                         {
-        // Replace the payload with the timestamp. But also extending a JSON 
-        // based payload with the timestamp is a suitable use case.
-        context.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(DateTime.Now.ToString("O"));
+                            // Replace the payload with the timestamp. But also extending a JSON 
+                            // based payload with the timestamp is a suitable use case.
+                            context.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(DateTime.Now.ToString("O"));
                         }
-                    };
-                    // Protect several topics from being subscribed from every client.
-                    options.SubscriptionsInterceptor = context =>
+                    },
+                    SubscriptionsInterceptor = context =>
                     {
                         if (context.TopicFilter.Topic.StartsWith("admin/foo/bar") && context.ClientId != "theAdmin")
                         {
@@ -58,11 +52,11 @@ namespace MQTTnet.TestApp.NetCore
                             context.AcceptSubscription = false;
                             context.CloseConnection = true;
                         }
-                    };
-                });
+                    }
+                };
 
-                var serviceProvider = services.BuildServiceProvider();
-                serviceProvider.GetRequiredService<ILoggerFactory>().AddConsole();
+                // Extend the timestamp for all messages from clients.
+                // Protect several topics from being subscribed from every client.
 
                 //var certificate = new X509Certificate(@"C:\certs\test\test.cer", "");
                 //options.TlsEndpointOptions.Certificate = certificate.Export(X509ContentType.Cert);
@@ -70,18 +64,18 @@ namespace MQTTnet.TestApp.NetCore
                 //options.DefaultEndpointOptions.IsEnabled = true;
                 //options.TlsEndpointOptions.IsEnabled = false;
 
-                var mqttServer = new MqttFactory(serviceProvider).CreateMqttServer();
+                var mqttServer = new MqttFactory().CreateMqttServer();
                 mqttServer.ClientDisconnected += (s, e) =>
                 {
                     Console.Write("Client disconnected event fired.");
                 };
 
-                mqttServer.StartAsync();
+                await mqttServer.StartAsync(options);
 
                 Console.WriteLine("Press any key to exit.");
                 Console.ReadLine();
 
-                mqttServer.StopAsync();
+                await mqttServer.StopAsync();
             }
             catch (Exception e)
             {
@@ -89,7 +83,6 @@ namespace MQTTnet.TestApp.NetCore
             }
 
             Console.ReadLine();
-            return Task.FromResult(0);
         }
     }
 }

Tests/MQTTnet.TestApp.UniversalWindows/MQTTnet.TestApp.UniversalWindows.csproj

@@ -137,12 +137,6 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging">
-      <Version>1.1.2</Version>
-    </PackageReference>
-    <PackageReference Include="Microsoft.Extensions.Logging.Console">
-      <Version>1.1.2</Version>
-    </PackageReference>
     <PackageReference Include="Microsoft.NETCore.UniversalWindowsPlatform">
       <Version>5.4.0</Version>
     </PackageReference>

Tests/MQTTnet.TestApp.UniversalWindows/MainPage.xaml.cs

@@ -5,8 +5,6 @@ using System.Threading.Tasks;
 using Windows.Security.Cryptography.Certificates;
 using Windows.UI.Core;
 using Windows.UI.Xaml;
-using Microsoft.Extensions.DependencyInjection;
-using Microsoft.Extensions.Logging;
 using MQTTnet.Core;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Diagnostics;
@@ -19,7 +17,7 @@ namespace MQTTnet.TestApp.UniversalWindows
 {
     public sealed partial class MainPage
     {
-        private readonly ConcurrentQueue<MqttNetTraceMessage> _traceMessages = new ConcurrentQueue<MqttNetTraceMessage>();
+        private readonly ConcurrentQueue<MqttNetLogMessage> _traceMessages = new ConcurrentQueue<MqttNetLogMessage>();
 
         private IMqttClient _mqttClient;
         private IMqttServer _mqttServer;
@@ -28,10 +26,10 @@ namespace MQTTnet.TestApp.UniversalWindows
         {
             InitializeComponent();
 
-            MqttNetTrace.TraceMessagePublished += OnTraceMessagePublished;
+            MqttNetGlobalLog.LogMessagePublished += OnTraceMessagePublished;
         }
 
-        private async void OnTraceMessagePublished(object sender, MqttNetTraceMessagePublishedEventArgs e)
+        private async void OnTraceMessagePublished(object sender, MqttNetLogMessagePublishedEventArgs e)
         {
             _traceMessages.Enqueue(e.TraceMessage);
             while (_traceMessages.Count > 100)
@@ -252,7 +250,7 @@ namespace MQTTnet.TestApp.UniversalWindows
         {
             {
                 // Write all trace messages to the console window.
-                MqttNetTrace.TraceMessagePublished += (s, e) =>
+                MqttNetGlobalLog.LogMessagePublished += (s, e) =>
                 {
                     Console.WriteLine($">> [{e.TraceMessage.Timestamp:O}] [{e.TraceMessage.ThreadId}] [{e.TraceMessage.Source}] [{e.TraceMessage.Level}]: {e.TraceMessage.Message}");
                     if (e.TraceMessage.Exception != null)
@@ -262,32 +260,12 @@ namespace MQTTnet.TestApp.UniversalWindows
                 };
             }
 
-            {
-                // Add the console logger to the logger factory.
-                var services = new ServiceCollection()
-                    .AddMqttClient()
-                    .BuildServiceProvider();
-
-                services.GetRequiredService<ILoggerFactory>()
-                    .AddConsole();
-            }
-
             {
                 // Use a custom identifier for the trace messages.
                 var clientOptions = new MqttClientOptionsBuilder()
-                    .WithLogId("ClientX")
                     .Build();
             }
 
-            {
-                // Create a client from the service provider manually.
-                var serviceProvider = new ServiceCollection()
-                    .AddMqttClient()
-                    .BuildServiceProvider();
-
-                var mqttClient = serviceProvider.GetRequiredService<IMqttClient>();
-            }
-
             {
                 // Create a new MQTT client.
                 var factory = new MqttFactory();
@@ -371,34 +349,31 @@ namespace MQTTnet.TestApp.UniversalWindows
 
             // ----------------------------------
             {
-                var services = new ServiceCollection()
-                    .AddMqttServer(options =>
+                var options = new MqttServerOptions();
+
+                options.ConnectionValidator = c =>
+                {
+                    if (c.ClientId.Length < 10)
                     {
-                        options.ConnectionValidator = c =>
-                        {
-                            if (c.ClientId.Length < 10)
-                            {
-                                return MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
-                            }
+                        return MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
+                    }
 
-                            if (c.Username != "mySecretUser")
-                            {
-                                return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
-                            }
+                    if (c.Username != "mySecretUser")
+                    {
+                        return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
+                    }
 
-                            if (c.Password != "mySecretPassword")
-                            {
-                                return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
-                            }
+                    if (c.Password != "mySecretPassword")
+                    {
+                        return MqttConnectReturnCode.ConnectionRefusedBadUsernameOrPassword;
+                    }
 
-                            return MqttConnectReturnCode.ConnectionAccepted;
-                        };
-                    })
-                    .BuildServiceProvider();
+                    return MqttConnectReturnCode.ConnectionAccepted;
+                };
 
-                var factory = new MqttFactory(services);
+                var factory = new MqttFactory();
                 var mqttServer = factory.CreateMqttServer();
-                await mqttServer.StartAsync();
+                await mqttServer.StartAsync(options);
 
                 Console.WriteLine("Press any key to exit.");
                 Console.ReadLine();
@@ -422,7 +397,7 @@ namespace MQTTnet.TestApp.UniversalWindows
             {
                 // Start a MQTT server.
                 var mqttServer = new MqttFactory().CreateMqttServer();
-                await mqttServer.StartAsync();
+                await mqttServer.StartAsync(new MqttServerOptions());
                 Console.WriteLine("Press any key to exit.");
                 Console.ReadLine();
                 await mqttServer.StopAsync();
@@ -430,27 +405,31 @@ namespace MQTTnet.TestApp.UniversalWindows
 
             {
                 // Configure MQTT server.
-                var mqttServer = new MqttFactory().CreateMqttServer(options =>
+                var options = new MqttServerOptions
+                {
+                    ConnectionBacklog = 100
+                };
+
+                options.DefaultEndpointOptions.Port = 1884;
+                options.ConnectionValidator = packet =>
                 {
-                    options.ConnectionBacklog = 100;
-                    options.DefaultEndpointOptions.Port = 1884;
-                    options.ConnectionValidator = packet =>
+                    if (packet.ClientId != "Highlander")
                     {
-                        if (packet.ClientId != "Highlander")
-                        {
-                            return MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
-                        }
+                        return MqttConnectReturnCode.ConnectionRefusedIdentifierRejected;
+                    }
 
-                        return MqttConnectReturnCode.ConnectionAccepted;
-                    };
-                });
+                    return MqttConnectReturnCode.ConnectionAccepted;
+                };
+
+                var mqttServer = new MqttFactory().CreateMqttServer();
+                await mqttServer.StartAsync(options);
             }
 
             {
                 // Setup client validator.
-                var mqttServer = new MqttFactory().CreateMqttServer(options =>
+                var options = new MqttServerOptions
                 {
-                    options.ConnectionValidator = c =>
+                    ConnectionValidator = c =>
                     {
                         if (c.ClientId.Length < 10)
                         {
@@ -468,8 +447,8 @@ namespace MQTTnet.TestApp.UniversalWindows
                         }
 
                         return MqttConnectReturnCode.ConnectionAccepted;
-                    };
-                });
+                    }
+                };
             }
 
             {
@@ -512,13 +491,13 @@ namespace MQTTnet.TestApp.UniversalWindows
                 }
             }
 
-            _mqttServer = new MqttFactory().CreateMqttServer(o =>
-            {
-                o.DefaultEndpointOptions.Port = int.Parse(ServerPort.Text);
-                o.Storage = storage;
-            });
+            _mqttServer = new MqttFactory().CreateMqttServer();
+
+            var options = new MqttServerOptions();
+            options.DefaultEndpointOptions.Port = int.Parse(ServerPort.Text);
+            options.Storage = storage;
 
-            await _mqttServer.StartAsync();
+            await _mqttServer.StartAsync(options);
         }
 
         private async void StopServer(object sender, RoutedEventArgs e)