protected virtual void OnTcpServer_MessageReceived(object sender, TcpRawMessageReceivedEventArgs args) { GeneralMessage clientMessage = GeneralMessage.Deserialize(args.Message.MessageRawData, false); //if the server message is model if (clientMessage.Header == (int)MessageHeader.Model) { //get model from general message object model = _tcpServer.ConvertToModel(clientMessage); if (model is QueryServerTimeRequest) { QueryServerTimeRequest queryTimeReq = model as QueryServerTimeRequest; QueryServerTimeResponse response = new QueryServerTimeResponse { RequestID = queryTimeReq.ID, ServerTime = DateTime.Now }; ServerRecvText += $"Received Request:\r\nfrom {queryTimeReq.Name}\r\n"; _tcpServer.SendModelMessage(args.Message.ClientID, response); } else { //do something for other model } } else { } }
private void _tcpServer_MessageReceived(object sender, TcpRawMessageReceivedEventArgs args) { if (!_tcpServer.IsRunning) { return; } //get GeneralMessage from raw data without detached. The message will use shared memory with the receiving buffer. //So this function can't be returned until the buffer used up. GeneralMessage clientMessage = GeneralMessage.Deserialize(args.Message.MessageRawData, false); //if the client message is model if (clientMessage.Header == _tcpServer.HeaderIndicator) { //get model from general message object model = _tcpServer.ConvertToModel(clientMessage); if (model is IUploadFileMessage) { _uploadFileHandler.ProcessFileMessage(args.Message.ClientID, model as IUploadFileMessage, clientMessage.Payload); } else { //detach the message from the receiving buffer, so the message can be processed at any time. clientMessage.Detach(); } } else { } }
private void _server_MessageReceived(object sender, TcpRawMessageReceivedEventArgs args) { if (!IsRunning) { return; } long proxyClientID = args.Message.ClientID; if (!_clientDict.ContainsKey(proxyClientID)) { //If remote connection is not ready, we have to wait until connection completed _waitConnDict.TryRemove(proxyClientID, out ManualResetEvent temp); ManualResetEvent waitEvent = new ManualResetEvent(false); _waitConnDict.TryAdd(proxyClientID, waitEvent); for (int i = 0; i < 300; i++) { if (!IsRunning) { return; } if (_clientDict.ContainsKey(proxyClientID)) { _waitConnDict.TryRemove(proxyClientID, out ManualResetEvent temp2); break; } else { if (waitEvent.WaitOne(10)) { break; } } } } if (_clientDict.ContainsKey(proxyClientID)) { if (DataFilter != null) { DataFilter.BeforeClientToServer(args.Message); } try { //the method may throw exception when stopping, so try catch is used but do nothing. _clientDict[proxyClientID].SendMessage(args.Message.MessageRawData.ToArray()); } catch { } } }
private void _tcpClient_MessageReceived(object sender, TcpRawMessageReceivedEventArgs args) { GeneralMessage serverMessage = GeneralMessage.Deserialize(args.Message.MessageRawData); //if the server message is model if (serverMessage.Header == _tcpClient.HeaderIndicator) { //get model from general message object model = _tcpClient.ConvertToModel(serverMessage); if (model is ChatMessage) { ChatMessage chatMessage = model as ChatMessage; //1.Process the message in synchronized mode. The operation will block until the operation is completed. AddChatMessage(chatMessage); /*2.Process the message in asynchronized mode with client's associated scheduler. * This operation will not block. The message will be put into the queue and be processed one by one in sequence. * * Task.Factory.StartNew(() => * { * AddChatMessage(chatMessage); * }, CancellationToken.None, TaskCreationOptions.None, args.Scheduler); */ /*3.Process the message in asynchronized mode with default scheduler. * This operation can process many messages at the same time. * The order of message processing may be different from that of receiving. * * Task.Factory.StartNew(() => * { * AddChatMessage(chatMessage); * }); */ } } else { } }
protected override bool ReceivedMessageFilter(TcpRawMessageReceivedEventArgs tcpRawMessageArgs) { GeneralMessage serverMessage = GeneralMessage.Deserialize(tcpRawMessageArgs.Message.MessageRawData, false); if (serverMessage == null) { return(false); } //if the server message is model if (serverMessage.Header == _modelHeaderIndicator) { //get model from general message object model = TcpModelConverter.Default.ToModel(serverMessage); //if model is response message if (model is ResponseMessageBase) { _reqResponseAgent.SetRequestResult(model as ResponseMessageBase); return(false); } } return(false); }
protected virtual void OnTcpClient_PacketReceived(object sender, TcpRawMessageReceivedEventArgs args) { GeneralMessage serverMessage = GeneralMessage.Deserialize(args.Message.MessageRawData, false); //if the server message is model if (serverMessage.Header == (int)MessageHeader.Model) { //get model from general message object model = _tcpClient.ConvertToModel(serverMessage); if (model is ServerMessage) { ServerMessage serverMsg = model as ServerMessage; ClientRecvText += "received msg: " + serverMsg.Title + "," + serverMsg.Body + "\r\n"; } else { //do something for other model } } else { } }
private void TcpClient_MessageReceived(object sender, TcpRawMessageReceivedEventArgs args) { if (!IsRunning) { return; } TcpClientEx clientEx = sender as TcpClientEx; long proxyClientID = (long)clientEx.Tag; if (DataFilter != null) { DataFilter.BeforeServerToClient(new TcpRawMessage { ClientID = proxyClientID, MessageRawData = args.Message.MessageRawData }); } try { //the method may throw exception when stopping, so try catch is used but do nothing. _server.SendMessage(proxyClientID, args.Message.MessageRawData.ToArray()); } catch { } }
protected virtual void OnTcpServer_MessageReceived(object sender, TcpRawMessageReceivedEventArgs args) { string text = _tcpServer.TextEncoding.GetString(args.Message.MessageRawData.ToArray()); ServerRecvText += text + "\r\n"; }