private static void Session_OnDataReceived(object sender, AsyncUdpUserToken token)
{
if (token.Length == 0)
{
token.Length = token.Data.Length;
}
Console.WriteLine(System.Text.Encoding.Default.GetString(token.Data, token.Offset, token.Length));
}
private static void Session_OnDataReceived(object sender, AsyncUdpUserToken token)
{
RequestResult result = SerializerFactory <CommonSerializer> .Deserialize <RequestResult>(token.Data);
if (result != null)
{
Console.WriteLine(result.ErrorMsg);
}
}
/// <summary>
/// 监视执行
/// 说明：task.Wait(cts.Token)会异常，同时注册的事件无效；
/// 采用这种方式的优势是捕获异常，当前线程可以返回；在异常中处理超时
/// 当前的方式，task.Result会永久阻塞，如果底层一直不返回，就会一直占用2线程
/// 比起捕获异常的方式会多占用一个线程，但是执行过程更加直观
/// 这里不采用捕获异常的方式，认为大多数情况执行线程不会一直阻塞。
///
/// </summary>
/// <param name="transfer"></param>
/// <param name="address"></param>
private void ProcessMonitor(DBTransfer transfer, EndPoint address)
{
long rspid = Interlocked.Increment(ref ResponeID);
CancellationTokenSource cts = null;
if (transfer.TimeOut == 0)
{
cts = new CancellationTokenSource();
}
else if (transfer.TimeOut == -1)
{
cts = new CancellationTokenSource(Timeout);
}
else if (transfer.TimeOut > 0)
{
cts = new CancellationTokenSource(transfer.TimeOut * 1000);
}
var cancellation = cts.Token.Register(() =>
{
dicTimeOut[rspid] = DateTime.Now;
TimeOutProcesser(transfer.RequestID, rspid, address);
});
var task = Task.Factory.StartNew(() =>
{
return(Processor(rspid, transfer));
}, cts.Token);
// task.Wait(cts.Token);
var result = task.Result;
DateTime date;
if (dicTimeOut.TryRemove(rspid, out date))
{
//说明已经做了超时处理
return;
}
cancellation.Dispose();
byte[] r = SerializerFactory <CommonSerializer> .Serializer <RequestResult>(result);
AsyncUdpUserToken token = new AsyncUdpUserToken();
token.Data = r;
token.Length = r.Length;
token.Remote = address;
udp.SendPackage(token);
Console.WriteLine("回复：" + r.Length);
}
/// <summary>
/// 超时处理
/// </summary>
/// <param name="RequestID"></param>
/// <param name="address"></param>
private void TimeOutProcesser(long RequestID, long rspid, EndPoint address)
{
RequestResult result = new RequestResult();
result.Error = ErrorCode.TimeOut;
result.ErrorMsg = result.Error.ToDescriptionString();
result.ReslutMsg = "执行超时";
result.Result = null;
result.RequestID = RequestID;
result.ID = rspid;
byte[] r = SerializerFactory <CommonSerializer> .Serializer <RequestResult>(result);
AsyncUdpUserToken token = new AsyncUdpUserToken();
token.Data = r;
token.Length = r.Length;
token.Remote = address;
udp.SendPackage(token);
}
private void Udp_OnDataReceived(object sender, AsyncUdpUserToken token)
{
byte[] buffer = null;
if (token.Offset == 0 && (token.Length == 0 || token.Data.Length == token.Length))
{
buffer = token.Data;
}
else
{
buffer = new byte[token.Length];
Array.Copy(buffer, 0, token.Data, token.Offset, token.Length);
}
DBTransfer transfer = SerializerFactory <CommonSerializer> .Deserialize <DBTransfer>(buffer);
token.FreeCache();
Task.Factory.StartNew(() =>
{
ProcessMonitor(transfer, token.Remote);
});
//
}
