网 络 框 架

客户端

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using UnityEngine;
public class NetManager : Singleton<NetManager>
{
    public Socket m_Socket;  //客户端通讯类
    public byte[] Data = new byte[1024];//缓存
    public byte[] m_Stream = new byte[0];//流
    public Queue<byte[]> que = new Queue<byte[]>();//客户端队列用于保存流数据 ID和包
    public void Init()
    {
        //创建通讯类
        m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        //BeginConnect给服务器发信息127.0.0.1是本机ID，3000是服务器端口号
        m_Socket.BeginConnect("127.0.0.1", 3000, OnConnect, null);
    }

    private void OnConnect(IAsyncResult ar)
    {
        m_Socket.EndConnect(ar); //与BeginConnect成对出现
        //接受服务器发的数据
        m_Socket.BeginReceive(Data, 0, Data.Length, SocketFlags.None,OnReceive ,null);
    }
    private void OnReceive(IAsyncResult ar)
    {
        int len =m_Socket.EndReceive(ar);//接受数据长度
        if (len > 0)
        {
            byte[] data = new byte[len];//创建一个byte的数组，长度为传过来的数据长度
                                        //缓冲类，复制快(客户端发过来的缓存，从0获取，保存到data中，索引从0开始，data的长度)
            Buffer.BlockCopy(Data, 0, data, 0, len);
            //给流赋值，Concat中固定写保存的缓存变量
            m_Stream = m_Stream.Concat(data).ToArray();
            while (m_Stream.Length > 2)
            {
                ushort bodyLen = BitConverter.ToUInt16(m_Stream, 0);//获取包的长度
                int allLen = bodyLen + 2;//总长度需要加上ID长度和包的长度，所以加2，（理解不了死记即可）
                if (m_Stream.Length >= allLen)
                {
                    byte[] oneData = new byte[bodyLen];
                    Buffer.BlockCopy(m_Stream, 2, oneData, 0, bodyLen);//2是从第二位开始，因为包长占2位
                    que.Enqueue(oneData);
                    int syLen = m_Stream.Length - allLen;//获取剩余的包
                    if (syLen > 0)//如果里面有数据就运行
                    {
                        byte[] syBody = new byte[syLen];
                        Buffer.BlockCopy(m_Stream, allLen, syBody, 0, syLen);//arrLen是刚才解析完的
                        m_Stream = syBody;//重新给流赋值剩下的包
                    }
                    else
                    {
                        m_Stream = new byte[0];//如果没有数据就初始化
                        break;//跳出循环
                    }
                }
                else
                {
                    break;
                }
            }
            //等待接受数据，不写的话只能运行一次
            m_Socket.BeginReceive(Data, 0, Data.Length, SocketFlags.None, OnReceive, null); ;
        }
    }

    public void Send(int id, byte[] body)
    {
        byte[] head = BitConverter.GetBytes(id);//包头就是id
        byte[] len = BitConverter.GetBytes((ushort)(head.Length + body.Length));//整个包的长度
        //用于粘包，这里是把他们黏在一起，一个包有三个东西：包长+ID+数据
         //包长固定是2
        byte[] data = new byte[0];
        data = data.Concat(len).ToArray();//第一个是包长
        data = data.Concat(head).ToArray();//第二个是ID
        data = data.Concat(body).ToArray();//第三个是包的内容也就是数据，必须按顺序写
        m_Socket.BeginSend(data, 0, data.Length, SocketFlags.None, OnSend, null);
    }

    private void OnSend(IAsyncResult ar)
    {
        int len = m_Socket.EndSend(ar);//获取发送的长度
        //Console.WriteLine("服务器发送的长度" + len);
    }
    public void OnData()
    {
        if(que.Count>0)
        {
            byte[] oneData = que.Dequeue();
            int id = BitConverter.ToInt32(oneData, 0);//去掉包头后剩下ID和保存数据的包，0索引对应的就是ID
            byte[] body = new byte[oneData.Length - 4];//int类型是4个字节，所以长度减去4剩余的就是包的内容
            Buffer.BlockCopy(oneData, 4, body, 0, body.Length);//从第4位开始取值
            MessagerManager.Ins.Dispatch(id, body);//将传来的信息发出去，此处已经解析完成
        }
    }
}

服务器

using System;
using System.Net;
using System.Net.Sockets;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
namespace 服务器
{
    class YBNetManager:Singleton<YBNetManager>
    {
        public Socket m_Socket;  //定义一个服务器的通讯
        public List<Client> m_List = new List<Client>();  //定义一个保存客户端的集合，用于保存客户端数据
        public void Init()
        {
            //固定写法            添加互联网地址              通讯的类型（流）   通讯协议是TCP       
            m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //创建IP端点类能够被连接               任意地址       端口号（此处必须大于1024）
            IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Any,3000);
            m_Socket.Bind(iPEndPoint); //绑定给服务器固定地址和端口号  用于被连接
            m_Socket.Listen(100); //同时侦听最多100个，多余的派对等待
            m_Socket.BeginAccept(OnAccept, null);//等待客户端链接  BeginAccept是接收客户端发送的链接发送消息
            Console.WriteLine("服务器已启动...");
        }

        private void OnAccept(IAsyncResult ar)
        {
            //创建一个客户端
            Client client = new Client();
            client.socket = m_Socket.EndAccept(ar);//与服务器建立联系，获取通讯
            //                                      客户端的链接地址
            IPEndPoint iPEndPoint = client.socket.RemoteEndPoint as IPEndPoint;
            client.m_sreIP = iPEndPoint.Address + "" + iPEndPoint.Port; //客户端的IP
            Console.WriteLine(client.m_sreIP + "连接成功");
            //此处接受异步信息BeginReceive,数据，0索引开始，数据长度，           套接字标志，无    函数       客户端变量  
            client.socket.BeginReceive(client.Data, 0, client.Data.Length, SocketFlags.None, OnReceive, client);
            m_List.Add(client); //添加到集合
            m_Socket.BeginAccept(OnAccept, null);  //等待新的链接，如果此处不写，那么只接受一次，后面重复创建客户端的消息无效
        }

        private void OnReceive(IAsyncResult ar)
        {
            Client client = ar.AsyncState as Client; //将客户端类中的东西传过来
            int len = client.socket.EndReceive(ar);//接受数据长度
            if (len > 0)
            {
                byte[] data = new byte[len];//创建一个byte的数组，长度为传过来的数据长度
                //缓冲类，复制快(客户端发过来的缓存，从0获取，保存到data中，索引从0开始，data的长度)
                Buffer.BlockCopy(client.Data, 0, data, 0, len);
                //给流赋值，Concat中固定写保存的缓存变量
                client.m_Stream = client.m_Stream.Concat(data).ToArray();
                while (client.m_Stream.Length > 2)
                {
                    ushort bodyLen = BitConverter.ToUInt16(client.m_Stream, 0);//获取包的长度
                    int allLen = bodyLen + 2;//总长度需要加上ID长度和包的长度，所以加2，（理解不了死记即可）
                    if(client.m_Stream.Length>=allLen)
                    {
                        byte[] oneData = new byte[bodyLen];
                        Buffer.BlockCopy(client.m_Stream, 2, oneData,0, bodyLen);//2是从第二位开始，因为包长占2位
                        int id = BitConverter.ToInt32(oneData, 0);//去掉包头后剩下ID和保存数据的包，0索引对应的就是ID
                        byte[] body = new byte[oneData.Length - 4];//int类型是4个字节，所以长度减去4剩余的就是包的内容
                        Buffer.BlockCopy(oneData, 4, body, 0, body.Length);//从第4位开始取值
                        MessManager.Ins.Dispatch(id, body, client);//将传来的信息发出去，此处已经解析完成
                        int syLen = client.m_Stream.Length - allLen;//获取剩余的包
                        if(syLen>0)//如果里面有数据就运行
                        {
                            byte[] syBody = new byte[syLen];
                            Buffer.BlockCopy(client.m_Stream, allLen, syBody, 0, syLen);//arrLen是刚才解析完的
                            client.m_Stream = syBody;//重新给流赋值剩下的包
                        }
                        else
                        {
                            client.m_Stream = new byte[0];//如果没有数据就初始化
                            break;//跳出循环
                        }
                    }
                    else
                    {
                        break;
                    }
                }
                //等待接受数据，不写的话只能运行一次
                client.socket.BeginReceive(client.Data, 0, client.Data.Length, SocketFlags.None, OnReceive, client); ;
            }
            else //如果接受的长度为0，就运行离线操作，就是你客户端关闭的时候会运行
            {
                Console.WriteLine(client.m_sreIP + "已离线");
                m_List.Remove(client); //删除这个离线的客户端
                //此处离线的时候可以发送一个离线后客户端执行的操作（下线把自己的角色从别人的客户端删除）
                MessManager.Ins.Dispatch(MsgID.Ins.SC_LINE, client.m_sreIP);
            }
        }
        public void AllSend(int id,byte[]body)
        {
            foreach (var item in m_List)
            {
                Send(id, body, item);
            }
        }

        public void Send(int id, byte[] body, Client client)
        {
            byte[] head = BitConverter.GetBytes(id);//包头就是id
            byte[] len = BitConverter.GetBytes((ushort)(head.Length + body.Length));//整个包的长度
            //用于粘包，这里是把他们黏在一起，一个包有三个东西：包长+ID+数据
            //包长固定是2
            byte[] data = new byte[0];
            data = data.Concat(len).ToArray();//第一个是包长
            data = data.Concat(head).ToArray();//第二个是ID
            data = data.Concat(body).ToArray();//第三个是包的内容也就是数据，必须按顺序写
            client.socket.BeginSend(data, 0, data.Length, SocketFlags.None, OnSend, client);
        }

        private void OnSend(IAsyncResult ar)
        {
            Client client = ar.AsyncState as Client;
            int len = client.socket.EndSend(ar);//获取发送的长度
            //Console.WriteLine("服务器发送的长度" + len);
        }
    }
}

Client脚本

 class Client
    {
        public Socket socket;
        public string m_sreIP;
        public byte[] Data = new byte[1024];
        public byte[] m_Stream = new byte[0];
        
    }

MsgID是管理消息号的脚本