public WebSocketMessageWriteRfc6455Stream(WebSocketRfc6455 client, WebSocketMessageType messageType, WebSocketExtensionFlags extensionFlags)
     : this(client, messageType)
 {
     ExtensionFlags.Rsv1 = extensionFlags.Rsv1;
     ExtensionFlags.Rsv2 = extensionFlags.Rsv2;
     ExtensionFlags.Rsv3 = extensionFlags.Rsv3;
 }

        public virtual Task SendAsync(ArraySegment<byte> message, WebSocketMessageType messageType, bool endOfMessage = true)
        {
            if (WebSocket.State != WebSocketState.Open)
            {
                return TaskAsyncHelper.Empty;
            }

            var sendContext = new SendContext(this, message, messageType, endOfMessage);

            return _sendQueue.Enqueue(async state =>
            {
                var context = (SendContext)state;

                if (context.Handler.WebSocket.State != WebSocketState.Open)
                {
                    return;
                }

                try
                {
                    await context.Handler.WebSocket.SendAsync(context.Message, context.MessageType, context.EndOfMessage, CancellationToken.None);
                }
                catch (Exception ex)
                {
                    // Swallow exceptions on send
                    Trace.TraceError("Error while sending: " + ex);
                }
            },
            sendContext);
        }

        public override Task OnMessageReceived(ArraySegment<byte> message, WebSocketMessageType type)
        {
            if (this.MessageReceived != null)
                this.MessageReceived(this, new SocketMessage(this.Id, new UTF8Encoding().GetString(message.Array)));

            return base.OnMessageReceived(message, type);
        }

 private void TestChatHanlder_OnReceive(WebSocket Socket, WebSocketMessageType Type, byte[] ReceiveMessage)
 {
     //並行廣播給所有使用者，也可以轉發給指定使用者
     Parallel.ForEach(WebSocketList, async socket => {
         await socket.SendAsync(new ArraySegment<byte>(ReceiveMessage), Type, true, CancellationToken.None);
     });
 }

 internal WebSocketMessageProperty(WebSocketContext context, string subProtocol, WebSocketMessageType incomingMessageType, ReadOnlyDictionary<string, object> properties)
 {
     this.context = context;
     this.subProtocol = subProtocol;
     this.messageType = incomingMessageType;
     this.properties = properties;
 }

        internal static Interop.WinHttp.WINHTTP_WEB_SOCKET_BUFFER_TYPE GetWinHttpMessageType(WebSocketMessageType messageType, bool endOfMessage)
        {
            switch (messageType)
            {
                case WebSocketMessageType.Binary:
                    if (endOfMessage)
                    {
                        return Interop.WinHttp.WINHTTP_WEB_SOCKET_BUFFER_TYPE.WINHTTP_WEB_SOCKET_BINARY_MESSAGE_BUFFER_TYPE;
                    }
                    else
                    {
                        return Interop.WinHttp.WINHTTP_WEB_SOCKET_BUFFER_TYPE.WINHTTP_WEB_SOCKET_BINARY_FRAGMENT_BUFFER_TYPE;
                    }

                case WebSocketMessageType.Text:
                    if (endOfMessage)
                    {
                        return Interop.WinHttp.WINHTTP_WEB_SOCKET_BUFFER_TYPE.WINHTTP_WEB_SOCKET_UTF8_MESSAGE_BUFFER_TYPE;
                    }
                    else
                    {
                        return Interop.WinHttp.WINHTTP_WEB_SOCKET_BUFFER_TYPE.WINHTTP_WEB_SOCKET_UTF8_FRAGMENT_BUFFER_TYPE;
                    }

                case WebSocketMessageType.Close:
                    return Interop.WinHttp.WINHTTP_WEB_SOCKET_BUFFER_TYPE.WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE;

                default:
                    Debug.Fail("Unknown WebSocketMessageType.");
                    return Interop.WinHttp.WINHTTP_WEB_SOCKET_BUFFER_TYPE.WINHTTP_WEB_SOCKET_CLOSE_BUFFER_TYPE;
            }
        }

 public SendContext(ArraySegment<byte> buffer, bool endOfMessage, WebSocketMessageType type, CancellationToken cancelToken)
 {
     this.Buffer = buffer;
     this.EndOfMessage = endOfMessage;
     this.Type = type;
     this.CancelToken = cancelToken;
 }

 public PendingSend(TaskCompletionSource<bool> tcs, WebSocketMessageType type, ArraySegment<byte> buffer, CancellationToken cancellationToken)
 {
     Type = type;
     _tcs = tcs;
     Buffer = buffer;
     CancellationToken = cancellationToken;
 }

 public Task SendAsync(
     ArraySegment<byte> bytes,
     WebSocketMessageType webSocketMessageType,
     bool endOfMessage,
     CancellationToken cancellationToken)
 {
     return this.socket.SendAsync(bytes, webSocketMessageType, endOfMessage, cancellationToken);
 }

 public Task SendAsync(
     ArraySegment<byte> buffer,
     WebSocketMessageType messageType,
     bool endOfMessage,
     CancellationToken cancellationToken)
 {
     throw new PlatformNotSupportedException(SR.net_WebSockets_UnsupportedPlatform);
 }

 public Task SendAsync(
     ArraySegment<byte> buffer,
     WebSocketMessageType messageType,
     bool endOfMessage,
     CancellationToken cancellationToken)
 {
     return _webSocket.SendAsync(buffer, messageType, endOfMessage, cancellationToken);
 }

 public Task SendAsync(
     ArraySegment<byte> bytes,
     WebSocketMessageType webSocketMessageType,
     bool endOfMessage,
     CancellationToken cancellationToken)
 {
     return Task.Run(() => this.socket.Send(new[] { bytes }), cancellationToken);
 }

		public WebSocketReceiveResult (int count,
		                               WebSocketMessageType messageType,
		                               bool endOfMessage,
		                               WebSocketCloseStatus? closeStatus,
		                               string closeStatusDescription)
		{
			throw new NotImplementedException ();
		}

 public void ConstructorTest_Success(int count, WebSocketMessageType messageType, bool endOfMessage, WebSocketCloseStatus? closeStatus, string closeStatusDescription)
 {
     var wsrr = new WebSocketReceiveResult(count, messageType, endOfMessage, closeStatus, closeStatusDescription);
     Assert.Equal(wsrr.Count, count);
     Assert.Equal(wsrr.MessageType, messageType);
     Assert.Equal(wsrr.EndOfMessage, endOfMessage);
     Assert.Equal(wsrr.CloseStatus, closeStatus);
     Assert.Equal(wsrr.CloseStatusDescription, closeStatusDescription);
 }

        public WebSocketMessageWriteRfc6455Stream(WebSocketRfc6455 webSocket, WebSocketMessageType messageType)
        {
            if (webSocket == null)
                throw new ArgumentNullException("webSocket");

            _internalUsedBufferLength = 0;
            _messageType = messageType;
            _webSocket = webSocket;
        }

        public override WebSocketMessageWriteStream CreateMessageWriter(WebSocketMessageType messageType)
        {
            Connection.BeginWritting();
            WebSocketMessageWriteStream writer = new WebSocketMessageWriteRfc6455Stream(this, messageType);

            foreach (var extension in _extensions)
                writer = extension.ExtendWriter(writer);

            return writer;
        }

        private Message CreateMessage(byte[] message,
            WebSocketMessageType type = WebSocketMessageType.Binary)
        {
            Message channelMessage = ByteStreamMessage.CreateMessage(new ArraySegment<byte>(message));

            channelMessage.Properties[webSocketMessageProperty] =
                new WebSocketMessageProperty { MessageType = type };

            return channelMessage;
        }

 public static int GetOpCode(WebSocketMessageType messageType)
 {
     switch (messageType)
     {
         case WebSocketMessageType.Text: return Constants.OpCodes.TextFrame;
         case WebSocketMessageType.Binary: return Constants.OpCodes.BinaryFrame;
         case WebSocketMessageType.Close: return Constants.OpCodes.CloseFrame;
         default: throw new NotImplementedException(messageType.ToString());
     }
 }

        public Task Send(ArraySegment<byte> data, WebSocketMessageType messageType, bool endOfMessage, CancellationToken cancelToken)
        {
            var sendContext = new SendContext(data, endOfMessage, messageType, cancelToken);

            return this.mSendQueue.Enqueue(
                async s =>
                {
                    await this.mSendAsync(s.Buffer, MessageTypeEnumToOpCode(s.Type), s.EndOfMessage, s.CancelToken);
                },
                sendContext);
        }

        /// <summary>
        /// Sends data to the client
        /// </summary>
        /// <param name="buffer">Data to send</param>
        /// <param name="endOfMessage">End of the message?</param>
        /// <param name="type">Message type of the data</param>
        /// <returns>Task to send the data</returns>
        public Task SendAsync(ArraySegment<byte> buffer, bool endOfMessage, WebSocketMessageType type)
        {
            var sendContext = new SendContext { Buffer = buffer, EndOfMessage = endOfMessage, Type = type };

            return mSendQueue.Enqueue(
                async s =>
                    {
                        await mWebSocket.SendAsync(s.Buffer, s.Type, s.EndOfMessage, CancellationToken.None);
                    },
                sendContext);
        }