Merge branch 'develop' of https://github.com/chkr1011/MQTTnet into develop

# Conflicts:
#	MQTTnet.Core/Serializer/MqttPacketReader.cs
#	MQTTnet.Core/Serializer/MqttPacketSerializer.cs
#	Tests/MQTTnet.TestApp.NetFramework/PerformanceTest.cs

MQTTnet.Core/Client/IMqttClient.cs

@@ -15,7 +15,7 @@ namespace MQTTnet.Core.Client
 
         Task ConnectAsync(MqttApplicationMessage willApplicationMessage = null);
         Task DisconnectAsync();
-        Task PublishAsync(MqttApplicationMessage applicationMessage);
+        Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages);
         Task<IList<MqttSubscribeResult>> SubscribeAsync(IList<TopicFilter> topicFilters);
         Task<IList<MqttSubscribeResult>> SubscribeAsync(params TopicFilter[] topicFilters);
         Task Unsubscribe(IList<string> topicFilters);

MQTTnet.Core/Client/MqttClient.cs

@@ -161,32 +161,43 @@ namespace MQTTnet.Core.Client
             return SendAndReceiveAsync<MqttUnsubAckPacket>(unsubscribePacket);
         }
 
-        public Task PublishAsync(MqttApplicationMessage applicationMessage)
+        public async Task PublishAsync(IEnumerable<MqttApplicationMessage> applicationMessages)
         {
-            if (applicationMessage == null) throw new ArgumentNullException(nameof(applicationMessage));
             ThrowIfNotConnected();
 
-            var publishPacket = applicationMessage.ToPublishPacket();
+            var publishPackets = applicationMessages.Select(m => m.ToPublishPacket());
 
-            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
+            foreach (var qosGroup in publishPackets.GroupBy(p => p.QualityOfServiceLevel))
             {
-                // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
-                return SendAsync(publishPacket);
+                var qosPackets = qosGroup.ToArray();
+                switch (qosGroup.Key)
+                {
+                    case MqttQualityOfServiceLevel.AtMostOnce:
+                        // No packet identifier is used for QoS 0 [3.3.2.2 Packet Identifier]
+                        await _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, qosPackets);
+                        break;
+                    case MqttQualityOfServiceLevel.AtLeastOnce:
+                        {
+                            foreach (var publishPacket in qosPackets)
+                            {
+                                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
+                                await SendAndReceiveAsync<MqttPubAckPacket>(publishPacket);
+                            }
+                            break;
+                        }
+                    case MqttQualityOfServiceLevel.ExactlyOnce:
+                        {
+                            foreach (var publishPacket in qosPackets)
+                            {
+                                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
+                                await PublishExactlyOncePacketAsync(publishPacket);
+                            }
+                            break;
+                        }
+                    default:
+                        throw new InvalidOperationException();
+                }
             }
-
-            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
-            {
-                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
-                return SendAndReceiveAsync<MqttPubAckPacket>(publishPacket);
-            }
-
-            if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
-            {
-                publishPacket.PacketIdentifier = GetNewPacketIdentifier();
-                return PublishExactlyOncePacketAsync(publishPacket);
-            }
-
-            throw new InvalidOperationException();
         }
 
         private async Task PublishExactlyOncePacketAsync(MqttBasePacket publishPacket)
@@ -277,12 +288,14 @@ namespace MQTTnet.Core.Client
             if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtMostOnce)
             {
                 FireApplicationMessageReceivedEvent(publishPacket);
+                return;
             }
 
             if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.AtLeastOnce)
             {
                 FireApplicationMessageReceivedEvent(publishPacket);
                 await SendAsync(new MqttPubAckPacket { PacketIdentifier = publishPacket.PacketIdentifier });
+                return;
             }
 
             if (publishPacket.QualityOfServiceLevel == MqttQualityOfServiceLevel.ExactlyOnce)
@@ -295,6 +308,7 @@ namespace MQTTnet.Core.Client
 
                 FireApplicationMessageReceivedEvent(publishPacket);
                 await SendAsync(new MqttPubRecPacket { PacketIdentifier = publishPacket.PacketIdentifier });
+                return;
             }
 
             throw new MqttCommunicationException("Received a not supported QoS level.");
@@ -312,13 +326,12 @@ namespace MQTTnet.Core.Client
 
         private Task SendAsync(MqttBasePacket packet)
         {
-            return _adapter.SendPacketAsync(packet, _options.DefaultCommunicationTimeout);
+            return _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, packet);
         }
 
         private async Task<TResponsePacket> SendAndReceiveAsync<TResponsePacket>(MqttBasePacket requestPacket) where TResponsePacket : MqttBasePacket
         {
-            await _adapter.SendPacketAsync(requestPacket, _options.DefaultCommunicationTimeout).ConfigureAwait(false);
-
+            await _adapter.SendPacketsAsync(_options.DefaultCommunicationTimeout, requestPacket).ConfigureAwait(false);
             return (TResponsePacket)await _packetDispatcher.WaitForPacketAsync(requestPacket, typeof(TResponsePacket), _options.DefaultCommunicationTimeout).ConfigureAwait(false);
         }
 

MQTTnet.Core/Client/MqttClientExtensions.cs

@@ -0,0 +1,12 @@
+using System.Threading.Tasks;
+
+namespace MQTTnet.Core.Client
+{
+    public static class MqttClientExtensions
+    {
+        public static Task PublishAsync(this IMqttClient client, params MqttApplicationMessage[] applicationMessages)
+        {
+            return client.PublishAsync(applicationMessages);
+        }
+    }
+}

MQTTnet.Core/Client/MqttPacketDispatcher.cs

@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Threading.Tasks;
 using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
+using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using System.Collections.Concurrent;
 
@@ -13,7 +14,7 @@ namespace MQTTnet.Core.Client
         private readonly object _syncRoot = new object();
         private readonly HashSet<MqttBasePacket> _receivedPackets = new HashSet<MqttBasePacket>();
         private readonly ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>> _packetByResponseType = new ConcurrentDictionary<Type, TaskCompletionSource<MqttBasePacket>>();
-        private readonly ConcurrentDictionary<ushort,TaskCompletionSource<MqttBasePacket>> _packetByIdentifier = new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>();
+        private readonly ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>> _packetByIdentifier = new ConcurrentDictionary<ushort, TaskCompletionSource<MqttBasePacket>>();
 
         public async Task<MqttBasePacket> WaitForPacketAsync(MqttBasePacket request, Type responseType, TimeSpan timeout)
         {
@@ -22,16 +23,19 @@ namespace MQTTnet.Core.Client
             var packetAwaiter = AddPacketAwaiter(request, responseType);
             DispatchPendingPackets();
 
-            var hasTimeout = await Task.WhenAny(Task.Delay(timeout), packetAwaiter.Task).ConfigureAwait(false) != packetAwaiter.Task;
-            RemovePacketAwaiter(request, responseType);
-
-            if (hasTimeout)
+            try
+            {
+                return await packetAwaiter.Task.TimeoutAfter(timeout);
+            }
+            catch (MqttCommunicationTimedOutException)
             {
                 MqttTrace.Warning(nameof(MqttPacketDispatcher), "Timeout while waiting for packet.");
-                throw new MqttCommunicationTimedOutException();
+                throw;
+            }
+            finally
+            {
+                RemovePacketAwaiter(request, responseType);
             }
-
-            return packetAwaiter.Task.Result;
         }
 
         public void Dispatch(MqttBasePacket packet)
@@ -48,9 +52,9 @@ namespace MQTTnet.Core.Client
                     packetDispatched = true;
                 }
             }
-            else if (_packetByResponseType.TryRemove(packet.GetType(), out var tcs) )
+            else if (_packetByResponseType.TryRemove(packet.GetType(), out var tcs))
             {
-                tcs.TrySetResult( packet);
+                tcs.TrySetResult(packet);
                 packetDispatched = true;
             }
 
@@ -96,11 +100,11 @@ namespace MQTTnet.Core.Client
         {
             if (request is IMqttPacketWithIdentifier withIdent)
             {
-                _packetByIdentifier.TryRemove(withIdent.PacketIdentifier, out var tcs);
+                _packetByIdentifier.TryRemove(withIdent.PacketIdentifier, out var _);
             }
             else
             {
-                _packetByResponseType.TryRemove(responseType, out var tcs);
+                _packetByResponseType.TryRemove(responseType, out var _);
             }
         }