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

Frameworks/MQTTnet.UniversalWindows/Implementations/MqttServerAdapter.cs

@@ -10,7 +10,7 @@ namespace MQTTnet.Implementations
     public class MqttServerAdapter : IMqttServerAdapter, IDisposable
     {
         private StreamSocketListener _defaultEndpointSocket;
-        
+
         private bool _isRunning;
 
         public event EventHandler<MqttClientConnectedEventArgs> ClientConnected;
@@ -20,13 +20,14 @@ namespace MQTTnet.Implementations
             if (options == null) throw new ArgumentNullException(nameof(options));
 
             if (_isRunning) throw new InvalidOperationException("Server is already started.");
+
             _isRunning = true;
 
             if (options.DefaultEndpointOptions.IsEnabled)
             {
                 _defaultEndpointSocket = new StreamSocketListener();
                 _defaultEndpointSocket.BindServiceNameAsync(options.GetDefaultEndpointPort().ToString(), SocketProtectionLevel.PlainSocket).GetAwaiter().GetResult();
-                _defaultEndpointSocket.ConnectionReceived += AcceptDefaultEndpointConnectionsAsync;                
+                _defaultEndpointSocket.ConnectionReceived += AcceptDefaultEndpointConnectionsAsync;
             }
 
             if (options.TlsEndpointOptions.IsEnabled)

Frameworks/MQTTnet.UniversalWindows/Implementations/MqttWebSocketChannel.cs

@@ -2,6 +2,7 @@
 using MQTTnet.Core.Client;
 using MQTTnet.Core.Exceptions;
 using System;
+using System.IO;
 using System.Net.WebSockets;
 using System.Threading;
 using System.Threading.Tasks;
@@ -11,8 +12,11 @@ namespace MQTTnet.Implementations
     public sealed class MqttWebSocketChannel : IMqttCommunicationChannel, IDisposable
     {
         private ClientWebSocket _webSocket = new ClientWebSocket();
-        private int _bufferSize;
-        private int _bufferOffset;
+
+        public Stream RawStream { get; private set; }
+
+        public Stream SendStream => RawStream;
+        public Stream ReceiveStream => RawStream;
 
         public async Task ConnectAsync(MqttClientOptions options)
         {
@@ -22,6 +26,8 @@ namespace MQTTnet.Implementations
             {
                 _webSocket = new ClientWebSocket();
                 await _webSocket.ConnectAsync(new Uri(options.Server), CancellationToken.None);
+
+                RawStream = new WebSocketStream(_webSocket);
             }
             catch (WebSocketException exception)
             {
@@ -31,6 +37,7 @@ namespace MQTTnet.Implementations
 
         public Task DisconnectAsync()
         {
+            RawStream = null;
             return _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
         }
 
@@ -38,64 +45,5 @@ namespace MQTTnet.Implementations
         {
             _webSocket?.Dispose();
         }
-
-        public async Task<ArraySegment<byte>> ReadAsync(int length, byte[] buffer)
-        {
-            await ReadToBufferAsync(length, buffer).ConfigureAwait(false);
-
-            var result = new ArraySegment<byte>(buffer, _bufferOffset, length);
-            _bufferSize -= length;
-            _bufferOffset += length;
-
-            return result;
-        }
-
-        private async Task ReadToBufferAsync(int length, byte[] buffer)
-        {
-            if (_bufferSize > 0)
-            {
-                return;
-            }
-
-            var offset = 0;
-            while (_webSocket.State == WebSocketState.Open && _bufferSize < length)
-            {
-                WebSocketReceiveResult response;
-                do
-                {
-                    response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer, offset, buffer.Length - offset), CancellationToken.None).ConfigureAwait(false);
-                    offset += response.Count;
-                } while (!response.EndOfMessage);
-
-                _bufferSize = response.Count;
-
-                if (response.MessageType == WebSocketMessageType.Close)
-                {
-                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).ConfigureAwait(false);
-                }
-            }
-        }
-
-        public async Task WriteAsync(byte[] buffer)
-        {
-            if (buffer == null)
-            {
-                throw new ArgumentNullException(nameof(buffer));
-            }
-
-            try
-            {
-                await _webSocket.SendAsync(new ArraySegment<byte>(buffer), WebSocketMessageType.Binary, true, CancellationToken.None);
-            }
-            catch (WebSocketException exception)
-            {
-                throw new MqttCommunicationException(exception);
-            }
-        }
-
-        public int Peek()
-        {
-            return _bufferSize;
-        }
     }
 }

Frameworks/MQTTnet.UniversalWindows/Implementations/WebSocketStream.cs

@@ -0,0 +1,80 @@
+using System;
+using System.IO;
+using System.Net.WebSockets;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MQTTnet.Implementations
+{
+    public class WebSocketStream : Stream
+    {
+        private readonly ClientWebSocket _webSocket;
+
+        public WebSocketStream(ClientWebSocket webSocket)
+        {
+            _webSocket = webSocket;
+        }
+
+        public override void Flush()
+        {
+        }
+
+        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            var currentOffset = offset;
+            var targetOffset = offset + count;
+            while (_webSocket.State == WebSocketState.Open && currentOffset < targetOffset)
+            {
+                var response = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer, currentOffset, count), cancellationToken).ConfigureAwait(false);
+                currentOffset += response.Count;
+
+                if (response.MessageType == WebSocketMessageType.Close)
+                {
+                    await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, cancellationToken).ConfigureAwait(false);
+                }
+            }
+
+            return currentOffset - offset;
+        }
+
+        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+        {
+            return _webSocket.SendAsync(new ArraySegment<byte>(buffer, offset, count), WebSocketMessageType.Binary, true, cancellationToken);
+        }
+
+        public override int Read(byte[] buffer, int offset, int count)
+        {
+            return ReadAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        public override void Write(byte[] buffer, int offset, int count)
+        {
+            WriteAsync(buffer, offset, count).GetAwaiter().GetResult();
+        }
+
+        public override bool CanRead => true;
+        public override bool CanSeek => false;
+        public override bool CanWrite => true;
+
+        public override long Length
+        {
+            get { throw new NotSupportedException(); }
+        }
+
+        public override long Position
+        {
+            get { throw new NotSupportedException(); }
+            set { throw new NotSupportedException(); }
+        }
+
+        public override long Seek(long offset, SeekOrigin origin)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void SetLength(long value)
+        {
+            throw new NotSupportedException();
+        }
+    }
+}