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";
}
