public async Task Invoke(HttpContext context, ICustomWebSocketFactory wsFactory, ICustomWebSocketMessageHandler wsmHandler)
        {
            if (!context.WebSockets.IsWebSocketRequest)
            {
                await next(context);

                return;
            }

            if (context.Request.Path == "/ws")
            {
                //var auth = context.Request.Headers.Where(header => header.Key == "Authorization").FirstOrDefault();
                //if (auth.Key == null || string.IsNullOrWhiteSpace(auth.Value))
                //{
                //    context.Response.StatusCode = 401;
                //    return;
                //}

                WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();

                CustomWebSocket userWebSocket = new CustomWebSocket()
                {
                    WebSocket = webSocket,
                    SocketId  = new Random().Next(100000).ToString()
                };
                wsFactory.Add(userWebSocket);
                await Listen(context, userWebSocket, wsFactory, wsmHandler);
            }
            else
            {
                context.Response.StatusCode = 400;
                return;
            }
        }
        /// <summary>
        /// 获取除指定socket外的socket
        /// </summary>
        /// <param name="client"></param>
        /// <returns></returns>
        public List <CustomWebSocket> Others(CustomWebSocket client)
        {
            var list = (sockets.Values as List <CustomWebSocket>);

            list.Remove(client);
            return(list);
        }
        /// <summary>
        /// 向用户发送消息
        /// </summary>
        /// <param name="userWebSocket"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public async Task SendMessageToUser(CustomWebSocket userWebSocket, Object data)
        {
            WebSocket webSocket         = userWebSocket.WebSocket;
            string    serialisedMessage = JsonConvert.SerializeObject(data);

            byte[] bytes = Encoding.UTF8.GetBytes(serialisedMessage);
            await webSocket.SendAsync(new ArraySegment <byte>(bytes, 0, bytes.Length), WebSocketMessageType.Text, true, CancellationToken.None);
        }
        public async Task BroadcastOthers(byte[] buffer, CustomWebSocket userWebSocket, ICustomWebSocketFactory wsFactory)
        {
            var others = wsFactory.Others(userWebSocket);

            foreach (var uws in others)
            {
                await uws.WebSocket.SendAsync(new ArraySegment <byte>(buffer, 0, buffer.Length), WebSocketMessageType.Text, true, CancellationToken.None);
            }
        }
        /// <summary>
        /// 发送初识内容
        /// </summary>
        /// <param name="userWebSocket"></param>
        /// <returns></returns>
        public async Task SendInitialMessages(CustomWebSocket userWebSocket)
        {
            WebSocket webSocket = userWebSocket.WebSocket;
            var       msg       = new CustomWebSocketMessage
            {
                Time     = DateTime.Now,
                Content  = "测试内容",
                Title    = "测试",
                Username = "******"
            };

            string serialisedMessage = JsonConvert.SerializeObject(msg);

            byte[] bytes = Encoding.UTF8.GetBytes(serialisedMessage);
            await webSocket.SendAsync(new ArraySegment <byte>(bytes, 0, bytes.Length), WebSocketMessageType.Text, true, CancellationToken.None);
        }
        private async Task Listen(HttpContext context, CustomWebSocket userWebSocket, ICustomWebSocketFactory wsFactory, ICustomWebSocketMessageHandler wsmHandler)
        {
            //await wsmHandler.SendInitialMessages(userWebSocket);

            WebSocket webSocket           = userWebSocket.WebSocket;
            var       buffer              = new byte[1024 * 4];
            WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);

            while (!result.CloseStatus.HasValue)
            {
                //await wsmHandler.HandleMessage(result, buffer, userWebSocket, wsFactory);
                //await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);
                await wsmHandler.SendInitialMessages(userWebSocket);

                result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None);
            }

            wsFactory.Remove(userWebSocket.SocketId);
            await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
        }
        public async Task HandleMessage(WebSocketReceiveResult result, byte[] buffer, CustomWebSocket userWebSocket, ICustomWebSocketFactory wsFactory)
        {
            string msg = Encoding.UTF8.GetString(buffer);

            try
            {
                var message = JsonConvert.DeserializeObject <CustomWebSocketMessage>(msg);
                await userWebSocket.WebSocket.SendAsync(new ArraySegment <byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);

                //if (message.Type == WSMessageType.anyType)
                //{
                //    await BroadcastOthers(buffer, userWebSocket, wsFactory);
                //}
            }
            catch (Exception e)
            {
                await userWebSocket.WebSocket.SendAsync(new ArraySegment <byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None);
            }
        }
 /// <summary>
 /// 添加socket
 /// </summary>
 /// <param name="uws"></param>
 public void Add(CustomWebSocket uws)
 {
     sockets.TryAdd(uws.SocketId, uws);
 }