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

拆包一直是个硬伤呀，MLGB的，服务端各种乱数据，果断整理下

拆包思路：设计一个网络协议，一般都会分包，一个包就相当于一个逻辑上的命令。
1、如果我们用udp协议，省事的多，一次会收到一个完整的包，但UDP不可靠，顺序也不能保证，当然像QQ对UDP封装的很好，模拟了TCP的可靠性。网上也有一些封装好的可靠的UDP组件，大家用的话可以找找。关于用什么协议好这个问题，本贴不讨论。
2、如果我们用TCP协议不是长连接，像HTTP（不考虑KeepAlive）那样，一个连接上只发送一个包，我们也会很清晰的区分出接受到的每一个包。
3、还有就是我们还用TCP长连接，但每次发送固定长度的包，如果要发送的数据长度不够就用补齐，如果大于固定长度，就分成几个发，这个也很简单实用。
4、再有就是一个包有特定的开始和结尾，比如包头是<bof>包尾是<eof>，我们在可以从头读到尾，并把一个一个的包放入队列，由处理线程去处理。
5、再有一种就是每个包有固定长度的header，这个header里包含一个包的长度信息，我们可以先从头里读出长度信息，然后再借着读这么长的数据，完了这就是一个包。

关于封包的几种类型我就想到这么多，其中的利弊大家一看便知，我就不忽悠了，本文主要介绍最后一种方式，好多网络协议用的都是这种，包括CMPP协议，我们自己设计协议的时候一般不用像CMPP协议那样，因为二进制协议虽然虽然节省网络流量，但可读性不好。出问题，抓个包分析起来太麻烦。我们可以用.net自带的序列功能把要发送的类序列化成XML字符串发送出去，这多好看呀。

由于Socket缓冲区设置及其他的原因，Socket在接受数据的时候有时候不能完整的收到一个包，就是你读出包的长度后，可能不能一次就读取这么多数据。而如果读个半截儿的包就用UTF8Encoding等来解析，会解析出乱码的，我们这里用Encoding.UTF8.GetDecoder()来对包进行成块儿的解析，它就是用来做这种事情的。

下面就来看一下代码，代码的注释很全，演示了一个包从发到接受、解析的全过程，其中接受的过程没有一次收全所有的包，而是收了好几次，但我们最终还是成功的解析了收到的包。

 

 

public static void UnPack()
{
    //1、声明通过socket发送的字符串
    string toSendStringBySocket = "娃娃士大夫%#￥%My name is 蛙蛙王子！！";
    //2、转换成utf-8字节数组
    byte[] bsInput = Encoding.UTF8.GetBytes(toSendStringBySocket);

    //3、计算要发送的字节数组的长度，并写到第一块儿字节数组的开头
    //一般协议设计里都有一个长度的Header,这里就是写这个Header
    int inputBytesCount = bsInput.Length;
    byte[] bs1 = new byte[4 + 3]; //4是一个int的长度，3是底一块字节数组除了Header剩余的大小
    Buffer.BlockCopy(BitConverter.GetBytes(inputBytesCount), 0, bs1, 0, 4);

    //4、把要发送的字节数组拆分成3块儿发出去，因为socket在接受字节数组的时候
    //也可能半截半截儿的接收，我们就是要模拟这种效果下的拆包，因为第一块包写了
    //一个4个字节的Header，而第一块字节数组长度是7，所以再写三个字节长度的数据
    int offSet = 0;
    Buffer.BlockCopy(bsInput, offSet, bs1, 4, 3);
    offSet += bs1.Length - 4;

    //5、写第二块儿数据
    byte[] bs2 = new byte[8];
    Buffer.BlockCopy(bsInput, offSet, bs2, 0, bs2.Length);
    offSet += bs2.Length;

    //6、写第三块儿数据，我们这里模拟在最后一块数据的末尾加一些乱七八糟的数据
    //这些乱七八糟的数据有可能是下一个包的header。
    byte[] bs3 = new byte[bsInput.Length - offSet + 4];
    Buffer.BlockCopy(bsInput, offSet, bs3, 0, bsInput.Length - offSet);
    Buffer.BlockCopy(new byte[] { 1, 2, 3, 4 }, 0, bs3, bs3.Length - 4, 4);

    //7、Socket的接收方在执行BeginReceive函数，并回调函数里把收到的数据放入一个队列里
    //dotNet的队列内部就是一个环形数组，这里直接就当环形缓冲区来用了。
    Queue<byte[]> bufferPool = new Queue<byte[]>();
    bufferPool.Enqueue(bs1);
    bufferPool.Enqueue(bs2);
    bufferPool.Enqueue(bs3);

    //8、初始化一些变量准备解包
    
    //声明一个字符串缓冲区，大小是你的协议里规定的最大的包体长度
    char[] chars = new char[256]; 
    //定义一个UTF-8的Decoder，它可以成块的解包，内部自动维护解析状态
    //关于它的使用请参考MSDN或者《.net框架设计》
    Decoder d = Encoding.UTF8.GetDecoder();
    int charLen = 0; //定义每次解包返回的字符长度
    int parseBytesCount = 0;  //定义已解包的字节数
    int LenghHeader = 0; //定义收到包的长度
    bool needReadLengthHeader = true; //是否需要读取长度的头

    int srcOffSet = 0; //定义要解析的数据块的偏移量
    byte[] tempBuffer;
    //9、当环形缓冲里有数据的时候就一直解析
    while (bufferPool.Count > 0)
    {
        //10、读取数据包的长度信息，LengthHeader
        //因为第一块儿包包含长度信息，所以要先读出来
        //读了长度包后，要把数据库解析偏移量加4
        if(needReadLengthHeader)
        {
            LenghHeader = BitConverter.ToInt32(bs1, parseBytesCount);
            needReadLengthHeader = false;
            srcOffSet = 4;
        }
        
        //11、从环形缓冲区取出一块儿数据
        tempBuffer = bufferPool.Dequeue();
        parseBytesCount += tempBuffer.Length-srcOffSet; //更改已解析的字节数

        //12、如果已解析的字节数大于数据的长度，那么只解需要解析的字节
        if (parseBytesCount > LenghHeader)
        {
            parseBytesCount -= tempBuffer.Length;
            d.GetChars(tempBuffer, srcOffSet, inputBytesCount - parseBytesCount, chars, charLen);
            //这里记录下当前的临时缓冲区已解析到了什么位置，准备解析下一个包
            srcOffSet = inputBytesCount - parseBytesCount; //
            break;
        }
        //13、解析这半拉包
        charLen += d.GetChars(tempBuffer, srcOffSet, tempBuffer.Length-srcOffSet, chars, charLen);
        srcOffSet = 0;
    }

    string s = new string(chars);
    //14、通知包处理线程来处理这个包
    Console.WriteLine(s); 
}

实际场景中应用

 

using UnityEngine;
using System.Collections;
using System;
using System.Threading;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class JFSocket
{

    //Socket客户端对象
    private Socket clientSocket;
    //JFPackage.WorldPackage是我封装的结构体，
    //在与服务器交互的时候会传递这个结构体
    //当客户端接到到服务器返回的数据包时，我把结构体add存在链表中。
    public List<JFPackage.WorldPackage> worldpackage;
    //单例模式
    private static JFSocket instance;
    public static JFSocket GetInstance()
    {
        if (instance == null)
        {
            instance = new JFSocket();
        }
        return instance;
     }      

    //单例的构造函数
    JFSocket()
    {
        //创建Socket对象， 这里我的连接类型是TCP
        clientSocket = new Socket (AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
        //服务器IP地址
        IPAddress ipAddress = IPAddress.Parse ("192.168.1.100");
        //服务器端口
        IPEndPoint ipEndpoint = new IPEndPoint (ipAddress, 10060);
        //这是一个异步的建立连接，当连接建立成功时调用connectCallback方法
        IAsyncResult result = clientSocket.BeginConnect (ipEndpoint,new AsyncCallback (connectCallback),clientSocket);
        //这里做一个超时的监测，当连接超过5秒还没成功表示超时
        bool success = result.AsyncWaitHandle.WaitOne( 5000, true );
        if ( !success )
           {
               //超时
              Closed();
            Debug.Log("connect Time Out");
        }else
        {
            //与socket建立连接成功，开启线程接受服务端数据。
            worldpackage = new List<JFPackage.WorldPackage>();
            Thread thread = new Thread(new ThreadStart(ReceiveSorket));
                thread.IsBackground = true;
            thread.Start();
        }
    }

    private void connectCallback(IAsyncResult asyncConnect)
    {
        Debug.Log("connectSuccess");
    }

    private void ReceiveSorket()
    {
        //在这个线程中接受服务器返回的数据
        while (true)
        { 

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

                //这里条件可根据你的情况来判断。
                //因为我目前的项目先要监测包头长度，
                //我的包头长度是2，所以我这里有一个判断
                if(bytes.Length > 2)
                {
                    SplitPackage(bytes,0);
                }else
                {
                    Debug.Log("length is not  >  2");
                }

             }
             catch (Exception e)
             {
                Debug.Log("Failed to clientSocket error." + e);
                clientSocket.Close();
                break;
             }
        }
    }    

    private void SplitPackage(byte[] bytes , int index)
    {
        //在这里进行拆包，因为一次返回的数据包的数量是不定的
        //所以需要给数据包进行查分。
        while(true)
        {
            //包头是2个字节
            byte[] head = new byte[2];
            int headLengthIndex = index + 2;
            //把数据包的前两个字节拷贝出来
            Array.Copy(bytes,index,head,0,2);
            //计算包头的长度
            short length = BitConverter.ToInt16(head,0);
            //当包头的长度大于0 那么需要依次把相同长度的byte数组拷贝出来
            if(length > 0)
            {
                byte[] data = new byte[length];
                //拷贝出这个包的全部字节数
                Array.Copy(bytes,headLengthIndex,data,0,length);
                //把数据包中的字节数组强制转换成数据包的结构体
                //BytesToStruct()方法就是用来转换的
                //这里需要和你们的服务端程序商量，
                JFPackage.WorldPackage wp = new JFPackage.WorldPackage();
                wp = (JFPackage.WorldPackage)BytesToStruct(data,wp.GetType());
                //把每个包的结构体对象添加至链表中。
                worldpackage.Add(wp);
                //将索引指向下一个包的包头
                index  =  headLengthIndex + length;

            }else
            {
                //如果包头为0表示没有包了，那么跳出循环
                break;
            }
        }
    }    

    //向服务端发送一条字符串
    //一般不会发送字符串 应该是发送数据包
    public void SendMessage(string str)
    {
         byte[] msg = Encoding.UTF8.GetBytes(str);

        if(!clientSocket.Connected)
        {
            clientSocket.Close();
            return;
        }
        try
        {
            //int i = clientSocket.Send(msg);
            IAsyncResult asyncSend = clientSocket.BeginSend (msg,0,msg.Length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);
            bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );
            if ( !success )
               {
                  clientSocket.Close();
                Debug.Log("Failed to SendMessage server.");
            }
        }
        catch
        {
             Debug.Log("send message error" );
        }
    }

    //向服务端发送数据包，也就是一个结构体对象
    public void SendMessage(object obj)
    {

        if(!clientSocket.Connected)
        {
            clientSocket.Close();
            return;
        }
        try
        {
            //先得到数据包的长度
            short size = (short)Marshal.SizeOf(obj);
            //把数据包的长度写入byte数组中
            byte [] head = BitConverter.GetBytes(size);
            //把结构体对象转换成数据包，也就是字节数组
            byte[] data = StructToBytes(obj);

            //此时就有了两个字节数组，一个是标记数据包的长度字节数组， 一个是数据包字节数组，
            //同时把这两个字节数组合并成一个字节数组

            byte[] newByte = new byte[head.Length + data.Length];
            Array.Copy(head,0,newByte,0,head.Length);
            Array.Copy(data,0,newByte,head.Length, data.Length);

            //计算出新的字节数组的长度
            int length = Marshal.SizeOf(size) + Marshal.SizeOf(obj);

            //向服务端异步发送这个字节数组
            IAsyncResult asyncSend = clientSocket.BeginSend (newByte,0,length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);
            //监测超时
            bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );
            if ( !success )
               {
                  clientSocket.Close();
                Debug.Log("Time Out !");
            } 

        }
        catch (Exception e)
        {
             Debug.Log("send message error: " + e );
        }
    }

    //结构体转字节数组
    public byte[] StructToBytes(object structObj)
    {

        int size = Marshal.SizeOf(structObj);
        IntPtr buffer =  Marshal.AllocHGlobal(size);
        try
          {
              Marshal.StructureToPtr(structObj,buffer,false);
            byte[]  bytes  =   new byte[size];
            Marshal.Copy(buffer, bytes,0,size);
            return   bytes;
          }
          finally
          {
              Marshal.FreeHGlobal(buffer);
          }
    }
    //字节数组转结构体
    public object BytesToStruct(byte[] bytes,   Type   strcutType)
    {
        int size = Marshal.SizeOf(strcutType);
        IntPtr buffer = Marshal.AllocHGlobal(size);
          try
         {
                Marshal.Copy(bytes,0,buffer,size);
               return  Marshal.PtrToStructure(buffer,   strcutType);
          }
        finally
          {
              Marshal.FreeHGlobal(buffer);
          }   

    }

    private void sendCallback (IAsyncResult asyncSend)
    {

    }

    //关闭Socket
    public void Closed()
    {

        if(clientSocket != null && clientSocket.Connected)
        {
            clientSocket.Shutdown(SocketShutdown.Both);
            clientSocket.Close();
        }
        clientSocket = null;
    }

}

为了与服务端达成默契，判断数据包是否完成。我们需要在数据包中定义包头 ，包头一般是这个数据包的长度，也就是结构体对象的长度。正如代码中我们把两个数据类型 short 和 object 合并成一个新的字节数组。

 

然后是数据包结构体的定义，需要注意如果你在做IOS和Android的话数据包中不要包含数组，不然在结构体转换byte数组的时候会出错。

Marshal.StructureToPtr () error : Attempting to JIT compile method

 

JFPackage.cs

 

using UnityEngine;
using System.Collections;
using System.Runtime.InteropServices;

public class JFPackage
{
    //结构体序列化
    [System.Serializable]
    //4字节对齐 iphone 和 android上可以1字节对齐
    [StructLayout(LayoutKind.Sequential, 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;
         }

    };  

}

让角色发生移动的时候，调用该方法向服务端发送数据。

 

 

void SendPlayerWorldMessage()
{
                //组成新的结构体对象，包括主角坐标旋转等。
     Vector3 PlayerTransform = transform.localPosition;
     Vector3 PlayerRotation = transform.localRotation.eulerAngles;
                //用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;
     JFPackage.WorldPackage wordPackage = new JFPackage.WorldPackage(px,py,pz,rx,ry,rz,equipID,animationID,hp);
                //通过Socket发送结构体对象
     mJFsorket.SendMessage(wordPackage);
}

 

接着就是客户端同步服务器的数据，目前是测试阶段所以写的比较简陋，不过原理都是一样的

 

 

//上次同步时间
      private float mSynchronous;

void Update ()
{

    mSynchronous +=Time.deltaTime;
    //在Update中每0.5s的时候同步一次
    if(mSynchronous > 0.5f)
    {
        int count = mJFsorket.worldpackage.Count;
        //当接受到的数据包长度大于0 开始同步
        if(count > 0)
        {
                               //遍历数据包中 每个点的坐标
            foreach(JFPackage.WorldPackage wp in mJFsorket.worldpackage)
            {
                float x = (float)(wp.mPosx / 100.0f);
                float y = (float)(wp.mPosy /100.0f);
                float z = (float)(wp.mPosz /100.0f);

                Debug.Log("x = " + x + " y = " + y+" z = " + z);
                  //同步主角的新坐标
                mPlayer.transform.position = new Vector3 (x,y,z);
            }
                               //清空数据包链表
            mJFsorket.worldpackage.Clear();
        }
        mSynchronous = 0;
    }
}

 

单个移动同步包实现了，我了个去

 

 

用到的一些网络传输时数据转换的函数
对于现在的网络世界，Tcp协议是经常用到的协议，Tcp可以确保网络传输数据的有序性，可靠性，那么你的工作就更加简单了，只需要经文件转换为字节数组，送到网络传输，有接收方把收到的字节组装起来就可以了。
      下面说一下将各种数据类型转换为字节数组的方法：
      BitConverter类可以将数值型数据转换为字节数组，同样可以将字节数组装换位数值。
     //把test转化为byte[]
 int test = 1990;
   byte[] data = BitConverter.GetBytes(test);


     //将byte[]转换为Int16

  int test=BitConverter.ToInt16(byte[] data, int offset);


       说明：BitConverter类存在ToString（），但是使用它的结果，可能同你预想的不同。
   //

string data = "this is a test";
string test = BitConverter.ToString(Encoding.ASCII.GetBytes(data));
Console.WriteLine("data = '{0}'", data);
Console.WriteLine("test = '{0}'", test);

结果：
C:\>test
data = 'this is a test'
test = '74-68-69-73-20-69-73-20-61-20-74-65-73-74'
C:\>
       BitConvert.ToString()是把字节数组中的值用16进制显示出来，所以如果要显示文本，要用Encoding.ASCII.GetString（）方法。

       如果在2台基于Intel处理器，Ms Windows操作系统的机器上传送数值型数据，那么是没有问题的；但是如果传送给其他计算机，就不见得没有问题。
因为BitConvert.GetBytes（）方法是把数值转换为字节并按照一定次序放入数组,这个次序同处理器和操作系统有关。
这个问题同CPU存储二进制数据不同有关,字节数组的存储有2种形式：
低位优先：先存放不重要的数据
高位优先：先存放重要的数据
所以对于相同系统的计算机，处理数值型字节数组没有问题，而对于不同系统的计算机，就会带来问题。
//

using System;
using System.Net;
using System.Text;
class BinaryDataTest
{
public static void Main()
{
int test1 = 45;
double test2 = 3.14159;
int test3 = -1234567890;
bool test4 = false;
byte[] data = new byte[1024];
string output;
data = BitConverter.GetBytes(test1);
output = BitConverter.ToString(data);
Console.WriteLine("test1 = {0}, string = {1}", test1, output);
data = BitConverter.GetBytes(test2);
output = BitConverter.ToString(data);
Console.WriteLine("test2 = {0}, string = {1}", test2, output);
data = BitConverter.GetBytes(test3);
output = BitConverter.ToString(data);
Console.WriteLine("test3 = {0}, string = {1}", test3, output);
data = BitConverter.GetBytes(test4);
output = BitConverter.ToString(data);
Console.WriteLine("test4 = {0}, string = {1}", test4, output);
}
}


结果：
C:\>BinaryDataTest
test1 = 45, string = 2D-00-00-00
test2 = 3.14159, string = 6E-86-1B-F0-F9-21-09-40
test3 = -1234567890, string = 2E-FD-69-B6
test4 = False, string = 00
C:\>
        可以看到，执行这个程序的计算机是低位优先的，因为字节放入数组的次序是先0，后2D，先存放的是不重要的数据;如果是高位优先的系统，那么应该是00-00-00-2D。 
        这个问题在Unix世界非常明显，因为运行Unix系统的计算机种类非常多，你不能保证本机处理数值型数据同远程计算机相同。
解决办法：使用相同类型的存储格式传输数值型数据。
网络字节顺序，即高位优先的定义，要求所有网络传输的数值型数据都要按照相同标准。这样，即使不同平台的计算机也可以通过网络互相交换数值型数据而不会有错误。
       .Net 提供了HostToNetworkOrder（）可以将本机的数值型数据的数组格式转换为网络字节顺序。
NetworkToHost（）可以把网络字节顺序的数组转换为本机数值型数据字节数据。
//

using System;
using System.Net;
using System.Text;
class BinaryNetworkByteOrder
{
public static void Main()
{
short test1 = 45;
int test2 = 314159;
long test3 = -123456789033452;
byte[] data = new byte[1024];
string output;
data = BitConverter.GetBytes(test1);
output = BitConverter.ToString(data);
Console.WriteLine("test1 = {0}, string = {1}", test1, output);
data = BitConverter.GetBytes(test2);
output = BitConverter.ToString(data);
Console.WriteLine("test2 = {0}, string = {1}", test2, output);
data = BitConverter.GetBytes(test3);
output = BitConverter.ToString(data);
Console.WriteLine("test3 = {0}, string = {1}", test3, output);
short test1b = IPAddress.HostToNetworkOrder(test1);
data = BitConverter.GetBytes(test1b);
output = BitConverter.ToString(data);
Console.WriteLine("test1 = {0}, nbo = {1}", test1b, output);
int test2b = IPAddress.HostToNetworkOrder(test2);
data = BitConverter.GetBytes(test2b);
output = BitConverter.ToString(data);
Console.WriteLine("test2 = {0}, nbo = {1}", test2b, output);
long test3b = IPAddress.HostToNetworkOrder(test3);
data = BitConverter.GetBytes(test3b);
output = BitConverter.ToString(data);
Console.WriteLine("test3 = {0}, nbo = {1}", test3b, output);
}
}


//
C:\>BinaryNetworkByteOrder
test1 = 45, string = 2D-00
test2 = 314159, string = 2F-CB-04-00
test3 = -123456789033452, string = 14-CE-F1-79-B7-8F-FF-FF
test1 = 11520, nbo = 00-2D
test2 = 801833984, nbo = 00-04-CB-2F
test3 = 1499401231033958399, nbo = FF-FF-8F-B7-79-F1-CE-14
C:\>

       构造函数是特殊的方法，用在建立对象后初始化时。当建立引用类型的对象时，如果你不显式建立构造函数，系统也会建立一个默认的构造函数。