C#高性能大容量SOCKET并发（五）：粘包、分包、解包

本文转载连接： http://blog.csdn.net/SQLDebug_Fan/article/details/20465455

粘包

使用TCP长连接就会引入粘包的问题，粘包是指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。粘包可能由发送方造成，也可能由接收方造成。TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一包数据，造成多个数据包的粘连。如果接收进程不及时接收数据，已收到的数据就放在系统接收缓冲区，用户进程读取数据时就可能同时读到多个数据包。

粘包一般的解决办法是制定通讯协议，由协议来规定如何分包解包。

分包

在NETIOCPDemo例子程序中，我们分包的逻辑是先发一个长度，然后紧接着是数据包内容，这样就可以把每个包分开。

应用层数据包格式如下：

应用层数据包格式
数据包长度Len：Cardinal（4字节无符号整数）	数据包内容，长度为Len

AsyncSocketInvokeElement分包处理主要代码，我们收到的数据都是在ProcessReceive方法中处理，处理的方法是把收到的数据存到缓冲区数组中，然后取前4个字节为长度，如果剩下的字节数大于等于长度，则取到一个完整包，进行后续逻辑处理，如果取到的不够一个包，则不处理，等待后续包接收，具体代码如下：

[csharp]  view plain  copy

1. public virtual bool ProcessReceive(byte[] buffer, int offset, int count) //接收异步事件返回的数据，用于对数据进行缓存和分包  
2. {  
3.     m_activeDT = DateTime.UtcNow;  
4.     DynamicBufferManager receiveBuffer = m_asyncSocketUserToken.ReceiveBuffer;  
5.   
6.     receiveBuffer.WriteBuffer(buffer, offset, count);  
7.     if (receiveBuffer.DataCount > sizeof(int))  
8.     {  
9.         //按照长度分包  
10.         int packetLength = BitConverter.ToInt32(receiveBuffer.Buffer, 0); //获取包长度  
11.         if (NetByteOrder)  
12.             packetLength = System.Net.IPAddress.NetworkToHostOrder(packetLength); //把网络字节顺序转为本地字节顺序  
13.   
14.   
15.         if ((packetLength > 10 * 1024 * 1024) | (receiveBuffer.DataCount > 10 * 1024 * 1024)) //最大Buffer异常保护  
16.             return false;  
17.   
18.         if ((receiveBuffer.DataCount - sizeof(int)) >= packetLength) //收到的数据达到包长度  
19.         {  
20.             bool result = ProcessPacket(receiveBuffer.Buffer, sizeof(int), packetLength);  
21.             if (result)  
22.                 receiveBuffer.Clear(packetLength + sizeof(int)); //从缓存中清理  
23.             return result;  
24.         }  
25.         else  
26.         {  
27.             return true;  
28.         }  
29.     }  
30.     else  
31.     {  
32.         return true;  
33.     }  
34. }  

解包

由于我们应用层数据包既可以传命令也可以传数据，因而针对每个包我们进行解包，分出命令和数据分别处理，因而每个Socket服务对象都需要解包，我们解包的逻辑是放在ProcessPacket中，命令和数据的包格式为：

命令长度Len：Cardinal（4字节无符号整数）

命令

数据

[csharp]  view plain  copy

1. public virtual bool ProcessPacket(byte[] buffer, int offset, int count) //处理分完包后的数据，把命令和数据分开，并对命令进行解析  
2. {  
3.     if (count < sizeof(int))  
4.         return false;  
5.     int commandLen = BitConverter.ToInt32(buffer, offset); //取出命令长度  
6.     string tmpStr = Encoding.UTF8.GetString(buffer, offset + sizeof(int), commandLen);  
7.     if (!m_incomingDataParser.DecodeProtocolText(tmpStr)) //解析命令  
8.       return false;  
9.   
10.     return ProcessCommand(buffer, offset + sizeof(int) + commandLen, count - sizeof(int) - commandLen); //处理命令  
11. }  

每个包中包含多个协议关键字，每个协议关键字用回车换行分开，因此我们需要调用文本分开函数，然后针对每条命令解析出关键字和值，具体代码在IncomingDataParser.DecodeProtocolText如下：

[csharp]  view plain  copy

1. public bool DecodeProtocolText(string protocolText)  
2. {  
3.     m_header = "";  
4.     m_names.Clear();  
5.     m_values.Clear();  
6.     int speIndex = protocolText.IndexOf(ProtocolKey.ReturnWrap);  
7.     if (speIndex < 0)  
8.     {  
9.         return false;  
10.     }  
11.     else  
12.     {  
13.         string[] tmpNameValues = protocolText.Split(new string[] { ProtocolKey.ReturnWrap }, StringSplitOptions.RemoveEmptyEntries);  
14.         if (tmpNameValues.Length < 2) //每次命令至少包括两行  
15.             return false;  
16.         for (int i = 0; i < tmpNameValues.Length; i++)  
17.         {  
18.             string[] tmpStr = tmpNameValues[i].Split(new string[] { ProtocolKey.EqualSign }, StringSplitOptions.None);  
19.             if (tmpStr.Length > 1) //存在等号  
20.             {  
21.                 if (tmpStr.Length > 2) //超过两个等号，返回失败  
22.                     return false;  
23.                 if (tmpStr[0].Equals(ProtocolKey.Command, StringComparison.CurrentCultureIgnoreCase))  
24.                 {  
25.                     m_command = tmpStr[1];  
26.                 }  
27.                 else  
28.                 {  
29.                     m_names.Add(tmpStr[0].ToLower());  
30.                     m_values.Add(tmpStr[1]);  
31.                 }  
32.             }  
33.         }  
34.         return true;  
35.     }  
36. }  

处理命令

解析出命令后，需要对每个命令进行处理，各个协议实现类从AsyncSocketInvokeElement.ProcessCommand继承，然后编写各自协议处理逻辑，如吞吐量的测试协议逻辑实现代码如下：

[csharp]  view plain  copy

1. namespace SocketAsyncSvr  
2. {  
3.     class ThroughputSocketProtocol : BaseSocketProtocol  
4.     {  
5.         public ThroughputSocketProtocol(AsyncSocketServer asyncSocketServer, AsyncSocketUserToken asyncSocketUserToken)  
6.             : base(asyncSocketServer, asyncSocketUserToken)  
7.         {  
8.             m_socketFlag = "Throughput";  
9.         }  
10.   
11.         public override void Close()  
12.         {  
13.             base.Close();  
14.         }  
15.   
16.         public override bool ProcessCommand(byte[] buffer, int offset, int count) //处理分完包的数据，子类从这个方法继承  
17.         {  
18.             ThroughputSocketCommand command = StrToCommand(m_incomingDataParser.Command);  
19.             m_outgoingDataAssembler.Clear();  
20.             m_outgoingDataAssembler.AddResponse();  
21.             m_outgoingDataAssembler.AddCommand(m_incomingDataParser.Command);  
22.             if (command == ThroughputSocketCommand.CyclePacket)  
23.                 return DoCyclePacket(buffer, offset, count);  
24.             else  
25.             {  
26.                 Program.Logger.Error("Unknow command: " + m_incomingDataParser.Command);  
27.                 return false;  
28.             }  
29.         }  
30.   
31.         public ThroughputSocketCommand StrToCommand(string command)  
32.         {  
33.             if (command.Equals(ProtocolKey.CyclePacket, StringComparison.CurrentCultureIgnoreCase))  
34.                 return ThroughputSocketCommand.CyclePacket;  
35.             else  
36.                 return ThroughputSocketCommand.None;  
37.         }  
38.   
39.         public bool DoCyclePacket(byte[] buffer, int offset, int count)  
40.         {  
41.             int cycleCount = 0;  
42.             if (m_incomingDataParser.GetValue(ProtocolKey.Count, ref cycleCount))  
43.             {  
44.                 m_outgoingDataAssembler.AddSuccess();  
45.                 cycleCount = cycleCount + 1;  
46.                 m_outgoingDataAssembler.AddValue(ProtocolKey.Count, cycleCount);  
47.             }  
48.             else  
49.                 m_outgoingDataAssembler.AddFailure(ProtocolCode.ParameterError, "");  
50.             return DoSendResult(buffer, offset, count);  
51.         }  
52.     }  
53. }  

DEMO下载地址： http://download.csdn.net/detail/sqldebug_fan/7467745
免责声明：此代码只是为了演示C#完成端口编程，仅用于学习和研究，切勿用于商业用途。水平有限，C#也属于初学，错误在所难免，欢迎指正和指导。邮箱地址：fansheng_hx@163.com。