Unity丛林战争学习02_TCP_解决分包和黏包的问题

最新推荐文章于 2024-06-02 17:52:29 发布

菜大西瓜

最新推荐文章于 2024-06-02 17:52:29 发布

阅读量340

点赞数 1

文章标签： socket c#

本文链接：https://blog.csdn.net/qq_43455634/article/details/106153294

版权

1.分包和黏包
分包：当发送的消息过长时会出现分包的情况，即一个消息分多次接收。
黏包：当发送的消息过短时会出现黏包的情况，即多个消息合在一起接收。

2.导致的问题
分包：UTF-8 使用一至四个字节为每个字符编码，比如有一个字符有三个自己，它的一个字节被分包到了上一个包中，另外两个字节被分配到下一个包中，这样每接收一个包后使用System.Text.Encoding.UTF8.ToString之后，就会出现上一个包结尾出现乱码，下个包开头出现乱码的情况
黏包：接收方不知道一次提取多少个字节。

3.改进思路
思路：发送方每次发送消息的时候在消息前面加上一个int类型的数据，表示该消息的长度，接收方就可以根据该int数据进行提取后面对应长度，转换为字符串。

4.发送方（客户端）

定义下面这样一个类，给每一条消息前面加上长度信息（int）：

	class Message
	{
		public static byte[] PackageData(string message)
		{
			byte[] originalByte = Encoding.UTF8.GetBytes(message);
			byte[] sizeByte = BitConverter.GetBytes(originalByte.Length);
			return (sizeByte.Concat(originalByte).ToArray());
		}
	}

发送的时候就可以发送处理好的消息，即：

clientSocket.Send(Message.PackageData(sendMessage));

整个客户端代码：

Message类（处理消息：给消息前加上长度）

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace clientProject
{
	class Message
	{
		public static byte[] PackageData(string message)
		{
			byte[] originalByte = Encoding.UTF8.GetBytes(message);
			byte[] sizeByte = BitConverter.GetBytes(originalByte.Length);
			return (sizeByte.Concat(originalByte).ToArray());
		}
	}
}

Program.cs（对处理好的消息进行发送）

using System;
using System.Net.Sockets;
using System.Net;

namespace clientProject
{
	class Program
	{
		static void Main(string[] args)
		{
			//创建客户端套接字
			Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
			//连接服务器
			clientSocket.Connect(new IPEndPoint(IPAddress.Parse("192.168.137.1"), 13001));

			//接收服务器的一条消息
			byte[] messageRecieve = new byte[1024];
			int size = clientSocket.Receive(messageRecieve);
			string messageRecieveStr = System.Text.Encoding.UTF8.GetString(messageRecieve,0,size);
			Console.WriteLine(messageRecieveStr);

			//连续发送短包
			string sendMessage = null;
			for (int i=0;i<100;i++)
			{
				sendMessage = i.ToString();
			    clientSocket.Send(Message.PackageData(sendMessage));
			}


			Console.ReadKey();
			clientSocket.Close();
		}
	}
}

5.接收方（服务器端）

定义一个类，对接收的消息进行存储和解析：

	class Message
	{
		//存储接受到的数据
		byte[] data = new byte[1024];
		public byte[] Data
		{
			get { return data; }
			//set { data = value; }
		}
		//下一次应该从哪存放
		int startIndex = 0;
		public int StartIndex
		{
			get { return startIndex; }
			//set { startIndex = value; }
		}
		public void AddStartIndex(int num)
		{
			startIndex += num;
		}
		/// <summary>
		/// 返回剩余存储长度
		/// </summary>
		/// <returns></returns>
		public int GetRestLength()
		{
			return (data.Length - startIndex);
		}
		/// <summary>
		/// 解析消息，解析到一条完整的消息就输出，然后把后面的数据前移覆盖已输出的消息
		/// </summary>
		public void ParsingData()
		{

			while (true)
			{
				//data内容没有四个字节(标记的长度)
				if (startIndex <= 4) break;

				// 具体消息的内容长度
				int count = BitConverter.ToInt32(data, 0);

				//data内容包含一次发送的内容
				if (startIndex - 4 >= count)
				{
					//输出消息内容
					string str = Encoding.UTF8.GetString(data, 4, count);
					Console.WriteLine("从客户端发来：" + str);

					//把未输出的内容前移，计算startIndex
					Array.Copy(data, 4 + count, data, 0, startIndex - count);
					startIndex = startIndex - count - 4;
				}
				//data内容不及一次发送的内容
				else
				{
					break;
				}

			}
		}

在Program.cs里面，接收时，我们对消息进行存储：

clientSocket.BeginReceive(msg.Data, msg.StartIndex, msg.GetRestLength(), SocketFlags.None, RecieveMessage, clientSocket);

注：存储到Message类的对象的data里，StartIndex表示我应该存放的位置，也就是data存放内容的长度。

然后解析数据，对StartIndex进行更新：

msg.AddStartIndex(size);
msg.ParsingData();

整个代码：
Message类（对消息进行存储，根据标记好的长度输出消息，并用后面未输出的消息覆盖掉已输出的消息）

using System;
using System.Collections.Generic;
using System.Text;

namespace SeverProject
{
	class Message
	{
		//存储接受到的数据
		byte[] data = new byte[1024];
		public byte[] Data
		{
			get { return data; }
			//set { data = value; }
		}
		//下一次应该从哪存放
		int startIndex = 0;
		public int StartIndex
		{
			get { return startIndex; }
			//set { startIndex = value; }
		}
		public void AddStartIndex(int num)
		{
			startIndex += num;
		}
		/// <summary>
		/// 返回剩余存储长度
		/// </summary>
		/// <returns></returns>
		public int GetRestLength()
		{
			return (data.Length - startIndex);
		}
		/// <summary>
		/// 解析消息，解析到一条完整的消息就输出，然后把后面的数据前移覆盖已输出的消息
		/// </summary>
		public void ParsingData()
		{

			while (true)
			{
				//data内容没有四个字节(标记的长度)
				if (startIndex <= 4) break;

				// 具体消息的内容长度
				int count = BitConverter.ToInt32(data, 0);

				//data内容包含一次发送的内容
				if (startIndex - 4 >= count)
				{
					//输出消息内容
					string str = Encoding.UTF8.GetString(data, 4, count);
					Console.WriteLine("从客户端发来：" + str);

					//把未输出的内容前移，计算startIndex
					Array.Copy(data, 4 + count, data, 0, startIndex - count);
					startIndex = startIndex - count - 4;
				}
				//data内容不及一次发送的内容
				else
				{
					break;
				}

			}
		}

	}
}

Program.cs(接收消息后，存放到Message.data后面空白区域，即StartIndex索引处，调用解析方法，最后更新StarIndex)

using System;
using System.Net.Sockets;
using System.Net;


namespace SeverProject
{
    class Program
    {
        static Message msg = new Message();
        static byte[] messageRecieve = new byte[1024];
        static void Main(string[] args)
        {

            //创建服务器端套接字
            Socket severSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

            //绑定套接字
            IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Parse("192.168.137.1"), 13001);
            severSocket.Bind(iPEndPoint);

            //监听连接
            severSocket.Listen(0);

            //异步接受连接,返回客户端套接字
            //Socket clientSocket = severSocket.Accept();
            severSocket.BeginAccept(AcceptCallBack, severSocket);
            //暂停主线程
            Console.ReadKey();
        }
        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket severSocket = (Socket)ar.AsyncState;
            Socket clientSocket = severSocket.EndAccept(ar);


            //向客户端发送一条消息
            string message = "Hello Client";
            clientSocket.Send(System.Text.Encoding.UTF8.GetBytes(message));

            //异步接收消息
            clientSocket.BeginReceive(msg.Data, msg.StartIndex, msg.GetRestLength(), SocketFlags.None, RecieveMessage, clientSocket);
            //异步连接其他客户端
            severSocket.BeginAccept(AcceptCallBack, severSocket);

        }
        static void RecieveMessage(IAsyncResult ar)
        {

            Socket clientSocket = (Socket)ar.AsyncState;
           try
           {
                int size = clientSocket.EndReceive(ar);
                string recieveStr = System.Text.Encoding.UTF8.GetString(msg.Data, 0, size);
                if (recieveStr.Length == 0)
                    return;
                msg.AddStartIndex(size);
                msg.ParsingData();

                clientSocket.BeginReceive(msg.Data, msg.StartIndex, msg.GetRestLength(), SocketFlags.None, RecieveMessage, clientSocket);
            }
            catch (Exception e)
            {

                Console.WriteLine(e);
                clientSocket.Close();

            }

        }
    }
}