public async Task ProcessSocket(AspNetWebSocketContext context) { WebSocket socket = context.WebSocket; while (true) { ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]); // Asynchronously wait for a message to arrive from a client WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); // If the socket is still open, echo the message back to the client if (socket.State == WebSocketState.Open) { string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); userMessage = "You sent: " + userMessage + " at " + DateTime.Now.ToLongTimeString(); buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage)); // Asynchronously send a message to the client await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } else { break; } } }
private async Task ProcessWSChat(AspNetWebSocketContext arg) { System.Net.WebSockets.WebSocket websct = arg.WebSocket; while (true) { ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]); WebSocketReceiveResult result = await websct.ReceiveAsync(buffer, CancellationToken.None); if (websct.State == WebSocketState.Open) { if (result.Count > 0) { string message = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); JavaScriptSerializer js = new JavaScriptSerializer(); SocketMsgTypeModel data = js.Deserialize<SocketMsgTypeModel>(message); string requetype = data.Msgtype; string send = await SocketService.MessageTypes(requetype); var returnMessage = "收到 :" + data + "_时间:" + DateTime.Now.ToLongTimeString(); buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(returnMessage)); await websct.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } else { websct.Abort(); } } else { break; } } await websct.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", CancellationToken.None); }
private async Task ProcessWebSocketRequest(AspNetWebSocketContext context) { var socket = context.WebSocket; while (true) { /* if (!HelicopterWorker.ProcessCommands) { Task.Run(() => new HelicopterWorker().Run()); } * */ var buffer = new ArraySegment<byte>(new byte[1024]); var result = await socket.ReceiveAsync(buffer, CancellationToken.None); if (socket.State != WebSocketState.Open) break; var userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); var state = JObject.Parse(userMessage); if (state != null) { //var response = string.Format("Throttle:{0}\tPitch:{1}\tYaw:{2}", state["Throttle"], state["Pitch"], state["Yaw"]); Debug.WriteLine("Throttle:{0}\tPitch:{1}\tYaw:{2}", state["Throttle"], state["Pitch"], state["Yaw"]); HelicopterState.SetValues(false, Convert.ToInt32(state["Throttle"].ToString()), Convert.ToInt32(state["Pitch"].ToString()), Convert.ToInt32(state["Yaw"].ToString()), 0); } buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage)); await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } }
private async Task ProcessWSChat(AspNetWebSocketContext context) { WebSocket socket = context.WebSocket; while (true) { ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]); WebSocketReceiveResult result = await socket.ReceiveAsync( buffer, CancellationToken.None); if (socket.State == WebSocketState.Open) { string userMessage = Encoding.UTF8.GetString( buffer.Array, 0, result.Count); userMessage = "You sent: " + userMessage + " at " + DateTime.Now.ToLongTimeString(); buffer = new ArraySegment<byte>( Encoding.UTF8.GetBytes(userMessage)); await socket.SendAsync( buffer, WebSocketMessageType.Text, true, CancellationToken.None); } else { break; } } }
private async Task ProcessSocket(AspNetWebSocketContext context) { //generate a new ID for this socket connection var socketId = Guid.NewGuid().ToString(); //get socket off context and send the socketId back to client WebSocket socket = context.WebSocket; await socket.SendAsync(new ArraySegment<byte>(Encoding.UTF8.GetBytes(socketId)), WebSocketMessageType.Text, true, CancellationToken.None); //add the socket to the dictionary Clients.Add(socketId, socket); //keep the connection open which checking for notifications to go out while (true) { ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]); WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); if (socket.State == WebSocketState.Open) { string userMessage = Encoding.UTF8.GetString( buffer.Array, 0, result.Count); userMessage = "You sent: " + userMessage + " at " + DateTime.Now.ToLongTimeString(); buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage)); await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } else { break; } } }
private async Task ProcessWebsocketSession(AspNetWebSocketContext context) { var ws = context.WebSocket; new Task(async () => { var inputSegment = new ArraySegment<byte>(new byte[1024]); while (true) { // MUST read if we want the state to get updated... var result = await ws.ReceiveAsync(inputSegment, CancellationToken.None); if (ws.State != WebSocketState.Open) { break; } } }).Start(); while (true) { if (ws.State != WebSocketState.Open) { break; } else { byte[] binaryData = { 0xde, 0xad, 0xbe, 0xef, 0xca, 0xfe }; var segment = new ArraySegment<byte>(binaryData); await ws.SendAsync(segment, WebSocketMessageType.Binary, true, CancellationToken.None); } } }
private async Task ProcessWSChat(AspNetWebSocketContext context, string homeHubId, string userEmail) { WebSocket socket = context.WebSocket; using (var userAppSocket = new UserAppSocket(context.WebSocket, Services, homeHubId, userEmail)) { await userAppSocket.Process(); } }
private async Task ProcessWSChat(AspNetWebSocketContext context) { WebSocket socket = context.WebSocket; using (var cameraSocket = new CameraSocket(context.WebSocket, Services)) { await cameraSocket.Process(); } }
private async Task WebSocketLoop(AspNetWebSocketContext context) { WebSocket socket = null; try { socket = context.WebSocket; try { while (socket.State == WebSocketState.Open) { string serializedMessage = await ReadSerializedMessage(socket); LogHelper.LogInfo("serializedMessage e: " + serializedMessage); if (String.IsNullOrWhiteSpace(serializedMessage)) { LogHelper.LogInfo(SerializationHelper.Serialize("serializedMessage is empty!")); return; } Message message = JsonConvert.DeserializeObject<Message>(serializedMessage); if (message == null || String.IsNullOrWhiteSpace(message.FromId) == true) { LogHelper.LogInfo("invalid messsage!"); return; } AddOrUpdateEntry(message.FromId, socket); switch (message.MessageType) { case Enums.MessageType.Initialization: break; case Enums.MessageType.Chat: await SendChatMessage(message); break; case Enums.MessageType.Broadcast: break; } } } catch (Exception ex) { LogHelper.LogInfo(SerializationHelper.Serialize(ex.Message)); } } catch (Exception ex) { LogHelper.LogInfo(SerializationHelper.Serialize(ex.Message)); } }
private async Task WebSocketRequest(AspNetWebSocketContext context) { // Получаем сокет клиента из контекста запроса WebSocket socket = context.WebSocket; // Добавляем его в список клиентов Locker.EnterWriteLock(); try { Clients.Add(socket); } finally { Locker.ExitWriteLock(); } // Слушаем его while (true) { var buffer = new ArraySegment<byte>(new byte[1024]); // Ожидаем данные от него WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); //Передаём сообщение всем клиентам for (int i = 0; i < Clients.Count; i++) { WebSocket client = Clients[i]; try { if (client.State == WebSocketState.Open) { await client.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } } catch (ObjectDisposedException) { Locker.EnterWriteLock(); try { Clients.Remove(client); i--; } finally { Locker.ExitWriteLock(); } } } } }
private static async Task WebSocketProcessRequest(AspNetWebSocketContext context) { byte[] bytes = new byte[4096]; while (true) { var result = context.WebSocket.ReceiveAsync(new ArraySegment<byte>(bytes), CancellationToken.None).Result; if (result.MessageType == WebSocketMessageType.Close) { return; } context.WebSocket.SendAsync(new ArraySegment<byte>(bytes, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None).Wait(); } }
private async Task ProcessChat(AspNetWebSocketContext context) { using (WebSocket socket = context.WebSocket) { var key = Guid.NewGuid().ToString(); socketList.Add(key, socket); while (true) { ClearExpiredSocket(); if (socket.State == WebSocketState.Open) { ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[2048]); WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); string userMsg = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); var responseResult = string.Empty; if (userMsg == "progress1") { responseResult = GetPlayer(); } if (userMsg == "progress2") { responseResult = GetAllPosition(); } if (responseResult != string.Empty) { buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(responseResult)); foreach (var s in socketList) { try { if (s.Value.State == WebSocketState.Open) { await s.Value.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } } catch { } } } } else { break; } } } }
public async Task SocketReceiver(AspNetWebSocketContext context) { Context = context; // We have just made a connecton, so tell the client about the current player SendMessage(new PlayerConnectedMessage(this)); // If the game is on, we're the second player if (this.Game.Status == GameInProgress.GameStatus.InProgress) { SendMessage(new GameOnMessage()); } // Start listening on the socket var socket = context.WebSocket as AspNetWebSocket; var buffer = new ArraySegment<byte>(new byte[2048]); try { while (true) { var message = await socket.ReceiveAsync(buffer, CancellationToken.None); if (socket.State != WebSocketState.Open) { Disconnects(this); } var json = Encoding.UTF8.GetString(buffer.Array, 0, message.Count); var test = new { type = "" }; test = JsonConvert.DeserializeAnonymousType(json, test); if (test.type == "move") { var move = JsonConvert.DeserializeObject<PlayerMovesMessage>(json, settings: null); Moves(this, move); } else if (test.type == "wins") { var wins = JsonConvert.DeserializeObject<PlayerWinsMessage>(json, settings: null); Game.Winner(wins.player); } } } catch( Exception ex ) { Disconnects(this); } }
private async Task ProcessWSRequest(AspNetWebSocketContext context) { WebSocket socket = context.WebSocket; var screenGuid = Guid.NewGuid(); //tell the client about their new identifier await socket.sendObject(new { identifier = screenGuid }); dynamic confirmation = await socket.receiveObject(); bool isokay = false; try { isokay = confirmation.ok; } catch (RuntimeBinderException) { //om nom nom } if (!isokay) { await socket.CloseAsync(WebSocketCloseStatus.ProtocolError, "Expecting confirmation to be true", CancellationToken.None); return; } TypeResolver.IScreenManager.AddScreen(screenGuid, socket); /* while (true) { dynamic msg = await socket.receiveObject(); if (socket.State != WebSocketState.Open) { TypeResolver.IScreenManager.RemoveScreen(screenGuid); return; } }*/ }
private async Task ProcessProtoBufDecodeRecode(AspNetWebSocketContext context) { System.Net.WebSockets.WebSocket socket = context.WebSocket; while (true) { ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]); WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); var inputStream = new System.IO.MemoryStream(buffer.Array, buffer.Offset, buffer.Count); TestObject msg = Serializer.Deserialize<TestObject>(inputStream); if (socket.State == WebSocketState.Open) { msg.Name = "now I change you"; msg.TestId = 12; msg.IsWorking = true; msg.Priority = Priority.HIGH; msg.Balance = 876.54321; msg.Contacts.Add(new Contact { Name = "Jo", ContactDetails = "*****@*****.**" }); msg.Contacts.Add(new Contact { Name = "Fred", ContactDetails = "01234121412" }); ArraySegment<byte> outputBuffer; using (var serializationBuffer = new System.IO.MemoryStream()) { Serializer.Serialize(serializationBuffer, msg); outputBuffer = new ArraySegment<byte>(serializationBuffer.GetBuffer(), 0, (int)serializationBuffer.Length); } await socket.SendAsync(outputBuffer, WebSocketMessageType.Binary, true, CancellationToken.None); } else { break; } } }
private async Task ProcessWS(AspNetWebSocketContext context) { WebSocket socket = context.WebSocket; sockets.Add(socket); ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]); //WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); try { while (socket.State == WebSocketState.Open) { WebSocketReceiveResult receiveResult = await socket.ReceiveAsync(buffer, CancellationToken.None); if (receiveResult.MessageType == WebSocketMessageType.Close) { await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); } else if (receiveResult.MessageType == WebSocketMessageType.Text) { string receivedMessage = Encoding.UTF8.GetString(buffer.Array, 0, receiveResult.Count); string userMessage = string.Format("{0}", receivedMessage); buffer = new ArraySegment<byte>(Encoding.UTF8.GetBytes(userMessage)); sockets.ForEach(sck => { sck.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); }); } else { } } } catch { } finally { sockets.Remove(socket); socket.Dispose(); } }
private async Task ProcessWSChat(AspNetWebSocketContext context) { WebSocket socket = context.WebSocket; while (true) { ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[1024]); WebSocketReceiveResult result = await socket.ReceiveAsync( buffer, CancellationToken.None); if (socket.State != WebSocketState.Open) break; //string userMessage = Encoding.UTF8.GetString( // buffer.Array, 0, result.Count); //buffer = new ArraySegment<byte>( // Encoding.UTF8.GetBytes(userMessage)); await socket.SendAsync( buffer, WebSocketMessageType.Text, true, CancellationToken.None); } }
/// <summary> /// Принимает соединения сокета /// </summary> public async Task Receiver(AspNetWebSocketContext context) { _context = context; var socket = _context.WebSocket as AspNetWebSocket; // подготовить буфер для чтения сообщений var inputBuffer = new ArraySegment<byte>(new byte[1024]); // отправить номер игрока другому игроку SendMessage(new PlayerNumberMessage { PlayerNumber = _game.GetPlayerIndex(this) }); try { while (true) { // чтение из сокета var result = await socket.ReceiveAsync(inputBuffer, CancellationToken.None); if (socket.State != WebSocketState.Open) { if (PlayerDisconnected != null) PlayerDisconnected(this); break; } // конвертация bytes в string var messageString = Encoding.UTF8.GetString(inputBuffer.Array, 0, result.Count); // десериализует толькоPlayerPositionMessage var positionMessage = JsonConvert.DeserializeObject<PlayerPositionMessage>(messageString); //сохранить новую позицию и отправить в игру YPos = positionMessage.YPos; if (PlayerMoved != null) PlayerMoved(this, positionMessage); } } catch (Exception ex) { if (PlayerDisconnected != null) PlayerDisconnected(this); } }
/// <summary> /// This method is used as delegate to accept WebSocket connection /// </summary> public async Task Receiver(AspNetWebSocketContext context) { _context = context; var socket = _context.WebSocket as AspNetWebSocket; // prepare buffer for reading messages var inputBuffer = new ArraySegment<byte>(new byte[1024]); // send player number to player SendMessage(new PlayerNumberMessage { PlayerNumber = _game.GetPlayerIndex(this) }); try { while (true) { // read from socket var result = await socket.ReceiveAsync(inputBuffer, CancellationToken.None); if (socket.State != WebSocketState.Open) { if (PlayerDisconnected != null) PlayerDisconnected(this); break; } // convert bytes to text var messageString = Encoding.UTF8.GetString(inputBuffer.Array, 0, result.Count); // only PlayerPositionMessage is expected, deserialize var positionMessage = JsonConvert.DeserializeObject<PlayerPositionMessage>(messageString); // save new position and notify game YPos = positionMessage.YPos; if (PlayerMoved != null) PlayerMoved(this, positionMessage); } } catch (Exception ex) { if (PlayerDisconnected != null) PlayerDisconnected(this); } }
private async Task AcceptCallback(AspNetWebSocketContext webSocketContext) { OwinWebSocketWrapper wrapper = null; try { wrapper = new OwinWebSocketWrapper(webSocketContext); await _webSocketFunc(wrapper.Environment); // Making sure to close the web socket is not necessary, Asp.Net will do this for us. wrapper.Dispose(); } catch (Exception ex) { if (wrapper != null) { wrapper.Cancel(); wrapper.Dispose(); } // traced as warning here because it is re-thrown _trace.WriteWarning(Resources.Trace_WebSocketException, ex); throw; } }
public async Task Receiver(AspNetWebSocketContext context) { this.context = context; var socket = this.context.WebSocket as AspNetWebSocket; var inputBuffer = new ArraySegment<byte>(new byte[1024]); try { while (true) { var result = await socket.ReceiveAsync(inputBuffer, CancellationToken.None); if (socket.State != WebSocketState.Open) { if (this.Disconnected != null) { this.Disconnected(this); } break; } var message = Encoding.UTF8.GetString(inputBuffer.Array, 0, result.Count); if (this.MessageReceived != null) { this.MessageReceived(this, message); } } } catch (Exception) { if (this.Disconnected != null) { this.Disconnected(this); } throw; } }
/* * IMPLEMENTATION */ public Task ProcessWebSocketRequestAsync(AspNetWebSocketContext webSocketContext) { if (webSocketContext == null) { throw new ArgumentNullException("webSocketContext"); } byte[] buffer = new byte[_receiveLoopBufferSize]; WebSocket webSocket = webSocketContext.WebSocket; return ProcessWebSocketRequestAsync(webSocketContext, () => WebSocketMessageReader.ReadMessageAsync(webSocket, buffer, MaxIncomingMessageSize)); }
Task ProcessWebSocketRequest(AspNetWebSocketContext context) { var socket = context.WebSocket; var connection = new DemoWebSocketHandler(socket); return connection.Start(); }
Task PostAcceptWebSocket(AspNetWebSocketContext context) { this.webSocketWaitingTask = new TaskCompletionSource<object>(); this.WebSocketChannel.Closed += new EventHandler(this.FinishWebSocketWaitingTask); this.webSocketContextTaskSource.SetResult(context); return webSocketWaitingTask.Task; }
private Task ProcessWebsocketSession(AspNetWebSocketContext context) { var handler = new NyanWebSocketHandler(); var processTask = handler.ProcessWebSocketRequestAsync(context); return processTask; }
Task ProcessWebSocketRequest(AspNetWebSocketContext context) { var socket = context.WebSocket; var connection = new LiveClientConnection(socket); return connection.Start(); }
/// <summary> /// Initiates an ASP.Net websocket and starts accepting messages. /// </summary> public virtual Task Init(AspNetWebSocketContext socketContext) { _socketContext = socketContext; return ReceiveMessage(); }
private async Task WebSocketRequestHandler(AspNetWebSocketContext context) { Log("Accepted web socket request from {0}.", context.UserHostAddress); TaskCompletionSource<bool> tcs = null; if (!AllowConcurrentConnections) { tcs = new TaskCompletionSource<bool>(); while (true) { var currentSession = Interlocked.CompareExchange(ref _currentSession, tcs.Task, null); if (currentSession == null) { break; } Log("Another session is active, waiting for completion."); await currentSession; Log("The other session completed, proceeding."); } } try { var webSocket = context.WebSocket; using (var tcpClient = new TcpClient("localhost", DebuggerPort)) { try { var stream = tcpClient.GetStream(); var cts = new CancellationTokenSource(); // Start the workers that copy data from one socket to the other in both directions, and wait until either // completes. The workers are fully async, and so their loops are transparently interleaved when running. // Usually end of session is caused by VS dropping its connection on detach, and so it will be // CopyFromWebSocketToStream that returns first; but it can be the other one if debuggee process crashes. Log("Starting copy workers."); var copyFromStreamToWebSocketTask = CopyFromStreamToWebSocketWorker(stream, webSocket, cts.Token); var copyFromWebSocketToStreamTask = CopyFromWebSocketToStreamWorker(webSocket, stream, cts.Token); Task completedTask = null; try { completedTask = await Task.WhenAny(copyFromStreamToWebSocketTask, copyFromWebSocketToStreamTask); } catch (IOException ex) { Log(ex); } catch (WebSocketException ex) { Log(ex); } // Now that one worker is done, try to gracefully terminate the other one by issuing a cancellation request. // it is normally blocked on a read, and this will cancel it if possible, and throw OperationCanceledException. Log("One of the workers completed, shutting down the remaining one."); cts.Cancel(); try { await Task.WhenAny(Task.WhenAll(copyFromStreamToWebSocketTask, copyFromWebSocketToStreamTask), Task.Delay(1000)); } catch (OperationCanceledException ex) { Log(ex); } // Try to gracefully close the websocket if it's still open - this is not necessary, but nice to have. Log("Both workers shut down, trying to close websocket."); try { await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None); } catch (WebSocketException ex) { Log(ex); } } finally { // Gracefully close the TCP socket. This is crucial to avoid "Remote debugger already attached" problems. Log("Shutting down TCP socket."); try { tcpClient.Client.Shutdown(SocketShutdown.Both); tcpClient.Client.Disconnect(false); } catch (SocketException ex) { Log(ex); } Log("All done!"); } } } finally { if (tcs != null) { Volatile.Write(ref _currentSession, null); tcs.SetResult(true); } } }
internal async Task ProcessWebSocketRequestAsync(AspNetWebSocketContext webSocketContext, Func<Task<WebSocketMessage>> messageRetriever) { try { // first, set primitives and initialize the object WebSocketContext = webSocketContext; OnOpen(); // dispatch incoming messages while (true) { WebSocketMessage incomingMessage = await messageRetriever(); switch (incomingMessage.MessageType) { case WebSocketMessageType.Binary: OnMessage((byte[])incomingMessage.Data); break; case WebSocketMessageType.Text: OnMessage((string)incomingMessage.Data); break; default: // If we received an incoming CLOSE message, we'll queue a CLOSE frame to be sent. // We'll give the queued frame some amount of time to go out on the wire, and if a // timeout occurs we'll give up and abort the connection. await Task.WhenAny(CloseAsync(), Task.Delay(_closeTimeout)) .ContinueWith(_ => { }, TaskContinuationOptions.ExecuteSynchronously); // swallow exceptions occurring from sending the CLOSE return; } } } catch (Exception ex) { if (IsFatalException(ex)) { Error = ex; OnError(); } } finally { try { // we're finished OnClose(); } finally { // call Dispose if it exists IDisposable disposable = this as IDisposable; if (disposable != null) { disposable.Dispose(); } } } }
public async Task WebSocketHandler(AspNetWebSocketContext context) { WebSocket socket = context.WebSocket; while (socket.State == WebSocketState.Open) { var buffer = new ArraySegment<byte>(new byte[1024]); WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); if (result.MessageType == WebSocketMessageType.Text) { string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); Task.Run(async () => { OnMessageArrived(socket, userMessage); }); } else if (result.MessageType == WebSocketMessageType.Binary) { var lists = new List<ArraySegment<byte>>(); if (result.EndOfMessage) { lists.Add(new ArraySegment<byte>(buffer.Array, 0, result.Count)); } else { lists.Add(buffer); while (!result.EndOfMessage) { buffer = new ArraySegment<byte>(new byte[1024]); result = await socket.ReceiveAsync(buffer, CancellationToken.None); if (!result.EndOfMessage) { lists.Add(buffer); } else { lists.Add(new ArraySegment<byte>(buffer.Array, 0, result.Count)); } } } Task.Run(async () => { var buff = MergeAllBytes(lists); OnDataArrived(socket, buff); }); } else if (result.MessageType == WebSocketMessageType.Close) { socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); } } }