internal void Disconnect(string message)
{
this.Asyn = null;
Stream.Flush();
IsDisconnect = true;
DisconnectDateTime = DateTime.Now;
if (AsyncCallDict != null)
{
AsyncCallDict.Clear();
}
if (CallBackDict != null)
{
foreach (var item in CallBackDict.Values)
{
var disconn = GetExceptionResult("Disconnect", (int)ErrorTag.Disconnect, item.Id);
disconn.Arguments = new List <byte[]>();
item.SetRes(disconn);
}
CallBackDict.Clear();
}
UserDisconnect?.Invoke(this, message);
UserDisconnect = null;
}
internal bool CheckTimeOut()
{
if (CallBackDict == null || CallBackDict.Count == 0)
{
return(false);
}
else
{
var res = AsyncWaitTimeOut.FindAll(p => p.Value < DateTime.Now);
if (res.Count == 0)
{
return(false);
}
else
{
foreach (var item in res)
{
long id = item.Key;
if (CallBackDict.ContainsKey(id))
{
if (CallBackDict.TryRemove(id, out AsyncCalls value))
{
Task.Run(() =>
{
var timeout = GetExceptionResult("Server call client time out", (int)ErrorTag.TimeOut, id);
try
{
value.SetRes(timeout);
}
catch (Exception er)
{
if (PushException(new SetResultException(er.Message, (int)ErrorTag.SetErr, er)))
{
Log.Error($"CMD:{value.Cmd} Id:{value.Id} ERROR:\r\n{er.Message}");
}
}
});
}
}
AsyncWaitTimeOut.Remove(item);
}
return(true);
}
}
}
internal void AddAsyncCallBack(AsyncCalls asyncalls, long id)
{
if (CallBackDict == null)
{
CallBackDict = new ConcurrentDictionary <long, AsyncCalls>();
}
CallBackDict.AddOrUpdate(id, asyncalls, (a, b) => asyncalls);
if (asyncalls.CurrentServer.IsCheckReadTimeOut)
{
KeyValuePair <long, DateTime> tot = new KeyValuePair <long, DateTime>(id, DateTime.Now.AddMilliseconds(asyncalls.CurrentServer.ReadOutTimeMilliseconds));
AsyncWaitTimeOut.Add(tot);
}
}
private void DataOn(byte[] data)
{
ReadBytes read = null;
if (CurrentServer.DecodeingHandler != null)
{
read = new ReadBytes(data, 4, -1, CurrentServer.DecodeingHandler);
}
else
{
read = new ReadBytes(data);
}
if (read.ReadInt32(out int length) && read.ReadInt32(out int cmd) && read.Length == length)
{
switch (cmd)
{
case CmdDef.CallCmd:
{
CallPack call = new CallPack();
try
{
call.Id = read.ReadInt64();
call.CmdTag = read.ReadInt32();
call.Arguments = new List <byte[]>();
var lengt = read.ReadInt32();
for (int i = 0; i < lengt; i++)
{
call.Arguments.Add(read.ReadByteArray());
}
CallPackRun(call);
}
catch (Exception er)
{
if (PushException(new CallException(er.Message, (int)ErrorTag.CallErr, er)))
{
Log.Error($"CMD:{call.CmdTag} Error:\r\n{er}");
}
}
}
break;
case CmdDef.ReturnResult:
{
Result result = new Result
{
Id = read.ReadInt64(),
ErrorId = read.ReadInt32()
};
byte[] strdata = read.ReadByteArray();
if (strdata.Length > 0)
{
result.ErrorMsg = Encoding.UTF8.GetString(strdata);
}
var arglengt = read.ReadInt32();
for (int i = 0; i < arglengt; i++)
{
result.Arguments.Add(read.ReadByteArray());
}
if (CallBackDict.ContainsKey(result.Id))
{
if (CallBackDict.TryRemove(result.Id, out AsyncCalls call))
{
try
{
call.SetRes(result);
}
catch (Exception er)
{
var ermsg = $"Cmd:{call.Cmd} Error:\r\n {er}";
if (PushException(new CallException(ermsg, (int)ErrorTag.CallErr, er)))
{
Log.Error(ermsg);
}
}
}
}
}
break;
}
}
}
