unity的tcp和udp

近來有需求如下：局域網內兩個人合作拆裝一個東西，比如汽車引擎。於是開始學習socket通信。還好網上這個教程已經很多了，整理了一下自己拿過來用了。
最開始用的是UDP，因爲想着客戶端A做了什麼直接扔給服務器然後服務器再扔給客戶端B（反過來也一樣）就完事了。
udp客戶端和服務器端的基類：

using UnityEngine;

public abstract class BaseUDP : MonoBehaviour {

    public abstract void InitSocket();
    public abstract void SocketSend(string sender);
    public abstract void SocketReceive();
}

服務器端：

using UnityEngine;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using LitJson;
using System.Collections.Generic;
using UnityEngine.UI;
using HoloMax;
public class UDPServer : BaseUDP
{
    /// <summary>
    /// 設置服務器IP
    /// </summary>
    public string ipAddress;
    /// <summary>
    /// 服務器偵聽端口
    /// </summary>
    public int ConnectPort;
    /// <summary>
    /// 服務器接收到的消息
    /// </summary>
    public string recvStr=null;
    /// <summary>
    /// 服務器接收到的IP和端口信息，記錄下來
    /// </summary>
    private List<EndPoint> mEndPoint = null;
    /// <summary>
    /// 聲明套接字
    /// </summary>
    private Socket socket;
    /// <summary>
    /// 客戶端地址
    /// </summary>
    private EndPoint clientEnd;
    /// <summary>
    /// 服務器端地址
    /// </summary>
    private IPEndPoint ipEnd;
    /// <summary>
    /// 服務器發送的消息
    /// </summary>
    private string sendStr;
    /// <summary>
    /// 接收和發送消息字節流
    /// </summary>
    byte[] recvData = new byte[1024];
    byte[] sendData = new byte[1024];
    /// <summary>
    /// 接收消息的長度
    /// </summary>
    private int recvLen;
    /// <summary>
    /// 偵聽客戶端的線程
    /// </summary>
    private Thread connectThread;
    public Text mInfo;
    private Dictionary<string, EndPoint> mClients=new Dictionary<string, EndPoint>();
    //初始化
    public override void InitSocket()
    {
        //用指定的端口和地址初始化IPEndPoint實例
        ipEnd = new IPEndPoint(IPAddress.Parse(ipAddress), ConnectPort);
        //初始化socket（AddressFamily.InterNetwork，指定socket的尋址方案是IPV4）
        //SocketType.Dgram   支持數據報，即最大長度固定（通常很小）的無連接、不可靠消息
        socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        socket.Bind(ipEnd);
        //定義客戶端
        IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
        clientEnd = (EndPoint)sender;
        print("等待連接數據");
        //開啓一個線程連接
        connectThread = new Thread(new ThreadStart(SocketReceive));
        connectThread.Start();
    }
    //服務器發送消息
    public override void SocketSend(string sendStr)
    {
        sendData = new byte[1024];
        sendData = Encoding.UTF8.GetBytes(sendStr);
        foreach (var item in mClients)
        {
            if (item.Key!=clientEnd.ToString())
            {
                socket.SendTo(sendData, sendData.Length, SocketFlags.None, item.Value);
                Debug.Log("發送" + sendStr + "給" + item.ToString());
            }
        }
    }
    //服務器接收
    public override void SocketReceive()
    {
        while (true)
        {
            recvData = new byte[1024];
            recvLen = socket.ReceiveFrom(recvData, ref clientEnd);
            recvStr = Encoding.UTF8.GetString(recvData, 0, recvLen);
            Debug.Log("服務器接收到的："+recvStr);
            Debug.Log(clientEnd.ToString());
            if (mClients==null||!mClients.ContainsKey(clientEnd.ToString()))
            {
                mClients.Add(clientEnd.ToString(), clientEnd);
            }
            SocketSend(recvStr);

        }
    }
   
    //連接關閉
    void SocketQuit()
    {
        //關閉線程
        if (connectThread != null)
        {
            connectThread.Interrupt();
            connectThread.Abort();
        }
        //最後關閉socket
        if (socket != null)
            socket.Close();
        Debug.LogWarning("斷開連接");
    }

    // 這裏是用配表的方式來加載ip和端口
    void Start()
    {
        TableManager.Self.SetTable();
        Record record1 = TableManager.mApplicationTable["IP"];
        ipAddress = record1["Value"];
        Record record2 = TableManager.mApplicationTable["Port"];
        ConnectPort = record2.GetCell("Value");
        InitSocket(); //在這裏初始化server
    }
    private void Update()
    {
        //用來顯示接收到的消息
        mInfo.text = recvStr;
    }
    //應用退出時socket也要關閉
    void OnApplicationQuit()
    {
        SocketQuit();
    }
   
}

客戶端：

using UnityEngine;
using System.Collections;
using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using LitJson;
using HoloMax;
public class UDPClient : BaseUDP
{
    /// <summary>
    /// 客戶端接收到的信息
    /// </summary>
    public string mRecvStr;
    /// <summary>
    /// 服務器端IP
    /// </summary>
    private string mUDPServerIP;
    //服務器端監聽端口
    private int mUDPServerPort;
    /// <summary>
    /// 要發送的信息
    /// </summary>
    private string mSendStr = "";
    /// <summary>
    /// socket
    /// </summary>
    private Socket socket;
    /// <summary>
    /// 服務器端地址
    /// </summary>
    private EndPoint serverEnd;
    private IPEndPoint ipEnd;
    //接收信息和發送信息的緩衝字節區
    private byte[] recvData = new byte[1024];
    private byte[] sendData = new byte[1024];
    //接收信息長度
    private int recvLen = 0;
    //接收信息的線程
    private Thread connectThread;

    void Start()
    {
        Record record1 = TableManager.mApplicationTable["IP"];
        mUDPServerIP = record1["Value"];
        Record record2 = TableManager.mApplicationTable["Port"];
        mUDPServerPort = record2["Value"];
        mUDPServerIP = mUDPServerIP.Trim();
        InitSocket();
    }

    public override void InitSocket()
    {
        ipEnd = new IPEndPoint(IPAddress.Parse(mUDPServerIP),mUDPServerPort );
        socket = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0);
        serverEnd = (EndPoint)sender;
        print("等待連接");
        SocketSend(mSendStr);
        print("連接");
        //開啓一個線程連接
        connectThread = new Thread(new ThreadStart(SocketReceive));
        connectThread.Start();
    }
    public override void SocketSend(string sendStr)
    {
        //清空
        sendData = new byte[1024];
        //數據轉換
        sendData = Encoding.UTF8.GetBytes(sendStr);
        //發送給指定服務端
        socket.SendTo(sendData, sendData.Length, SocketFlags.None, ipEnd);
    }

    //接收服務器信息
    public override void SocketReceive()
    {
        while (true)
        {

            recvData = new byte[1024];
            try
            {
                recvLen = socket.ReceiveFrom(recvData, ref serverEnd);
            }
            catch (Exception e)
            {
            }

            print("信息來自: " + serverEnd.ToString());
            if (recvLen > 0)
            {
                mRecvStr = Encoding.UTF8.GetString(recvData, 0, recvLen);
                Controller.instance.s = mRecvStr;
            }


        }
    }

    //連接關閉
    void SocketQuit()
    {
        //關閉線程
        if (connectThread != null)
        {
            connectThread.Interrupt();
            connectThread.Abort();
        }
        //最後關閉socket
        if (socket != null)
            socket.Close();
    }
    void OnApplicationQuit()
    {
        SocketQuit();
    }
}

後來測試的時候發現了一個問題，客戶端A拖拽物體有時候和客戶端B的物體不一定能同步。。。。。。於是改用TCP。
TCP基類：

using UnityEngine;

public abstract class BaseTCP : MonoBehaviour {
    public abstract void InitSocket();
    public abstract void SocketSend(string sender);
    public abstract void SocketReceive();
    public abstract void SocketConnect();
}

服務器端：

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using HoloMax;
using System.Text;
using UnityEngine.UI;
public class TCPServer : BaseTCP {
    private Socket mServerSocket;
    private List<Socket> mClinetSockets=new List<Socket>();
    private IPEndPoint mIPEndPoint;
    private string mServerIPAddress;
    private int mServerPort;
    private string mRecvStr;
    private string mSendStr;
    private byte[] mRecvData = new byte[1024];
    private byte[] mSendData = new byte[1024];
    private int mRecvLength;
    private Thread mServerThread;
    public Text mText;
    /// <summary>
    /// 初始化socket，綁定IP和端口
    /// </summary>
    public override void InitSocket()
    {
        //監聽端口是mServerPort，監聽所有IP
        mIPEndPoint = new IPEndPoint(IPAddress.Any,mServerPort);
        //初始化一個socket，指定socket的尋址方案是IPV4，支持可靠雙向的字節流，協議類型是IPV4
        mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        //socket綁定一個地址
        mServerSocket.Bind(mIPEndPoint);
        //最大監聽數10個
        mServerSocket.Listen(10);
        mServerThread = new Thread(new ThreadStart(SocketConnect));
        mServerThread.Start();
    }

    public override void SocketReceive()
    {
        //SocketConnect();
        //while (true)
        //{
        //    mRecvData = new byte[1024];
        //    mRecvLength = mClinetSocket.Receive(mRecvData);
        //    if (mRecvLength==0)
        //    {
        //        SocketConnect();
        //        continue;
        //    }
        //    mRecvStr = Encoding.ASCII.GetString(mRecvData, 0, mRecvLength);
        //    print(mRecvStr);
        //    mSendStr = "來自服務器:" + mRecvStr;
        //    SocketSend(mSendStr);
            
        //}
    }
    /// <summary>
    /// 接收客戶端消息的線程
    /// </summary>
    /// <param name="obj">客戶端socket（線程只能傳遞object類型）</param>
    public void RecvMsg(object obj)
    {
        Socket client = obj as Socket;
        mRecvData = new byte[1024];
        IPEndPoint clinetPoint = client.RemoteEndPoint as IPEndPoint;
        try
        {
            while (true)
            {
                mRecvLength = client.Receive(mRecvData);
                mRecvStr = Encoding.ASCII.GetString(mRecvData, 0, mRecvLength);
                SocketSend(mRecvStr);
            }
        }
        catch (System.Exception)
        {
            throw;
        }
    }
    /// <summary>
    /// 給指定客戶端發送消息
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="socket"></param>
    public void SocketSend(string sender,Socket socket)
    {
        for (int i = 0; i < mClinetSockets.Count; i++)
        {
            if (mClinetSockets[i]!=socket)
            {
                try
                {
                    mSendData = new byte[1024];
                    mSendData = Encoding.ASCII.GetBytes(sender);
                    mClinetSockets[i].Send(mSendData);
                }
                catch (System.Exception)
                {

                    throw;
                }
            }
        }
    }
    /// <summary>
    /// 給所有客戶端傳遞消息
    /// </summary>
    /// <param name="sender"></param>
    public override void SocketSend(string sender)
    {
        for (int i = 0; i < mClinetSockets.Count; i++)
        {
            try
            {
                mSendData = new byte[1024];
                mSendData = Encoding.ASCII.GetBytes(sender);
                mClinetSockets[i].Send(mSendData);
            }
            catch (System.Exception)
            {
                throw;
            }
        }
       
    }
    /// <summary>
    /// 連接的線程，每接收到一個客戶端的socket就存入自己的列表然後開啓線程接收消息
    /// </summary>
    public override void SocketConnect()
    {

        while (true)
        {
            try
            {
                Socket client = mServerSocket.Accept();
                mClinetSockets.Add(client);
                IPEndPoint endPoint = client.RemoteEndPoint as IPEndPoint;
                print(endPoint.Address.ToString() + endPoint.Port.ToString());
                Thread recvThread = new Thread(RecvMsg);
                recvThread.Start(client);
            }
            catch (System.Exception)
            {
                throw;
            }
        }
    }
    /// <summary>
    /// 退出的時候要清空自己的表，關閉線程
    /// </summary>
    private void SocketQuit()
    {
        if (mClinetSockets.Count>0)
        {
            for (int i = 0; i < mClinetSockets.Count; i++)
            {
                mClinetSockets[i].Close();
            }
        }
        mClinetSockets.Clear();
        mServerSocket.Close();
        if (mServerThread!=null)
        {
            mServerThread.Interrupt();
            mServerThread.Abort();
        }
    }
    // Use this for initialization
    void Start () {
        TableManager.Self.SetTable();
        Record record1 = TableManager.mApplicationTable["IP"];
        mServerIPAddress = record1["Value"];
        Record record2 = TableManager.mApplicationTable["Port"];
        mServerPort = record2.GetCell("Value");
        InitSocket();
	}
    private void Update()
    {
        mText.text = mRecvStr;
    }
    private void OnApplicationQuit()
    {
        SocketQuit();
    }
}

客戶端：

using HoloMax;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
public class TCPClient : BaseTCP {
    private Socket mServerSocket;
    private Socket mClientSocket;
    private IPEndPoint mIPEndPoint;
    private string mServerIPAddress;
    private int mServerPort;
    private string mRecvStr;
    private string mSendStr;
    private byte[] mRecvData = new byte[1024];
    private byte[] mSendData = new byte[1024];
    private int mRecvLength;
    private Thread mRecvThread;
    public override void InitSocket()
    {
        mIPEndPoint = new IPEndPoint(IPAddress.Parse(mServerIPAddress), mServerPort);
        mRecvThread = new Thread(new ThreadStart(SocketReceive));
        mRecvThread.Start();
    }

    public override void SocketReceive()
    {
        SocketConnect();
        while (true)
        {
            mRecvData = new byte[1024];
            mRecvLength = mServerSocket.Receive(mRecvData);
            if (mRecvLength==0)
            {
                SocketConnect();
                continue;
            }
            mRecvStr = Encoding.ASCII.GetString(mRecvData, 0, mRecvLength);
            Controller.instance.s = mRecvStr;
        }
    }
    public override void SocketConnect()
    {
        if (mServerSocket != null)
        {
            mServerSocket.Close();
        }
        mServerSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        mServerSocket.Connect(mIPEndPoint);
        mRecvLength = mServerSocket.Receive(mRecvData);
        mRecvStr = Encoding.ASCII.GetString(mRecvData, 0, mRecvLength);
    }
    public override void SocketSend(string sender)
    {
        mSendData = new byte[1024];
        mSendData = Encoding.ASCII.GetBytes(sender);
        mServerSocket.Send(mSendData, mSendData.Length, SocketFlags.None);
    }
    void SocketQuit()
    {
        //關閉線程
        if (mRecvThread != null)
        {
            mRecvThread.Interrupt();
            mRecvThread.Abort();
        }
        //最後關閉服務器
        if (mServerSocket != null)
            mServerSocket.Close();
        print("diconnect");
    }
    // Use this for initialization
    void Start () {
        Record record1 = TableManager.mApplicationTable["IP"];
        mServerIPAddress = record1["Value"];
        Record record2 = TableManager.mApplicationTable["Port"];
        mServerPort = record2.GetCell("Value");
        InitSocket();
    }
    private void OnApplicationQuit()
    {
        SocketQuit();
    }

}

運行gif：

那一堆字符是自己寫的一個類，把物體的id和位置信息、角度信息、縮放信息封裝一下，好用litjson進行傳輸和解析

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObjectInfo {
    public string id;
    public string tx;
    public string ty;
    public string tz;
    public string qx;
    public string qy;
    public string qz;
    public string qw;
    public string sx;
    public string sy;
    public string sz;
    public ObjectInfo() { }
    public ObjectInfo(string id,Vector3 v3, Quaternion quaternion, Vector3 scale)
    {
        this.id = id;
        tx = v3.x.ToString();
        ty = v3.y.ToString();
        tz = v3.z.ToString();
        qx = quaternion.x.ToString();
        qy = quaternion.y.ToString();
        qz = quaternion.z.ToString();
        qw = quaternion.w.ToString();
        sx = scale.x.ToString();
        sy = scale.y.ToString();
        sz = scale.z.ToString();
    }
}

爲什麼都用string呢？因爲json不支持float類型的 。。。。。。支持double，但是呢同樣要轉型，索性都用string了。物體拖拽旋轉啥的腳本我就不貼了，篇幅太長了。