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/Adapter/IMqttCommunicationAdapter.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Packets;
@@ -12,7 +13,7 @@ namespace MQTTnet.Core.Adapter
 
         Task DisconnectAsync();
 
-        Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout);
+        Task SendPacketsAsync(TimeSpan timeout, IEnumerable<MqttBasePacket> packets);
 
         Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout);
 

MQTTnet.Core/Adapter/MqttChannelCommunicationAdapter.cs

@@ -1,9 +1,12 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Threading.Tasks;
 using MQTTnet.Core.Channel;
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Diagnostics;
 using MQTTnet.Core.Exceptions;
+using MQTTnet.Core.Internal;
 using MQTTnet.Core.Packets;
 using MQTTnet.Core.Serializer;
 
@@ -12,6 +15,9 @@ namespace MQTTnet.Core.Adapter
     public class MqttChannelCommunicationAdapter : IMqttCommunicationAdapter
     {
         private readonly IMqttCommunicationChannel _channel;
+        private readonly byte[] _readBuffer = new byte[BufferConstants.Size];
+
+        private Task _sendTask = Task.FromResult(0); // this task is used to prevent overlapping write
 
         public MqttChannelCommunicationAdapter(IMqttCommunicationChannel channel, IMqttPacketSerializer serializer)
         {
@@ -23,7 +29,7 @@ namespace MQTTnet.Core.Adapter
 
         public Task ConnectAsync(MqttClientOptions options, TimeSpan timeout)
         {
-            return ExecuteWithTimeoutAsync(_channel.ConnectAsync(options), timeout);
+            return _channel.ConnectAsync(options).TimeoutAfter(timeout);
         }
 
         public Task DisconnectAsync()
@@ -31,25 +37,38 @@ namespace MQTTnet.Core.Adapter
             return _channel.DisconnectAsync();
         }
 
-        public Task SendPacketAsync(MqttBasePacket packet, TimeSpan timeout)
+        public async Task SendPacketsAsync(TimeSpan timeout, IEnumerable<MqttBasePacket> packets)
         {
-            MqttTrace.Information(nameof(MqttChannelCommunicationAdapter), "TX >>> {0} [Timeout={1}]", packet, timeout);
+            lock (_channel)
+            {
+                foreach (var packet in packets)
+                {
+                    MqttTrace.Information(nameof(MqttChannelCommunicationAdapter), "TX >>> {0} [Timeout={1}]", packet, timeout);
 
-            return ExecuteWithTimeoutAsync(PacketSerializer.SerializeAsync(packet, _channel), timeout);
+                    var writeBuffer = PacketSerializer.Serialize(packet);
+
+                    _sendTask = _sendTask.ContinueWith(p => _channel.SendStream.WriteAsync(writeBuffer, 0, writeBuffer.Length));
+                }
+            }
+
+            await _sendTask; // configure await false geneates stackoverflow
+            await _channel.SendStream.FlushAsync().TimeoutAfter(timeout).ConfigureAwait(false);
         }
 
         public async Task<MqttBasePacket> ReceivePacketAsync(TimeSpan timeout)
         {
-            MqttBasePacket packet;
+            Tuple<MqttPacketHeader, MemoryStream> tuple;
             if (timeout > TimeSpan.Zero)
             {
-                packet = await ExecuteWithTimeoutAsync(PacketSerializer.DeserializeAsync(_channel), timeout).ConfigureAwait(false);
+                tuple = await ReceiveAsync(_channel.RawStream).TimeoutAfter(timeout).ConfigureAwait(false);
             }
             else
             {
-                packet = await PacketSerializer.DeserializeAsync(_channel).ConfigureAwait(false);
+                tuple = await ReceiveAsync(_channel.ReceiveStream).ConfigureAwait(false);
             }
 
+            var packet = PacketSerializer.Deserialize(tuple.Item1, tuple.Item2);
+
             if (packet == null)
             {
                 throw new MqttProtocolViolationException("Received malformed packet.");
@@ -59,34 +78,27 @@ namespace MQTTnet.Core.Adapter
             return packet;
         }
 
-        private static async Task<TResult> ExecuteWithTimeoutAsync<TResult>(Task<TResult> task, TimeSpan timeout)
+        private async Task<Tuple<MqttPacketHeader, MemoryStream>> ReceiveAsync(Stream stream)
         {
-            var timeoutTask = Task.Delay(timeout);
-            if (await Task.WhenAny(timeoutTask, task).ConfigureAwait(false) == timeoutTask)
+            var header = MqttPacketReader.ReadHeaderFromSource(stream);
+
+            MemoryStream body;
+            if (header.BodyLength > 0)
             {
-                throw new MqttCommunicationTimedOutException();
+                var totalRead = 0;
+                do
+                {
+                    var read = await stream.ReadAsync(_readBuffer, totalRead, header.BodyLength - totalRead).ConfigureAwait(false);
+                    totalRead += read;
+                } while (totalRead < header.BodyLength);
+                body = new MemoryStream(_readBuffer, 0, header.BodyLength);
+            }
+            else
+            {
+                body = new MemoryStream();
             }
 
-            if (task.IsFaulted)
-            {
-                throw new MqttCommunicationException(task.Exception);
-            }
-
-            return task.Result;
-        }
-
-        private static async Task ExecuteWithTimeoutAsync(Task task, TimeSpan timeout)
-        {
-            var timeoutTask = Task.Delay(timeout);
-            if (await Task.WhenAny(timeoutTask, task).ConfigureAwait(false) == timeoutTask)
-            {
-                throw new MqttCommunicationTimedOutException();
-            }
-
-            if (task.IsFaulted)
-            {
-                throw new MqttCommunicationException(task.Exception);
-            }
+            return Tuple.Create(header, body);
         }
     }
 }

MQTTnet.Core/Adapter/MqttCommunicationAdapterExtensions.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Threading.Tasks;
+using MQTTnet.Core.Packets;
+
+namespace MQTTnet.Core.Adapter
+{
+    public static class MqttCommunicationAdapterExtensions
+    {
+        public static Task SendPacketsAsync(this IMqttCommunicationAdapter adapter, TimeSpan timeout, params MqttBasePacket[] packets)
+        {
+            return adapter.SendPacketsAsync(timeout, packets);
+        }
+    }
+}

MQTTnet.Core/Adapter/MqttConnectingFailedException.cs

@@ -5,7 +5,7 @@ namespace MQTTnet.Core.Adapter
 {
     public class MqttConnectingFailedException : MqttCommunicationException
     {
-        public MqttConnectingFailedException(MqttConnectReturnCode returnCode) 
+        public MqttConnectingFailedException(MqttConnectReturnCode returnCode)
             : base($"Connecting with MQTT server failed ({returnCode}).")
         {
             ReturnCode = returnCode;