public abstract CloseAsync ( System closeStatus, string statusDescription, System cancellationToken ) : System.Threading.Tasks.Task | ||
closeStatus | System | |
statusDescription | string | |
cancellationToken | System | |
Результат | System.Threading.Tasks.Task |
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 override async Task CloseAsync() { if (IsConnected) { State = ChannelState.ClosedReceived; } if (socket != null) { try { await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Normal", CancellationToken.None); socket.Dispose(); socket = null; } catch (Exception ex) { Console.WriteLine($"Fault closing Web socket server socket - {ex.Message}"); } } OnClose?.Invoke(this, new ChannelCloseEventArgs(Id)); await Task.CompletedTask; }
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(); } }
/// <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); } } }
/// <summary> /// Closes the transport, implementing the websocket close handshake. /// </summary> /// <param name="cancellationToken"></param> /// <returns></returns> /// <exception cref="InvalidOperationException">The listener is not active</exception> protected override async Task PerformCloseAsync(CancellationToken cancellationToken) { await _closeSemaphore.WaitAsync(cancellationToken); try { // Awaits for the client to send the close connection frame. // If the session was clearly closed, the client should received the finished envelope and is closing the connection. using (var cts = new CancellationTokenSource(CloseTimeout)) using (var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, cts.Token)) { if (WebSocket.State == WebSocketState.Open || WebSocket.State == WebSocketState.CloseReceived) { await WebSocket.CloseAsync(CloseStatus, CloseStatusDescription, linkedCts.Token) .ConfigureAwait(false); } } if (!_receiveCts.IsCancellationRequested) { _receiveCts.Cancel(); } } finally { _closeSemaphore.Release(); } }
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); }
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"); } }
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); }
/// <summary> /// Close the connection. /// </summary> public async void Close() { // Close the connection. if (_webSocket != null) { try { // Close the connection. await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None); } catch (Exception ex) { _lastError = ex; } } }
protected override async void OnClose(CancellationToken ct) { try { await _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Session Ended", ct); } catch { } try { await _webSocket.CloseOutputAsync(WebSocketCloseStatus.NormalClosure, "Session Ended", ct); } catch { } }
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); }
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); } } }
/// <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 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); } }
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(); } }
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 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 void InternalReceive() { Task.Run(async() => { byte[] _buffer = new byte[WebSocketProtocol.BUFFER_SIZE]; while (Connected && !connectionManager.Token.IsCancellationRequested) { ArraySegment <byte> buffer = new ArraySegment <byte>(_buffer); var received = await socket.ReceiveAsync(buffer, connectionManager.Token); if (received.MessageType != WebSocketMessageType.Close) { byte[] result = new byte[received.Count]; Array.ConstrainedCopy(buffer.Array, 0, result, 0, received.Count); receivedPackages.Enqueue(result); } else { await socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "close", connectionManager.Token); } } }); }
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 void RemoveSocket(string connectionGUID, System.Net.WebSockets.WebSocket socket) { lock (_socketsList) { HashSet <System.Net.WebSockets.WebSocket> sockets; if (!_socketsList.TryGetValue(connectionGUID, out sockets)) { return; } lock (sockets) { sockets.Remove(socket); if (sockets.Count == 0) { _socketsList.Remove(connectionGUID); } } } socket.CloseAsync(closeStatus: WebSocketCloseStatus.NormalClosure, statusDescription: "Closed by the WebSocketManager", cancellationToken: CancellationToken.None); }
private static async Task HandleMessage(System.Net.WebSockets.WebSocket webSocket) { //Gets the current WebSocket object. /*We define a certain constant which will represent * size of received data. It is established by us and * we can set any value. We know that in this case the size of the sent * data is very small. */ const int maxMessageSize = 1024; //Buffer for received bits. var receivedDataBuffer = new ArraySegment <Byte>(new Byte[maxMessageSize]); var cancellationToken = new CancellationToken(); WebSocketHelper webSocketHandler = new WebSocketHelper(webSocket, /*webSocketContext, */ cancellationToken); var messageHandler = WebSocketConfig.WebSocketMessageHandlerFunc.Invoke(); while (webSocket.State == WebSocketState.Open) { //var incoming = await this._socket.ReceiveAsync(seg, CancellationToken.None); //var outgoing = new ArraySegment<byte>(buffer, 0, incoming.Count); //await this._socket.SendAsync(outgoing, WebSocketMessageType.Text, true, CancellationToken.None); //Reads data. WebSocketReceiveResult webSocketReceiveResult = await webSocket.ReceiveAsync(receivedDataBuffer, cancellationToken).ConfigureAwait(false); //If input frame is cancelation frame, send close command. if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close) { if (WebSocketConfig.WebSocketMessageHandlerFunc != null) { await messageHandler.OnDisConnected(webSocketHandler).ConfigureAwait(false);//调用MessageHandler } await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken).ConfigureAwait(false); } else { byte[] payloadData = receivedDataBuffer.Array .Where(b => b != 0) .Take(webSocketReceiveResult.Count) .ToArray(); if (WebSocketConfig.WebSocketMessageHandlerFunc != null) { //Because we know that is a string, we convert it. string receiveString = //System.Text.Encoding.UTF8.GetString(payloadData, 0, payloadData.Length); System.Text.Encoding.UTF8.GetString(payloadData, 0, payloadData.Length); try { ReceivedMessage receivedMessage; try { receivedMessage = new ReceivedMessage() { Message = receiveString// + " | 系统错误:" + e.Message }; #if NET45 JavaScriptSerializer js = new JavaScriptSerializer(); receivedMessage = js.Deserialize <ReceivedMessage>(receiveString); #else receivedMessage = Newtonsoft.Json.JsonConvert.DeserializeObject <ReceivedMessage>(receiveString); #endif } catch (Exception e) { receivedMessage = new ReceivedMessage() { Message = receiveString// + " | 系统错误:" + e.Message }; } await messageHandler.OnMessageReceiced(webSocketHandler, receivedMessage, receiveString).ConfigureAwait(false);//调用MessageHandler } catch (Exception ex) { } } } } }
public static async Task CloseAsync(this WebSocket client, WebSocketCloseStatus state) { await client.CloseAsync(state, "", CancellationToken.None); }
/// <summary> /// Awaitable task that reads incoming messages from the WebSocket. /// This is a blocking method /// </summary> /// <returns></returns> public async Task <ConnectionResult> ReadLoopAsync(CancellationToken ct) { while (!ct.IsCancellationRequested && !_disconnecting) { if (_ws.State != WebSocketState.Open) { TraceEvent( "(ReadLoopAsync) Invalid attempt to read a closed socket", EventIdentifiers.WS_ERR_READ_SOCK_CLOSE_ASYNC, TraceEventType.Error ); throw new InvalidOperationException("Websocket is not open"); } if (ct.IsCancellationRequested) { TraceEvent( "(ReadLoopAsync) Operation cancelled", EventIdentifiers.WS_WAR_CANC_READ, TraceEventType.Warning ); ct.ThrowIfCancellationRequested(); } await _sem.WaitAsync(ct); WebSocketReceiveResult res; ArraySegment <byte> buf = new ArraySegment <byte>(new byte[1024]); res = await _ws.ReceiveAsync(buf, ct); _sem.Release(); //We don't know how long the receive task has waited, so check for cancellation again if (ct.IsCancellationRequested) { TraceEvent( "(ReadLoopAsync) Operation cancelled", EventIdentifiers.WS_WAR_CANC_READ_ASYNC, TraceEventType.Warning ); ct.ThrowIfCancellationRequested(); } if (res.MessageType == WebSocketMessageType.Close) { _disconnecting = true; TraceEvent( $"(ReadLoopAsync) Close request: [{res.CloseStatus}] {res.CloseStatusDescription}", EventIdentifiers.WS_INF_CONN_CLOSE_REQ, TraceEventType.Information ); await _ws.CloseAsync(WebSocketCloseStatus.NormalClosure, "Close request acknowledged", ct); TraceEvent( "(ReadLoopAsync) Socket disconnected", EventIdentifiers.WS_INF_CONN_CLOSE, TraceEventType.Information ); return(ConnectionResult.Disconnecting); } if (!res.EndOfMessage) { _rQ.Enqueue(buf.Take(res.Count)); continue; } List <byte> msg = new List <byte>(); while (!_rQ.IsEmpty) { _rQ.TryDequeue(out IEnumerable <byte> result); msg.AddRange(result); } msg.AddRange(buf.Take(res.Count)); TraceEvent( $"(ReadLoopAsync) Received bytes [ len: {res.Count} ]", EventIdentifiers.WS_VER_RBYTES_ASYNC, TraceEventType.Verbose ); if (res.MessageType == WebSocketMessageType.Binary) { OnBinaryMessage?.Invoke(this, new BinaryMessageEventArgs(msg.ToArray())); } else { string strMsg = Encoding.UTF8.GetString(msg.ToArray()); OnTextMessage?.Invoke(this, new StringMessageEventArgs(strMsg)); } } if (ct.IsCancellationRequested) { TraceEvent( "(ReadLoopAsync) Operation cancelled", EventIdentifiers.WS_WAR_CANC_READ_ASYNC, TraceEventType.Warning ); ct.ThrowIfCancellationRequested(); } TraceEvent( "(ReadLoopAsync) Socket disconnecting", EventIdentifiers.WS_INF_CONN_CLOSE, TraceEventType.Information ); return(ConnectionResult.Disconnecting); }
/// <summary> /// 部分Handler过程参考:http://www.cnblogs.com/lookbs/p/MVC-IMG.html /// </summary> /// <param name="webSocketContext"></param> /// <returns></returns> public static async Task WebSocketRequestHandler(AspNetWebSocketContext webSocketContext) { //Gets the current WebSocket object. System.Net.WebSockets.WebSocket webSocket = webSocketContext.WebSocket; /*We define a certain constant which will represent * size of received data. It is established by us and * we can set any value. We know that in this case the size of the sent * data is very small. */ const int maxMessageSize = 1024; //Buffer for received bits. var receivedDataBuffer = new ArraySegment <Byte>(new Byte[maxMessageSize]); var cancellationToken = new CancellationToken(); WebSocketHelper webSocketHandler = new WebSocketHelper(webSocketContext, cancellationToken); var messageHandler = WebSocketConfig.WebSocketMessageHandlerFunc.Invoke(); if (webSocket.State == WebSocketState.Connecting) { if (WebSocketConfig.WebSocketMessageHandlerFunc != null) { await messageHandler.OnConnecting(webSocketHandler);//调用MessageHandler } } //Checks WebSocket state. while (webSocket.State == WebSocketState.Open) { //Reads data. WebSocketReceiveResult webSocketReceiveResult = await webSocket.ReceiveAsync(receivedDataBuffer, cancellationToken); //If input frame is cancelation frame, send close command. if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close) { if (WebSocketConfig.WebSocketMessageHandlerFunc != null) { await messageHandler.OnDisConnected(webSocketHandler);//调用MessageHandler } await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, String.Empty, cancellationToken); } else { byte[] payloadData = receivedDataBuffer.Array .Where(b => b != 0) .Take(webSocketReceiveResult.Count) .ToArray(); if (WebSocketConfig.WebSocketMessageHandlerFunc != null) { //Because we know that is a string, we convert it. string receiveString = System.Text.Encoding.UTF8.GetString(payloadData, 0, payloadData.Length); try { ReceivedMessage receivedMessage; try { receivedMessage = new ReceivedMessage() { Message = receiveString// + " | 系统错误:" + e.Message }; receivedMessage = Newtonsoft.Json.JsonConvert.DeserializeObject <ReceivedMessage>(receiveString); } catch (Exception e) { receivedMessage = new ReceivedMessage() { Message = receiveString// + " | 系统错误:" + e.Message }; } await messageHandler.OnMessageReceiced(webSocketHandler, receivedMessage, receiveString);//调用MessageHandler } catch (Exception ex) { } } } } }
public override async Task CloseAsync(WebSocketCloseStatus closeStatus, string statusDescription, CancellationToken cancellationToken) { await _webSocket.CloseAsync(closeStatus, statusDescription, cancellationToken); }
public Task Close(WebSocketCloseStatus closeStatus, string closeDescription, CancellationToken cancelToken) { return(mWebSocket.CloseAsync(closeStatus, closeDescription, cancelToken)); }
public override Task CloseAsync(WebSocketCloseStatus closeStatus, string statusDescription, CancellationToken cancellationToken) { ThrowIfNotConnected(); return(innerWebSocket.CloseAsync(closeStatus, statusDescription, cancellationToken)); }
private async Task RunWebSocket(IDictionary<string, object> websocketContext) { // Try to get the websocket context from the environment object value; if (!websocketContext.TryGetValue(typeof(WebSocketContext).FullName, out value)) { throw new InvalidOperationException("Unable to find web socket context"); } mWebSocket = ((WebSocketContext)value).WebSocket; OnOpen(); var buffer = new byte[MaxMessageSize]; do { var received = await ReceiveOneMessage(buffer); if (received.Item1.Count > 0) OnMessageReceived(received.Item1, received.Item2); } while (!mWebSocket.CloseStatus.HasValue); await mWebSocket.CloseAsync(mWebSocket.CloseStatus.GetValueOrDefault(WebSocketCloseStatus.Empty), mWebSocket.CloseStatusDescription, mCancellToken.Token); mCancellToken.Cancel(); OnClose(); }
public Task CloseAsync(WebSocketCloseStatus closeStatus, string statusDescription, CancellationToken cancellationToken) => _webSocket.CloseAsync(closeStatus, statusDescription, cancellationToken);
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; }
internal async Task ProcessWebSocketRequestAsync(WebSocket webSocket, CancellationToken disconnectToken, Func<object, Task<WebSocketMessage>> messageRetriever, object state) { bool closedReceived = false; try { // first, set primitives and initialize the object WebSocket = webSocket; OnOpen(); // dispatch incoming messages while (!disconnectToken.IsCancellationRequested && !closedReceived) { WebSocketMessage incomingMessage = await messageRetriever(state); switch (incomingMessage.MessageType) { case WebSocketMessageType.Binary: OnMessage((byte[])incomingMessage.Data); break; case WebSocketMessageType.Text: OnMessage((string)incomingMessage.Data); break; default: closedReceived = true; // 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)); break; } } } catch (OperationCanceledException ex) { // ex.CancellationToken never has the token that was actually cancelled if (!disconnectToken.IsCancellationRequested) { Error = ex; OnError(); } } catch (ObjectDisposedException) { // If the websocket was disposed while we were reading then noop } catch (Exception ex) { if (IsFatalException(ex)) { Error = ex; OnError(); } } try { if (WebSocket.State == WebSocketState.Closed || WebSocket.State == WebSocketState.Aborted) { // No-op if the socket is already closed or aborted } else { // Close the socket await WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None); } } finally { OnClose(); } }
private static async Task Echo(System.Net.WebSockets.WebSocket webSocket) { WebSocketReceiveResult wResult; { byte[] buffer = new byte[size]; do { try { wResult = await webSocket.ReceiveAsync(new ArraySegment <byte>(buffer), CancellationToken.None); var str = getStrFromByte(ref buffer); if (str == "allMap") { Dictionary <string, bool> Cs = new Dictionary <string, bool>(); List <object> listOfCrosses = new List <object>(); Dictionary <string, Dictionary <int, OssModel.SaveRoad.RoadInfo> > result; Program.dt.GetData(out result); List <double[]> meshPoints = new List <double[]>(); // List<int> colors = new List<int>(); foreach (var item in result) { foreach (var itemj in item.Value) { var value = itemj.Value; var ps = getRoadRectangle(value, item.Value); meshPoints.Add(ps); for (var i = 0; i < value.Cross1.Length; i++) { var cross = value.Cross1[i]; var key = cross.RoadCode1.CompareTo(cross.RoadCode2) > 0 ? $"{cross.RoadCode1}_{cross.RoadOrder1}_{cross.RoadCode2}_{cross.RoadOrder2}" : $"{cross.RoadCode2}_{cross.RoadOrder2}_{cross.RoadCode1}_{cross.RoadOrder1}"; if (Cs.ContainsKey(key)) { } else { Cs.Add(key, false); listOfCrosses.Add(new { lon = cross.BDLongitude, lat = cross.BDLatitude, state = cross.CrossState }); } } //value.Cross1 } } { var msg = Newtonsoft.Json.JsonConvert.SerializeObject(new { reqMsg = str, t = "road", obj = meshPoints }); var sendData = Encoding.UTF8.GetBytes(msg); await webSocket.SendAsync(new ArraySegment <byte>(sendData, 0, sendData.Length), wResult.MessageType, true, CancellationToken.None); } { var msg = Newtonsoft.Json.JsonConvert.SerializeObject(new { reqMsg = str, t = "cross", obj = listOfCrosses }); var sendData = Encoding.UTF8.GetBytes(msg); await webSocket.SendAsync(new ArraySegment <byte>(sendData, 0, sendData.Length), wResult.MessageType, true, CancellationToken.None); } //foreach (var item in result) //{ // foreach (var itemj in item.Value) // { // var value = itemj.Value; // var ps = getCrossPoints(value, result); // meshPoints.Add(ps); // } //} } } catch { // Console.WriteLine($"step2:webSockets数量:{ BufferImage.webSockets.Count}"); return; } }while (!wResult.CloseStatus.HasValue); try { await webSocket.CloseAsync(wResult.CloseStatus.Value, wResult.CloseStatusDescription, CancellationToken.None); } catch { return; } }; }