socket 的连接粘包的问题

---恢复内容开始---html

 前边两个是服务器的 数组

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

namespace Socket1
{
    class Message
    {
        private byte[] data = new byte[1024];
        private int starIndex = 0;//剩余长度

        public byte[] Data { get => data; set => data = value; }
        public int StarIndex { get => starIndex; set => starIndex = value; }

        public int RemainSize//剩余空间大小
        {
            get { return data.Length - starIndex; }
        }
        public void AddCount(int count)//每次获得新的数据 就更新StartIndex
        {
            starIndex += count;
        }

        public void ReadMassage()
        {
            while (true)
            {
                if (StarIndex<=4)
                {
                    return;
                }
                int count = BitConverter.ToInt32(data, 0);//第一段数据的长度
                if (StarIndex-4>=count)
                {
                    string s= Encoding.UTF8.GetString(data,4,count);
                    Console.WriteLine("解析到一条数据"+s);

                    Array.Copy(data,count+4,data,0,StarIndex-4-count);
                    StarIndex -= (count + 4);
                }
                else
                {
                    break;
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;


namespace Socket1
{
    class Program
    {
        static void Main(string[] args)
        {
            StartServer();
            Console.ReadKey();
        }
        static void StartServer()
        {
            Socket server = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
            IPAddress ipAddress = IPAddress.Parse("127.0.0.1");
            IPEndPoint iPEndPoint = new IPEndPoint(ipAddress,1234);
            server.Bind(iPEndPoint);

            server.Listen(0);//开始监听

            //Socket clientSocket= server.Accept();

            server.BeginAccept(AcceptCallBack,server);
        }
        static void AcceptCallBack(IAsyncResult ar)
        {
            Socket server=ar.AsyncState as Socket;
            Socket clientSocket=server.EndAccept(ar);

            string msg = "恭喜你链接成功";
            byte[] data = Encoding.UTF8.GetBytes(msg);
            clientSocket.Send(data);

            //异步接收
            dataBuffer = new byte[1024];
            clientSocket.BeginReceive(message.Data, message.StarIndex,message.RemainSize , SocketFlags.None, ReceiveCallBack, clientSocket);
            server.BeginAccept(AcceptCallBack, server);
        }
        static Message message = new Message();
        static byte[] dataBuffer = new byte[1024];
        static void ReceiveCallBack(IAsyncResult ar)
        {
            //检测数据接收结束
            Socket clientSocket=null;
            try
            {
                clientSocket = ar.AsyncState as Socket;
                int count = clientSocket.EndReceive(ar);
                if (count==0)
                {
                    clientSocket.Close();
                    return;
                }
                message.AddCount(count);
                message.ReadMassage();
                clientSocket.BeginReceive(message.Data, message.StarIndex, message.RemainSize, SocketFlags.None, ReceiveCallBack, clientSocket);
            }
            catch (Exception e)
            {
                clientSocket.Close();
                Console.WriteLine(e.Message);
            }

            //重复接收
        }
    }
}

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

namespace 客户端1
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSokcet = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);

            clientSokcet.Connect(new IPEndPoint(IPAddress.Parse("127.0.0.1"),1234));

            byte[] data = new byte[1024];
            int count = clientSokcet.Receive(data);
            string msg = Encoding.UTF8.GetString(data, 0, count);
            System.Console.WriteLine(msg);

            //while (true)
            //{
            //    string s = Console.ReadLine();
            //    if (s == "a")
            //    {
            //        clientSokcet.Close();
            //        return;
            //    }
            //    clientSokcet.Send(Encoding.UTF8.GetBytes(s));
            //}
            for (int i = 0; i < 100; i++)
            {
                clientSokcet.Send(Message.GetByte(i.ToString()));
            }
            //数据的粘包


            Console.ReadKey();
        }
    }
}

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

namespace 客户端1
{
    class Message
    {
        public static byte[] GetByte(string data)
        {
            byte[] dataByte= Encoding.UTF8.GetBytes(data);//数据
            int dataLength= dataByte.Length;
            byte[] lengthBytes= BitConverter.GetBytes(dataLength);

            byte[] newByte=lengthBytes.Concat(dataByte).ToArray();

            return newByte;
        }
    }
}

 

一。这个是服务器服务器

建立一个socket 地址，传输方式（流的方式），协议类型
异步

本地ip地址的写法：
socket

绑定ip地址和端口号：
ide

监听：多少秒钟监听一次
持续监听：函数

 

 客户端的socket：
post

 

 给客户端发送消息：spa

 

 总的客户端发送消息：3d

 

 

 服务器接受：

 异步接受的方式
//字节类型，从头开始存，表明接收的长度，枚举类型的（接收和发送数据的行为），须要一个回调函数（一个方法），回调函数 的参数（把服务器给他传入）

 

回调方法接收的时候必须是这个类型的值

 

 转换数据类型

 

 

全部接收到数据的长度：

 

 存起来：

 

 每次接收完 再调用本身：

———————————————————————————————————————————

 二。这个号是客户端

 

 建立。连接：

接收：

 

穿消息给服务器断筋：

 

服务器能够重复接收客户端消息：

 

 

如何实现多个客户端连接服务器？

 

不用这个同步接收的方式，

改用异步接收：

还须要一个异步接收客户端消息方法：

 

 

 

 在方法里拿到服务器：

调用服务器里的结束，接收到的就是客户端：

 

 

 

同步接收消息

 

 

客户端发送消息的重复接收 连接的重负：

 

 接收消息是只有一个

 

 有时候对的：

 

 客户端关闭服务器错误的问题？

改正方式：

 

 

 

客户端非正常的关闭？？？
若是你输入的值等于某个数字的时候，关闭.

这样的话一直死循环：

也便是它一直还在这个地方，才一直循环

改正方法，若是接收的数据字节只有0个：

 

 

 

---恢复内容结束---

---恢复内容开始---

 

一。这个是服务器

建立一个socket 地址，传输方式（流的方式），协议类型

本地ip地址的写法：

绑定ip地址和端口号：

监听：多少秒钟监听一次
持续监听：

 

 客户端的socket：

 

 给客户端发送消息：

 

 总的客户端发送消息：

 

 

 服务器接受：

 异步接受的方式
//字节类型，从头开始存，表明接收的长度，枚举类型的（接收和发送数据的行为），须要一个回调函数（一个方法），回调函数 的参数（把服务器给他传入）

 

回调方法接收的时候必须是这个类型的值

 

 转换数据类型

 

 

全部接收到数据的长度：

 

 存起来：

 

 每次接收完 再调用本身：

———————————————————————————————————————————

 二。这个号是客户端

 

 建立。连接：

接收：

 

穿消息给服务器断筋：

 

服务器能够重复接收客户端消息：

 

 

如何实现多个客户端连接服务器？

 

不用这个同步接收的方式，

改用异步接收：

还须要一个异步接收客户端消息方法：

 

 

 

 在方法里拿到服务器：

调用服务器里的结束，接收到的就是客户端：

 

 

 

同步接收消息

 

 

客户端发送消息的重复接收 连接的重负：

 

 接收消息是只有一个

 

 有时候对的：

 

 客户端关闭服务器错误的问题？

改正方式：

 

 

 

客户端非正常的关闭？？？
若是你输入的值等于某个数字的时候，关闭.

这样的话一直死循环：

也便是它一直还在这个地方，才一直循环

改正方法，若是接收的数据字节只有0个：

 

 

应该是接收一百次，但是一次就接收完了

 这种只有TCp有的特征，发现你发的这个是小数据 就一次性了，就叫数据的粘包

 要解决这个问题：

发消息的时候，不发字节 发数组，把长度和数据一块儿放包里发送

 添加一个新类 专门处理这个消息：

把消息传进来，
先转换数据
再去得到他的长度，

把长度也转换为字节：

 

整数类型永远占用4个字节 

 再来一个数组把 数据长度 数组长度结合起来，（数组长度在前 数据在后）

 

 到客户端的时候就不直接发送tostring了，而是

 

服务器解析消息的时候也的改变

 服务器也添加新类：

 先解析前四个字节 再日后 而后
添加一个数组 接收一下：

一个新的方法，去解析粘包的数据，一直解析，直到发现接收的数组小于4，就不解析了
没有数据不解析了

 

转换数据类型为int类型，

从4的位置开始解析，

第一条信息就解析出来了

 

 把解析出来的第一条数据砍掉，放到一个新的数组里面去，
从数据的长度，加上四的长度：
复制剩余的长度=总长-4-第一条长

 

 添加属性：

剩余的长度的方法：
剩余长度=总长度-用过的长度：

每次得新的长度 ，加起来：

 

类写完 到服务器里更新

 不能用之前的解析了，

 

 存如这个数组里面

 

从哪里开始从 从已经存的长度开始存，
能存多长（还能存类的方法）

 

解析也饿的换：
首先更新message里面的数据，

再用法法

 

 

 

上边就是完整的了
  最难的就是这里了

 

---恢复内容结束---