[网络协议]unity 简易udp通信

UDP服务端代码?

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

public class Udp : MonoBehaviour
{
    public InputField inputField;
    void Start()
    {
        inputField = GameObject.Find("Canvas/ReceivePanel/InputField").GetComponent<InputField>();
        OpenServer();
    }
    public void OpenServer()
    {
        try
        {
            IPEndPoint ipPoint = new IPEndPoint(IPAddress.Any, 7777);
            Socket socketServer = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
            socketServer.Bind(ipPoint);

            Loom.RunAsync(() =>
            {
                Loom.QueueOnMainThread(delegate
                {
                    Thread th = new Thread(listen);
                    th.IsBackground = true;
                    th.Start(socketServer);
                });
            });
        }
        catch (Exception e)
        {
            throw;
        }
    }
    void listen(object o)
    {
        Socket socketWatch = o as Socket;
        byte[] by = new byte[1024];
        while (true)
        {
            IPEndPoint client = new IPEndPoint(IPAddress.Any, 0);
            EndPoint Remote = (EndPoint)(client);
            int len = socketWatch.ReceiveFrom(by,ref Remote);
            Loom.QueueOnMainThread(delegate
            {
                inputField.text +=Encoding.UTF8.GetString(by, 0, len)+"\n";
            });
        }
    }
} 

UDP客户端

using UnityEngine;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using System;
using System.Text;
using UnityEngine.UI;
public class UDPClient : MonoBehaviour
{
    public byte[] byteSendingArray;
    public EndPoint ep;
    public Socket socketClient;
    void Start()
    {
        byteSendingArray = new byte[100];
        IPEndPoint iep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 7777);
        socketClient = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);
        ep = (EndPoint)iep;
        String strMsg = "fghjklku法定规划";
        byteSendingArray = Encoding.UTF8.GetBytes(strMsg);
        socketClient.SendTo(byteSendingArray, ep);
    }
}

?Loom脚本：线程与unity主线程交互。

using UnityEngine;
using System.Collections.Generic;
using System;
using System.Threading;
using System.Linq;

public class Loom : MonoBehaviour
{
    public static int maxThreads = 8;
    static int numThreads;

    private static Loom _current;
    public static Loom Current
    {
        get
        {
            Initialize();
            return _current;
        }
    }

    void Awake()
    {
        _current = this;
        initialized = true;
    }

    static bool initialized;

    //####作为初始化方法自己调用，可在初始化场景调用一次即可
    public static void Initialize()
    {
        if (!initialized)
        {

            if (!Application.isPlaying)
                return;
            initialized = true;
        }
    }

    private List<Action> _actions = new List<Action>();
    public struct DelayedQueueItem
    {
        public float time;
        public Action action;
    }
    private List<DelayedQueueItem> _delayed = new List<DelayedQueueItem>();

    List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();

    public static void QueueOnMainThread(Action action)
    {
        QueueOnMainThread(action, 0f);
    }
    public static void QueueOnMainThread(Action action, float time)
    {
        if (time != 0)
        {
            if (Current != null)
            {
                lock (Current._delayed)
                {
                    Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action });
                }
            }
        }
        else
        {
            if (Current != null)
            {
                lock (Current._actions)
                {
                    Current._actions.Add(action);
                }
            }
        }
    }
    public static Thread RunAsync(Action a)
    {
        Initialize();
        while (numThreads >= maxThreads)
        {
            Thread.Sleep(1);
        }
        Interlocked.Increment(ref numThreads);
        ThreadPool.QueueUserWorkItem(RunAction, a);
        return null;
    }

    private static void RunAction(object action)
    {
        try
        {
            ((Action)action)();
        }
        catch
        {
        }
        finally
        {
            Interlocked.Decrement(ref numThreads);
        }
    }
    void OnDisable()
    {
        if (_current == this)
        {

            _current = null;
        }
    }
    List<Action> _currentActions = new List<Action>();
    // Update is called once per frame  
    void Update()
    {
        lock (_actions)
        {
            _currentActions.Clear();
            _currentActions.AddRange(_actions);
            _actions.Clear();
        }
        foreach (var a in _currentActions)
        {
            a();
        }
        lock (_delayed)
        {
            _currentDelayed.Clear();
            _currentDelayed.AddRange(_delayed.Where(d => d.time <= Time.time));
            foreach (var item in _currentDelayed)
                _delayed.Remove(item);
        }
        foreach (var delayed in _currentDelayed)
        {
            delayed.action();
        }
    }
}