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 \t -> \t 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("\n【拆包】=" + Encoding.Unicode.GetString(msgXY.MessageContent) + "\n");
 
                             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 + "\n\n\n\n");
 
                     continue;
                 }
                 catch
                 {
                     //異常處理
                 }
             }
         }
         #endregion