C#下利用封包、拆包原理解决Socket粘包、半包问题（新手篇）

介于网络上充斥着大量的含糊其辞的Socket初级教程，扰乱着新手的学习方向，我来扼要的教一下新手应该怎么合理的处理Socket这个玩意儿。
一般来说，教你C#下Socket编程的老师，很少会教你如何解决Socket粘包、半包问题。
更甚至，某些师德有问题的老师，根本就没跟你说过Socket的粘包、半包问题是什么玩意儿。
直到有一天，你的Socket程序在传输信息时出现了你预期之外的结果（多于的信息、不完整的信息、乱码、Bug等等）。
任你喊了一万遍“我擦”，依旧是不知道问题出在哪儿！
好了，不说废话了，进入正题，包教包会，学不会，送路费。
如果你读到这篇文章了，想必你已经遇到了以上问题，情况再理想一点儿，其实你在原理上已经知道怎么解决这个问题了，只是不知道怎么动手。
那么，首先，你需要新建一个【消息协议类】，这个类我们暂定由5大属性组成，分别是：
【（①=1个byte）（②=1个byte]）（③=1个int）（④=1个byte[]）（⑤=1个byte[]）】
解释一下这个【消息协议类】：
（①=1个byte）：这个属性占1个字节，可以放一个0到254的整数，我称作1号标志；
（②=1个byte）：这个属性占1个字节，可以放一个0到254的整数，我称作2号标志。那么1号标志和2号标志就有多达255×255个组合，我们用它来自定义这个消息的标志，比如，0-0表示登录请求消息，1-1表示物理攻击，1-2表示魔法攻击，3-3表示坐标移动；
（③=1个int）：这个属性占4个字节，可以放一个0到2147483647的整数，它表示（④=1个byte[]）的长度；
（④=1个byte[]）：这个属性存着你要发送的全部消息体字节，所以，你的消息体需要被转化为字节数组才可存放进去；
（⑤=1个byte[]）：这个属性存着【多余的消息体字节】。那么问题来了，什么是【多余的消息体字节】？休息一下继续往下看。
再解释一下这个【消息协议类】具体怎么用。
1，【消息发送方】先定义【消息协议类】①②属性，也就是随便写2个数；
2，【消息发送方】再将消息“装入”【消息协议类】的④属性，那么③属性就有了；
3，【消息发送方】将封装好的【消息协议类】转为byte[]，发送给【消息接收方】，我们把这道工序称作【封包】；
4，【消息接收方】接收到【消息发送方】发来的byte[]时，先判断这个byte[]长度是否大于6，即是否大于①属性+②属性+③属性的长度和，如果byte[]长度小于6，【消息接收方】就循环继续接收；
5，【消息接收方】接收到【消息发送方】发来的byte[]长度大于等于6了！！则将byte[]还原为【消息协议类】，为了区别，我们暂时把它为【新消息协议类】；
6，循环判断【消息发送方】发来的byte[]长度减去6之后的值是否大于等于【新消息协议类】的③的值。这个可以理解为byte[]是否为一个完整的【消息协议类】，如果是就把【新消息协议类】的④属性拆出来，就得到了一个刚刚好完整的消息，不多也不少。那么，我们就把这道工序称作【拆包】；
7，相信你已经反应过来⑤这个【多余的消息体字节】是干嘛用的了。上一步当中，如果byte[]信息刚好是一个完整长度自然用不到⑤了，但是在网络传输中byte[]自然不会永远那么刚好了，所以当byte[]长度大于一个完整消息时，就把多于的byte放入⑤当中，和下次新接收的byte[]组合在一起，再次进行这样的循环，保证数据的完整性和独立性。
8，好了，以上过程就是利用封包、拆包原理解决Socket粘包、半包问题，接下来你可以在发送方以非常频繁的发送频率来发送，接收方依然会规规矩矩完完整整的以正确的姿势来接收消息了。最下面是要点代码，相信聪明的你一定学会了，如果还没学会，可以加我QQ：119945778，包教包会，不然我还得送路费不是...
下面是源码时间：

     /// <summary>
     /// 【消息协议】=【协议一级标志】+【协议二级标志】+【实际消息长度】+【实际消息内容】+【多于消息内容】
     /// </summary>
     public class MessageXieYi
     {
         #region 自定义
         #region 协议一级标志，值 = (0 至 254 )
         private byte xieYiFirstFlag;
         /// <summary>
         /// 协议类别，值 = ( 0 直 254 )
         /// </summary>
         public byte XieYiFirstFlag
         {
             get { return xieYiFirstFlag; }
             set { xieYiFirstFlag = value; }
         }
         #endregion
 
         #region 协议二级标志，值 = (0 至 254 )
         private byte xieYiSecondFlag;
         /// <summary>
         /// 协议二级标志，值 = (0 至 254 )
         /// </summary>
         public byte XieYiSecondFlag
         {
             get { return xieYiSecondFlag; }
             set { xieYiSecondFlag = value; }
         }
         #endregion
 
         #region 实际消息长度
         private int messageContentLength;
         /// <summary>
         /// 实际消息长度
         /// </summary>
         public int MessageContentLength
         {
             get { return messageContentLength; }
             set { messageContentLength = value; }
         }
         #endregion
 
         #region 实际消息内容
         private byte[] messageContent = new byte[] { };
         /// <summary>
         /// 实际消息内容
         /// </summary>
         public byte[] MessageContent
         {
             get { return messageContent; }
             set { messageContent = value; }
         }
         #endregion
 
         #region 多余的Bytes
         private byte[] duoYvBytes;
         /// <summary>
         /// 多余的Bytes
         /// </summary>
         public byte[] DuoYvBytes
         {
             get { return duoYvBytes; }
             set { duoYvBytes = value; }
         }
 
         #endregion
         #endregion
 
         #region 构造函数两个
         public MessageXieYi()
         {
             //
         }
 
         public MessageXieYi(byte _xieYiFirstFlage, byte _xieYiSecondFlage, byte[] _messageContent)
         {
             xieYiFirstFlag = _xieYiFirstFlage;
             xieYiFirstFlag = _xieYiSecondFlage;
             messageContentLength = _messageContent.Length;
             messageContent = _messageContent;
         }
         #endregion
 
         #region MessageXieYi 转换为 byte[]
         /// <summary>
         /// MessageXieYi 转换为 byte[]
         /// </summary>
         /// <returns></returns>
         public byte[] ToBytes()
         {
             byte[] _bytes; //自定义字节数组，用以装载消息协议
 
             using (MemoryStream memoryStream = new MemoryStream()) //创建内存流
             {
                 BinaryWriter binaryWriter = new BinaryWriter(memoryStream); //以二进制写入器往这个流里写内容
 
                 binaryWriter.Write(xieYiFirstFlag); //写入协议一级标志，占1个字节
                 binaryWriter.Write(xieYiSecondFlag); //写入协议二级标志，占1个字节
                 binaryWriter.Write(messageContentLength); //写入实际消息长度，占4个字节
 
                 )
                 {
                     binaryWriter.Write(messageContent); //写入实际消息内容
                 }
 
                 _bytes = memoryStream.ToArray(); //将流内容写入自定义字节数组
 
                 binaryWriter.Close(); //关闭写入器释放资源
             }
 
             return _bytes; //返回填充好消息协议对象的自定义字节数组
         }
         #endregion
 
         #region byte[] 转换为 MessageXieYi
         /// <summary>
         /// byte[] 转换为 MessageXieYi
         /// </summary>
         /// <param name="buffer">字节数组缓冲器。</param>
         /// <returns></returns>
         public static MessageXieYi FromBytes(byte[] buffer)
         {
             int bufferLength = buffer.Length;
 
             MessageXieYi messageXieYi = new MessageXieYi();
 
             using (MemoryStream memoryStream = new MemoryStream(buffer)) //将字节数组填充至内存流
             {
                 BinaryReader binaryReader = new BinaryReader(memoryStream); //以二进制读取器读取该流内容
 
                 messageXieYi.xieYiFirstFlag = binaryReader.ReadByte(); //读取协议一级标志，读1个字节
                 messageXieYi.xieYiSecondFlag = binaryReader.ReadByte(); //读取协议二级标志，读1个字节
                 messageXieYi.messageContentLength = binaryReader.ReadInt32(); //读取实际消息长度，读4个字节                
 
                 //如果【进来的Bytes长度】大于【一个完整的MessageXieYi长度】
                 if ((bufferLength - 6) > messageXieYi.messageContentLength)
                 {
                     messageXieYi.messageContent = binaryReader.ReadBytes(messageXieYi.messageContentLength); //读取实际消息内容，从第7个字节开始读
                     messageXieYi.duoYvBytes = binaryReader.ReadBytes(bufferLength -  - messageXieYi.messageContentLength);
                 }
 
                 //如果【进来的Bytes长度】等于【一个完整的MessageXieYi长度】
                 if ((bufferLength - 6) == messageXieYi.messageContentLength)
                 {
                     messageXieYi.messageContent = binaryReader.ReadBytes(messageXieYi.messageContentLength); //读取实际消息内容，从第7个字节开始读
                 }
 
                 binaryReader.Close(); //关闭二进制读取器，是否资源
             }
 
             return messageXieYi; //返回消息协议对象
         }
         #endregion
     }
     /// <summary>
     /// 按照先后顺序合并字节数组类
     /// </summary>
     public class CombineBytes
     {
         /// <summary>
         /// 按照先后顺序合并字节数组，并返回合并后的字节数组。
         /// </summary>
         /// <param name="firstBytes">第一个字节数组</param>
         /// <param name="firstIndex">第一个字节数组的开始截取索引</param>
         /// <param name="firstLength">第一个字节数组的截取长度</param>
         /// <param name="secondBytes">第二个字节数组</param>
         /// <param name="secondIndex">第二个字节数组的开始截取索引</param>
         /// <param name="secondLength">第二个字节数组的截取长度</param>
         /// <returns></returns>
         public static byte[] ToArray(byte[] firstBytes, int firstIndex, int firstLength,  byte[] secondBytes, int secondIndex, int secondLength)
         {
             using (MemoryStream ms = new MemoryStream())
             {
                 BinaryWriter bw = new BinaryWriter(ms);
                 bw.Write(firstBytes, firstIndex, firstLength);
                 bw.Write(secondBytes, secondIndex, secondLength);
 
                 bw.Close();
                 bw.Dispose();
 
                 return ms.ToArray();
             }
         }
     }
 byte[] msgBytes = Encoding.Unicode.GetBytes("要发送的消息");
 MessageXieYi msgXY = , , msgBytes);
 networkStream.Write(msgXY.ToBytes(), , msgXY.ToBytes().Length);
         #region 线程执行体,接收消息
         /// <summary>
         /// 线程执行体,接收消息
         /// </summary>
         /// <param name="obj">传递给线程执行体的用户名，用以与用户通信</param>
         private void ThreadReceive(object obj)
         {
             //通过用户名找出已经保存在哈希表里的Socket
             Socket savedSocket = hashtable_UserNameToSocket[obj] as Socket;
 
             MessageXieYi msgXY = new MessageXieYi();
 
             ];//定义一个大小为64的缓冲区
             //byte[] receivedBytes = new byte[] { };
             byte[] newBuffer = new byte[] { };//大小可变的缓存器
 
             int receivedLength;
             int availableLength;//没什么实际意义，就是为了方便理解Socket传输机制
 
             while (true)
             {
                 try
                 {
                     buffer = ];
 
                     ; i < ; i++)
                     {
                         availableLength = savedSocket.Available;
 
                         Console.WriteLine("【循环判断有多少可读Bytes】savedSocket.Available[" + i + "]=" + availableLength);//没实际意义，就是来个直观感受Socket的原理
                     }
 
                     Console.WriteLine("【可变缓存器大小】newBuffer.Length=" + newBuffer.Length);
 
                     receivedLength = savedSocket.Receive(buffer);
 
                     Console.WriteLine("【接收到数据】buffer.Length=" + receivedLength);
 
                     newBuffer = CombineBytes.ToArray(newBuffer, , newBuffer.Length, buffer, , receivedLength);
 
                     Console.WriteLine("【将接收到的数据追加在newBuffer后】newBuffer.Length=" + newBuffer.Length);
 
                     )
                     {
                         Console.WriteLine("newBuffer.Length=" + newBuffer.Length + "< 6 	 -> 	 continue");
                         continue;
                     }
                     else //newBuffer.Length >= 6
                     {
                         //取msgXY包头部分
                         msgXY = MessageXieYi.FromBytes(newBuffer);
                         int firstFlag = msgXY.XieYiFirstFlag;
                         int secondFlag = msgXY.XieYiSecondFlag;
                         int msgContentLength = msgXY.MessageContentLength;
 
                         //判断去掉msgXY包头剩下的长度是否达到可以取包实质内容
                         ) >= msgContentLength)
                         {
                             Console.WriteLine() + "】>=【" + "包实质内容长度=" + msgContentLength + "】");
                             msgXY = null;
                             msgXY = MessageXieYi.FromBytes(newBuffer);
                             Console.WriteLine("
【拆包】=" + Encoding.Unicode.GetString(msgXY.MessageContent) + "
");
 
                             newBuffer = msgXY.DuoYvBytes;
                             Console.WriteLine("【剩余的newBuffer】newBuffer.Length=" + newBuffer.Length);
 
                             )
                             {
                                 msgXY = MessageXieYi.FromBytes(newBuffer);
                                 firstFlag = msgXY.XieYiFirstFlag;
                                 secondFlag = msgXY.XieYiSecondFlag;
                                 msgContentLength = msgXY.MessageContentLength;
                                 continue;
                             }
                             else
                             {
                                 break;
                             }
                         }
                     }
 
                     availableLength = savedSocket.Available;
                     Console.WriteLine("savedSocket.Available=" + availableLength + "



");
 
                     continue;
                 }
                 catch
                 {
                     //异常处理
                 }
             }
         }
         #endregion