C#_socket拆包_封包_模拟乱序包

小程序870 更新时间：2025-06-08 11:21:47

2023年8月3日发(作者：)

C#_socket拆包_封包_模拟乱序包⼀.为什么基于TCP的通讯程序需要进⾏封包和拆包.TCP是个"流"协议,所谓流,就是没有界限的⼀串数据.⼤家可以想想河⾥的流⽔,是连成⼀⽚的,其间是没有分界线的.但⼀般通讯程序开发是需要定义⼀个个相互独⽴的数据包的,⽐如⽤于登陆的数据包,⽤于注销的数据包.由于TCP"流"的特性以及⽹络状况,在进⾏数据传输时会出现以下⼏种情况.假设我们连续调⽤两次send分别发送两段数据data1和data2,在接收端有以下⼏种接收情况(当然不⽌这⼏种情况,这⾥只列出了有代表性的情况).A.先接收到data1,然后接收到data2.B.先接收到data1的部分数据,然后接收到data1余下的部分以及data2的全部.C.先接收到了data1的全部数据和data1的部分数据,然后接收到了data2的余下的数据.D.⼀次性接收到了data1和data2的全部数据.对于A这种情况正是我们需要的,不再做讨论.对于B,C,D的情况就是⼤家经常说的"粘包",就需要我们把接收到的数据进⾏拆包,拆成⼀个个独⽴的数据包.为了拆包就必须在发送端进⾏封包. 另:对于UDP来说就不存在拆包的问题,因为UDP是个"数据包"协议,也就是两段数据间是有界限的,在接收端要么接收不到数据要么就是接收⼀个完整的⼀段数据,不会少接收也不会多接收.⼆.为什么会出现B.C.D的情况."粘包"可发⽣在发送端也可发⽣在接收端.1.由Nagle算法造成的发送端的粘包:Nagle算法是⼀种改善⽹络传输效率的算法.简单的说,当我们提交⼀段数据给TCP发送时,TCP并不⽴刻发送此段数据,⽽是等待⼀⼩段时间,看看在等待期间是否还有要发送的数据,若有则会⼀次把这两段数据发送出去.这是对Nagle算法⼀个简单的解释,详细的请看相关书籍.象C和D的情况就有可能是Nagle算法造成的. 2.接收端接收不及时造成的接收端粘包:TCP会把接收到的数据存在⾃⼰的缓冲区中,然后通知应⽤层取数据.当应⽤层由于某些原因不能及时的把TCP的数据取出来,就会造成TCP缓冲区中存放了⼏段数据.三.怎样封包和拆包. 最初遇到"粘包"的问题时,我是通过在两次send之间调⽤sleep来休眠⼀⼩段时间来解决.这个解决⽅法的缺点是显⽽易见的,使传输效率⼤⼤降低,⽽且也并不可靠.后来就是通过应答的⽅式来解决,尽管在⼤多数时候是可⾏的,但是不能解决象B的那种情况,⽽且采⽤应答⽅式增加了通讯量,加重了⽹络负荷. 再后来就是对数据包进⾏封包和拆包的操作. 封包:封包就是给⼀段数据加上包头,这样⼀来数据包就分为包头和包体两部分内容了(以后讲过滤⾮法包时封包会加⼊"包尾"内容).包头其实上是个⼤⼩固定的结构体,其中有个结构体成员变量表⽰包体的长度,这是个很重要的变量,其他的结构体成员可根据需要⾃⼰定义.根据包头长度固定以及包头中含有包体长度的变量就能正确的拆分出⼀个完整的数据包. 对于拆包⽬前我最常⽤的是以下两种⽅式. 1.动态缓冲区暂存⽅式.之所以说缓冲区是动态的是因为当需要缓冲的数据长度超出缓冲区的长度时会增⼤缓冲区长度. ⼤概过程描述如下: A,为每⼀个连接动态分配⼀个缓冲区,同时把此缓冲区和SOCKET关联,常⽤的是通过结构体关联. B,当接收到数据时⾸先把此段数据存放在缓冲区中. C,判断缓存区中的数据长度是否够⼀个包头的长度,如不够,则不进⾏拆包操作. D,根据包头数据解析出⾥⾯代表包体长度的变量. E,判断缓存区中除包头外的数据长度是否够⼀个包体的长度,如不够,则不进⾏拆包操作. F,取出整个数据包.这⾥的"取"的意思是不光从缓冲区中拷贝出数据包,⽽且要把此数据包从缓存区中删除掉.删除的办法就是把此包后⾯的数据移动到缓冲区的起始地址. 这种⽅法有两个缺点.1.为每个连接动态分配⼀个缓冲区增⼤了内存的使⽤.2.有三个地⽅需要拷贝数据,⼀个地⽅是把数据存放在缓冲区,⼀个地⽅是把完整的数据包从缓冲区取出来,⼀个地⽅是把数据包从缓冲区中删除.第⼆种拆包的⽅法会解决和完善这些缺点. 下⾯给出相关代码.

前⾯提到过这种⽅法的缺点.下⾯给出⼀个改进办法,即采⽤环形缓冲.但是这种改进⽅法还是不能解决第⼀个缺点以及第⼀个数据拷贝,只能解决第三个地⽅的数据拷贝(这个地⽅是拷贝数据最多的地⽅).第2种拆包⽅式会解决这两个问题.对于基于TCP开发的通讯程序,有个很重要的问题需要解决,就是封包和拆包.⾃从我从事⽹络通讯编程⼯作以来(⼤概有三年的时间了),我⼀直在思索和改进封包和拆包的⽅法.下⾯就针对这个问题谈谈我的想法,抛砖引⽟.若有不对,不妥之处,恳求⼤家指正环形缓冲实现⽅案是定义两个指针,分别指向有效数据的头和尾.在存放数据和删除数据时只是进⾏头尾指针的移动.⽤代码来说明.注:下⾯的代码是采⽤⼀个开源的游戏服务器的代码,我对此代码有所修改. 2.利⽤底层的缓冲区来进⾏拆包由于TCP也维护了⼀个缓冲区,所以我们完全可以利⽤TCP的缓冲区来缓存我们的数据,这样⼀来就不需要为每⼀个连接分配⼀个缓冲区了.另⼀⽅⾯我们知道recv或者wsarecv都有⼀个参数,⽤来表⽰我们要接收多长长度的数据.利⽤这两个条件我们就可以对第⼀种⽅法进⾏优化. 对于阻塞SOCKET来说,我们可以利⽤⼀个循环来接收包头长度的数据,然后解析出代表包体长度的那个变量,再⽤⼀个循环来接收包体长度的数据.拆包⼀直是个硬伤呀，MLGB的，服务端各种乱数据，果断整理下拆包思路：设计⼀个⽹络协议，⼀般都会分包，⼀个包就相当于⼀个逻辑上的命令。1、如果我们⽤udp协议，省事的多，⼀次会收到⼀个完整的包，但UDP不可靠，顺序也不能保证，当然像QQ对UDP封装的很好，模拟了TCP的可靠性。⽹上也有⼀些封装好的可靠的UDP组件，⼤家⽤的话可以找找。关于⽤什么协议好这个问题，本2、如果我们⽤TCP协议不是长连接，像HTTP（不考虑KeepAlive）那样，⼀个连接上只发送⼀个包，我们也会很清晰的区分出接受到的每⼀个包。3、还有就是我们还⽤TCP长连接，但每次发送固定长度的包，如果要发送的数据长度不够就⽤补齐，如果⼤于固定长度，就分成⼏个发，这个也很简单实⽤。4、再有就是⼀个包有特定的开始和结尾，⽐如包头是包尾是，我们在可以从头读到尾，并把⼀个⼀个的包放⼊队列，由处理线程去处理。5、再有⼀种就是每个包有固定长度的header，这个header⾥包含⼀个包的长度信息，我们可以先从头⾥读出长度信息，然后再借着读这么长的数据，完了这就是⼀个包。关于封包的⼏种类型我就想到这么多，其中的利弊⼤家⼀看便知，我就不忽悠了，本⽂主要介绍最后⼀种⽅式，好多⽹络协议⽤的都是这种，包括CMPP协议，我们⾃⼰设计协议的时候⼀般不⽤像CMPP协议那样，因为⼆进制协议虽然虽然节省⽹络由于Socket缓冲区设置及其他的原因，Socket在接受数据的时候有时候不能完整的收到⼀个包，就是你读出包的长度后，可能不能⼀次就读取这么多数据。⽽如果读个半截⼉的包就⽤UTF8Encoding等来解析，会解析出乱码的，我们这⾥⽤Encoding下⾯就来看⼀下代码，代码的注释很全，演⽰了⼀个包从发到接受、解析的全过程，其中接受的过程没有⼀次收全所有的包，⽽是收了好⼏次，但我们最终还是成功的解析了收到的包。public static void UnPack(){ //1、声明通过socket发送的字符串 string toSendStringBySocket = "娃娃⼠⼤夫%#￥%My name is 蛙蛙王⼦！！"; //2、转换成utf-8字节数组 byte[] bsInput = es(toSendStringBySocket); //3、计算要发送的字节数组的长度，并写到第⼀块⼉字节数组的开头 //⼀般协议设计⾥都有⼀个长度的Header,这⾥就是写这个Header int inputBytesCount = ; byte[] bs1 = new byte[4 + 3]; //4是⼀个int的长度，3是底⼀块字节数组除了Header剩余的⼤⼩ opy(es(inputBytesCount), 0, bs1, 0, 4); //4、把要发送的字节数组拆分成3块⼉发出去，因为socket在接受字节数组的时候 //也可能半截半截⼉的接收，我们就是要模拟这种效果下的拆包，因为第⼀块包写了 //⼀个4个字节的Header，⽽第⼀块字节数组长度是7，所以再写三个字节长度的数据 int offSet = 0; opy(bsInput, offSet, bs1, 4, 3); offSet += - 4; //5、写第⼆块⼉数据 byte[] bs2 = new byte[8]; opy(bsInput, offSet, bs2, 0, ); offSet += ; //6、写第三块⼉数据，我们这⾥模拟在最后⼀块数据的末尾加⼀些乱七⼋糟的数据 //这些乱七⼋糟的数据有可能是下⼀个包的header。 byte[] bs3 = new byte[ - offSet + 4]; opy(bsInput, offSet, bs3, 0, - offSet); opy(new byte[] { 1, 2, 3, 4 }, 0, bs3, - 4, 4); //7、Socket的接收⽅在执⾏BeginReceive函数，并回调函数⾥把收到的数据放⼊⼀个队列⾥ //dotNet的队列内部就是⼀个环形数组，这⾥直接就当环形缓冲区来⽤了。 Queue bufferPool = new Queue(); e(bs1); e(bs2); e(bs3); //8、初始化⼀些变量准备解包

//声明⼀个字符串缓冲区，⼤⼩是你的协议⾥规定的最⼤的包体长度 char[] chars = new char[256];

//定义⼀个UTF-8的Decoder，它可以成块的解包，内部⾃动维护解析状态 //关于它的使⽤请参考MSDN或者《.net框架设计》 Decoder d = oder(); int charLen = 0; //定义每次解包返回的字符长度 int parseBytesCount = 0; //定义已解包的字节数 int LenghHeader = 0; //定义收到包的长度 bool needReadLengthHeader = true; //是否需要读取长度的头 int srcOffSet = 0; //定义要解析的数据块的偏移量 byte[] tempBuffer; //9、当环形缓冲⾥有数据的时候就⼀直解析 while ( > 0) { //10、读取数据包的长度信息，LengthHeader //因为第⼀块⼉包包含长度信息，所以要先读出来 //读了长度包后，要把数据库解析偏移量加4 if(needReadLengthHeader) { LenghHeader = 32(bs1, parseBytesCount); needReadLengthHeader = false; srcOffSet = 4; }

//11、从环形缓冲区取出⼀块⼉数据 tempBuffer = e(); parseBytesCount += -srcOffSet; //更改已解析的字节数 //12、如果已解析的字节数⼤于数据的长度，那么只解需要解析的字节 if (parseBytesCount > LenghHeader) { parseBytesCount -= ; rs(tempBuffer, srcOffSet, inputBytesCount - parseBytesCount, chars, charLen); //这⾥记录下当前的临时缓冲区已解析到了什么位置，准备解析下⼀个包 srcOffSet = inputBytesCount - parseBytesCount; // break; } //13、解析这半拉包 charLen += rs(tempBuffer, srcOffSet, -srcOffSet, chars, charLen); srcOffSet = 0; } string s = new string(chars); //14、通知包处理线程来处理这个包 ine(s);

}实际场景中应⽤using UnityEngine;using tions;using System;using ing;using ;using ;using s;using c;using ;using pServices;using ization;using ;public class JFSocket{ //Socket客户端对象 private Socket clientSocket; //ackage是我封装的结构体， //在与服务器交互的时候会传递这个结构体 //当客户端接到到服务器返回的数据包时，我把结构体add存在链表中。 public List worldpackage; //单例模式 private static JFSocket instance; public static JFSocket GetInstance() { if (instance == null) { instance = new JFSocket(); } return instance; }

//单例的构造函数 JFSocket() { //创建Socket对象，这⾥我的连接类型是TCP clientSocket = new Socket (etwork,,); //服务器IP地址 IPAddress ipAddress = ("192.168.1.100"); //服务器端⼝ IPEndPoint ipEndpoint = new IPEndPoint (ipAddress, 10060); //这是⼀个异步的建⽴连接，当连接建⽴成功时调⽤connectCallback⽅法 IAsyncResult result = onnect (ipEndpoint,new AsyncCallback (connectCallback),clientSocket); //这⾥做⼀个超时的监测，当连接超过5秒还没成功表⽰超时 bool success = e( 5000, true ); if ( !success ) { //超时 Closed(); ("connect Time Out"); }else { //与socket建⽴连接成功，开启线程接受服务端数据。 worldpackage = new List(); Thread thread = new Thread(new ThreadStart(ReceiveSorket)); ground = true; (); } } private void connectCallback(IAsyncResult asyncConnect) { ("connectSuccess"); } private void ReceiveSorket() { //在这个线程中接受服务器返回的数据 while (true) {

if(!ted) { //与服务器断开连接跳出循环 ("Failed to clientSocket server."); (); break; } try { //接受数据保存⾄bytes当中 byte[] bytes = new byte[4096]; //Receive⽅法中会⼀直等待服务端回发消息 //如果没有回发会⼀直在这⾥等着。 int i = e(bytes); if(i <= 0) { (); break; }

//这⾥条件可根据你的情况来判断。 //因为我⽬前的项⽬先要监测包头长度， //我的包头长度是2，所以我这⾥有⼀个判断 if( > 2) { SplitPackage(bytes,0); }else { ("length is not > 2"); } } catch (Exception e) { ("Failed to clientSocket error." + e); (); break; } } }

private void SplitPackage(byte[] bytes , int index) { //在这⾥进⾏拆包，因为⼀次返回的数据包的数量是不定的 //所以需要给数据包进⾏查分。 while(true) { //包头是2个字节 byte[] head = new byte[2]; int headLengthIndex = index + 2; //把数据包的前两个字节拷贝出来 (bytes,index,head,0,2); //计算包头的长度 short length = 16(head,0); //当包头的长度⼤于0 那么需要依次把相同长度的byte数组拷贝出来 if(length > 0) { byte[] data = new byte[length]; //拷贝出这个包的全部字节数 (bytes,headLengthIndex,data,0,length); //把数据包中的字节数组强制转换成数据包的结构体 //BytesToStruct()⽅法就是⽤来转换的 //这⾥需要和你们的服务端程序商量， ackage wp = new ackage(); wp = (ackage)BytesToStruct(data,e()); //把每个包的结构体对象添加⾄链表中。 (wp); //将索引指向下⼀个包的包头 index = headLengthIndex + length; }else { //如果包头为0表⽰没有包了，那么跳出循环 break; } } }

//向服务端发送⼀条字符串 //⼀般不会发送字符串应该是发送数据包 public void SendMessage(string str) { byte[] msg = es(str); if(!ted) { (); return; } try { //int i = (msg); IAsyncResult asyncSend = end (msg,0,,,new AsyncCallback (sendCallback),clientSocket); bool success = e( 5000, true ); if ( !success ) { (); ("Failed to SendMessage server."); } } catch { ("send message error" ); } } //向服务端发送数据包，也就是⼀个结构体对象 public void SendMessage(object obj) { if(!ted) { (); return; } try { //先得到数据包的长度 short size = (short)(obj); //把数据包的长度写⼊byte数组中 byte [] head = es(size); //把结构体对象转换成数据包，也就是字节数组 byte[] data = StructToBytes(obj); //此时就有了两个字节数组，⼀个是标记数据包的长度字节数组，⼀个是数据包字节数组， //同时把这两个字节数组合并成⼀个字节数组 byte[] newByte = new byte[ + ]; (head,0,newByte,0,); (data,0,newByte,, ); //计算出新的字节数组的长度 int length = (size) + (obj); //向服务端异步发送这个字节数组 IAsyncResult asyncSend = end (newByte,0,length,,new AsyncCallback (sendCallback),clientSocket); //监测超时 bool success = e( 5000, true ); if ( !success ) { (); ("Time Out !"); }

} catch (Exception e) { ("send message error: " + e ); } } //结构体转字节数组 public byte[] StructToBytes(object structObj) { int size = (structObj); IntPtr buffer = Global(size); try { ureToPtr(structObj,buffer,false); byte[] bytes = new byte[size]; (buffer, bytes,0,size); return bytes; } finally { lobal(buffer); } } //字节数组转结构体 public object BytesToStruct(byte[] bytes, Type strcutType) { int size = (strcutType); IntPtr buffer = Global(size); try { (bytes,0,buffer,size); return tructure(buffer, strcutType); } finally { lobal(buffer); }

} private void sendCallback (IAsyncResult asyncSend) { } //关闭Socket public void Closed() { if(clientSocket != null && ted) { wn(); (); } clientSocket = null; }}为了与服务端达成默契，判断数据包是否完成。我们需要在数据包中定义包头，包头⼀般是这个数据包的长度，也就是结构体对象的长度。正如代码中我们把两个数据类型short 和 object 合并成⼀个新的字节数组。然后是数据包结构体的定义，需要注意如果你在做IOS和Android的话数据包中不要包含数组，不然在结构体转换byte数组的时候会出错。ureToPtr () error : Attempting to JIT compile g UnityEngine;using tions;using pServices;public class JFPackage{ //结构体序列化 [izable] //4字节对齐 iphone 和 android上可以1字节对齐 [StructLayout(tial, Pack = 4)] public struct WorldPackage { public byte mEquipID; public byte mAnimationID; public byte mHP; public short mPosx; public short mPosy; public short mPosz; public short mRosx; public short mRosy; public short mRosz; public WorldPackage(short posx,short posy,short posz, short rosx, short rosy, short rosz,byte equipID,byte animationID,byte hp) { mPosx = posx; mPosy = posy; mPosz = posz; mRosx = rosx; mRosy = rosy; mRosz = rosz; mEquipID = equipID; mAnimationID = animationID; mHP = hp; } };

}让⾓⾊发⽣移动的时候，调⽤该⽅法向服务端发送数据。oid SendPlayerWorldMessage(){ //组成新的结构体对象，包括主⾓坐标旋转等。 Vector3 PlayerTransform = osition; Vector3 PlayerRotation = ngles; //⽤short的话是2字节，为了节省包的长度。这⾥乘以100 避免使⽤float 4字节。当服务器接受到的时候⼩数点向前移动两位就是真实的float数据 short px = (short)(PlayerTransform.x*100); short py = (short)(PlayerTransform.y*100); short pz = (short)(PlayerTransform.z*100); short rx = (short)(PlayerRotation.x*100); short ry = (short)(PlayerRotation.y*100); short rz = (short)(PlayerRotation.z*100); byte equipID = 1; byte animationID =9; byte hp = 2; ackage wordPackage = new ackage(px,py,pz,rx,ry,rz,equipID,animationID,hp); //通过Socket发送结构体对象 ssage(wordPackage);}接着就是客户端同步服务器的数据，⽬前是测试阶段所以写的⽐较简陋，不过原理都是⼀样的//上次同步时间 private float mSynchronous;void Update (){ mSynchronous +=ime; //在Update中每0.5s的时候同步⼀次 if(mSynchronous > 0.5f) { int count = ; //当接受到的数据包长度⼤于0 开始同步 if(count > 0) { //遍历数据包中每个点的坐标 foreach(ackage wp in ackage) { float x = (float)( / 100.0f); float y = (float)( /100.0f); float z = (float)( /100.0f); ("x = " + x + " y = " + y+" z = " + z); //同步主⾓的新坐标 on = new Vector3 (x,y,z); } //清空数据包链表 (); } mSynchronous = 0; }}