Fix UnitTests

Build/MQTTnet.AspNetCore.nuspec

@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>MQTTnet.AspNetCore</id>
-    <version>2.7.1</version>
+    <version>2.7.3</version>
     <authors>Christian Kratky</authors>
     <owners>Christian Kratky</owners>
     <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
@@ -10,13 +10,13 @@
     <iconUrl>https://raw.githubusercontent.com/chkr1011/MQTTnet/master/Images/Logo_128x128.png</iconUrl>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>
     <description>This is a support library to integrate MQTTnet into AspNetCore.</description>
-    <releaseNotes>* Updated to MQTTnet 2.7.1.
+    <releaseNotes>* Updated to MQTTnet 2.7.3.
     </releaseNotes>
     <copyright>Copyright Christian Kratky 2016-2018</copyright>
     <tags>MQTT Message Queue Telemetry Transport MQTTClient MQTTServer Server MQTTBroker Broker NETStandard IoT InternetOfThings Messaging Hardware Arduino Sensor Actuator M2M ESP Smart Home Cities Automation Xamarin</tags> 
     <dependencies>
       <group targetFramework="netstandard2.0">
-        <dependency id="MQTTnet" version="2.7.1" />
+        <dependency id="MQTTnet" version="2.7.3" />
       </group>
     </dependencies>
   </metadata>

Build/MQTTnet.nuspec

@@ -2,7 +2,7 @@
 <package >
   <metadata>
     <id>MQTTnet</id>
-    <version>2.7.2</version>
+    <version>2.7.3</version>
     <authors>Christian Kratky</authors>
     <owners>Christian Kratky</owners>
     <licenseUrl>https://github.com/chkr1011/MQTTnet/blob/master/LICENSE</licenseUrl>
@@ -10,11 +10,14 @@
     <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>* [Client] Added the subprotocol "mqtt" as default for web socket based connections.
-* [Client] Added a new client setting called "KeepAliveSendInterval". It allows configuring the effective interval for sending ping requests.
-* [Client] The client will no longer send ping requests if other packets are sent within the configured interval.
-* [Server] The server now generates a valid packet identifier when disaptching publish packets to clients.
-* [Core] Add several new extension methods.
+    <releaseNotes>* [Core] Add several new extension methods.
+* [Client] Fixed an issue in _ManagedMqttClientOptionsBuilder_ when using _WithClientOptions_ and an options builder.
+* [Client] Added the "IsStarted" property for the managed client.
+* [Client] Optimized stream buffer for UWP apps.
+* [Client] Added the _BufferSize_ to the TCP options.
+* [Client] Fixed a race condition which leads to exceptions when reconnecting rapidly.
+* [Server] Fixed a race condition which leads to exceptions when clients are reconnecting rapidly.
+* [Core] Fixed some issues in stream and socket handling.
     </releaseNotes>
     <copyright>Copyright Christian Kratky 2016-2018</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> 

Frameworks/MQTTnet.NetStandard/Adapter/IMqttChannelAdapter.cs

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

Frameworks/MQTTnet.NetStandard/Adapter/MqttChannelAdapter.cs

@@ -14,11 +14,12 @@ using MQTTnet.Serializer;
 
 namespace MQTTnet.Adapter
 {
-    public class MqttChannelAdapter : IMqttChannelAdapter
+    public sealed class MqttChannelAdapter : IMqttChannelAdapter
     {
         private const uint ErrorOperationAborted = 0x800703E3;
         private const int ReadBufferSize = 4096;  // TODO: Move buffer size to config
 
+        private bool _isDisposed;
         private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
         private readonly IMqttNetLogger _logger;
         private readonly IMqttChannel _channel;
@@ -34,6 +35,7 @@ namespace MQTTnet.Adapter
 
         public Task ConnectAsync(TimeSpan timeout)
         {
+            ThrowIfDisposed();
             _logger.Trace<MqttChannelAdapter>("Connecting [Timeout={0}]", timeout);
 
             return ExecuteAndWrapExceptionAsync(() => _channel.ConnectAsync().TimeoutAfter(timeout));
@@ -41,6 +43,7 @@ namespace MQTTnet.Adapter
 
         public Task DisconnectAsync(TimeSpan timeout)
         {
+            ThrowIfDisposed();
             _logger.Trace<MqttChannelAdapter>("Disconnecting [Timeout={0}]", timeout);
 
             return ExecuteAndWrapExceptionAsync(() => _channel.DisconnectAsync().TimeoutAfter(timeout));
@@ -48,6 +51,8 @@ namespace MQTTnet.Adapter
 
         public Task SendPacketsAsync(TimeSpan timeout, CancellationToken cancellationToken, IEnumerable<MqttBasePacket> packets)
         {
+            ThrowIfDisposed();
+
             return ExecuteAndWrapExceptionAsync(async () =>
             {
                 await _semaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
@@ -55,6 +60,11 @@ namespace MQTTnet.Adapter
                 {
                     foreach (var packet in packets)
                     {
+                        if (cancellationToken.IsCancellationRequested)
+                        {
+                            return;
+                        }
+
                         if (packet == null)
                         {
                             continue;
@@ -65,10 +75,20 @@ namespace MQTTnet.Adapter
                         var chunks = PacketSerializer.Serialize(packet);
                         foreach (var chunk in chunks)
                         {
+                            if (cancellationToken.IsCancellationRequested)
+                            {
+                                return;
+                            }
+
                             await _channel.SendStream.WriteAsync(chunk.Array, chunk.Offset, chunk.Count, cancellationToken).ConfigureAwait(false);
                         }
                     }
 
+                    if (cancellationToken.IsCancellationRequested)
+                    {
+                        return;
+                    }
+
                     if (timeout > TimeSpan.Zero)
                     {
                         await _channel.SendStream.FlushAsync(cancellationToken).TimeoutAfter(timeout).ConfigureAwait(false);
@@ -87,6 +107,8 @@ namespace MQTTnet.Adapter
 
         public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout, CancellationToken cancellationToken)
         {
+            ThrowIfDisposed();
+
             MqttBasePacket packet = null;
             await ExecuteAndWrapExceptionAsync(async () =>
             {
@@ -214,5 +236,20 @@ namespace MQTTnet.Adapter
                 throw new MqttCommunicationException(exception);
             }
         }
+
+        public void Dispose()
+        {
+            _isDisposed = true;
+            _semaphore?.Dispose();
+            _channel?.Dispose();
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (_isDisposed)
+            {
+                throw new ObjectDisposedException(nameof(MqttChannelAdapter));
+            }
+        }
     }
 }

Frameworks/MQTTnet.NetStandard/Channel/IMqttChannel.cs

@@ -1,9 +1,10 @@
-using System.IO;
+using System;
+using System.IO;
 using System.Threading.Tasks;
 
 namespace MQTTnet.Channel
 {
-    public interface IMqttChannel
+    public interface IMqttChannel : IDisposable
     {
         Stream SendStream { get; }
         Stream ReceiveStream { get; }

Frameworks/MQTTnet.NetStandard/Client/MqttClient.cs

@@ -17,6 +17,7 @@ namespace MQTTnet.Client
     {
         private readonly MqttPacketIdentifierProvider _packetIdentifierProvider = new MqttPacketIdentifierProvider();
         private readonly Stopwatch _sendTracker = new Stopwatch();
+        private readonly SemaphoreSlim _disconnectLock = new SemaphoreSlim(1, 1);
         private readonly IMqttClientAdapterFactory _adapterFactory;
         private readonly MqttPacketDispatcher _packetDispatcher;
         private readonly IMqttNetLogger _logger;
@@ -24,13 +25,15 @@ namespace MQTTnet.Client
         private IMqttClientOptions _options;
         private bool _isReceivingPackets;
         private CancellationTokenSource _cancellationTokenSource;
+        private Task _packetReceiverTask;
+        private Task _keepAliveMessageSenderTask;
         private IMqttChannelAdapter _adapter;
 
         public MqttClient(IMqttClientAdapterFactory channelFactory, IMqttNetLogger logger)
         {
             _adapterFactory = channelFactory ?? throw new ArgumentNullException(nameof(channelFactory));
             _logger = logger ?? throw new ArgumentNullException(nameof(logger));
-            
+
             _packetDispatcher = new MqttPacketDispatcher(logger);
         }
 
@@ -55,12 +58,12 @@ namespace MQTTnet.Client
                 _packetDispatcher.Reset();
 
                 _adapter = _adapterFactory.CreateClientAdapter(options.ChannelOptions, _logger);
-                
+
                 _logger.Trace<MqttClient>("Trying to connect with server.");
                 await _adapter.ConnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
                 _logger.Trace<MqttClient>("Connection with server established.");
 
-                await StartReceivingPacketsAsync(_cancellationTokenSource.Token).ConfigureAwait(false);
+                await StartReceivingPacketsAsync().ConfigureAwait(false);
 
                 var connectResponse = await AuthenticateAsync(options.WillMessage).ConfigureAwait(false);
                 _logger.Trace<MqttClient>("MQTT connection with server established.");
@@ -69,7 +72,7 @@ namespace MQTTnet.Client
 
                 if (_options.KeepAlivePeriod != TimeSpan.Zero)
                 {
-                    StartSendingKeepAliveMessages(_cancellationTokenSource.Token);
+                    StartSendingKeepAliveMessages();
                 }
 
                 IsConnected = true;
@@ -94,7 +97,10 @@ namespace MQTTnet.Client
 
             try
             {
-                await SendAsync(new MqttDisconnectPacket()).ConfigureAwait(false);
+                if (!_cancellationTokenSource.IsCancellationRequested)
+                {
+                    await SendAsync(new MqttDisconnectPacket()).ConfigureAwait(false);
+                }
             }
             finally
             {
@@ -144,7 +150,7 @@ namespace MQTTnet.Client
             ThrowIfNotConnected();
 
             var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
-            var packetGroups = publishPackets.GroupBy(p => p.QualityOfServiceLevel).OrderBy(g => g.Key); 
+            var packetGroups = publishPackets.GroupBy(p => p.QualityOfServiceLevel).OrderBy(g => g.Key);
 
             foreach (var qosGroup in packetGroups)
             {
@@ -153,7 +159,7 @@ namespace MQTTnet.Client
                     case MqttQualityOfServiceLevel.AtMostOnce:
                         {
                             // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
-                            await SendAsync(qosGroup.ToArray()).ConfigureAwait(false);
+                            await SendAsync((MqttPublishPacket[])qosGroup.ToArray()).ConfigureAwait(false);
                             break;
                         }
                     case MqttQualityOfServiceLevel.AtLeastOnce:
@@ -194,6 +200,9 @@ namespace MQTTnet.Client
         public void Dispose()
         {
             _cancellationTokenSource?.Dispose();
+            _cancellationTokenSource = null;
+
+            _adapter?.Dispose();
         }
 
         private async Task<MqttConnAckPacket> AuthenticateAsync(MqttApplicationMessage willApplicationMessage)
@@ -229,23 +238,31 @@ namespace MQTTnet.Client
 
         private async Task DisconnectInternalAsync(Exception exception)
         {
+            await _disconnectLock.WaitAsync();
             var clientWasConnected = IsConnected;
-            IsConnected = false;
-
-            var cts = _cancellationTokenSource;
-            if (cts == null || cts.IsCancellationRequested)
-            {
-                return;
-            }
-
-            cts.Cancel(false);
-            cts.Dispose();
-            _cancellationTokenSource = null;
-
             try
             {
+                IsConnected = false;
+
+                if (_cancellationTokenSource == null || _cancellationTokenSource.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                _cancellationTokenSource.Cancel(false);
+
+                if (_packetReceiverTask != null)
+                {
+                    Task.WaitAll(_packetReceiverTask);
+                }
+
+                if (_keepAliveMessageSenderTask != null)
+                {
+                    Task.WaitAll(_keepAliveMessageSenderTask);
+                }
+
                 await _adapter.DisconnectAsync(_options.CommunicationTimeout).ConfigureAwait(false);
-                _logger.Info<MqttClient>("Disconnected from adapter.");
+                _logger.Trace<MqttClient>("Disconnected from adapter.");
             }
             catch (Exception adapterException)
             {
@@ -253,6 +270,14 @@ namespace MQTTnet.Client
             }
             finally
             {
+                _adapter?.Dispose();
+                _adapter = null;
+
+                _cancellationTokenSource?.Dispose();
+                _cancellationTokenSource = null;
+
+                _disconnectLock.Release();
+                
                 _logger.Info<MqttClient>("Disconnected.");
                 Disconnected?.Invoke(this, new MqttClientDisconnectedEventArgs(clientWasConnected, exception));
             }
@@ -263,7 +288,7 @@ namespace MQTTnet.Client
             try
             {
                 _logger.Info<MqttClient>("Received <<< {0}", packet);
-                
+
                 if (packet is MqttPublishPacket publishPacket)
                 {
                     await ProcessReceivedPublishPacketAsync(publishPacket).ConfigureAwait(false);
@@ -311,6 +336,11 @@ namespace MQTTnet.Client
 
         private Task ProcessReceivedPublishPacketAsync(MqttPublishPacket publishPacket)
         {
+            if (_cancellationTokenSource.IsCancellationRequested)
+            {
+                return Task.FromResult(0);
+            }
+
             if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
             {
                 FireApplicationMessageReceivedEvent(publishPacket);
@@ -363,54 +393,48 @@ namespace MQTTnet.Client
             return (TResponsePacket)await packetAwaiter.ConfigureAwait(false);
         }
 
-        private async Task SendKeepAliveMessagesAsync(CancellationToken cancellationToken)
+        private async Task SendKeepAliveMessagesAsync()
         {
             _logger.Info<MqttClient>("Start sending keep alive packets.");
 
             try
             {
-                while (!cancellationToken.IsCancellationRequested)
+                while (!_cancellationTokenSource.Token.IsCancellationRequested)
                 {
-                    TimeSpan keepAliveSendInterval;
+                    var keepAliveSendInterval = TimeSpan.FromSeconds(_options.KeepAlivePeriod.TotalSeconds * 0.75);
                     if (_options.KeepAliveSendInterval.HasValue)
                     {
                         keepAliveSendInterval = _options.KeepAliveSendInterval.Value;
                     }
-                    else
-                    {
-                        keepAliveSendInterval = TimeSpan.FromSeconds(_options.KeepAlivePeriod.TotalSeconds * 0.75);
-                    }
 
                     if (_sendTracker.Elapsed > keepAliveSendInterval)
                     {
                         await SendAndReceiveAsync<MqttPingRespPacket>(new MqttPingReqPacket()).ConfigureAwait(false);
                     }
-                    
-                    await Task.Delay(keepAliveSendInterval, cancellationToken).ConfigureAwait(false);
+
+                    await Task.Delay(keepAliveSendInterval, _cancellationTokenSource.Token).ConfigureAwait(false);
                 }
             }
             catch (OperationCanceledException)
             {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                await DisconnectInternalAsync(null).ConfigureAwait(false);
-            }
-            catch (MqttCommunicationException exception)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                _logger.Warning<MqttClient>(exception, "MQTT communication exception while sending/receiving keep alive packets.");
-                await DisconnectInternalAsync(exception).ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                _logger.Warning<MqttClient>(exception, "Unhandled exception while sending/receiving keep alive packets.");
+                if (_cancellationTokenSource.Token.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                if (exception is MqttCommunicationException)
+                {
+                    _logger.Warning<MqttClient>(exception, "MQTT communication exception while sending/receiving keep alive packets.");
+                }
+                else
+                {
+                    _logger.Warning<MqttClient>(exception, "Unhandled exception while sending/receiving keep alive packets.");
+
+                }
+
                 await DisconnectInternalAsync(exception).ConfigureAwait(false);
             }
             finally
@@ -419,48 +443,46 @@ namespace MQTTnet.Client
             }
         }
 
-        private async Task ReceivePacketsAsync(CancellationToken cancellationToken)
+        private async Task ReceivePacketsAsync()
         {
             _logger.Info<MqttClient>("Start receiving packets.");
 
             try
             {
-                while (!cancellationToken.IsCancellationRequested)
+                while (!_cancellationTokenSource.Token.IsCancellationRequested)
                 {
                     _isReceivingPackets = true;
 
-                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
+                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, _cancellationTokenSource.Token).ConfigureAwait(false);
 
-                    if (cancellationToken.IsCancellationRequested)
+                    if (_cancellationTokenSource.Token.IsCancellationRequested)
                     {
                         return;
                     }
 
-                    StartProcessReceivedPacket(packet, cancellationToken);
+                    StartProcessReceivedPacket(packet);
                 }
             }
             catch (OperationCanceledException)
             {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                await DisconnectInternalAsync(null).ConfigureAwait(false);
-            }
-            catch (MqttCommunicationException exception)
-            {
-                if (cancellationToken.IsCancellationRequested)
-                {
-                    return;
-                }
-
-                _logger.Warning<MqttClient>(exception, "MQTT communication exception while receiving packets.");
-                await DisconnectInternalAsync(exception).ConfigureAwait(false);
             }
             catch (Exception exception)
             {
-                _logger.Error<MqttClient>(exception, "Unhandled exception while receiving packets.");
+                if (_cancellationTokenSource.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                if (exception is MqttCommunicationException)
+                {
+                    _logger.Warning<MqttClient>(exception, "MQTT communication exception while receiving packets.");
+                }
+                else
+                {
+                    _logger.Error<MqttClient>(exception, "Unhandled exception while receiving packets.");
+
+                }
+
                 await DisconnectInternalAsync(exception).ConfigureAwait(false);
             }
             finally
@@ -469,38 +491,26 @@ namespace MQTTnet.Client
             }
         }
 
-        private void StartProcessReceivedPacket(MqttBasePacket packet, CancellationToken cancellationToken)
+        private void StartProcessReceivedPacket(MqttBasePacket packet)
         {
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(
-                async () => await ProcessReceivedPacketAsync(packet).ConfigureAwait(false),
-                cancellationToken).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            Task.Run(() => ProcessReceivedPacketAsync(packet), _cancellationTokenSource.Token);
         }
 
-        private async Task StartReceivingPacketsAsync(CancellationToken cancellationToken)
+        private async Task StartReceivingPacketsAsync()
         {
             _isReceivingPackets = false;
 
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(
-                async () => await ReceivePacketsAsync(cancellationToken).ConfigureAwait(false),
-                cancellationToken).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            _packetReceiverTask = Task.Run(ReceivePacketsAsync, _cancellationTokenSource.Token);
 
-            while (!_isReceivingPackets && !cancellationToken.IsCancellationRequested)
+            while (!_isReceivingPackets && !_cancellationTokenSource.Token.IsCancellationRequested)
             {
-                await Task.Delay(TimeSpan.FromMilliseconds(100), cancellationToken).ConfigureAwait(false);
+                await Task.Delay(TimeSpan.FromMilliseconds(100), _cancellationTokenSource.Token).ConfigureAwait(false);
             }
         }
 
-        private void StartSendingKeepAliveMessages(CancellationToken cancellationToken)
+        private void StartSendingKeepAliveMessages()
         {
-#pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
-            Task.Run(
-                async () => await SendKeepAliveMessagesAsync(cancellationToken).ConfigureAwait(false), 
-                cancellationToken).ConfigureAwait(false);
-#pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed
+            _keepAliveMessageSenderTask = Task.Run(SendKeepAliveMessagesAsync, _cancellationTokenSource.Token);
         }
     }
 }

Frameworks/MQTTnet.NetStandard/Client/MqttClientTcpOptions.cs

@@ -6,6 +6,8 @@
 
         public int? Port { get; set; }
 
+        public int BufferSize { get; set; } = 20 * 4096;
+
         public MqttClientTlsOptions TlsOptions { get; set; } = new MqttClientTlsOptions();
     }
 }

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

@@ -13,14 +13,21 @@ using MQTTnet.Client;
 
 namespace MQTTnet.Implementations
 {
-    public sealed class MqttTcpChannel : IMqttChannel, IDisposable
+    public sealed class MqttTcpChannel : IMqttChannel
     {
+        // ReSharper disable once MemberCanBePrivate.Global
+        // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
+        public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
+
+        private readonly int _bufferSize = BufferSize;
         private readonly MqttClientTcpOptions _options;
+
         private StreamSocket _socket;
 
         public MqttTcpChannel(MqttClientTcpOptions options)
         {
             _options = options ?? throw new ArgumentNullException(nameof(options));
+            _bufferSize = _options.BufferSize;
         }
 
         public MqttTcpChannel(StreamSocket socket)
@@ -69,14 +76,56 @@ namespace MQTTnet.Implementations
 
         public void Dispose()
         {
-            _socket?.Dispose();
-            _socket = null;
+            try
+            {
+                SendStream?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                SendStream = null;
+            }
+
+            try
+            {
+                ReceiveStream?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                ReceiveStream = null;
+            }
+
+            try
+            {
+                _socket?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                _socket = null;
+            }
         }
 
         private void CreateStreams()
         {
-            SendStream = _socket.OutputStream.AsStreamForWrite();
-            ReceiveStream = _socket.InputStream.AsStreamForRead();
+            SendStream = _socket.OutputStream.AsStreamForWrite(_bufferSize);
+            ReceiveStream = _socket.InputStream.AsStreamForRead(_bufferSize);
         }
 
         private static Certificate LoadCertificate(MqttClientTcpOptions options)

Frameworks/MQTTnet.NetStandard/Implementations/MqttTcpChannel.cs

@@ -12,17 +12,20 @@ using MQTTnet.Client;
 
 namespace MQTTnet.Implementations
 {
-    public sealed class MqttTcpChannel : IMqttChannel, IDisposable
+    public sealed class MqttTcpChannel : IMqttChannel
     {
-        private readonly MqttClientTcpOptions _options;
-
-        //todo: this can be used with min dependency NetStandard1.6
 #if NET452 || NET461
         // ReSharper disable once MemberCanBePrivate.Global
         // ReSharper disable once AutoPropertyCanBeMadeGetOnly.Global
         public static int BufferSize { get; set; } = 4096 * 20; // Can be changed for fine tuning by library user.
+
+        private readonly int _bufferSize = BufferSize;
+#else
+        private readonly int _bufferSize = 0;
 #endif
 
+        private readonly MqttClientTcpOptions _options;
+
         private Socket _socket;
         private SslStream _sslStream;
 
@@ -32,6 +35,7 @@ namespace MQTTnet.Implementations
         public MqttTcpChannel(MqttClientTcpOptions options)
         {
             _options = options ?? throw new ArgumentNullException(nameof(options));
+            _bufferSize = options.BufferSize;
         }
 
         /// <summary>
@@ -43,7 +47,7 @@ namespace MQTTnet.Implementations
             _socket = socket ?? throw new ArgumentNullException(nameof(socket));
             _sslStream = sslStream;
 
-            CreateStreams(socket, sslStream);
+            CreateStreams();
         }
 
         public Stream SendStream { get; private set; }
@@ -58,7 +62,6 @@ namespace MQTTnet.Implementations
                 _socket = new Socket(SocketType.Stream, ProtocolType.Tcp);
             }
 
-            //todo: else brach can be used with min dependency NET46
 #if NET452 || NET461
             await Task.Factory.FromAsync(_socket.BeginConnect, _socket.EndConnect, _options.Server, _options.GetPort(), null).ConfigureAwait(false);
 #else
@@ -68,10 +71,10 @@ namespace MQTTnet.Implementations
             if (_options.TlsOptions.UseTls)
             {
                 _sslStream = new SslStream(new NetworkStream(_socket, true), false, InternalUserCertificateValidationCallback);
-                await _sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(_options), SslProtocols.Tls12, _options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
+                await _sslStream.AuthenticateAsClientAsync(_options.Server, LoadCertificates(), SslProtocols.Tls12, _options.TlsOptions.IgnoreCertificateRevocationErrors).ConfigureAwait(false);
             }
             
-            CreateStreams(_socket, _sslStream);
+            CreateStreams();
         }
 
         public Task DisconnectAsync()
@@ -82,11 +85,70 @@ namespace MQTTnet.Implementations
 
         public void Dispose()
         {
-            _socket?.Dispose();
-            _socket = null;
+            var oneStreamIsUsed = SendStream != null && ReceiveStream != null && ReferenceEquals(SendStream, ReceiveStream);
 
-            _sslStream?.Dispose();
-            _sslStream = null;
+            try
+            {
+                SendStream?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                SendStream = null;
+            }
+
+            try
+            {
+                if (!oneStreamIsUsed)
+                {
+                    ReceiveStream?.Dispose();
+                }
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                ReceiveStream = null;
+            }
+
+            try
+            {
+                _sslStream?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                _sslStream = null;
+            }
+
+            try
+            {
+                _socket?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            catch (NullReferenceException)
+            {
+            }
+            finally
+            {
+                _socket = null;
+            }
         }
 
         private bool InternalUserCertificateValidationCallback(object sender, X509Certificate x509Certificate, X509Chain chain, SslPolicyErrors sslPolicyErrors)
@@ -120,15 +182,15 @@ namespace MQTTnet.Implementations
             return _options.TlsOptions.AllowUntrustedCertificates;
         }
 
-        private static X509CertificateCollection LoadCertificates(MqttClientTcpOptions options)
+        private X509CertificateCollection LoadCertificates()
         {
             var certificates = new X509CertificateCollection();
-            if (options.TlsOptions.Certificates == null)
+            if (_options.TlsOptions.Certificates == null)
             {
                 return certificates;
             }
 
-            foreach (var certificate in options.TlsOptions.Certificates)
+            foreach (var certificate in _options.TlsOptions.Certificates)
             {
                 certificates.Add(new X509Certificate2(certificate));
             }
@@ -136,20 +198,26 @@ namespace MQTTnet.Implementations
             return certificates;
         }
 
-        private void CreateStreams(Socket socket, Stream sslStream)
+        private void CreateStreams()
         {
-            var stream = sslStream ?? new NetworkStream(socket);
+            Stream stream;
+            if (_sslStream != null)
+            {
+                stream = _sslStream;
+            }
+            else
+            {
+                stream = new NetworkStream(_socket, true);
+            }
             
-            //todo: if branch can be used with min dependency NetStandard1.6
 #if NET452 || NET461
-            SendStream = new BufferedStream(stream, BufferSize);
-            ReceiveStream = new BufferedStream(stream, BufferSize);
+            SendStream = new BufferedStream(stream, _bufferSize);
+            ReceiveStream = new BufferedStream(stream, _bufferSize);
 #else
             SendStream = stream;
             ReceiveStream = stream;
 #endif
         }
-
     }
 }
 #endif

Frameworks/MQTTnet.NetStandard/Implementations/MqttWebSocketChannel.cs

@@ -96,8 +96,17 @@ namespace MQTTnet.Implementations
 
         public void Dispose()
         {
-            _webSocket?.Dispose();
-            _webSocket = null;
+            try
+            {
+                _webSocket?.Dispose();
+            }
+            catch (ObjectDisposedException)
+            {
+            }
+            finally
+            {
+                _webSocket = null;
+            }            
         }
     }
 }

Frameworks/MQTTnet.NetStandard/ManagedClient/IManagedMqttClient.cs

@@ -7,6 +7,7 @@ namespace MQTTnet.ManagedClient
 {
     public interface IManagedMqttClient : IApplicationMessageReceiver, IApplicationMessagePublisher, IDisposable
     {
+        bool IsStarted { get; }
         bool IsConnected { get; }
 
         event EventHandler<MqttClientConnectedEventArgs> Connected;

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClient.cs

@@ -40,6 +40,7 @@ namespace MQTTnet.ManagedClient
         }
 
         public bool IsConnected => _mqttClient.IsConnected;
+        public bool IsStarted => _connectionCancellationToken != null;
 
         public event EventHandler<MqttClientConnectedEventArgs> Connected;
         public event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClientExtensions.cs

@@ -21,6 +21,14 @@ namespace MQTTnet.ManagedClient
             return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).WithQualityOfServiceLevel(qualityOfServiceLevel).Build());
         }
 
+        public static Task SubscribeAsync(this IManagedMqttClient managedClient, string topic)
+        {
+            if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));
+            if (topic == null) throw new ArgumentNullException(nameof(topic));
+
+            return managedClient.SubscribeAsync(new TopicFilterBuilder().WithTopic(topic).Build());
+        }
+
         public static Task UnsubscribeAsync(this IManagedMqttClient managedClient, params string[] topicFilters)
         {
             if (managedClient == null) throw new ArgumentNullException(nameof(managedClient));

Frameworks/MQTTnet.NetStandard/ManagedClient/ManagedMqttClientOptionsBuilder.cs

@@ -47,7 +47,7 @@ namespace MQTTnet.ManagedClient
         {
             if (options == null) throw new ArgumentNullException(nameof(options));
 
-            if (_clientOptionsBuilder != null)
+            if (_clientOptionsBuilder == null)
             {
                 _clientOptionsBuilder = new MqttClientOptionsBuilder();
             }

Frameworks/MQTTnet.NetStandard/Serializer/MqttPacketReader.cs

@@ -24,6 +24,11 @@ namespace MQTTnet.Serializer
 
         public static async Task<MqttPacketHeader> ReadHeaderAsync(Stream stream, CancellationToken cancellationToken)
         {
+            if (cancellationToken.IsCancellationRequested)
+            {
+                return null;
+            }
+
             // Wait for the next package which starts with the header. At this point there will probably
             // some large delay and thus the thread should be put back to the pool (await). So ReadByte()
             // is not an option here.

Frameworks/MQTTnet.NetStandard/Server/MqttClientKeepAliveMonitor.cs

@@ -16,6 +16,8 @@ namespace MQTTnet.Server
         private readonly Func<Task> _timeoutCallback;
         private readonly IMqttNetLogger _logger;
 
+        private Task _workerTask;
+
         public MqttClientKeepAliveMonitor(string clientId, Func<Task> timeoutCallback, IMqttNetLogger logger)
         {
             _clientId = clientId;
@@ -34,7 +36,15 @@ namespace MQTTnet.Server
                 return;
             }
 
-            Task.Run(async () => await RunAsync(keepAlivePeriod, cancellationToken).ConfigureAwait(false), cancellationToken).ConfigureAwait(false);
+            _workerTask = Task.Run(() => RunAsync(keepAlivePeriod, cancellationToken).ConfigureAwait(false), cancellationToken);
+        }
+
+        public void WaitForCompletion()
+        {
+            if (_workerTask != null)
+            {
+                Task.WaitAll(_workerTask);
+            }
         }
 
         private async Task RunAsync(int keepAlivePeriod, CancellationToken cancellationToken)

Frameworks/MQTTnet.NetStandard/Server/MqttClientPendingMessagesQueue.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Concurrent;
+using System.Runtime.CompilerServices;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
@@ -18,6 +19,8 @@ namespace MQTTnet.Server
         private readonly MqttClientSession _clientSession;
         private readonly IMqttNetLogger _logger;
 
+        private Task _workerTask;
+
         public MqttClientPendingMessagesQueue(IMqttServerOptions options, MqttClientSession clientSession, IMqttNetLogger logger)
         {
             _options = options ?? throw new ArgumentNullException(nameof(options));
@@ -36,7 +39,15 @@ namespace MQTTnet.Server
                 return;
             }
 
-            Task.Run(async () => await SendQueuedPacketsAsync(adapter, cancellationToken), cancellationToken).ConfigureAwait(false);
+            _workerTask = Task.Run(() => SendQueuedPacketsAsync(adapter, cancellationToken), cancellationToken);
+        }
+
+        public void WaitForCompletion()
+        {
+            if (_workerTask != null)
+            {
+                Task.WaitAll(_workerTask);
+            }
         }
 
         public void Enqueue(MqttBasePacket packet)
@@ -55,7 +66,7 @@ namespace MQTTnet.Server
             {
                 while (!cancellationToken.IsCancellationRequested)
                 {
-                    await SendQueuedPacketAsync(adapter, cancellationToken);
+                    await SendNextQueuedPacketAsync(adapter, cancellationToken).ConfigureAwait(false);
                 }
             }
             catch (OperationCanceledException)
@@ -67,7 +78,7 @@ namespace MQTTnet.Server
             }
         }
 
-        private async Task SendQueuedPacketAsync(IMqttChannelAdapter adapter, CancellationToken cancellationToken)
+        private async Task SendNextQueuedPacketAsync(IMqttChannelAdapter adapter, CancellationToken cancellationToken)
         {
             MqttBasePacket packet = null;
             try
@@ -78,6 +89,11 @@ namespace MQTTnet.Server
                     throw new InvalidOperationException(); // should not happen
                 }
 
+                if (cancellationToken.IsCancellationRequested)
+                {
+                    return;
+                }
+
                 await adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[] { packet }).ConfigureAwait(false);
 
                 _logger.Trace<MqttClientPendingMessagesQueue>("Enqueued packet sent (ClientId: {0}).", _clientSession.ClientId);
@@ -110,7 +126,10 @@ namespace MQTTnet.Server
                     }
                 }
 
-                await _clientSession.StopAsync();
+                if (!cancellationToken.IsCancellationRequested)
+                {
+                    await _clientSession.StopAsync().ConfigureAwait(false);
+                }
             }
         }
 

Frameworks/MQTTnet.NetStandard/Server/MqttClientSession.cs

@@ -96,14 +96,14 @@ namespace MQTTnet.Server
                 }
 
                 _cancellationTokenSource?.Cancel(false);
+
+                PendingMessagesQueue.WaitForCompletion();
+                KeepAliveMonitor.WaitForCompletion();
+
                 _cancellationTokenSource?.Dispose();
                 _cancellationTokenSource = null;
 
-                if (_adapter != null)
-                {
-                    await _adapter.DisconnectAsync(_options.DefaultCommunicationTimeout).ConfigureAwait(false);
-                    _adapter = null;
-                }
+                _adapter = null;
 
                 _logger.Info<MqttClientSession>("Client '{0}': Session stopped.", ClientId);
             }

Frameworks/MQTTnet.NetStandard/Server/MqttClientSessionsManager.cs

@@ -33,16 +33,18 @@ namespace MQTTnet.Server
         public Action<string, TopicFilter> ClientSubscribedTopicCallback { get; set; }
         public Action<string, string> ClientUnsubscribedTopicCallback { get; set; }
         public Action<string, MqttApplicationMessage> ApplicationMessageReceivedCallback { get; set; }
-        
+
         public async Task RunSessionAsync(IMqttChannelAdapter clientAdapter, CancellationToken cancellationToken)
         {
             var clientId = string.Empty;
             MqttClientSession clientSession = null;
             try
             {
-                if (!(await clientAdapter.ReceivePacketAsync(_options.DefaultCommunicationTimeout, cancellationToken).ConfigureAwait(false) is MqttConnectPacket connectPacket))
+                if (!(await clientAdapter.ReceivePacketAsync(_options.DefaultCommunicationTimeout, cancellationToken)
+                    .ConfigureAwait(false) is MqttConnectPacket connectPacket))
                 {
-                    throw new MqttProtocolViolationException("The first packet from a client must be a 'CONNECT' packet [MQTT-3.1.0-1].");
+                    throw new MqttProtocolViolationException(
+                        "The first packet from a client must be a 'CONNECT' packet [MQTT-3.1.0-1].");
                 }
 
                 clientId = connectPacket.ClientId;
@@ -53,10 +55,13 @@ namespace MQTTnet.Server
                 var connectReturnCode = ValidateConnection(connectPacket);
                 if (connectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
                 {
-                    await clientAdapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[] { new MqttConnAckPacket
+                    await clientAdapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[]
                     {
-                        ConnectReturnCode = connectReturnCode
-                    }}).ConfigureAwait(false);
+                        new MqttConnAckPacket
+                        {
+                            ConnectReturnCode = connectReturnCode
+                        }
+                    }).ConfigureAwait(false);
 
                     return;
                 }
@@ -64,11 +69,14 @@ namespace MQTTnet.Server
                 var result = await GetOrCreateClientSessionAsync(connectPacket).ConfigureAwait(false);
                 clientSession = result.Session;
 
-                await clientAdapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[] { new MqttConnAckPacket
+                await clientAdapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, cancellationToken, new[]
                 {
-                    ConnectReturnCode = connectReturnCode,
-                    IsSessionPresent = result.IsExistingSession
-                }}).ConfigureAwait(false);
+                    new MqttConnAckPacket
+                    {
+                        ConnectReturnCode = connectReturnCode,
+                        IsSessionPresent = result.IsExistingSession
+                    }
+                }).ConfigureAwait(false);
 
                 ClientConnectedCallback?.Invoke(new ConnectedMqttClient
                 {
@@ -78,6 +86,9 @@ namespace MQTTnet.Server
 
                 await clientSession.RunAsync(connectPacket, clientAdapter).ConfigureAwait(false);
             }
+            catch (OperationCanceledException)
+            {
+            }
             catch (Exception exception)
             {
                 _logger.Error<MqttClientSessionsManager>(exception, exception.Message);
@@ -87,12 +98,13 @@ namespace MQTTnet.Server
                 try
                 {
                     await clientAdapter.DisconnectAsync(_options.DefaultCommunicationTimeout).ConfigureAwait(false);
+                    clientAdapter.Dispose();
                 }
-                catch (Exception)
+                catch (Exception exception)
                 {
-                    // ignored
+                    _logger.Error<MqttClientSessionsManager>(exception, exception.Message);
                 }
-
+                
                 ClientDisconnectedCallback?.Invoke(new ConnectedMqttClient
                 {
                     ClientId = clientId,
@@ -308,7 +320,7 @@ namespace MQTTnet.Server
             ClientSubscribedTopicCallback = null;
             ClientUnsubscribedTopicCallback = null;
             ApplicationMessageReceivedCallback = null;
-            
+
             _semaphore?.Dispose();
         }
     }

Tests/MQTTnet.Core.Tests/MqttServerTests.cs

@@ -156,7 +156,7 @@ namespace MQTTnet.Core.Tests
                 var message = new MqttApplicationMessageBuilder().WithTopic("a").WithAtLeastOnceQoS().Build();
                 await c1.SubscribeAsync(new TopicFilter("a", MqttQualityOfServiceLevel.AtLeastOnce));
 
-                s.PublishAsync(message).Wait();
+                await s.PublishAsync(message);
                 await Task.Delay(500);
             }
             finally

Tests/MQTTnet.Core.Tests/TestMqttCommunicationAdapter.cs

@@ -17,6 +17,10 @@ namespace MQTTnet.Core.Tests
 
         public IMqttPacketSerializer PacketSerializer { get; } = new MqttPacketSerializer();
 
+        public void Dispose()
+        {
+        }
+
         public Task ConnectAsync(TimeSpan timeout)
         {
             return Task.FromResult(0);
@@ -43,7 +47,17 @@ namespace MQTTnet.Core.Tests
         {
             ThrowIfPartnerIsNull();
 
-            return Task.Run(() => _incomingPackets.Take(), cancellationToken);
+            return Task.Run(() =>
+            {
+                try
+                {
+                    return _incomingPackets.Take(cancellationToken);
+                }
+                catch
+                {
+                    return null;
+                }
+            }, cancellationToken);
         }
 
         private void EnqueuePacketInternal(MqttBasePacket packet)

Tests/MQTTnet.TestApp.NetCore/ServerTest.cs

@@ -89,7 +89,7 @@ namespace MQTTnet.TestApp.NetCore
                             c.ApplicationMessage.Payload = Encoding.UTF8.GetBytes(content.ToString());
                         }
                     }
-                    catch (Exception e)
+                    catch (Exception)
                     {
                     }
                 };