public void ClientReceiveData(IAsyncResult ar)
{
try
{
Socket socket = (Socket)ar.AsyncState;
int count = socket.EndReceive(ar);
if (count <= 0)
{
Clear();
return;
}
package.WriteIndex += count;
ProcessData();
if (package.Remain < 8)
{
package.MoveBytes();
package.Resize(package.Length * 2);
}
socket.BeginReceive(package.Bytes, package.WriteIndex, package.Remain, 0, ClientReceiveData, socket);
}
catch (SocketException e)
{
DetailLog.Error("ClientReceiveError:" + e.Message);
Clear();
}
}
private void ProcessData()
{
if (package.Length <= 4 || package.ReadIndex < 0)
{
return;
}
int dataLength = BitConverter.ToInt32(package.Bytes, package.ReadIndex);
if (package.Length < dataLength + 4)
{
return;
}
package.ReadIndex += 4;
try
{
T data = NetTool.Deserialize <T>(package.Bytes, package.ReadIndex, dataLength);
OnReceiveData(data);
}
catch (Exception e)
{
DetailLog.Error("ProcessDataError:" + e.Message);
return;
}
package.ReadIndex += dataLength;
package.CheckAndMoveBytes();
if (package.Length > 4)
{
ProcessData();
}
}
internal void SendData(byte[] data)
{
try
{
clientSocket.BeginSend(data, 0, data.Length, 0, null, null);
}
catch (Exception e)
{
DetailLog.Error("SendMessageError:" + e.Message);
}
}
private void ServerConnectCallBack(IAsyncResult ar)
{
try
{
socket.EndConnect(ar);
clientSession = new T();
clientSession.ReceiveData(socket, null);
}
catch (Exception e)
{
DetailLog.Error("ConnectServer:" + e.Message);
}
}
public void StartClient(IPEndPoint ipEndPoint)
{
DetailLog.InitSettings();
try
{
socket.BeginConnect(ipEndPoint, ServerConnectCallBack, socket);
DetailLog.ColorLog(LogColor.Blue, "Client Start Success!\nConnecting To Server......");
}
catch (Exception e)
{
DetailLog.Error("StartClient:" + e.Message);
}
}
public void StartServer(IPEndPoint ipEndPoint)
{
DetailLog.InitSettings();
try
{
socket.Bind(ipEndPoint);
socket.Listen(50000);
DetailLog.ColorLog(LogColor.Blue, "Server Start Success!\nWaiting for Connecting......");
while (true)
{
ResetCheckRead();
try
{
//检查当前Socket，返回可读Socket数组
Socket.Select(checkReadList, null, null, 5000);
}
catch (SocketException e)
{
DetailLog.Error("StartReceiveError:" + e.Message);
}
for (int i = checkReadList.Count - 1; i >= 0; i--)
{
Socket s = checkReadList[i];
if (s == socket)
{
//监听Socket可读，有新的客户端连接到服务器
Socket client = socket.Accept();
T clientSession = new T();
clientSession.InitNetSession(client, () =>
{
if (clientSocketDic.ContainsKey(client))
{
clientSocketDic.Remove(client);
}
}, false);
clientSocketDic.Add(client, clientSession);
}
else
{
//连接客户端的Socket可读，客户端向服务端发送消息
clientSocketDic[s].ServerReceiveData();
}
}
}
}
catch (Exception e)
{
DetailLog.Error("StartServerError:" + e.Message);
}
}
private void SendCallBack(IAsyncResult ar)
{
NetworkStream ns = (NetworkStream)ar.AsyncState;
try
{
ns.EndWrite(ar);
ns.Flush();
ns.Close();
}
catch (Exception e)
{
DetailLog.Error("SndMsgError:" + e.Message);
}
}
public void StartServer(IPEndPoint ipEndPoint)
{
DetailLog.InitSettings();
try
{
socket.Bind(ipEndPoint);
socket.Listen(50000);
socket.BeginAccept(ClientConnectCallBack, socket);
DetailLog.ColorLog(LogColor.Blue, "Server Start Success!\nWaiting for Connecting......");
}
catch (Exception e)
{
DetailLog.Error("StartServer:" + e.Message);
}
}
internal static T Deserialize <T>(byte[] data) where T : NetData
{
using (MemoryStream ms = new MemoryStream(Decompession(data)))
{
try
{
T result = Serializer.NonGeneric.Deserialize(typeof(T), ms) as T;
return(result);
}
catch (SerializationException e)
{
DetailLog.Error("Failed to deserialize. Log: " + e.Message);
return(null);
}
}
}
private void ReceiveHeadData(IAsyncResult ar)
{
try
{
NetPackage mPackage = (NetPackage)ar.AsyncState;
if (clientSocket.Available == 0)
{
Clear();
return;
}
int len = clientSocket.EndReceive(ar);
if (len > 0)
{
mPackage.HeadIndex += len;
if (mPackage.HeadIndex < mPackage.HeadLength)
{
clientSocket.BeginReceive(
mPackage.HeadBuffer,
mPackage.HeadIndex,
mPackage.HeadLength - mPackage.HeadIndex,
SocketFlags.None,
ReceiveHeadData,
mPackage);
}
else
{
mPackage.InitBodyBuffer();
clientSocket.BeginReceive(mPackage.BodyBuffer,
0,
mPackage.BodyLength,
SocketFlags.None,
ReceiveBodyData,
mPackage);
}
}
else
{
Clear();
}
}
catch (Exception e)
{
DetailLog.Error("RcvHeadError:" + e.Message);
}
}
internal void SendData(byte[] data)
{
NetworkStream ns = null;
try
{
ns = new NetworkStream(clientSocket);
if (ns.CanWrite)
{
ns.BeginWrite(data, 0, data.Length, new AsyncCallback(SendCallBack), ns);
}
}
catch (Exception e)
{
DetailLog.Error("SndMsgError:" + e.Message);
}
}
internal static byte[] Serialize <T>(T data) where T : NetData
{
using (MemoryStream ms = new MemoryStream())
{
try
{
Serializer.Serialize(ms, data);
ms.Seek(0, SeekOrigin.Begin);
return(Compession(ms.ToArray()));
}
catch (SerializationException e)
{
DetailLog.Error("Failed to serialize. Log: " + e.Message);
return(null);
}
}
}
internal static T Deserialize <T>(byte[] data, int offset, int count) where T : NetData
{
byte[] realData = new byte[count];
Array.Copy(data, offset, realData, 0, count);
using (MemoryStream ms = new MemoryStream(Decompession(realData)))
{
try
{
T result = Serializer.NonGeneric.Deserialize(typeof(T), ms) as T;
return(result);
}
catch (SerializationException e)
{
DetailLog.Error("Failed to deserialize. Log: " + e.Message);
return(null);
}
}
}
private void ReceiveBodyData(IAsyncResult ar)
{
try
{
NetPackage mPackage = (NetPackage)ar.AsyncState;
int len = clientSocket.EndReceive(ar);
if (len > 0)
{
mPackage.BodyIndex += len;
if (mPackage.BodyIndex < mPackage.BodyLength)
{
clientSocket.BeginReceive(mPackage.BodyBuffer,
mPackage.BodyIndex,
mPackage.BodyLength - mPackage.BodyIndex,
SocketFlags.None,
ReceiveBodyData,
mPackage);
}
else
{
//处理数据
T data = NetTool.Deserialize <T>(mPackage.BodyBuffer);
OnReceiveData(data);
mPackage.RestPackage();
clientSocket.BeginReceive(
mPackage.HeadBuffer,
0,
mPackage.HeadLength,
SocketFlags.None,
ReceiveHeadData,
mPackage);
}
}
else
{
Clear();
}
}
catch (Exception e)
{
DetailLog.Error("RcvBodyError:" + e.Message);
}
}
private void ClientConnectCallBack(IAsyncResult ar)
{
try
{
Socket clientSocket = socket.EndAccept(ar);
T session = new T();
clientSessionList.Add(session);
session.ReceiveData(clientSocket, () =>
{
if (clientSessionList.Contains(session))
{
clientSessionList.Remove(session);
}
});
}
catch (Exception e)
{
DetailLog.Error("ConnectClient:" + e.Message);
}
socket.BeginAccept(ClientConnectCallBack, socket);
}
public void ReceiveData(Socket socket, Action closeCB)
{
OnConnected();
try
{
clientSocket = socket;
closeCallBack = closeCB;
NetPackage mPackage = new NetPackage();
this.clientSocket.BeginReceive(
mPackage.HeadBuffer,
0,
mPackage.HeadLength,
SocketFlags.None,
new AsyncCallback(ReceiveHeadData),
mPackage);
}
catch (Exception e)
{
DetailLog.Error("StartRcvData:" + e.Message);
}
}
public void ServerReceiveData()
{
int count = 0;
if (package.Remain <= 0)
{
ProcessData();
package.CheckAndMoveBytes();
while (package.Remain <= 0)
{
int expandSize = package.Length < NetPackage.DEFAULT_SIZE
? NetPackage.DEFAULT_SIZE
: package.Length;
package.Resize(expandSize * 2);
}
}
try
{
count = clientSocket.Receive(package.Bytes, package.WriteIndex, package.Remain, 0);
}
catch (SocketException e)
{
DetailLog.Error("ServerReceiveError:" + e.Message);
Clear();
return;
}
if (count <= 0)
{
Clear();
return;
}
//根据协议内容处理消息，处理结果返回客户端
package.WriteIndex += count;
ProcessData();
package.CheckAndMoveBytes();
}
