public abstract ReceiveAsync ( System |
||
buffer | System |
|
cancellationToken | System | |
return | System.Threading.Tasks.Task |
private async Task HandleSocket(WebSocket socket) { var receiveBuffer = new byte[1024 * 4]; try { var result = await socket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); while (!socket.CloseStatus.HasValue) { await Task.WhenAll(tasks: SocketsSingleton.Instance.SocketsBag.Where(x => x.State == WebSocketState.Open) .Select(async x => { await x.SendAsync(new ArraySegment<byte>(receiveBuffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None); })); SocketsSingleton.Instance.SocketsBag = new ConcurrentBag<WebSocket>(SocketsSingleton.Instance.SocketsBag.Where(x => x.State == WebSocketState.Open)); result = await socket.ReceiveAsync(new ArraySegment<byte>(receiveBuffer), CancellationToken.None); } await socket.CloseAsync(result.CloseStatus ?? WebSocketCloseStatus.EndpointUnavailable, result.CloseStatusDescription, CancellationToken.None); } catch (Exception exception) { Console.Write(exception); } finally { socket?.Dispose(); } }
public static async Task<WebSocketMessage> ReadMessageAsync(WebSocket webSocket, byte[] buffer, int maxMessageSize) { ArraySegment<byte> arraySegment = new ArraySegment<byte>(buffer); WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false); // special-case close messages since they might not have the EOF flag set if (receiveResult.MessageType == WebSocketMessageType.Close) { return new WebSocketMessage(null, WebSocketMessageType.Close); } if (receiveResult.EndOfMessage) { // we anticipate that single-fragment messages will be common, so we optimize for them switch (receiveResult.MessageType) { case WebSocketMessageType.Binary: return new WebSocketMessage(BufferSliceToByteArray(buffer, receiveResult.Count), WebSocketMessageType.Binary); case WebSocketMessageType.Text: return new WebSocketMessage(BufferSliceToString(buffer, receiveResult.Count), WebSocketMessageType.Text); default: throw new Exception("This code path should never be hit."); } } else { // for multi-fragment messages, we need to coalesce ByteBuffer bytebuffer = new ByteBuffer(maxMessageSize); bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count)); WebSocketMessageType originalMessageType = receiveResult.MessageType; while (true) { // loop until an error occurs or we see EOF receiveResult = await webSocket.ReceiveAsync(arraySegment, CancellationToken.None).ConfigureAwait(continueOnCapturedContext: false); if (receiveResult.MessageType != originalMessageType) { throw new InvalidOperationException("Incorrect message type"); } bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count)); if (receiveResult.EndOfMessage) { switch (receiveResult.MessageType) { case WebSocketMessageType.Binary: return new WebSocketMessage(bytebuffer.GetByteArray(), WebSocketMessageType.Binary); case WebSocketMessageType.Text: return new WebSocketMessage(bytebuffer.GetString(), WebSocketMessageType.Text); default: throw new Exception("This code path should never be hit."); } } } } }
public async Task ProcessWebSocket(HttpContext context, WebSocket webSocket) { var connection = new Connection(context, webSocket); Console.WriteLine("Connect: {0}", context.Connection.RemoteIpAddress); var cancelToken = CancellationToken.None; var buffer = new byte[1024]; WebSocketReceiveResult received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancelToken); while (!webSocket.CloseStatus.HasValue) { string text = System.Text.Encoding.UTF8.GetString(buffer, 0, received.Count); Console.WriteLine("Recd: {0}", text); try { Cmd.Parse(text, connection)?.Run(); } catch (Exception ex) { Console.WriteLine("Unhandled exception: {0}", ex); } received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancelToken); } await webSocket.CloseAsync(webSocket.CloseStatus.Value, webSocket.CloseStatusDescription, cancelToken); }
public static async Task ExecuteAPI(HttpContext context, System.Net.WebSockets.WebSocket webSocket) { var buffer = new byte[1024 * 20]; WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); while (!result.CloseStatus.HasValue) { string strRequest = Encoding.UTF8.GetString(buffer); string str = strRequest.Replace("\0", string.Empty); string jsonStr = string.Empty; try { //Method APIModel apiModel = JsonSerializer.Deserialize <APIModel>(str); string apiName = apiModel.Method; BaseCommand command = Activator.CreateInstance(CommandsDict[apiName]) as BaseCommand; command.WebSocket = webSocket; jsonStr = command.Execute(str); buffer = Encoding.UTF8.GetBytes(jsonStr); BaseRequestModel requestModel = JsonSerializer.Deserialize <BaseRequestModel>(str); if (!string.IsNullOrEmpty(requestModel.Token)) { if (command is UserLogoutCommand) { //do nothing } else { UserInfo userInfo = UserInfoDict[requestModel.Token]; userInfo.ActionTime = DateTime.Now; } } else if (command is UserLoginCommand) { //do nothing } } catch (Exception ex) { ErrorResponseModel responseModel = new ErrorResponseModel(); responseModel.StatusCode = 0; responseModel.ErrorCode = "500"; responseModel.Message = ex.Message; jsonStr = JsonSerializer.Serialize(responseModel); buffer = Encoding.UTF8.GetBytes(jsonStr); } await webSocket.SendAsync(new ArraySegment <byte>(buffer, 0, jsonStr.Length), result.MessageType, result.EndOfMessage, CancellationToken.None); buffer = new byte[1024 * 20]; result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); } await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); }
private async Task Echo(WebSocket webSocket) { byte[] buffer = new byte[1024 * 4]; var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); while (!result.CloseStatus.HasValue) { await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None); result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); } await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); }
private static async Task Echo(HttpContext context, System.Net.WebSockets.WebSocket webSocket) { var buffer = new byte[1024 * 4]; WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); while (!result.CloseStatus.HasValue) { await webSocket.SendAsync(new ArraySegment <byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None); result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); } await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); }
private async Task EchoWebSocket(WebSocket webSocket) { byte[] buffer = new byte[1024]; WebSocketReceiveResult received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); while (!webSocket.CloseStatus.HasValue) { // Echo anything we receive await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, received.Count), received.MessageType, received.EndOfMessage, CancellationToken.None); received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); } await webSocket.CloseAsync(webSocket.CloseStatus.Value, webSocket.CloseStatusDescription, CancellationToken.None); }
/// <summary> /// /// </summary> /// <param name="webSocket"></param> /// <returns></returns> public async Task ConnectClientAsync(System.Net.WebSockets.WebSocket webSocket) { var buffer = new byte[1024 * 4]; WebSocketReceiveResult result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); while (!result.CloseStatus.HasValue) { string content = Encoding.UTF8.GetString(buffer); await webSocket.SendAsync(new ArraySegment <byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None); result = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); } await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); }
private static async Task Receive(System.Net.WebSockets.WebSocket socket, Action <WebSocketReceiveResult, string> handleMessage) { while (socket.State == WebSocketState.Open) { var buffer = new ArraySegment <byte>(new byte[1024 * 4]); string message; WebSocketReceiveResult result; using (var ms = new MemoryStream()) { do { result = await socket.ReceiveAsync(buffer, CancellationToken.None); ms.Write(buffer.Array, buffer.Offset, result.Count); } while (!result.EndOfMessage); ms.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(ms, Encoding.UTF8)) { message = await reader.ReadToEndAsync(); } } handleMessage(result, message); } }
static async Task<Message> ReceiveAsync(WebSocket ws) { byte[] buffer = new byte[4096]; var seg = new ArraySegment<byte>(buffer); var result = await ws.ReceiveAsync(seg, CancellationToken.None); return Message.Deserialize(new ArraySegment<byte>(buffer, 0, result.Count)); }
protected override async Task <byte[]> Receive(ArraySegment <byte> receiveBuffer, MessageParser parser, CancellationToken ct) { using (var ms = new MemoryStream()) { bool accepted = false; WebSocketReceiveResult result; int msgSize = 0; int received = 0; do { result = await _webSocket.ReceiveAsync(receiveBuffer, ct) .ConfigureAwait(false); if (!accepted) { parser.ValidateSize(receiveBuffer, out msgSize); accepted = true; } await ms.WriteAsync(receiveBuffer.Array, 0, result.Count); received += result.Count; }while (received < msgSize); return(ms.ToArray()); } }
private static async Task <string> ReceiveStringAsync(System.Net.WebSockets.WebSocket socket, CancellationToken ct = default(CancellationToken)) { var buffer = new ArraySegment <byte>(new byte[8192]); using (var ms = new MemoryStream()) { WebSocketReceiveResult result; do { ct.ThrowIfCancellationRequested(); result = await socket.ReceiveAsync(buffer, ct); ms.Write(buffer.Array, buffer.Offset, result.Count); }while (!result.EndOfMessage); ms.Seek(0, SeekOrigin.Begin); if (result.MessageType != WebSocketMessageType.Text) { return(null); } using (var reader = new StreamReader(ms, Encoding.UTF8)) { return(await reader.ReadToEndAsync()); } } }
internal async static Task <MessageData> ReceiveMessage( System.Net.WebSockets.WebSocket webSocket, CancellationToken ct, long maxSize = long.MaxValue) { ArraySegment <Byte> buffer = new ArraySegment <byte>(new Byte[ReceiveBufferSize]); WebSocketReceiveResult result = null; using (var ms = new MemoryStream()) { do { result = await webSocket.ReceiveAsync(buffer, ct); ms.Write(buffer.Array, buffer.Offset, result.Count); if (ms.Length > maxSize) { throw new InvalidOperationException("Maximum size of the message was exceeded."); } }while (!result.EndOfMessage); ms.Seek(0, SeekOrigin.Begin); return(new MessageData { Data = ms.ToArray(), MessageType = result.MessageType }); } }
private void keyboardHandler(WebSocket ws) { byte[] buffer = new byte[4096 * 4096]; var task = ws.ReceiveAsync(new ArraySegment<byte>(buffer), System.Threading.CancellationToken.None).ContinueWith((ReceiveResult) => { string s = System.Text.Encoding.ASCII.GetString(buffer); s = s.TrimEnd('\0', ' '); foreach (string keyboardCmd in s.Split(' ', '\0')) { string cmd = keyboardCmd.ToLower().Trim(); if (keyboardCmd.StartsWith("up/") && keyboardCmd.Length > "up/".Length) { Keyboard.KeyUp(int.Parse(keyboardCmd.Substring("up/".Length), System.Globalization.NumberStyles.AllowHexSpecifier)); } if (keyboardCmd.StartsWith("down/") && keyboardCmd.Length > "down/".Length) { Keyboard.KeyDown(int.Parse(keyboardCmd.Substring("down/".Length), System.Globalization.NumberStyles.AllowHexSpecifier)); } if (keyboardCmd.StartsWith("tap/") && keyboardCmd.Length > "tap/".Length) { Keyboard.KeyTap(int.Parse(keyboardCmd.Substring("tap/".Length), System.Globalization.NumberStyles.AllowHexSpecifier)); } } keyboardHandler(ws); }); }
/// <summary> /// 群发 /// </summary> /// <param name="socketContext"></param> /// <returns></returns> public async Task ProcessChat(AspNetWebSocketContext socketContext) { // SuperSocket:Session // 表示客户端发起请求的一个链接 System.Net.WebSockets.WebSocket socket = socketContext.WebSocket; CancellationToken token = new CancellationToken(); string socketGuid = Guid.NewGuid().ToString(); OldChatManager.AddUser(socketGuid, UserName, socket, token); await OldChatManager.SengdMessage(token, UserName, "进入聊天室"); while (socket.State == WebSocketState.Open) { ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[2048]); WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, token); string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); // 来自于客户端发送过来的消息内容 if (result.MessageType == WebSocketMessageType.Close) { OldChatManager.RemoveUser(socketGuid); await OldChatManager.SengdMessage(token, UserName, "离开聊天室"); await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, token); } else { await OldChatManager.SengdMessage(token, UserName, userMessage); } } }
public async Task EchoAsync(WebSocket webSocket) { var buffer = new ArraySegment<byte>(new byte[8192]); for (; ;) { var result = await webSocket.ReceiveAsync( buffer, CancellationToken.None); if (result.MessageType == WebSocketMessageType.Close) { return; } else if (result.MessageType == WebSocketMessageType.Text) { Console.WriteLine("{0}", System.Text.Encoding.UTF8.GetString(buffer.Array, 0, result.Count)); } await webSocket.SendAsync( new ArraySegment<byte>(buffer.Array, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None); } }
private WebSocketHost(WebSocket webSocket) { _webSocket = webSocket; _buffer = new byte[1024]; // Start listening for incoming messages _webSocket.ReceiveAsync(new ArraySegment<byte>(_buffer), CancellationToken.None).ContinueWith(ReceiveMessage); }
public async Task <string> RecieveMessageAsync(HttpContext context, System.Net.WebSockets.WebSocket socket, CancellationToken token) { var buffer = new byte[1024 * 4]; using (_Logger.BeginScope($"Recieving message from socket with state {socket.State}", socket)) { WebSocketReceiveResult result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), token); } return(Encoding.UTF8.GetString(buffer)); }
public async Task <T> RecieveItemAsync <T>(System.Net.WebSockets.WebSocket socket, CancellationToken token) { var buffer = new byte[1024 * 4]; using (_Logger.BeginScope($"Recieving message from socket with state {socket.State}", socket)) { WebSocketReceiveResult result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), token); } return(JsonConvert.DeserializeObject <T>(Encoding.UTF8.GetString(buffer))); }
//public async Task<string> ReceiveStringAsync(System.Net.WebSockets.WebSocket webSocket) //{ // var buffer = new ArraySegment<byte>(new byte[8192]); // WebSocketReceiveResult result = await webSocket.ReceiveAsync(buffer, CancellationToken.None); // while (!result.CloseStatus.HasValue) // { // //await webSocket.SendAsync(new ArraySegment<byte>(buffer, 0, result.Count), result.MessageType, result.EndOfMessage, CancellationToken.None); // result = await webSocket.ReceiveAsync(buffer, CancellationToken.None); // } //} private async Task <string> ReceiveStringAsync(System.Net.WebSockets.WebSocket socket) { var buffer = new ArraySegment <byte>(new byte[8192]); var result = await socket.ReceiveAsync(buffer, CancellationToken.None); while (!result.EndOfMessage) { result = await socket.ReceiveAsync(buffer, default(CancellationToken)); } //var json = Encoding.UTF8.GetString(buffer.Array); //json = json.Replace("\0", "").Trim(); //return json; //ArraySegment<byte> buffer = new ArraySegment<byte>(new byte[8192]); //WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); return(userMessage); }
private static async Task ListenToClients(HttpContext context, System.Net.WebSockets.WebSocket socket) { var buffer = new byte[6 * 1024]; WebSocketReceiveResult result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); while (!result.CloseStatus.HasValue) { var content = Encoding.UTF8.GetString(buffer).Substring(0, result.Count); try { CallServerMethod(content); } catch { } result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); } await socket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); }
private async Task Receive(System.Net.WebSockets.WebSocket socket, Action <WebSocketReceiveResult, byte[]> handleMessage) { var buffer = new byte[1024 * 4]; while (socket.State == WebSocketState.Open) { var result = await socket.ReceiveAsync(buffer : new ArraySegment <byte>(buffer), cancellationToken : CancellationToken.None); handleMessage(result, buffer); } }
public async Task <Tuple <ArraySegment <byte>, WebSocketMessageType> > ReceiveMessage(int maxMessageSize, CancellationToken cancelToken) { var buffer = new ArraySegment <byte>(new byte[1024 * 8]); var result = await mWebSocket.ReceiveAsync(buffer, cancelToken); if (result.EndOfMessage) { return(Tuple.Create(new ArraySegment <byte>(buffer.Array, 0, result.Count), result.MessageType)); } var stream = new MemoryStream(1024 * 8); stream.Write(buffer.Array, 0, result.Count); var opType = result.MessageType; do { result = await mWebSocket.ReceiveAsync(buffer, cancelToken); stream.Write(buffer.Array, 0, result.Count); if (stream.Length > maxMessageSize && !result.EndOfMessage) { // ignore rest of incoming message do { result = await mWebSocket.ReceiveAsync(buffer, cancelToken); }while (!result.EndOfMessage); throw new InternalBufferOverflowException( "The Buffer is to small to get the Websocket Message! Increase in the Constructor!"); } }while (!result.EndOfMessage); stream.Seek(0, SeekOrigin.Begin); buffer = new ArraySegment <byte>(new byte[stream.Length]); stream.Read(buffer.Array, 0, (int)stream.Length); return(Tuple.Create(buffer, opType)); }
public async Task ProcessWebSocket(HttpContext context, WebSocket webSocket) { var connection = new Connection(context, webSocket); _allConnections.Add(connection); Console.WriteLine("Connect: {0}", context.Connection.RemoteIpAddress); var cancelToken = CancellationToken.None; var buffer = new byte[1024]; WebSocketReceiveResult received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancelToken); while (!webSocket.CloseStatus.HasValue) { string text = System.Text.Encoding.UTF8.GetString(buffer, 0, received.Count); Console.WriteLine("Recd: {0}", text); try { var cmd = Cmd.Parse(text, connection); if (cmd != null) { // TODO: Remove these dependencies from Cmd cmd.SpawnDaemon = _spawnDaemon; cmd.DecayDaemon = _decayDaemon; cmd.Run(); } } catch (Exception ex) { Console.WriteLine("Unhandled exception: {0}", ex); } received = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancelToken); } _allConnections.Remove(connection); await webSocket.CloseAsync(webSocket.CloseStatus.Value, webSocket.CloseStatusDescription, cancelToken); }
public async Task <Tuple <ArraySegment <byte>, WebSocketMessageType> > ReceiveMessage(byte[] buffer, CancellationToken cancelToken) { var count = 0; WebSocketReceiveResult result; do { var segment = new ArraySegment <byte>(buffer, count, buffer.Length - count); result = await mWebSocket.ReceiveAsync(segment, cancelToken); count += result.Count; }while (!result.EndOfMessage); return(new Tuple <ArraySegment <byte>, WebSocketMessageType>(new ArraySegment <byte>(buffer, 0, count), result.MessageType)); }
private async Task Receive(System.Net.WebSockets.WebSocket socket, Action <WebSocketReceiveResult, byte[]> handleMessage) { try { var buffer = new byte[WebSocketManager.WebSocketBufferSize]; while (socket.State == WebSocketState.Open) { var result = await socket.ReceiveAsync(buffer : new ArraySegment <byte>(buffer), cancellationToken : CancellationToken.None); handleMessage(result, buffer); } } catch { await WebSocketHub.OnDisconnectedAsync(WebSocketHub.WSManager?.GetId(socket)); } }
private static async Task <WSMessage> ReceiveStreamAsync(System.Net.WebSockets.WebSocket socket, ArraySegment <byte> buffer, CancellationToken ct = default(CancellationToken)) { using (var ms = new MemoryStream()) { WebSocketReceiveResult result; do { result = await socket.ReceiveAsync(buffer, ct); ms.Write(buffer.Array, buffer.Offset, result.Count); }while (!result.EndOfMessage); ms.Seek(0, SeekOrigin.Begin); var msg = ProtoBuf.Serializer.Deserialize <WSMessage>(ms); return(msg); } }
private async Task DoRespond(WebSocketContext context) { if (!Global.sockets.ContainsKey(context.SecWebSocketKey)) { Global.sockets.TryAdd(context.SecWebSocketKey, context.WebSocket); } //foreach (var item in Global.sockets) //{ System.Net.WebSockets.WebSocket socket = context.WebSocket; while (true) { try { ArraySegment <byte> buffer = new ArraySegment <byte>(new byte[1024]); WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); if (socket.State == WebSocketState.Open) { if (!userMessage.StartsWith("b:")) { userMessage = string.Format("Message : {0}", userMessage); buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(userMessage)); await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } else { userMessage = string.Format("Message : {0}", userMessage); await Broadcast(userMessage); } } else { break; } } catch (Exception ex) { throw ex; } } //} }
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 Receive(System.Net.WebSockets.WebSocket socket, Action <WebSocketReceiveResult, byte[]> handleMessage) { var receiveBuffer = new byte[1024 * 4]; try { while (socket.State == WebSocketState.Open) { var result = await socket.ReceiveAsync(new ArraySegment <byte>(receiveBuffer), CancellationToken.None); handleMessage(result, receiveBuffer); } } catch (WebSocketException wsex) when(wsex.WebSocketErrorCode == WebSocketError.ConnectionClosedPrematurely) { Console.WriteLine("ConnectionClosedPrematurely"); } }
private async Task Receive(System.Net.WebSockets.WebSocket socket, Action <WebSocketReceiveResult, byte[]> handleMessage) { try { var buffer = new byte[1024 * 4]; while (socket.State == WebSocketState.Open) { var result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); handleMessage(result, buffer); } await WebSocketHandler.OnDisconnected(socket); } catch { // ignored } }
private async Task KeepAlive(WebSocket connection) { while (connection.State == WebSocketState.Open) { var token = CancellationToken.None; var buffer = new ArraySegment<byte>(new byte[4096]); var received = await connection.ReceiveAsync(buffer, token); switch (received.MessageType) { case WebSocketMessageType.Text: var request = Encoding.UTF8.GetString(buffer.Array, buffer.Offset, buffer.Count); SocketMessage receive = JsonConvert.DeserializeObject<SocketMessage>(request); await Map.Receive(receive); break; } } }
private async Task DoPull(WebSocket socket, CancellationToken cancellationToken) { try { var buf = new Byte[4 * 1024]; while (!cancellationToken.IsCancellationRequested && socket.State == WebSocketState.Open) { var data = await socket.ReceiveAsync(new ArraySegment <Byte>(buf), cancellationToken); var cmd = buf.ToStr(null, 0, data.Count).ToJsonEntity <CommandModel>(); if (cmd != null) { XTrace.WriteLine("Got Command: {0}", cmd.ToJson()); if (cmd.Expire.Year < 2000 || cmd.Expire > DateTime.Now) { switch (cmd.Command) { case "Deploy": // 发布中心通知有应用需要部署,马上执行一次心跳,拉取最新应用信息 _ = Task.Run(Ping); break; default: var rs = CommandQueue.Publish(cmd.Command, cmd); if (rs != null) { await ReportAsync(cmd.Id, rs); } break; } } } } } catch (Exception ex) { XTrace.WriteException(ex); } if (socket.State == WebSocketState.Open) { await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "finish", default); } }
public async Task <byte[]> ReadBytesAsync(System.Net.WebSockets.WebSocket websocket, CancellationToken cancellationToken) { WebSocketReceiveResult result; var buffer = new ArraySegment <byte>(new byte[8192]); int length = 0; do { result = await websocket.ReceiveAsync(buffer, cancellationToken); if (result.CloseStatus != null) { return(null); } length += result.Count; }while (!result.EndOfMessage); return(buffer.Array.Take(length).ToArray()); }
private async Task Receive(System.Net.WebSockets.WebSocket socket, Action <WebSocketReceiveResult, byte[]> handleMessage) { try { var buffer = new byte[1024 * 4]; while (socket.State == WebSocketState.Open) { var result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); handleMessage(result, buffer); } } catch (Exception ex) { _logger.LogError(null, ex); } }
private async Task HandleWebSocket(WebSocketContext wsContext) { var socketId = Guid.NewGuid().ToString(); System.Net.WebSockets.WebSocket webSocket = wsContext.WebSocket; try { _sockets.TryAdd(socketId, webSocket); byte[] receiveBuffer = new byte[1024 * 4]; while (webSocket.State == WebSocketState.Open) { //var msg = Encoding.UTF8.GetBytes(WebSocketSerivce.GetNewOrders()); //await webSocket.SendAsync(new ArraySegment<byte>(msg, 0, msg.Length), WebSocketMessageType.Text, // true, CancellationToken.None); WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(new ArraySegment <byte>(receiveBuffer), CancellationToken.None); if (receiveResult.MessageType == WebSocketMessageType.Close) { await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); _sockets.TryRemove(socketId, out System.Net.WebSockets.WebSocket removedSocket); } else { foreach (var socket in _sockets.Where(x => x.Key != socketId).Select(x => x.Value)) { await socket.SendAsync(new ArraySegment <byte>(receiveBuffer, 0, receiveResult.Count), WebSocketMessageType.Text, receiveResult.EndOfMessage, CancellationToken.None); } } } } catch (Exception e) { Console.WriteLine("Exception: {0}", e); } finally { webSocket?.Dispose(); } }
internal async Task <Packet> ReceiveAsync() { if (Closed) { return(null); } var result = await socket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); if (result.CloseStatus.HasValue) { this.closed = true; await this.socket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None); return(null); } return(packetDataSerializer.Deserialize(buffer, 0, result.Count, result.MessageType, result.EndOfMessage)); }
internal async Task RunAsync() { await _logger.InfoAsync($"Connected"); var token = _cancelToken.Token; try { var segment = new ArraySegment <byte>(_inBuffer); //Send HELLO await SendAsync(GatewayOpCode.Hello, new HelloEvent { HeartbeatInterval = 15000 }).ConfigureAwait(false); while (_socket.State == WebSocketState.Open) { var result = await _socket.ReceiveAsync(segment, token).ConfigureAwait(false); if (result.MessageType == WebSocketMessageType.Close) { await _logger.WarningAsync($"Received Close {result.CloseStatus} ({result.CloseStatusDescription ?? "No Reason"})").ConfigureAwait(false); } else { await _logger.InfoAsync($"Received {result.Count} bytes"); } } } catch (OperationCanceledException) { try { await _socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None).ConfigureAwait(false); } catch { } } catch (Exception ex) { try { await _socket.CloseAsync(WebSocketCloseStatus.InternalServerError, ex.Message, CancellationToken.None).ConfigureAwait(false); } catch { } } finally { await _logger.InfoAsync($"Disconnected"); } }
async Task websocketHandle(System.Net.WebSockets.WebSocket socket, HttpRequest request) { var bs = new byte[204800]; while (true) { if (socket.State == System.Net.WebSockets.WebSocketState.Open) { try { ArraySegment <byte> buffer = new ArraySegment <byte>(bs); WebSocketReceiveResult result = await socket.ReceiveAsync(buffer, CancellationToken.None); if (result.Count == 0) { //客户端要求关闭 socket.CloseAsync(WebSocketCloseStatus.NormalClosure, null, CancellationToken.None).Wait(); continue; } StringBuilder str = new StringBuilder(); foreach (var item in request.Headers) { foreach (var v in item.Value) { str.Append($"{item.Key}={v}\r\n"); } } byte[] sendbackBs = System.Text.Encoding.UTF8.GetBytes(str.ToString()); buffer = new ArraySegment <byte>(sendbackBs); await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } catch { } } else { break; } } }
private async Task DoRespond(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); if (socket.State == WebSocketState.Open) { string userMessage = Encoding.UTF8.GetString(buffer.Array, 0, result.Count); userMessage = "Message from client : " + userMessage; buffer = new ArraySegment <byte>(Encoding.UTF8.GetBytes(userMessage)); await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None); } else { break; } } }
private static async Task WebSocketToPipeWorker(WebSocket socket, IMessagePipeEnd pipe, CancellationToken cancellationToken) { const int blockSize = 0x10000; var buffer = new MemoryStream(blockSize); while (true) { cancellationToken.ThrowIfCancellationRequested(); int index = (int)buffer.Length; buffer.SetLength(index + blockSize); var wsrr = await socket.ReceiveAsync(new ArraySegment<byte>(buffer.GetBuffer(), index, blockSize), cancellationToken); buffer.SetLength(index + wsrr.Count); if (wsrr.CloseStatus != null) { break; } else if (wsrr.EndOfMessage) { pipe.Write(buffer.ToArray()); buffer.SetLength(0); } } }
private async Task ReceiveAsync(System.Net.WebSockets.WebSocket webSocket, CancellationToken disconnectToken) { bool closedReceived = false; var buffer = new byte[4096]; try { while (!disconnectToken.IsCancellationRequested && !closedReceived) { var arraySegment = new ArraySegment <byte>(buffer); var result = await webSocket.ReceiveAsync(arraySegment, disconnectToken); if (result.MessageType == WebSocketMessageType.Close) { closedReceived = true; await Task.WhenAny(CloseAsync(), Task.Delay(_closeTimeout)); } if (result.MessageType == WebSocketMessageType.Text) { OnMessage(Encoding.UTF8.GetString(arraySegment.Array.Take(result.Count).ToArray())); } else if (result.MessageType == WebSocketMessageType.Binary) { OnMessage(arraySegment.Array.Take(result.Count).ToArray()); } } } catch (Exception ex) { Trace.WriteLine("Error Receiving : " + ex.Message); } try { await CloseAsync(); } finally { OnClosed(); } }
private static async Task DoWebSocketReceiveSendAsync(WebSocket receiver, WebSocket sender, CancellationToken ct) { if (receiver == null || sender == null) { return; } ArraySegment<byte> receiveBuffer = new ArraySegment<byte>(new byte[65335]); while (receiver.State == WebSocketState.Open && sender.State == WebSocketState.Open) { if (ct.IsCancellationRequested) { receiver.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal closure", CancellationToken.None).SilenceException<WebSocketException>().DoNotWait(); sender.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal closure", CancellationToken.None).SilenceException<WebSocketException>().DoNotWait(); return; } WebSocketReceiveResult result = await receiver.ReceiveAsync(receiveBuffer, ct); byte[] data = await receiveBuffer.ToByteArrayAsync(result.Count); ArraySegment<byte> sendBuffer = new ArraySegment<byte>(data); await sender.SendAsync(sendBuffer, result.MessageType, result.EndOfMessage, ct); if (result.MessageType == WebSocketMessageType.Close) { await receiver.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal closure", ct); } } }
private async Task<String> ReadSerializedMessage(WebSocket socket) { var byteBuffer = new byte[MaxBufferSize]; var arraySegmentBuffer = new ArraySegment<byte>(byteBuffer); WebSocketReceiveResult result = await socket.ReceiveAsync(arraySegmentBuffer, CancellationToken.None); string ret = ""; if (result.MessageType == WebSocketMessageType.Close) { await socket.CloseAsync(result.CloseStatus.GetValueOrDefault(), result.CloseStatusDescription, CancellationToken.None); } else { int messageSize = 0; for (messageSize = result.Count; !result.EndOfMessage; messageSize += result.Count) { result = await socket.ReceiveAsync(new ArraySegment<byte>(byteBuffer, messageSize, MaxBufferSize - messageSize), CancellationToken.None); } if (result.MessageType == WebSocketMessageType.Text) { ret = Encoding.UTF8.GetString(byteBuffer, 0, messageSize); } } return ret; }
private async Task CopyFromWebSocketToStreamWorker(WebSocket webSocket, Stream stream, CancellationToken ct) { var buffer = new ArraySegment<byte>(new byte[0x10000]); while (webSocket.State == WebSocketState.Open) { ct.ThrowIfCancellationRequested(); Log("WS -> TCP: waiting for packet."); var recv = await webSocket.ReceiveAsync(buffer, ct); Log("WS -> TCP: received packet:\n{0}", Encoding.UTF8.GetString(buffer.Array, 0, recv.Count)); await stream.WriteAsync(buffer.Array, 0, recv.Count, ct); Log("WS -> TCP: packet relayed."); } }
/// <summary> /// WebSocket監聽主程序 /// </summary> /// <param name="Context">Http通訊內容</param> /// <param name="Socket">WebSocket物件</param> protected async Task Listen(HttpContext Context, WebSocket Socket) { OnConnected?.Invoke(Context, Socket); while (true) { bool ReceiveComplete = true; WebSocketReceiveResult ReceiveResult = null; List<byte> ReceiveData = new List<byte>(); //循環接收資料以防資料大於緩衝區大小時分段傳輸 do { //建立緩衝區 byte[] Buffer = new byte[BufferSize]; //接收資料 ReceiveResult = await Socket.ReceiveAsync(new ArraySegment<byte>(Buffer), CancellationToken.None); //乾淨資料 byte[] ClearData = new byte[ReceiveResult.Count]; //複製本次傳輸範圍資料 Array.Copy(Buffer, ClearData, ReceiveResult.Count); //存入接收資料集合 ReceiveData.AddRange(ClearData); //檢查是否接收完成 ReceiveComplete = !ReceiveResult.EndOfMessage; } while (ReceiveComplete); //檢查是否關閉連線,如關閉則跳脫循環監聽 if (ReceiveResult.CloseStatus.HasValue)break; OnReceive?.Invoke(Socket, ReceiveResult.MessageType, ReceiveData.ToArray()); }; OnDisconnected?.Invoke(Context, Socket); }
private void mouseHandler(WebSocket ws) { byte[] buffer = new byte[4096 * 4096]; var task = ws.ReceiveAsync(new ArraySegment<byte>(buffer), System.Threading.CancellationToken.None).ContinueWith((ReceiveResult) => { string s = System.Text.Encoding.ASCII.GetString(buffer); s = s.TrimEnd('\0', ' '); foreach (string mouseCmd in s.Split(' ', '\0')) { string cmd = mouseCmd.ToLower().Trim(); if (mouseCmd == "reset/") { Mouse.SetCursorPos(500, 500); } if (mouseCmd.StartsWith("click/")) { switch (int.Parse(mouseCmd.Substring("click/".Length))) { case 0: Mouse.LeftClick(); break; case 1: Mouse.RightClick(); break; case 2: Mouse.MiddleClick(); break; } } if (mouseCmd.StartsWith("position/")) { String[] stringArray = mouseCmd.Substring("position/".Length).Split('/'); Mouse.SetCursorPos(int.Parse(stringArray[0]), int.Parse(stringArray[1])); } if (mouseCmd.StartsWith("up/")) { switch (int.Parse(mouseCmd.Substring("up/".Length))) { case 0: Mouse.LeftUp(); break; case 1: Mouse.RightUp(); break; case 2: Mouse.MiddleUp(); break; } } if (mouseCmd.StartsWith("down/")) { switch (int.Parse(mouseCmd.Substring("down/".Length))) { case 0: Mouse.LeftDown(); break; case 1: Mouse.RightDown(); break; case 2: Mouse.MiddleDown(); break; } } } mouseHandler(ws); }); }
public static async Task<WebSocketMessage> ReadMessageAsync(WebSocket webSocket, int bufferSize, int? maxMessageSize, CancellationToken disconnectToken) { WebSocketMessage message; // Read the first time with an empty array WebSocketReceiveResult receiveResult = await webSocket.ReceiveAsync(_emptyArraySegment, disconnectToken).PreserveCultureNotContext(); if (TryGetMessage(receiveResult, null, out message)) { return message; } var buffer = new byte[bufferSize]; // Now read with the real buffer var arraySegment = new ArraySegment<byte>(buffer); receiveResult = await webSocket.ReceiveAsync(arraySegment, disconnectToken).PreserveCultureNotContext(); if (TryGetMessage(receiveResult, buffer, out message)) { return message; } else { // for multi-fragment messages, we need to coalesce ByteBuffer bytebuffer = new ByteBuffer(maxMessageSize); bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count)); WebSocketMessageType originalMessageType = receiveResult.MessageType; while (true) { // loop until an error occurs or we see EOF receiveResult = await webSocket.ReceiveAsync(arraySegment, disconnectToken).PreserveCultureNotContext(); if (receiveResult.MessageType == WebSocketMessageType.Close) { return WebSocketMessage.CloseMessage; } if (receiveResult.MessageType != originalMessageType) { throw new InvalidOperationException("Incorrect message type"); } bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count)); if (receiveResult.EndOfMessage) { switch (receiveResult.MessageType) { case WebSocketMessageType.Binary: return new WebSocketMessage(bytebuffer.GetByteArray(), WebSocketMessageType.Binary); case WebSocketMessageType.Text: return new WebSocketMessage(bytebuffer.GetString(), WebSocketMessageType.Text); default: throw new InvalidOperationException("Unknown message type"); } } } } }
// Web sockets start off as minimal HTTP connections, upgrade, and then behave like TCP sockets for the most part. // Thus the 'security service' abstraction is used to insulate this listener from direct TCP objects dependence. // Somewhat of a cheat, but it is the way it is :-)! private async Task CheckHeaders(WebSocket socket) { byte[] buffer = new byte[Config.Get(Constants.Configuration.MaxPayloadLength)]; var response = await socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.Token); // TODO: Ensure complete message is received var result = Encoding.ASCII.GetString(buffer, 0, response.Count); LogFacade.Instance.LogDebug("Received headers for web socket verification: " + result); SecurityService.DissectAndValidateFrame(result); }
public static async Task<WebSocketMessage> ReadMessageAsync(WebSocket webSocket, byte[] buffer, int maxMessageSize, CancellationToken disconnectToken) { var arraySegment = new ArraySegment<byte>(buffer); WebSocketReceiveResult receiveResult = null; try { receiveResult = await webSocket.ReceiveAsync(arraySegment, disconnectToken).ConfigureAwait(continueOnCapturedContext: false); } catch (Exception) { // If the websocket is aborted while we're reading then just rethrow // an operaton cancelled exception so the caller can handle it // appropriately if (webSocket.State == WebSocketState.Aborted) { throw new OperationCanceledException(); } else { // Otherwise rethrow the original exception throw; } } // special-case close messages since they might not have the EOF flag set if (receiveResult.MessageType == WebSocketMessageType.Close) { return new WebSocketMessage(null, WebSocketMessageType.Close); } if (receiveResult.EndOfMessage) { // we anticipate that single-fragment messages will be common, so we optimize for them switch (receiveResult.MessageType) { case WebSocketMessageType.Binary: return new WebSocketMessage(BufferSliceToByteArray(buffer, receiveResult.Count), WebSocketMessageType.Binary); case WebSocketMessageType.Text: return new WebSocketMessage(BufferSliceToString(buffer, receiveResult.Count), WebSocketMessageType.Text); default: throw new Exception("This code path should never be hit."); } } else { // for multi-fragment messages, we need to coalesce ByteBuffer bytebuffer = new ByteBuffer(maxMessageSize); bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count)); WebSocketMessageType originalMessageType = receiveResult.MessageType; while (true) { // loop until an error occurs or we see EOF receiveResult = await webSocket.ReceiveAsync(arraySegment, disconnectToken).ConfigureAwait(continueOnCapturedContext: false); if (receiveResult.MessageType != originalMessageType) { throw new InvalidOperationException("Incorrect message type"); } bytebuffer.Append(BufferSliceToByteArray(buffer, receiveResult.Count)); if (receiveResult.EndOfMessage) { switch (receiveResult.MessageType) { case WebSocketMessageType.Binary: return new WebSocketMessage(bytebuffer.GetByteArray(), WebSocketMessageType.Binary); case WebSocketMessageType.Text: return new WebSocketMessage(bytebuffer.GetString(), WebSocketMessageType.Text); default: throw new Exception("This code path should never be hit."); } } } } }
private static WebSocketReceiveAsync WebSocketReceiveAsync(WebSocket webSocket) { return async (buffer, cancel) => { var nativeResult = await webSocket.ReceiveAsync(buffer, cancel); return new WebSocketReceiveResultTuple( EnumToOpCode(nativeResult.MessageType), nativeResult.EndOfMessage, (nativeResult.MessageType == WebSocketMessageType.Close ? null : (int?)nativeResult.Count), (int?)nativeResult.CloseStatus, nativeResult.CloseStatusDescription); }; }
private static async void WebSocketServer() { HttpListener listener = new HttpListener(); listener.Prefixes.Add("http://localhost:3696/websocket/"); listener.Start(); bool wasOpen = false; while (listener.IsListening) { HttpListenerContext context = listener.GetContext(); HttpListenerRequest request = context.Request; if (request.IsWebSocketRequest) { WebSocketContext webCont = await context.AcceptWebSocketAsync(subProtocol: null); ws = webCont.WebSocket; byte[] receivebytes = new byte[1024]; while (ws.State == WebSocketState.Open) { WebSocketReceiveResult rcRes = await ws.ReceiveAsync(new ArraySegment<byte>(receivebytes), CancellationToken.None); string receivedString = Encoding.UTF8.GetString(receivebytes, 0, rcRes.Count); Console.WriteLine("RECEIVED: " + receivedString); wasOpen = true; Thread.Sleep(1); } if (ws.State != WebSocketState.Open && wasOpen) { Console.WriteLine("Websocket closed"); exit(); break; } } Thread.Sleep(1); } }
private static async Task<WebSocketReceiveResult> GetWebSocket(WebSocket webSocket, ArraySegment<byte> buffer) { WebSocketReceiveResult result; try { result = await webSocket.ReceiveAsync(buffer, CancellationToken.None); } catch (Exception ex) { logger.LogVerbose("Exception in GetWebSocket: {0}", ex.Message); result = new WebSocketReceiveResult(buffer.Count, WebSocketMessageType.Text, false, WebSocketCloseStatus.ProtocolError, "ReceiveAsync error"); } return result; }
private static async Task<string> ReceiveMessageAsync(WebSocket socket, CancellationToken cancel) { using (var stream = new MemoryStream()) { var buffer = ClientWebSocket.CreateServerBuffer(1024); WebSocketReceiveResult received; do { received = await socket.ReceiveAsync(buffer, cancel); stream.Write(buffer.Array, buffer.Offset, received.Count); } while (!received.EndOfMessage); stream.Position = 0; using (var reader = new StreamReader(stream, Encoding.UTF8)) { return reader.ReadToEnd(); } } }
private static async Task ReceiveCloseMessageAsync(WebSocket socket, CancellationToken cancel) { var buffer = ClientWebSocket.CreateServerBuffer(1024); var received = await socket.ReceiveAsync(buffer, cancel); if (received.MessageType != WebSocketMessageType.Close) { throw new InvalidOperationException(); } }
public static async Task<WebSocketMessage> ReadMessageAsync(WebSocket webSocket, MemoryPool _memoryPool, int bufferSize, int? maxMessageSize, CancellationToken disconnectToken) { WebSocketMessage message; // Read the first time with an empty array // Holds hear untill first message comes through. Because its empty, it will go onto the next // TryGetMessage when the data comes through. var receiveResult = await webSocket.ReceiveAsync(_emptyArraySegment, disconnectToken).PreserveCultureNotContext(); if (TryGetMessage(receiveResult, null, out message)) { return message; } var arraySegment = _memoryPool.AllocSegment(bufferSize); // Now read with the real buffer // We now know there is content, so we we allocate memory. Additionally this is setup in hopes // that the first message we read will only take one read. receiveResult = await webSocket.ReceiveAsync(arraySegment, disconnectToken).PreserveCultureNotContext(); if (TryGetMessage(receiveResult, arraySegment.Array, out message)) { return message; } // Lastly read the rest of the message if needed // For multi-fragment messages, we need to coalesce and use a buffer that can grow in size // as more of the message comes in. var bytebuffer = new ByteBuffer(maxMessageSize); bytebuffer.Append(BufferSliceToByteArray(arraySegment.Array, receiveResult.Count)); var originalMessageType = receiveResult.MessageType; while (true) { // loop until an error occurs or we see EOF receiveResult = await webSocket.ReceiveAsync(arraySegment, disconnectToken).PreserveCultureNotContext(); if (receiveResult.MessageType == WebSocketMessageType.Close) { return WebSocketMessage.CloseMessage; } if (receiveResult.MessageType != originalMessageType) { throw new InvalidOperationException("Incorrect message type"); } bytebuffer.Append(BufferSliceToByteArray(arraySegment.Array, receiveResult.Count)); if (receiveResult.EndOfMessage) { switch (receiveResult.MessageType) { case WebSocketMessageType.Binary: return new WebSocketMessage(bytebuffer.GetByteArray(), WebSocketMessageType.Binary); case WebSocketMessageType.Text: return new WebSocketMessage(bytebuffer.GetString(), WebSocketMessageType.Text); default: throw new InvalidOperationException("Unknown message type"); } } } }