你知道的越多，你不知道的越多 🇨🇳🇨🇳🇨🇳
点赞再看，养成习惯，别忘了一键三连哦 👍👍👍
文章持续更新中 📝📝📝

通信该如何搭建？

服务器端：

1. 入口类（Program）：

static void Main(string[] args)
{//1. 构造网络服务类： NetServer net = new NetServer();//2. 调用初始化方法： net.Init();//3. 调用开始方法：net.Start();//4. 死循环处理指令的输入Run();//5. 当循环跳出关闭服务器 调用停止服务方法net.Stop();
}public static void Run()
{bool run = true;while (run){//1. 处理输入的指令 输入 Exit 指令会关闭服务器}
}

2. 网络服务器类（Net Server）：

public void Init()
{//1. 绑定一个IP与端口号：IPEndPoint ipPoint = new IPEndPoint(IP, Port);//2. 构造一个监听类：ServerListener = new TcpSocketListener(ipPoint);//3. 给监听类绑定一个Socket连接事件：ServerListener.SocketConnected += OnSocketConnected;
}public void Start()
{//1. 调用监听类开始方法：Log.Warning("Starting Listener...");ServerListener.Start();//2. 调用消息分发器类开始函数MessageDistributer>.Instance.Start(8);Log.Warning("NetService Started");
}public void Stop()
{//1. 调用监听类停止方法ServerListener.Stop();
}//监听类监听到了对象连接，最后执行此方法
private void OnSocketConnected(object sender, Socket e)
{//1. 获取连接的IP端地址 IPEndPoint clientIP = (IPEndPoint)e.RemoteEndPoint;//2. 构造一个 连接模型SocketAsyncEventArgs args = new SocketAsyncEventArgs();//3. 构造一个 NetSessionNetSession session = new NetSession();//4. 构造一个 连接类 NetConnectionNetConnection connection = new NetConnection()
}//传递给连接类的接收数据事件
void DataReceived(NetConnection sender, DataEventArgs e)
{//打印一条信息Log.WarningFormat("Client[{0}] DataReceived Len:{1}", e.RemoteEndPoint, e.Length);//1. 处理接收到的数据lock (sender.packageHandler){// 调用消息处理类的 接收数据方法sender.packageHandler.ReceiveData(e.Data, 0, e.Data.Length);}
}//传递给连接类的断开连接事件
void Disconnected(NetConnection sender, SocketAsyncEventArgs e)
{//打印一条信息Log.WarningFormat("Client[{0}] Disconnected", e.RemoteEndPoint);
}

3. 监听类（TCP Socket Listener）

private Socket m_ListenSocket;		//监听Socket
private SocketAsyncEventArgs args;  //连接的一种模型//构造函数
public TcpSocketListener(IPEndPoint endPoint)
{//1. 实例化连接模型args = new SocketAsyncEventArgs();//2. 加上监听事件，到监听到有对象连接会执行args.Completed += OnSocketAccepted; 
}public void Start()
{lock (this)	//加 Lock 是以为 此类会有多个客户端同时发起连接 {//1. 初始化Socket 绑定终端 然后 开始监听：m_ListenSocket.Listen(0);//2. 监听到有连接执行：BeginAccept(args);}        
}public void Stop()
{lock (this){if (listenerSocket == null)retutn；//1. 关闭监听套接字listenerSocket.Close();listenerSocket = null;}
}private void BeginAccept(SocketAsyncEventArgs args)
{//1. 制空 否则会报错 args.AcceptSocket = null;			//2. 得到监听到的对象m_ListenSocket.AcceptAsync(args); 
}//监听事件
private void OnSocketAccepted(object sender, SocketAsyncEventArgs e)
{//1. 获取或设置异步套接字操作的结果。SocketError error = e.SocketError; //容错处理if (e.SocketError == SocketError.OperationAborted) retutn；//2. 连接成功if (e.SocketError == SocketError.Success){//1. 获取到连接的套接字：Socket handler = e.AcceptSocket;//2. 执行连接事件：OnSocketConnected(handler);}lock (this){BeginAccept(e);	//达到循环监听}
}//连接事件
private void OnSocketConnected(Socket client)
{//1. 执行连接事件： SocketConnected?.Invoke(this, client);
}//定义连接事件 网络服务器类初始化时 将此事件进行了赋值
public event EventHandler SocketConnected;//析构函数 结束时
~TcpSocketListener()
{Dispose(false);
}//此类继承了 IDisposable 实现接口
public void Dispose()
{Dispose(true);//请求公共语言运行时不要调用指定对象的终结器。手动调用了Dispose释放资源，那么析构函数就是不必要的了，这里阻止GC调用析构函数GC.SuppressFinalize(this);
}//处理结束函数 bool 参数，防止 析构函数清理资源一次 之后 Dispose 又一次清理
private void Dispose(bool disposing)
{if (!this.disposed){if (disposing){Stop();if (args != null)args.Dispose();}disposed = true;}       
}

4. 连接类（Net Connection <泛型类 T > ）

/* 1. 对此类的介绍
每当监听类监听到有对象连接，执行了对应的事件，会构造一个当前类。
当前为泛型类 泛型 T 为 NetSession 类，此类缓存了连接对象的数据。
可以说是，每个连接的客户端都 对应了一个当前类，之后当前类会为客户端所服务。
*/
public class NetConnection
{// 定义 接收数据的回调 （委托）public delegate void DataReceivedCallback(NetConnection sender, DataEventArgs e);// 定义 断开连接的回调 （委托）public delegate void DisconnectedCallback(NetConnection sender, SocketAsyncEventArgs e);internal class State{public DataReceivedCallback dataReceived;			//接收数据委托变量public DisconnectedCallback disconnectedCallback;	//断开连接委托变量public Socket socket;}// 异步套接字操作private SocketAsyncEventArgs eventArgs;// 消息处理类对象public PackageHandler> packageHandler;// 存储玩家数据类的变量private T session;public T Session { get { return session; } }//构造函数public NetConnection(Socket socket, SocketAsyncEventArgs args, DataReceivedCallback dataReceived,DisconnectedCallback disconnectedCallback, T session){lock (this)	// 因为类对 SocketAsyncEventArgs 此类进行操作时候 必须要加Lock 否则会出现报错{//构造一个 消息处理器this.packageHandler = new PackageHandler>(this);State state = new State(){//1. 持有对构造方传递过来的值socket = socket,dataReceived = dataReceived,disconnectedCallback = disconnectedCallback}//1. 初始化eventArgs = new SocketAsyncEventArgs();//2. 对 eventArgs 进行赋值eventArgs.AcceptSocket = socket;			//连接的SocketeventArgs.Completed += ReceivedCompleted;	//添加接收数据事件eventArgs.UserToken = state;				//将 对象 缓存eventArgs.SetBuffer(new byte[64 * 1024],0, 64 * 1024);	//设置 接收字节缓冲区this.session = session;		//将类缓存//执行消息接收BeginReceive(eventArgs);	}}//接收消息方法private void BeginReceive(SocketAsyncEventArgs args){lock (this){//取得socketSocket socket = (args.UserToken as State).socket;//判断socket的连接状态if (socket.Connected){//开启异步请求，接收来自连接的数据args.AcceptSocket.ReceiveAsync(args);//当接收到了数据就会执行，此类构造时，赋值的接收数据事件}}}//接收数据事件    private void ReceivedCompleted(Object sender, SocketAsyncEventArgs args){// 判断接收到的字节数if (args.BytesTransferred == 0){CloseConnection(args); //Graceful disconnectreturn;}// 判断造成结果，是否成功if (args.SocketError != SocketError.Success){CloseConnection(args); //NOT graceful disconnectreturn;}//1. 取得 对象  【这里又是对 UserToken 的应用】State state = args.UserToken as State;//2. 构建一个接收到的字节数长度的字节数组Byte[] data = new Byte[args.BytesTransferred];//3. 将 args 对象的字节数组内的数据 复制到 dataArray.Copy(args.Buffer, args.Offset, data, 0, data.Length);//4. 执行接收到数据的事件OnDataReceived(data, args.RemoteEndPoint as IPEndPoint, state.dataReceived);//5. 达到循环接收BeginReceive(args);}//调用接收数据事件的方法  事件是网络服务器类 构造此类是 传递来的private void OnDataReceived(Byte[] data, IPEndPoint remoteEndPoint, DataReceivedCallback callback){callback(this, new DataEventArgs() { RemoteEndPoint = remoteEndPoint, Data = data, Offset =0, Length = data.Length  });}//断开连接的方法private void CloseConnection(SocketAsyncEventArgs args){//1. 从对象中获取到 Socket的对象	【这里就体现出 UserToken 这个属性的作用，当然不止这些】State state = args.UserToken as State;Socket socket = state.socket;try{socket.Shutdown(SocketShutdown.Both);	//禁止掉 Socket 的接收和发送}catch { } // throws if client process has already closed//2. 关闭socketsocket.Close();socket = null;//3. 去掉接收数据的事件，没有这步会出现报错args.Completed -= ReceivedCompleted; //MUST Remember This!//4. 执行断开连接的事件OnDisconnected(args, state.disconnectedCallback);}//断开连接的事件，第二个参数 在网络服务器类构造此类时传递的事件方法private void OnDisconnected(SocketAsyncEventArgs args, DisconnectedCallback callback){callback(this, args);}
}

5. 字节数组类（Data Event ARGs）

public class DataEventArgs : EventArgs
{public IPEndPoint RemoteEndPoint { get; set; }public Byte[] Data { get; set; }public Int32 Offset { get; set; }public Int32 Length { get; set; }
}

6. 消息包处理类（Package Handler）

public class PackageHandler
{// 字节数据缓冲区private MemoryStream stream = new MemoryStream(64 * 1024);//字节读取索引private int readOffset = 0;//接收 数据方法，调用者：网络服务器类public void ReceiveData(byte[] data,int offset,int count){//判断缓存区加上一定长度的数据会不会超过缓存的容量if(stream.Position + count > stream.Capacity){throw new Exception("PackageHandler write buffer overflow");}//1. 将数据写入到 缓冲区stream.Write(data, offset, count);//2. 解析消息包方法ParsePackage();}//数据包解析方法bool ParsePackage(){/*这里为什么要加 4，这个判断很关键因为第一次接收 读取索引为0，加4可以判断，数据最基本的长度，如果这个都没有，那么这个包就没必要解析*/if (readOffset + 4 < stream.Position){//1. 获取包内容的大小int packageSize = BitConverter.ToInt32(stream.GetBuffer(), readOffset);//2. 这里的 读取索引readOffset，感觉加没加都一样，根据整个方法代码，这个变量在这的作用为0//但是这步判断很重要，包大小 加 4 如果小于等于成立，说明消息包是完整的，可解if (packageSize + readOffset + 4 <= stream.Position){//3. 调用通过字节提取消息类Message.NetMessage message = UnpackMessage(stream.GetBuffer(), this.readOffset + 4, packageSize);if (message == null){throw new Exception("PackageHandler ParsePackage faild,invalid package");//容错处理}//4. 得到了 类，调用消息分发器传递该类，进行处理MessageDistributer.Instance.ReceiveMessage(this.sender, message);//5. 将读取索引加上 整条完整数据长度this.readOffset += (packageSize + 4);//6. 返回这个类，是为了再次判断是否，有粘包，分包处理return ParsePackage();}}//当消息接收处理过一次，读取索引必定大于0if (this.readOffset > 0){//1. 这里是获取可能存在没有其他不完整的数据long size = stream.Position - this.readOffset;//2. 如果这个小于，说明缓冲区还有数据if (this.readOffset < stream.Position){Array.Copy(stream.GetBuffer(), this.readOffset, stream.GetBuffer(), 0, stream.Position - this.readOffset);}//3. Reset Streamthis.readOffset = 0;stream.Position = size;stream.SetLength(size);}return true;//结束}//提取消息类public static Message.NetMessage UnpackMessage(byte[] packet,int offset,int length){Message.NetMessage message = null;using (MemoryStream ms = new MemoryStream(packet, offset, length)){message = ProtoBuf.Serializer.Deserialize(ms);}return message;}// -------- 客户端专用构造方式 --------public class PackageHandler : PackageHandler