拆包一直是个硬伤呀，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;
    }

}

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- 
                       
                    
                    
 
                      




鲜花




握手




雷人




路过




鸡蛋