private uint _msLengthInfo; //_ms里的有效长度
///<summary>
/// 网络中接收到数据的事件发生
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
public void RecvInfoData(object sender, RecvDataEventArgs e)
{
while (_packetStartPosInfo < e.Length)
{
if (_bodyLenInfo == 0)
{
if ((_packetStartPosInfo + 3) < e.Length)
{
//获取包体长度
byte[] len = new byte[]
{
e.Data[_packetStartPosInfo], e.Data[_packetStartPosInfo + 1],
e.Data[_packetStartPosInfo + 2],
e.Data[_packetStartPosInfo + 3]
};
_bodyLenInfo = BitConverter.ToInt32(len, 0);
}
else
{
break;
}
}
//如果有一个完整包，解包
if (_packetStartPosInfo + 16 + _bodyLenInfo - _msLengthInfo < e.Length)
{
{
_msInfo.Write(e.Data, Convert.ToInt32(_packetStartPosInfo), Convert.ToInt32(17 + _bodyLenInfo - _msLengthInfo));
_packetStartPosInfo += 17 + (uint)_bodyLenInfo - _msLengthInfo;
InfoDataPacket dataPacket = InfoDataPacket.DecodePacket(_msInfo.ToArray(), Convert.ToInt32(17 + _bodyLenInfo));
_bodyLenInfo = 0;
_msInfo.Position = 0;
_msLengthInfo = 0;
if (dataPacket != null && dataPacket.IsResult)
{
//(new Thread(ProcessDataPacket)).Start(new CMRecvDataEventArgs(_ipAddressPort,
// dataPacket, e.Length));
}
}
}
else
{
break;
}
}
//有多余的字节，且不是一个完整包，存起来
if (e.Length > _packetStartPosInfo)
{
_msInfo.Write(e.Data, Convert.ToInt32(_packetStartPosInfo), Convert.ToInt32(e.Length - _packetStartPosInfo));
_msLengthInfo += (uint)(e.Length - _packetStartPosInfo);
}
else
{
_msLengthInfo = 0;
}
_packetStartPosInfo = 0;
}
void RecvEndCallBack(IAsyncResult iAsyncResult)
{
try
{
//lock (this)
{
int readBytes = _tcpClient.Client.EndReceive(iAsyncResult);
if (readBytes > 0)
{
_mutex.WaitOne();
try
{
RecvDataEventArgs e = new RecvDataEventArgs(_ipAddressPort,
(byte[])
iAsyncResult.AsyncState,
readBytes);
switch (SerMode)
{
case ServerMode.RealTime:
case ServerMode.History:
RecvRealTimeData(this, e);
break;
case ServerMode.Information:
RecvInfoData(this, e);
break;
case ServerMode.Org:
RecvOrgData(this, e);
break;
case ServerMode.Oversea:
RecvRealTimeData(this, e);
break;
}
}
catch (Exception ex)
{
LogUtilities.LogMessage(ex.Message);
}
finally
{
_mutex.ReleaseMutex();
}
}
_tcpClient.Client.BeginReceive((byte[])iAsyncResult.AsyncState, 0, _bufferSize, 0,
new AsyncCallback(RecvEndCallBack), iAsyncResult.AsyncState);
}
}
catch (Exception ex)
{
LogUtilities.LogMessage(SerMode.ToString() + ex.Message);
}
}
// 数据到达
private void _client_OnData(object sender, RecvDataEventArgs e)
{
lock (_queueLock)
{
_dataQueue.Enqueue(e.Data);
}
_semaphore.Release();
}
private int _msLengthOrg; //_ms里的有效长度
///<summary>
/// 网络中接收到数据的事件发生
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
public void RecvOrgData(object sender, RecvDataEventArgs e)
{
try
{
while (_packetStartPosOrg < e.Length)
{
if (_bodyLenOrg == 0)
{
if ((_packetStartPosOrg + 3) < e.Length)
{
//获取包体长度
byte[] len = new byte[]
{
e.Data[_packetStartPosOrg], e.Data[_packetStartPosOrg + 1],
e.Data[_packetStartPosOrg + 2],
e.Data[_packetStartPosOrg + 3]
};
_bodyLenOrg = BitConverter.ToInt32(len, 0);
}
else
{
break;
}
}
//如果有一个完整包，解包
if (_packetStartPosOrg + 16 + _bodyLenOrg - _msLengthOrg < e.Length)
{
_msOrg.Write(e.Data, _packetStartPosOrg, 17 + _bodyLenOrg - _msLengthOrg);
_packetStartPosOrg += 17 + _bodyLenOrg - _msLengthOrg;
OrgDataPacket dataPacket = OrgDataPacket.DecodePacket(_msOrg.ToArray(), 17 + _bodyLenOrg);
_bodyLenOrg = 0;
_msOrg.Position = 0;
_msLengthOrg = 0;
if (dataPacket != null && dataPacket.IsResult)
{
//(new Thread(ProcessDataPacket)).Start(new ClientRecvDataEventArgs(_ipAddressPort,
// dataPacket, e.Length));
}
}
else
{
break;
}
}
//有多余的字节，且不是一个完整包，存起来
if (e.Length > _packetStartPosOrg)
{
_msOrg.Write(e.Data, _packetStartPosOrg, e.Length - _packetStartPosOrg);
_msLengthOrg += e.Length - _packetStartPosOrg;
}
else
{
_msLengthOrg = 0;
}
_packetStartPosOrg = 0;
}
catch (Exception ex)
{
LogUtilities.LogMessage(ex.Message);
}
}
private int _msLengthRealTime; //_ms里的有效长度
///<summary>
/// 网络中接收到数据的事件发生
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
public void RecvRealTimeData(object sender, RecvDataEventArgs e)
{
try
{
while (_packetStartPosRealTime < e.Length)
{
if (_bodyLenRealTime == 0)
{
if ((_packetStartPosRealTime + 3) < e.Length)
{
//获取包体长度
byte[] len = new byte[]
{
e.Data[_packetStartPosRealTime], e.Data[_packetStartPosRealTime + 1],
e.Data[_packetStartPosRealTime + 2],
e.Data[_packetStartPosRealTime + 3]
};
_bodyLenRealTime = BitConverter.ToInt32(len, 0);
}
else
{
break;
}
}
//如果有一个完整包，解包
if (_packetStartPosRealTime + 16 + _bodyLenRealTime - _msLengthRealTime < e.Length)
{
_msRealTime.Write(e.Data, _packetStartPosRealTime, 17 + _bodyLenRealTime - _msLengthRealTime);
_packetStartPosRealTime += 17 + _bodyLenRealTime - _msLengthRealTime;
RealTimeDataPacket dataPacket = RealTimeDataPacket.DecodePacket(_msRealTime.ToArray(), 17 + _bodyLenRealTime);
_bodyLenRealTime = 0;
_msRealTime.Position = 0;
_msLengthRealTime = 0;
if (dataPacket != null && (dataPacket.IsResult || dataPacket.RequestType == FuncTypeRealTime.Init))
{
//(new Thread(ProcessDataPacket)).Start(new CMRecvDataEventArgs(_ipAddressPort,
// dataPacket, e.Length));
}
}
else
{
break;
}
}
//有多余的字节，且不是一个完整包，存起来
if (e.Length > _packetStartPosRealTime)
{
_msRealTime.Write(e.Data, _packetStartPosRealTime, e.Length - _packetStartPosRealTime);
_msLengthRealTime += e.Length - _packetStartPosRealTime;
}
else
{
_msLengthRealTime = 0;
}
_packetStartPosRealTime = 0;
}
catch (Exception ex)
{
LogUtilities.LogMessage(ex.Message);
}
}
