Refactor namespaces.

Source/MQTTnet/Client/Connecting/MqttClientConnectResult.cs

@@ -0,0 +1,9 @@
+namespace MQTTnet.Client.Connecting
+{
+    public class MqttClientConnectResult
+    {
+        public bool IsSessionPresent { get; set; }
+
+        public MqttClientConnectResultCode ResultCode { get; set; }
+    }
+}

Source/MQTTnet/Client/Connecting/MqttClientConnectResultCode.cs

@@ -0,0 +1,28 @@
+namespace MQTTnet.Client.Connecting
+{
+    public enum MqttClientConnectResultCode
+    {
+        Success = 0,
+        UnspecifiedError = 128,
+        MalformedPacket = 129,
+        ProtocolError = 130,
+        ImplementationSpecificError = 131,
+        UnsupportedProtocolVersion = 132,
+        ClientIdentifierNotValid = 133,
+        BadUserNameOrPassword = 134,
+        NotAuthorized = 135,
+        ServerUnavailable = 136,
+        ServerBusy = 137,
+        Banned = 138,
+        BadAuthenticationMethod = 140,
+        TopicNameInvalid = 144,
+        PacketTooLarge = 149,
+        QuotaExceeded = 151,
+        PayloadFormatInvalid = 153,
+        RetainNotSupported = 154,
+        QoSNotSupported = 155,
+        UseAnotherServer = 156,
+        ServerMoved = 157,
+        ConnectionRateExceeded = 159
+    }
+}

Source/MQTTnet/Client/Connecting/MqttClientConnectedEventArgs.cs

@@ -0,0 +1,14 @@
+using System;
+
+namespace MQTTnet.Client.Connecting
+{
+    public class MqttClientConnectedEventArgs : EventArgs
+    {
+        public MqttClientConnectedEventArgs(MqttClientConnectResult connectResult)
+        {
+            ConnectResult = connectResult ?? throw new ArgumentNullException(nameof(connectResult));
+        }
+
+        public MqttClientConnectResult ConnectResult { get; }
+    }
+}

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectOptions.cs

@@ -0,0 +1,9 @@
+namespace MQTTnet.Client.Disconnecting
+{
+    public class MqttClientDisconnectOptions
+    {
+        public MqttClientDisconnectReason ReasonCode { get; set; } = MqttClientDisconnectReason.NormalDisconnection;
+
+        public string ReasonString { get; set; }
+    }
+}

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectReason.cs

@@ -0,0 +1,8 @@
+namespace MQTTnet.Client.Disconnecting
+{
+    public enum MqttClientDisconnectReason
+    {
+        NormalDisconnection = 0,
+
+    }
+}

Source/MQTTnet/Client/Disconnecting/MqttClientDisconnectedEventArgs.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Disconnecting
 {
     public class MqttClientDisconnectedEventArgs : EventArgs
     {

Source/MQTTnet/Client/IMqttClient.cs

@@ -1,6 +1,11 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using MQTTnet.Client.Connecting;
+using MQTTnet.Client.Disconnecting;
+using MQTTnet.Client.Options;
+using MQTTnet.Client.Subscribing;
+using MQTTnet.Client.Unsubscribing;
 
 namespace MQTTnet.Client
 {
@@ -13,9 +18,9 @@ namespace MQTTnet.Client
         event EventHandler<MqttClientDisconnectedEventArgs> Disconnected;
 
         Task<MqttClientConnectResult> ConnectAsync(IMqttClientOptions options);
-        Task DisconnectAsync();
+        Task DisconnectAsync(MqttClientDisconnectOptions options);
 
-        Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
-        Task UnsubscribeAsync(IEnumerable<string> topics);
+        Task<MqttClientSubscribeResult> SubscribeAsync(IEnumerable<TopicFilter> topicFilters);
+        Task<MqttClientUnsubscribeResult> UnsubscribeAsync(IEnumerable<string> topics);
     }
 }

Source/MQTTnet/Client/IMqttClientAdapterFactory.cs

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

Source/MQTTnet/Client/IMqttClientFactory.cs

@@ -1,4 +1,5 @@
-using MQTTnet.Diagnostics;
+using MQTTnet.Adapter;
+using MQTTnet.Diagnostics;
 
 namespace MQTTnet.Client
 {

Source/MQTTnet/Client/MqttClient.cs

@@ -2,14 +2,19 @@
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
 using MQTTnet.Adapter;
+using MQTTnet.Client.Connecting;
+using MQTTnet.Client.Disconnecting;
+using MQTTnet.Client.Options;
+using MQTTnet.Client.PacketDispatcher;
+using MQTTnet.Client.Publishing;
+using MQTTnet.Client.Subscribing;
+using MQTTnet.Client.Unsubscribing;
 using MQTTnet.Diagnostics;
 using MQTTnet.Exceptions;
 using MQTTnet.Formatter;
-using MQTTnet.Internal;
 using MQTTnet.Packets;
 using MQTTnet.Protocol;
 
@@ -71,7 +76,7 @@ namespace MQTTnet.Client
 
                 StartReceivingPackets(_cancellationTokenSource.Token);
 
-                var connectResponse = await AuthenticateAsync(options.WillMessage, _cancellationTokenSource.Token).ConfigureAwait(false);
+                var connectResult = await AuthenticateAsync(options.WillMessage, _cancellationTokenSource.Token).ConfigureAwait(false);
                 _logger.Verbose("MQTT connection with server established.");
 
                 _sendTracker.Restart();
@@ -82,10 +87,11 @@ namespace MQTTnet.Client
                 }
 
                 IsConnected = true;
-                Connected?.Invoke(this, new MqttClientConnectedEventArgs(connectResponse.IsSessionPresent));
+                Connected?.Invoke(this, new MqttClientConnectedEventArgs(connectResult));
 
                 _logger.Info("Connected.");
-                return new MqttClientConnectResult(connectResponse.IsSessionPresent);
+
+                return connectResult;
             }
             catch (Exception exception)
             {
@@ -100,7 +106,7 @@ namespace MQTTnet.Client
             }
         }
 
-        public async Task DisconnectAsync()
+        public async Task DisconnectAsync(MqttClientDisconnectOptions options)
         {
             try
             {
@@ -108,7 +114,8 @@ namespace MQTTnet.Client
 
                 if (IsConnected && !_cancellationTokenSource.IsCancellationRequested)
                 {
-                    await SendAsync(new MqttDisconnectPacket(), _cancellationTokenSource.Token).ConfigureAwait(false);
+                    var disconnectPacket = CreateDisconnectPacket(options);
+                    await SendAsync(disconnectPacket, _cancellationTokenSource.Token).ConfigureAwait(false);
                 }
             }
             finally
@@ -120,7 +127,7 @@ namespace MQTTnet.Client
             }
         }
 
-        public async Task<IList<MqttSubscribeResult>> SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
+        public async Task<MqttClientSubscribeResult> SubscribeAsync(IEnumerable<TopicFilter> topicFilters)
         {
             if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
 
@@ -128,21 +135,16 @@ namespace MQTTnet.Client
 
             var subscribePacket = new MqttSubscribePacket
             {
-                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
-                TopicFilters = topicFilters.ToList()
+                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier()
             };
 
-            var response = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+            subscribePacket.TopicFilters.AddRange(topicFilters);
 
-            if (response.SubscribeReturnCodes.Count != subscribePacket.TopicFilters.Count)
-            {
-                throw new MqttProtocolViolationException("The return codes are not matching the topic filters [MQTT-3.9.3-1].");
-            }
-
-            return subscribePacket.TopicFilters.Select((t, i) => new MqttSubscribeResult(t, response.SubscribeReturnCodes[i])).ToList();
+            var subAckPacket = await SendAndReceiveAsync<MqttSubAckPacket>(subscribePacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+            return _adapter.PacketFormatterAdapter.DataConverter.CreateClientSubscribeResult(subscribePacket, subAckPacket);
         }
 
-        public Task UnsubscribeAsync(IEnumerable<string> topicFilters)
+        public async Task<MqttClientUnsubscribeResult> UnsubscribeAsync(IEnumerable<string> topicFilters)
         {
             if (topicFilters == null) throw new ArgumentNullException(nameof(topicFilters));
 
@@ -150,36 +152,47 @@ namespace MQTTnet.Client
 
             var unsubscribePacket = new MqttUnsubscribePacket
             {
-                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier(),
-                TopicFilters = topicFilters.ToList()
+                PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier()
             };
 
-            return SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket, _cancellationTokenSource.Token);
+            unsubscribePacket.TopicFilters.AddRange(topicFilters);
+
+            var unsubAckPacket = await SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+            return _adapter.PacketFormatterAdapter.DataConverter.CreateClientUnsubscribeResult(unsubscribePacket, unsubAckPacket);
         }
 
-        public Task PublishAsync(MqttApplicationMessage applicationMessage)
+        public async Task<MqttClientPublishResult> PublishAsync(MqttApplicationMessage applicationMessage)
         {
             if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
 
             ThrowIfNotConnected();
 
-            var publishPacket = _adapter.PacketFormatterAdapter.ConvertApplicationMessageToPublishPacket(applicationMessage);
+            var publishPacket = _adapter.PacketFormatterAdapter.DataConverter.CreatePublishPacket(applicationMessage);
 
             switch (applicationMessage.QualityOfServiceLevel)
             {
                 case MqttQualityOfServiceLevel.AtMostOnce:
                     {
                         // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
-                        return SendAsync(publishPacket, _cancellationTokenSource.Token);
+                        await SendAsync(publishPacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+                        return new MqttClientPublishResult();
                     }
                 case MqttQualityOfServiceLevel.AtLeastOnce:
                     {
                         publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
-                        return SendAndReceiveAsync<MqttPubAckPacket>(publishPacket, _cancellationTokenSource.Token);
+                        var response = await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket, _cancellationTokenSource.Token).ConfigureAwait(false);
+
+                        var result = new MqttClientPublishResult();
+                        if (response.ReasonCode != null)
+                        {
+                            result.ReasonCode = (MqttClientPublishReasonCode)response.ReasonCode;
+                        }
+
+                        return result;
                     }
                 case MqttQualityOfServiceLevel.ExactlyOnce:
                     {
-                        return PublishExactlyOnce(publishPacket, _cancellationTokenSource.Token);
+                        return await PublishExactlyOnceAsync(publishPacket, _cancellationTokenSource.Token).ConfigureAwait(false);
                     }
                 default:
                     {
@@ -198,28 +211,22 @@ namespace MQTTnet.Client
             _adapter = null;
         }
 
-        private async Task<MqttConnAckPacket> AuthenticateAsync(MqttApplicationMessage willApplicationMessage, CancellationToken cancellationToken)
+        private async Task<MqttClientConnectResult> AuthenticateAsync(MqttApplicationMessage willApplicationMessage, CancellationToken cancellationToken)
         {
-            var connectPacket = new MqttConnectPacket
-            {
-                ClientId = Options.ClientId,
-                Username = Options.Credentials?.Username,
-                Password = Options.Credentials?.Password,
-                CleanSession = Options.CleanSession,
-                KeepAlivePeriod = (ushort)Options.KeepAlivePeriod.TotalSeconds,
-                WillMessage = willApplicationMessage
-            };
+            var connectPacket = _adapter.PacketFormatterAdapter.DataConverter.CreateConnectPacket(
+                willApplicationMessage,
+                Options);
 
-            //connectPacket.RequestProblemInformationProperty = true;
-            //connectPacket.RequestResponseInformationProperty = true;
+            var connAckPacket = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket, cancellationToken).ConfigureAwait(false);
 
-            var response = await SendAndReceiveAsync<MqttConnAckPacket>(connectPacket, cancellationToken).ConfigureAwait(false);
-            if (response.ConnectReturnCode != MqttConnectReturnCode.ConnectionAccepted)
+            var result = _adapter.PacketFormatterAdapter.DataConverter.CreateClientConnectResult(connAckPacket);
+
+            if (result.ResultCode != MqttClientConnectResultCode.Success)
             {
-                throw new MqttConnectingFailedException(response.ConnectReturnCode);
+                throw new MqttConnectingFailedException(result.ResultCode);
             }
 
-            return response;
+            return result;
         }
 
         private void ThrowIfNotConnected()
@@ -237,7 +244,7 @@ namespace MQTTnet.Client
             var clientWasConnected = IsConnected;
 
             InitiateDisconnect();
-            
+
             IsConnected = false;
 
             try
@@ -249,7 +256,7 @@ namespace MQTTnet.Client
 
                 await WaitForTaskAsync(_packetReceiverTask, sender).ConfigureAwait(false);
                 await WaitForTaskAsync(_keepAliveMessageSenderTask, sender).ConfigureAwait(false);
-                
+
                 _logger.Verbose("Disconnected from adapter.");
             }
             catch (Exception adapterException)
@@ -311,9 +318,9 @@ namespace MQTTnet.Client
             try
             {
                 await _adapter.SendPacketAsync(requestPacket, cancellationToken).ConfigureAwait(false);
-                var respone = await Internal.TaskExtensions.TimeoutAfterAsync(ct => packetAwaiter.Task, Options.CommunicationTimeout, cancellationToken).ConfigureAwait(false);
+                return await packetAwaiter.WaitOneAsync(Options.CommunicationTimeout);
 
-                return (TResponsePacket)respone;
+                //return (TResponsePacket)await Internal.TaskExtensions.TimeoutAfterAsync(ct => packetAwaiter.Task, Options.CommunicationTimeout, cancellationToken).ConfigureAwait(false);
             }
             catch (MqttCommunicationTimedOutException)
             {
@@ -388,8 +395,7 @@ namespace MQTTnet.Client
 
                 while (!cancellationToken.IsCancellationRequested)
                 {
-                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken)
-                        .ConfigureAwait(false);
+                    var packet = await _adapter.ReceivePacketAsync(TimeSpan.Zero, cancellationToken).ConfigureAwait(false);
 
                     if (packet != null && !cancellationToken.IsCancellationRequested)
                     {
@@ -443,7 +449,7 @@ namespace MQTTnet.Client
 
             if (packet is MqttDisconnectPacket)
             {
-                return DisconnectAsync();
+                return DisconnectAsync(null);
             }
 
             if (packet is MqttPubRelPacket pubRelPacket)
@@ -466,14 +472,14 @@ namespace MQTTnet.Client
             if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
             {
                 FireApplicationMessageReceivedEvent(publishPacket);
-                return SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier }, cancellationToken);
+                return SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubAckReasonCode.Success }, cancellationToken);
             }
 
             if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
             {
                 // QoS 2 is implement as method "B" (4.3.3 QoS 2: Exactly once delivery)
                 FireApplicationMessageReceivedEvent(publishPacket);
-                return SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier }, cancellationToken);
+                return SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier, ReasonCode = MqttPubRecReasonCode.Success }, cancellationToken);
             }
 
             throw new MqttCommunicationException("Received a not supported QoS level.");
@@ -483,23 +489,33 @@ namespace MQTTnet.Client
         {
             var response = new MqttPubCompPacket
             {
-                PacketIdentifier = pubRelPacket.PacketIdentifier
+                PacketIdentifier = pubRelPacket.PacketIdentifier,
+                ReasonCode = MqttPubCompReasonCode.Success
             };
 
             return SendAsync(response, cancellationToken);
         }
 
-        private async Task PublishExactlyOnce(MqttPublishPacket publishPacket, CancellationToken cancellationToken)
+        private async Task<MqttClientPublishResult> PublishExactlyOnceAsync(MqttPublishPacket publishPacket, CancellationToken cancellationToken)
         {
             publishPacket.PacketIdentifier = _packetIdentifierProvider.GetNewPacketIdentifier();
 
             var pubRecPacket = await SendAndReceiveAsync<MqttPubRecPacket>(publishPacket, cancellationToken).ConfigureAwait(false);
             var pubRelPacket = new MqttPubRelPacket
             {
-                PacketIdentifier = pubRecPacket.PacketIdentifier
+                PacketIdentifier = pubRecPacket.PacketIdentifier,
+                ReasonCode = MqttPubRelReasonCode.Success
             };
 
-            await SendAndReceiveAsync<MqttPubCompPacket>(pubRelPacket, cancellationToken).ConfigureAwait(false);
+            var pubCompPacket = await SendAndReceiveAsync<MqttPubCompPacket>(pubRelPacket, cancellationToken).ConfigureAwait(false);
+            var result = new MqttClientPublishResult();
+
+            if (pubRecPacket.ReasonCode != null)
+            {
+                result.ReasonCode = (MqttClientPublishReasonCode)pubRecPacket.ReasonCode;
+            }
+
+            return result;
         }
 
         private void StartReceivingPackets(CancellationToken cancellationToken)
@@ -507,7 +523,7 @@ namespace MQTTnet.Client
             _packetReceiverTask = Task.Factory.StartNew(
                 () => ReceivePacketsAsync(cancellationToken),
                 cancellationToken,
-                TaskCreationOptions.LongRunning, 
+                TaskCreationOptions.LongRunning,
                 TaskScheduler.Default).Unwrap();
         }
 
@@ -524,8 +540,7 @@ namespace MQTTnet.Client
         {
             try
             {
-                // TODO: Move conversion to formatter.
-                var applicationMessage = publishPacket.ToApplicationMessage();
+                var applicationMessage = _adapter.PacketFormatterAdapter.DataConverter.CreateApplicationMessage(publishPacket);
                 ApplicationMessageReceived?.Invoke(this, new MqttApplicationMessageReceivedEventArgs(Options.ClientId, applicationMessage));
             }
             catch (Exception exception)
@@ -559,5 +574,31 @@ namespace MQTTnet.Client
         {
             return Interlocked.CompareExchange(ref _disconnectGate, 1, 0) != 0;
         }
+
+        private MqttDisconnectPacket CreateDisconnectPacket(MqttClientDisconnectOptions options)
+        {
+            var packet = new MqttDisconnectPacket();
+
+            if (_adapter.PacketFormatterAdapter.ProtocolVersion == MqttProtocolVersion.V500)
+            {
+                if (options == null)
+                {
+                    packet.ReasonCode = MqttDisconnectReasonCode.NormalDisconnection;
+                }
+                else
+                {
+                    packet.ReasonCode = (MqttDisconnectReasonCode)options.ReasonCode;
+                }
+            }
+            else
+            {
+                if (options != null)
+                {
+                    throw new MqttProtocolViolationException("Reason codes for disconnect are only supported for MQTTv5.");
+                }
+            }
+
+            return packet;
+        }
     }
 }

Source/MQTTnet/Client/MqttClientConnectResult.cs

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

Source/MQTTnet/Client/MqttClientConnectedEventArgs.cs

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

Source/MQTTnet/Client/MqttClientExtensions.cs

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

Source/MQTTnet/Client/MqttSubscribeResult.cs

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

Source/MQTTnet/Client/Options/IMqttClientChannelOptions.cs

@@ -1,4 +1,4 @@
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public interface IMqttClientChannelOptions
     {

Source/MQTTnet/Client/Options/IMqttClientCredentials.cs

@@ -1,4 +1,4 @@
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public interface IMqttClientCredentials
     {

Source/MQTTnet/Client/Options/IMqttClientOptions.cs

@@ -1,7 +1,7 @@
 using System;
 using MQTTnet.Formatter;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public interface IMqttClientOptions
     {
@@ -16,5 +16,15 @@ namespace MQTTnet.Client
         TimeSpan? KeepAliveSendInterval { get; }
         
         MqttApplicationMessage WillMessage { get; }
+        uint? WillDelayInterval { get; }
+
+        string AuthenticationMethod { get; }
+        byte[] AuthenticationData { get; }
+        uint? MaximumPacketSize { get; }
+        ushort? ReceiveMaximum { get; }
+        bool? RequestProblemInformation { get; }
+        bool? RequestResponseInformation { get; }
+        uint? SessionExpiryInterval { get; }
+        ushort? TopicAliasMaximum { get; }
     }
 }

Source/MQTTnet/Client/Options/MqttClientCredentials.cs

@@ -1,4 +1,4 @@
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientCredentials : IMqttClientCredentials
     {

Source/MQTTnet/Client/Options/MqttClientOptions.cs

@@ -1,7 +1,7 @@
 using System;
 using MQTTnet.Formatter;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientOptions : IMqttClientOptions
     {
@@ -9,12 +9,23 @@ namespace MQTTnet.Client
         public bool CleanSession { get; set; } = true;
         public IMqttClientCredentials Credentials { get; set; } = new MqttClientCredentials();
         public MqttProtocolVersion ProtocolVersion { get; set; } = MqttProtocolVersion.V311;
-        public IMqttClientChannelOptions ChannelOptions { get; set; }
 
+        public IMqttClientChannelOptions ChannelOptions { get; set; }
         public TimeSpan CommunicationTimeout { get; set; } = TimeSpan.FromSeconds(10);
         public TimeSpan KeepAlivePeriod { get; set; } = TimeSpan.FromSeconds(15);
         public TimeSpan? KeepAliveSendInterval { get; set; }
         
         public MqttApplicationMessage WillMessage { get; set; }
+        public uint? WillDelayInterval { get; set; }
+
+        public string AuthenticationMethod { get; set; }
+        public byte[] AuthenticationData { get; set; }
+
+        public uint? MaximumPacketSize { get; set; }
+        public ushort? ReceiveMaximum { get; set; }
+        public bool? RequestProblemInformation { get; set; }
+        public bool? RequestResponseInformation { get; set; }
+        public uint? SessionExpiryInterval { get; set; }
+        public ushort? TopicAliasMaximum { get; set; }
     }
 }

Source/MQTTnet/Client/Options/MqttClientOptionsBuilder.cs

@@ -2,7 +2,7 @@
 using System.Linq;
 using MQTTnet.Formatter;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientOptionsBuilder
     {
@@ -55,6 +55,55 @@ namespace MQTTnet.Client
             return this;
         }
 
+        public MqttClientOptionsBuilder WithAuthentication(string method, byte[] data)
+        {
+            _options.AuthenticationMethod = method;
+            _options.AuthenticationData = data;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithWillDelayInterval(uint? willDelayInterval)
+        {
+            _options.WillDelayInterval = willDelayInterval;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithTopicAliasMaximum(ushort? topicAliasMaximum)
+        {
+            _options.TopicAliasMaximum = topicAliasMaximum;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithMaximumPacketSize(uint? maximumPacketSize)
+        {
+            _options.MaximumPacketSize = maximumPacketSize;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithReceiveMaximum(ushort? receiveMaximum)
+        {
+            _options.ReceiveMaximum = receiveMaximum;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithRequestProblemInformation(bool? requestProblemInformation = true)
+        {
+            _options.RequestProblemInformation = requestProblemInformation;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithRequestResponseInformation(bool? requestResponseInformation = true)
+        {
+            _options.RequestResponseInformation = requestResponseInformation;
+            return this;
+        }
+
+        public MqttClientOptionsBuilder WithSessionExpiryInterval(uint? sessionExpiryInterval)
+        {
+            _options.SessionExpiryInterval = sessionExpiryInterval;
+            return this;
+        }
+
         public MqttClientOptionsBuilder WithCredentials(string username, string password = null)
         {
             _options.Credentials = new MqttClientCredentials

Source/MQTTnet/Client/Options/MqttClientOptionsBuilderTlsParameters.cs

@@ -4,7 +4,7 @@ using System.Net.Security;
 using System.Security.Authentication;
 using System.Security.Cryptography.X509Certificates;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientOptionsBuilderTlsParameters
     {

Source/MQTTnet/Client/Options/MqttClientTcpOptions.cs

@@ -1,4 +1,4 @@
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientTcpOptions : IMqttClientChannelOptions
     {

Source/MQTTnet/Client/Options/MqttClientTcpOptionsExtensions.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public static class MqttClientTcpOptionsExtensions
     {

Source/MQTTnet/Client/Options/MqttClientTlsOptions.cs

@@ -1,10 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Net.Security;
-using System.Security.Cryptography.X509Certificates;
 using System.Security.Authentication;
+using System.Security.Cryptography.X509Certificates;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientTlsOptions
     {

Source/MQTTnet/Client/Options/MqttClientWebSocketOptions.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Net;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientWebSocketOptions : IMqttClientChannelOptions
     {

Source/MQTTnet/Client/Options/MqttClientWebSocketProxyOptions.cs

@@ -1,4 +1,4 @@
-namespace MQTTnet.Client
+namespace MQTTnet.Client.Options
 {
     public class MqttClientWebSocketProxyOptions
     {

Source/MQTTnet/Client/PacketDispatcher/IMqttPacketAwaiter.cs

@@ -0,0 +1,12 @@
+using System;
+using MQTTnet.Packets;
+
+namespace MQTTnet.Client.PacketDispatcher
+{
+    public interface IMqttPacketAwaiter
+    {
+        void Complete(MqttBasePacket packet);
+
+        void Fail(Exception exception);
+    }
+}

Source/MQTTnet/Client/PacketDispatcher/MqttPacketAwaiter.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using MQTTnet.Packets;
+
+namespace MQTTnet.Client.PacketDispatcher
+{
+    public sealed class MqttPacketAwaiter<TPacket> : IMqttPacketAwaiter where TPacket : MqttBasePacket
+    {
+        private readonly TaskCompletionSource<MqttBasePacket> _packet = new TaskCompletionSource<MqttBasePacket>();
+
+        public async Task<TPacket> WaitOneAsync(TimeSpan timeout)
+        {
+            using (var timeoutToken = new CancellationTokenSource(timeout))
+            {
+                timeoutToken.Token.Register(() => _packet.TrySetCanceled());
+
+                var packet = await _packet.Task.ConfigureAwait(false);
+                return (TPacket)packet;
+            }
+        }
+
+        public void Complete(MqttBasePacket packet)
+        {
+            if (packet == null) throw new ArgumentNullException(nameof(packet));
+
+            _packet.TrySetResult(packet);
+        }
+
+        public void Fail(Exception exception)
+        {
+            if (exception == null) throw new ArgumentNullException(nameof(exception));
+
+            _packet.TrySetException(exception);
+        }
+    }
+}

Source/MQTTnet/Client/PacketDispatcher/MqttPacketDispatcher.cs

@@ -3,17 +3,17 @@ using System.Collections.Concurrent;
 using System.Threading.Tasks;
 using MQTTnet.Packets;
 
-namespace MQTTnet.Client
+namespace MQTTnet.Client.PacketDispatcher
 {
     public class MqttPacketDispatcher
     {
-        private readonly ConcurrentDictionary<Tuple<ushort, Type>, TaskCompletionSource<MqttBasePacket>> _awaiters = new ConcurrentDictionary<Tuple<ushort, Type>, TaskCompletionSource<MqttBasePacket>>();
-        
+        private readonly ConcurrentDictionary<Tuple<ushort, Type>, IMqttPacketAwaiter> _awaiters = new ConcurrentDictionary<Tuple<ushort, Type>, IMqttPacketAwaiter>();
+
         public void Dispatch(Exception exception)
         {
             foreach (var awaiter in _awaiters)
             {
-                Task.Run(() => awaiter.Value.TrySetException(exception)); // Task.Run fixes a dead lock. Without this the client only receives one message.
+                Task.Run(() => awaiter.Value.Fail(exception)); // Task.Run fixes a dead lock. Without this the client only receives one message.
             }
 
             _awaiters.Clear();
@@ -31,10 +31,10 @@ namespace MQTTnet.Client
 
             var type = packet.GetType();
             var key = new Tuple<ushort, Type>(identifier, type);
-            
+
             if (_awaiters.TryRemove(key, out var awaiter))
             {
-                Task.Run(() => awaiter.TrySetResult(packet)); // Task.Run fixes a dead lock. Without this the client only receives one message.
+                Task.Run(() => awaiter.Complete(packet)); // Task.Run fixes a dead lock. Without this the client only receives one message.
                 return;
             }
 
@@ -46,22 +46,22 @@ namespace MQTTnet.Client
             _awaiters.Clear();
         }
 
-        public TaskCompletionSource<MqttBasePacket> AddPacketAwaiter<TResponsePacket>(ushort? identifier) where TResponsePacket : MqttBasePacket
+        public MqttPacketAwaiter<TResponsePacket> AddPacketAwaiter<TResponsePacket>(ushort? identifier) where TResponsePacket : MqttBasePacket
         {
-            var tcs = new TaskCompletionSource<MqttBasePacket>();
+            var awaiter = new MqttPacketAwaiter<TResponsePacket>();
 
             if (!identifier.HasValue)
             {
                 identifier = 0;
             }
-            
-            var key = new Tuple<ushort, Type>(identifier ?? 0, typeof(TResponsePacket));
-            if (!_awaiters.TryAdd(key, tcs))
+
+            var key = new Tuple<ushort, Type>(identifier.Value, typeof(TResponsePacket));
+            if (!_awaiters.TryAdd(key, awaiter))
             {
                 throw new InvalidOperationException($"The packet dispatcher already has an awaiter for packet of type '{key.Item2.Name}' with identifier {key.Item1}.");
             }
 
-            return tcs;
+            return awaiter;
         }
 
         public void RemovePacketAwaiter<TResponsePacket>(ushort? identifier) where TResponsePacket : MqttBasePacket

Source/MQTTnet/Client/Publishing/MqttClientPublishReasonCode.cs

@@ -0,0 +1,15 @@
+namespace MQTTnet.Client.Publishing
+{
+    public enum MqttClientPublishReasonCode
+    {
+        Success = 0,
+        NoMatchingSubscribers = 16,
+        UnspecifiedError = 128,
+        ImplementationSpecificError = 131,
+        NotAuthorized = 135,
+        TopicNameInvalid = 144,
+        PacketIdentifierInUse = 145,
+        QuotaExceeded = 151,
+        PayloadFormatInvalid = 153
+    }
+}

Source/MQTTnet/Client/Publishing/MqttClientPublishResult.cs

@@ -0,0 +1,8 @@
+
+namespace MQTTnet.Client.Publishing
+{
+    public class MqttClientPublishResult
+    {
+        public MqttClientPublishReasonCode ReasonCode { get; set; } = MqttClientPublishReasonCode.Success;
+    }
+}

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeResult.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace MQTTnet.Client.Subscribing
+{
+    public class MqttClientSubscribeResult
+    {
+        public List<MqttClientSubscribeResultItem> Items { get; } = new List<MqttClientSubscribeResultItem>();
+    }
+}

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeResultCode.cs

@@ -0,0 +1,18 @@
+namespace MQTTnet.Client.Subscribing
+{
+    public enum MqttClientSubscribeResultCode
+    {
+        GrantedQoS0 = 0,
+        GrantedQoS1 = 1,
+        GrantedQoS2 = 2,
+        UnspecifiedError = 128,
+        ImplementationSpecificError = 131,
+        NotAuthorized = 135,
+        TopicFilterInvalid = 143,
+        PacketIdentifierInUse = 145,
+        QuotaExceeded = 151,
+        SharedSubscriptionsNotSupported = 158,
+        SubscriptionIdentifiersNotSupported = 161,
+        WildcardSubscriptionsNotSupported = 162
+    }
+}

Source/MQTTnet/Client/Subscribing/MqttClientSubscribeResultItem.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace MQTTnet.Client.Subscribing
+{
+    public class MqttClientSubscribeResultItem
+    {
+        public MqttClientSubscribeResultItem(TopicFilter topicFilter, MqttClientSubscribeResultCode resultCode)
+        {
+            TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter));
+            ResultCode = resultCode;
+        }
+
+        public TopicFilter TopicFilter { get; }
+
+        public MqttClientSubscribeResultCode ResultCode { get; }
+    }
+}

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeResult.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace MQTTnet.Client.Unsubscribing
+{
+    public class MqttClientUnsubscribeResult
+    {
+        public List<MqttClientUnsubscribeResultItem> Items { get; }  =new List<MqttClientUnsubscribeResultItem>();
+    }
+}

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeResultCode.cs

@@ -0,0 +1,13 @@
+namespace MQTTnet.Client.Unsubscribing
+{
+    public enum MqttClientUnsubscribeResultCode
+    {
+        Success = 0,
+        NoSubscriptionExisted = 17,
+        UnspecifiedError = 128,
+        ImplementationSpecificError = 131,
+        NotAuthorized = 135,
+        TopicFilterInvalid = 143,
+        PacketIdentifierInUse = 145
+    }
+}

Source/MQTTnet/Client/Unsubscribing/MqttClientUnsubscribeResultItem.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace MQTTnet.Client.Unsubscribing
+{
+    public class MqttClientUnsubscribeResultItem
+    {
+        public MqttClientUnsubscribeResultItem(string topicFilter, MqttClientUnsubscribeResultCode reasonCode)
+        {
+            TopicFilter = topicFilter ?? throw new ArgumentNullException(nameof(topicFilter));
+            ReasonCode = reasonCode;
+        }
+
+        public string TopicFilter { get; }
+
+        public MqttClientUnsubscribeResultCode ReasonCode { get; }
+    }
+}