C# Unity 网络通信

最近在学unity的网络游戏开发，分享下unity的TCP通信

客户端用的是Unity写的，服务端用的是C#的控制台程序。

客户端：应用了TCP的异步发送

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System;

public class Echo : MonoBehaviour
{

    Socket socket;
    public InputField inputField;
    public Text text;
    byte[] readBuff = new byte[1024];
    string recvStr = "";

    public void Connection()
    {
        socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        socket.BeginConnect("127.0.0.1", 8888,ConnectCallBack,socket);
    }

    private void ConnectCallBack(IAsyncResult ar)
    {
        try
        {
            Socket socket = (Socket)ar.AsyncState;
            socket.EndConnect(ar);
            print("Socket Connect Succes");
            socket.BeginReceive(readBuff, 0, 1024, 0, ReceiveCallBack, socket);
        }
        catch (SocketException e)
        {
            print(e.ToString() + "  出错了");
        }
    }

    private void ReceiveCallBack(IAsyncResult ar)
    {
        try
        {
            Socket socket = (Socket)ar.AsyncState;
            int count = socket.EndReceive(ar);
            string s = Encoding.UTF8.GetString(readBuff, 0, count);
            recvStr += s + "\n";
            socket.BeginReceive(readBuff, 0, 1024, 0, ReceiveCallBack, socket);
        }
        catch (SocketException e)
        {
            Debug.LogError(e.ToString());
            throw;
        }
    }

    public void SendMessage_My()
    {
        string sendStr = inputField.text;
        byte[] sendBytes = Encoding.UTF8.GetBytes(sendStr);
        for (int i = 0; i < 1; i++)
        {
            socket.BeginSend(sendBytes, 0, sendBytes.Length, 0, SendCallBack, socket);
        }
    }

    private void SendCallBack(IAsyncResult ar)
    {
        try
        {
            Socket socket = (Socket)ar.AsyncState;
            int count = socket.EndSend(ar);
            print("Socket Send Succes" + count);
        }
        catch (SocketException e)
        {
            Debug.LogError(e.ToString());
        }
    }

    void Update()
    {
        text.text = recvStr;
    }

    private void OnDisable()
    {
        socket.Close();
    }

    private void OnDestroy()
    {
        socket.Close();
    }

    private void OnApplicationQuit()
    {
        socket.Close();
    }

}

服务端：（高级货）多路复用Select：就是同时处理多路信号，比如同时检测多个Soket的状态，在设置要监听的Socket列表后，有一个（或多个）Socket可读（或可写，或发生错误信息），那就返回这些可读的Socket，如果没有可读的，那就阻塞。

Select方法是实现多路复用的关键，它的原型如下：

public static void Select(
    IList checkRead, 
    IList checkWrite, 
    IList checkError, 
    int microSeconds
);

Select服务端：

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;

namespace SeverOfUnity
{
    class Program
    {

        #region Select服务器
        static Dictionary<Socket, ClientState> clients = new Dictionary<Socket, ClientState>();
        static Socket listenfd;
        static void Main(string[] args)
        {
            //Console.WriteLine("Hello World!");

            listenfd = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            IPAddress ipAdr = IPAddress.Parse("127.0.0.1");
            IPEndPoint ipEp = new IPEndPoint(ipAdr, 8888);
            listenfd.Bind(ipEp);
            listenfd.Listen(0);
            Console.WriteLine("Server Connect");
            List<Socket> checkRead = new List<Socket>();
            //主循环
            while (true)
            {
                checkRead.Clear();
                checkRead.Add(listenfd);
                foreach (ClientState s in clients.Values)
                {
                    checkRead.Add(s.socket);
                }
                //Select
                Socket.Select(checkRead, null, null, 1000);
                //检查可读对象
                foreach (Socket s in checkRead)
                {
                    if (s == listenfd)
                    {
                        ReadListendfd(s);
                    }
                    else
                    {
                        ReadClientfd(s);
                    }
                }
            }

        }

        private static bool ReadClientfd(Socket clientfd)
        {
            ClientState state = clients[clientfd];
            //接收
            int count = 0;
            try
            {
                count = clientfd.Receive(state.readBuff);
            }
            catch (SocketException ex)
            {
                clientfd.Close();
                clients.Remove(clientfd);
                Console.WriteLine("Recevie SocketException" + ex.ToString());
                return false;
            }
            //客户端关闭
            if (count == 0)
            {
                clientfd.Close();
                clients.Remove(clientfd);
                Console.WriteLine("Socket Close");
                return false;
            }
            //广播 向每个连接的客户端发送消息
            string recvStr = Encoding.Default.GetString(state.readBuff, 0, count);
            Console.WriteLine("Recevie " + recvStr);
            string sendStr = clientfd.RemoteEndPoint.ToString() + ":" + recvStr;
            byte[] sendBytes = Encoding.Default.GetBytes(sendStr);
            foreach (ClientState cs in clients.Values)
            {
                cs.socket.Send(sendBytes);
            }
            return true;
        }

        private static void ReadListendfd(Socket listenfd)
        {
            Console.WriteLine("Accept");
            Socket clientfd = listenfd.Accept();
            ClientState state = new ClientState();
            state.socket = clientfd;
            clients.Add(clientfd, state);
        }

        #endregion
    }

    public class ClientState
    {
        public Socket socket;
        public byte[] readBuff = new byte[1024];
    }

}