private int _msLengthOrg; //_ms里的有效长度
///<summary>
/// 网络中接收到数据的事件发生
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
public void RecvOrgData(object sender, RecvStreamEventArgs 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);
if (dataPacket is ResHeartOrgDataPacket)
{
RecHeart();
}
_bodyLenOrg = 0;
_msOrg.Position = 0;
_msLengthOrg = 0;
if (dataPacket != null && dataPacket.IsResult)
{
//(new Thread(ProcessDataPacket)).Start(new CMRecvDataEventArgs(_tcpService, dataPacket, e.Length));
lock (_DataPacketQueue)
{
_DataPacketQueue.Enqueue(new CMRecvDataEventArgs(_tcpService, 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, RecvStreamEventArgs 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);
if (dataPacket is ResHeartDataPacket)
{
RecHeart();
}
else if (dataPacket is ResOceanHeart)
{
RecHeart();
}
_bodyLenRealTime = 0;
_msRealTime.Position = 0;
_msLengthRealTime = 0;
if (dataPacket != null && (dataPacket.IsResult || dataPacket.RequestType == FuncTypeRealTime.Init))
{
(new Thread(ProcessDataPacket)).Start(new CMRecvDataEventArgs(_tcpService,
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);
}
}
private uint _msLengthInfo; //_ms里的有效长度
///<summary>
/// 网络中接收到数据的事件发生
///</summary>
///<param name="sender"></param>
///<param name="e"></param>
public void RecvInfoData(object sender, RecvStreamEventArgs 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));
if (dataPacket is ResInfoHeart)
{
RecHeart();
}
_bodyLenInfo = 0;
_msInfo.Position = 0;
_msLengthInfo = 0;
if (dataPacket != null && dataPacket.IsResult)
{
(new Thread(ProcessDataPacket)).Start(new CMRecvDataEventArgs(_tcpService,
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
{
int readBytes = _socket.EndReceive(iAsyncResult);
if (readBytes > 0)
{
_mutex.WaitOne();
try
{
RecvStreamEventArgs e = new RecvStreamEventArgs(
(byte[])
iAsyncResult.AsyncState,
readBytes);
switch (_tcpService)
{
case TcpService.SSHQ:
case TcpService.LSHQ:
case TcpService.WPFW:
RecvRealTimeData(this, e);
break;
case TcpService.ZXCFT:
RecvInfoData(this, e);
break;
case TcpService.JGFW:
case TcpService.DPZS:
RecvOrgData(this, e);
break;
}
}
catch (Exception ex)
{
LogUtilities.LogMessage(ex.Message);
}
finally
{
_mutex.ReleaseMutex();
}
_socket.BeginReceive((byte[])iAsyncResult.AsyncState, 0, _bufferSize, 0, new AsyncCallback(RecvEndCallBack), iAsyncResult.AsyncState);
}
//else if (readBytes == 0)
//{
// ReConnect();
//}
}
catch (Exception ex)
{
//if(ex is SocketException)
//{
// if((ex as SocketException).ErrorCode == 10060)
// {
// ReConnect();
// }
//}
LogUtilities.LogMessage(_tcpService.ToString() + ex.Message);
}
}
