private void DoStart(NetWorkMsg msg)
{
try
{
DxDebug.LogConsole("DNServer.DoStart()：工作线程开始执行DoStart()...");
if (_socketListener != null)
{
DxDebug.Log(" DNServer.DoStart():_socketListener.Dispose();");
_socketListener.Dispose();
}
DxDebug.Log("DNServer.DoStart():_socketListener = new SocketListener(CONNECTIONS_BUFFER_SIZE);");
_socketListener = new SocketListener(this, CONNECTIONS_BUFFER_SIZE);
DxDebug.Log("DNServer.DoStart():_socketListener.EventAccept += OnAccept;");
_socketListener.EventAccept += OnAccept;
_socketListener.EventReceive += OnReceive;
_socketListener.EventSend += OnSend;
_socketListener.EventError += OnTokenError;
DxDebug.Log("DNServer.DoStart(): _socketListener.Start(" + _port + ");");
_socketListener.Start(msg.text1, _port);
DxDebug.LogConsole("DNServer.DoStart()执行完毕！");
}
catch (Exception e)
{
DxDebug.LogWarning("DNServer.DoStart()：异常 " + e.Message);
}
}
/// <summary>
/// Dispose，这个对象的Close()函数会调用该函数
/// </summary>
public void Dispose()
{
if (_workThread != null)
{
DxDebug.Log("DNClient.Dispose():_threadTest.IsAlive 为:" + _workThread.IsAlive);
}
Dispose(true);
}
/// <summary>
/// 发送心跳包函数,调用DNClient单例，然后发送。
/// </summary>
public void SendHeartBeat()
{
DNClient client = DNClient.GetInstance();
if (client.IsConnected)
{
client.Send(Config.HeartBeatData); //发个心跳包
DxDebug.Log("ClientTimer：发送 HeartBeatData ~❤");
}
else
{
// DxDebug.Log("ClientTimer：发送心跳包 - 但是当前还未连接");
}
}
FindPacketResult IPacket.FindPacket(byte[] sData, int startIndex)
{
// DxDebug.LogConsole("DPacket.FindPacket(): sData长度:" + sData.Length + " startIndex: " + startIndex);
List <byte[]> packsList = new List <byte[]>();
FindPacketResult findPacketResult = new FindPacketResult();
findPacketResult.dataArr = null;
findPacketResult.reserveData = null;
//从头至尾依次检查
int checkStart = startIndex;
while (checkStart < sData.Length)
{
DPacket.OnceFindResult result = FindPacketOnce(sData, checkStart);
if (result.startIndex != checkStart)
{
DxDebug.LogWarning("DPacket.FindPacket():丢弃了一段数据，丢弃起始" + checkStart +
"丢弃长度" + (result.startIndex - checkStart));
}
if (result.e == DPacket.PacketError.Succeed)
{
packsList.Add(UnPack(sData, result)); //解包，添加到队列
// DxDebug.Log("DPacket.FindPacket():解包成功");
checkStart = result.startIndex + result.length; //解包成功，直接跳下一个长度位置
}
else if (result.e == DPacket.PacketError.PacketReceiveing)
{
findPacketResult.reserveData = new byte[sData.Length - result.startIndex];
Buffer.BlockCopy(sData, result.startIndex, findPacketResult.reserveData, 0, findPacketResult.reserveData.Length);
DxDebug.Log("DPacket.FindPacket():解包：数据可能还没有接收完");
break;
}
else if (result.e == DPacket.PacketError.PacketLengthTooShort)
{
findPacketResult.reserveData = new byte[sData.Length - result.startIndex];
Buffer.BlockCopy(sData, result.startIndex, findPacketResult.reserveData, 0, findPacketResult.reserveData.Length);
DxDebug.Log("DPacket.FindPacket():解包：数据太短");
break;
}
}
findPacketResult.dataArr = packsList.ToArray();
return(findPacketResult);
}
/// <summary>
/// 构造函数： 创建出一个Socket对象
/// </summary>
internal SocketClient(string hostName, int port, IPacket2 packet2)
{
try
{
IPHostEntry host;
if (Regex.IsMatch(hostName, @"\d{1,3}[.]\d{1,3}[.]\d{1,3}[.]\d{1,3}"))
{
byte[] ipadr = new byte[4];
MatchCollection ms = Regex.Matches(hostName, @"\d{1,3}");
for (int i = 0; i < ms.Count; i++)
{
ipadr[i] = Convert.ToByte(hostName.Substring(ms[i].Index, ms[i].Length));
}
IPAddress address = new IPAddress(ipadr);
this._hostEndPoint = new IPEndPoint(address, port);
}
else
{
host = Dns.GetHostEntry(hostName);
IPAddress[] addressList = host.AddressList;
//实例化 endpoint 和 socket.
this._hostEndPoint = new IPEndPoint(addressList[addressList.Length - 1], port);
}
this._clientSocket = new Socket(this._hostEndPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
//设置这个Timeout应该是无效的(是有效的，必须设置为0，否则自动断线)
_clientSocket.SendTimeout = 8 * 1000;
_clientSocket.ReceiveTimeout = 0;
}
catch (Exception e)
{
DxDebug.LogWarning("SocketClient.SocketClient():类构造函数错误: " + e.Message);
return;
}
if (_areConnectDone == null)
{
_areConnectDone = new AutoResetEvent(false);
}
if (_receiveBuffer == null)
{
_receiveBuffer = new byte[RECE_BUFFER_SIZE];
}
if (_sendBuffer == null)
{
_sendBuffer = new byte[SEND_BUFFER_SIZE];
}
_packet2 = packet2;
#if !NEW_EVENT_AEGS
_sendArgs = new SocketAsyncEventArgs();
_sendArgs.UserToken = this._clientSocket; //利用了Token
//_sendArgs.RemoteEndPoint = null;
_sendArgs.Completed += new EventHandler <SocketAsyncEventArgs>(ProcessSend);
_receiveArgs = new SocketAsyncEventArgs();
_receiveArgs.UserToken = this._clientSocket;//利用了Token
_receiveArgs.SetBuffer(_receiveBuffer, 0, _receiveBuffer.Length);
_receiveArgs.Completed += new EventHandler <SocketAsyncEventArgs>(ProcessReceive);
#endif
DxDebug.Log("SocketClient.SocketClient().SocketClient类构造对象成功！");
}
/// <summary>
/// 加入一条要执行的消息，如果加入的过快而无法发送，则将产生信号量溢出异常，表明当前发送数据频率要大于系统能力
/// </summary>
/// <param name="msg"></param>
internal void AddMessage(NetWorkMsg msg)
{
if (_disposed)
{
DxDebug.LogWarning("DNClient.AddMessage():DNClient对象已经被释放，不能再加入消息。msgType = " + msg.type.ToString());
return;
}
try
{
DxDebug.Log("DNClient.AddMessage():向消息队列中添加消息");
if (msg != null)
{
_msgQueue.Enqueue(msg); //消息进队列
}
if (_curSemCount < 1) //如果当前的信号量剩余不多的时候
{
Interlocked.Increment(ref _curSemCount);
_msgSemaphore.Release();// 释放信号量
}
//发送数据队列长度为128则认为消息已经积攒较长
if (_packet2.SendMsgCount > 128 && _isQueueFull == false)//MAX_SEND_DATA_QUEUE
{
_isQueueFull = true;
if (EventSendQueueIsFull != null)
{
try
{
EventSendQueueIsFull(this);
}
catch (Exception e)
{
DxDebug.LogWarning("DNClient.AddMessage():执行事件EventMsgQueueIsFull异常：" + e.Message);
}
}
if (_isDebugLog)
{
DxDebug.LogWarning("DNClient.AddMessage():向消息队列中添加消息，发送队列长度较长：" + _packet2.SendMsgCount);
}
}
else if (_isQueueFull)//如果现在的状态是发送队列较长的状态，那么再去记录峰值长度
{
if (_sendQueuePeakLength < _packet2.SendMsgCount)
{
_sendQueuePeakLength = _packet2.SendMsgCount;//记录当前的峰值长度
}
}
}
catch (SemaphoreFullException)
{
//当前发送数据频率要大于系统能力，可尝试增加消息队列长度
string msgtype = "";
switch (msg.type)
{
case NetWorkMsg.Tpye.C_Connect:
msgtype = "C_Connect";
break;
case NetWorkMsg.Tpye.C_Send:
msgtype = "C_Send";
break;
case NetWorkMsg.Tpye.C_Receive:
msgtype = "C_Receive";
break;
default:
break;
}
DxDebug.LogError("DNClient.AddMessage():大于系统能力，当前最后一条：" + msgtype);
//throw;//这个throw还是应该去掉
_msgPool.EnqueueMaxLimit(msg);
}
catch (Exception e)
{
DxDebug.LogError("DNClient.AddMessage():异常：" + e.Message);
//throw;//这个throw还是应该去掉
_msgPool.EnqueueMaxLimit(msg);
}
}
