客户端链接和接收

我们先将一些服务器上面的代码转移到之前的ResLoadPrg项目里。服务器和客户端不同，不要让客户端依赖服务器的dll库。反过来可以。在开发阶段可以将一些公用的代码放到客户端里，然后使用Unity的Assembly Definition生成一个独立的dll库来让服务端的工程依赖上。

首先在Script文件夹里新建Net文件夹，将服务器工程的ByteArray.cs粘贴过来，在Net文件夹内新建Proto文件夹，将服务器工程的MsgBase.cs、MsgSecret.cs、ProtocolEnum.cs粘贴过来。

将MsgBase内添加上一些命名空间，并把剩下的报错注释掉

using ProtoBuf;
using System;
using UnityEngine;
using System.IO;

给ByteArray添加命名空间

using System;

如果想要消除一些CS8632警告，将相关可空类型的声明的上下文添加#nullable enable 和#nullable disable

如果是新工程，参考热更教程里面接入protobuf的方法，并且将服务器工程的SingletonPattern.cs和AES.cs转移到Unity里。

NetManager

在Net文件夹内新建NetManager

using SimpleServer.Net;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Net.Sockets;
using UnityEngine;

public class NetManager : SingletonPattern<NetManager>
{
    public enum NetEvent
    {
        ConnectSucc,
        ConnectFail, 
        Close
    }
    public string PublicKey { get; private set; } = "ATAOServer";
    public string SecretKey { get; private set; }

    private Socket m_Socket;
    private ByteArray m_ReadBuff;
    private string m_IP;
    private int m_Port;

    //链接状态
    private bool m_IsConnecting;
    private bool m_IsClosing;

    public delegate void NetEventListener(string str);
    private Dictionary<NetEvent,NetEventListener> m_ListenerDic = new Dictionary<NetEvent,NetEventListener>();
    /// <summary>
    /// 监听连接事件
    /// </summary>
    /// <param name="netEvent">网络</param>
    /// <param name="listener"></param>
    public void AddNetEventListener(NetEvent netEvent, NetEventListener listener)
    {
        if (m_ListenerDic.ContainsKey(netEvent))
        {
            m_ListenerDic[netEvent] += listener;
        }
        else
        {
            m_ListenerDic.Add(netEvent, listener);
        }
    }
    /// <summary>
    /// 移除连接事件的监听
    /// </summary>
    /// <param name="netEvent"></param>
    /// <param name="listener"></param>
    public void RemoveNetEventListener(NetEvent netEvent,NetEventListener listener)
    {
        if (m_ListenerDic.ContainsKey(netEvent))
        {
            m_ListenerDic[netEvent] -= listener;
            if (m_ListenerDic[netEvent] == null)
            {
                m_ListenerDic.Remove(netEvent);
            }
        }
    }
    void FirstEvent(NetEvent netEvent,string str)
    {
        if (m_ListenerDic.ContainsKey(netEvent))
        {
            m_ListenerDic[netEvent].Invoke(str);
        }
    }
    public void SetKey(string key)
	{
    	SecretKey = key;
	}
    /// <summary>
    /// 链接到服务器
    /// </summary>
    /// <param name="ip">服务器IP</param>
    /// <param name="port">服务器端口</param>
    public void Connect(string ip, int port)
    {
        if (m_Socket != null && m_Socket.Connected)
        {
            Debug.LogError("链接失败，和服务器已经链接了");
            return;
        }
        if (m_IsConnecting)
        {
            Debug.LogError("链接失败，正在和服务器链接中");
            return;
        }
        InitState();
        m_Socket.NoDelay = true;
        m_IsConnecting = true;
        m_Socket.BeginConnect(ip, port, ConnectCallback, m_Socket);
        m_IP = ip;
        m_Port = port;
    }
    /// <summary>
    /// 初始化链接状态
    /// </summary>
    void InitState()
    {
        m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        m_ReadBuff = new ByteArray();
        m_IsConnecting = false;
        m_IsClosing = false;
    }
    /// <summary>
    /// 链接回调
    /// </summary>
    /// <param name="ar">回调的状态</param>
    void ConnectCallback(IAsyncResult ar)
    {
        try
        {
            Socket socket = (Socket)ar.AsyncState;
            socket.EndConnect(ar);
            FirstEvent(NetEvent.ConnectSucc, "");
            m_IsConnecting = false;
            Debug.Log("Socket Connect Success");
            m_Socket.BeginReceive(m_ReadBuff.Bytes, m_ReadBuff.WriteIdx, m_ReadBuff.Remain, SocketFlags.None, ReceiveCallback, socket);
        }
        catch (SocketException se)
        {
            Debug.LogError("Socket Connect fail: " + se);
            m_IsConnecting = false;
        }
    }
    /// <summary>
    /// 接收数据回调
    /// </summary>
    /// <param name="ar">回调的状态</param>
    void ReceiveCallback(IAsyncResult ar)
    {
        try
        {
            Socket socket = (Socket)ar.AsyncState;
            int count = socket.EndReceive(ar);
            if(count <= 0)
            {
                //说明服务器已经关闭链接
                return;
            }
            m_ReadBuff.WriteIdx += count;
            OnReceiveData();
            if(m_ReadBuff.Remain < 8)
            {
                m_ReadBuff.MoveBytes();
                m_ReadBuff.ReSize(m_ReadBuff.Length * 2);
            }
            socket.BeginReceive(m_ReadBuff.Bytes,m_ReadBuff.WriteIdx,m_ReadBuff.Remain,SocketFlags.None, ReceiveCallback, socket);
        }
        catch (SocketException ex)
        {
			Debug.LogError("Socket ReceiveCallback fail: " + ex);
			CloseConnection();
        }
    }
    /// <summary>
    /// 对接收的数据进行处理
    /// </summary>
    void OnReceiveData()
    {

    }
}

在正式的游戏中，分为游戏服和目录服，客户端需要先链接一次目录服，从目录服中可以查看到游戏所有服务器的在线情况并且可以自主选服，客户端选择后需要再链接一次游戏服。选择游戏服后，还需要根据当前服务器的拥挤状况进行排队。

客户端使用异步链接，所以NetManager内需要声明IsConnecting和IsClosing状态。

使用客户端连接时，打开m_Socket.NoDelay = true;这代表着关闭C#TCP的Nagle算法，这意味着减少TCP延迟，但是增加TCP流量。

使用m_Socket.BeginConnect(ip, port, ConnectCallback, m_Socket);开始连接服务器，其中ConnectCallback是一个回调方法，具体是ConnectCallback(IAsyncResult ar)，IAsyncResult存储了异步操作的状态信息和用户所有的保存数据，我们最后传入的m_Socket也会被保存在里面

在ConnectCallback(IAsyncResult ar)回调方法内，使用(Socket)ar.AsyncState;来将BeginConnect最后传入的m_Socket转换出来，并且调用socket.EndConnect(ar);结束异步链接请求。注意，每次调用Socket.BeginConnect一定要有对应的socket.EndConnect，注意这里的EndConnet和Socket.Close不一样，后者会关闭连接并释放所有资源。

在ConnectCallback回调内使用Socket.BeginReceive(byte[] buffer, int offset, int size, SocketFlags.None, ReceiveCallback, object o);这个异步方法来获取传输的内容，和服务器不同的是，服务器用的都是同步方法Socket.Recerive，这里需要有一个获取内容的回调方法，也就是ReceiveCallback，它和ConnectCallback相同。

在ReceiveCallback(IAsyncResult ar)回调方法内，使用(Socket)ar.AsyncState;来将BeginReceive最后传入的m_Socket转换出来，并且调用socket.EndReceive(ar)结束异步接收内容的请求。注意，每次调用Socket.BeginReceive一定要有对应的socket.EndReceive。

链接有链接的回调，获取传输内容有获取传输内容的回调，因为这两步都是异步操作。

接着在ReceiveCallback(IAsyncResult ar)回调方法内，调用OnReceiveData函数来处理接收来的数据。这里就像服务器ServerSocket.ReadClient和ServerSocket.OnReceiveData的关系一样。但是要注意，服务器用的都是同步方法多路复用，而客户端这里用的都是异步方法，而且服务器使用ByteArray.CheckAndMoveBytes来重置readBuff，客户端这里直接使用ByteArray.MoveBytes，服务器使用while(true)循环来扩容，而客户端不需要此循环，因为在ReceiveCallback里面又调用了Socket.BeginReceive，自己本身就是递归无限循环的，当需要扩容时，每次递归扩容一下，早晚会达到要求的。