Unity C#编写Socket服务器客户端功能代码及源文件

已于 2025-03-26 09:39:52 修改
阅读量894 收藏 7
点赞数 9
分类专栏： Socket 文章标签： unity c# 服务器
于 2024-07-23 11:05:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/ForKnowledgeMe/article/details/140628556
版权

文章目录

前言

unity中搭建简单的通讯功能一般采取Socket连接方式，下面是自己经常使用的功能代码，比较稳定可靠，代码贴出来一是为了分享，二是自己使用时也能够方便查找，忘记时可以看一下；
PS:抱着求是的态度把winform版本自己测试了一下，功能可用，源文件放文章最后了；

一、Socket介绍

所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议栈进行交互的接口

二、Unity使用步骤

1.创建单例模板

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

public class SingleTon<T> : MonoBehaviour where T : SingleTon<T>
{

    private static T instance;
    static readonly object mylock = new object();

    public static T GetInstance
    {
        get
        {

            if (instance == null)
            {

                lock (mylock)
                {
                    instance = FindObjectOfType(typeof(T)) as T;
                    if (instance == null)
                    {
                        GameObject obj = new GameObject();
                        obj.hideFlags = HideFlags.HideAndDontSave;
                        instance = (T)obj.AddComponent(typeof(T));

                    }
                }

            }
            return instance;

        }
    }
    protected virtual void Awake()
    {
        if (instance == null)
        {
            instance = (T)this;
        }
    }

    protected virtual void OnDestroy()
    {
        if (instance == this)
        {
            instance = null;
        }
    }
}

2.编辑NetworkStream服务端代码

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Xml;
using UnityEngine;

/// <summary>
/// SocketServer
/// 接收发送消息都采取以下格式："消息头#"  + "消息" + "#E\r\n"，用来规避消息粘包问题
/// </summary>
public class SocketServerManager : SingleTon<NetworkManager>
{
    /// <summary>
    /// 连接客户端集合
    /// </summary>
    Dictionary<string, SocketClient> Clients = new Dictionary<string, SocketClient>();
    SocketClient _socketClient;
    TcpListener server;
    public int GetClientCount
    {
        get { return Clients.Count; }
    }
    private void Start()
    {
        StartListener();
    }
    public void StartListener()
    {
        server = new TcpListener(IPAddress.Any, 6000);
        server.Start();
        server.BeginAcceptTcpClient(OnConnect, null);//开始监听
    }
    private void OnConnect(IAsyncResult ar)
    {
        try
        {
            TcpClient curClient = server.EndAcceptTcpClient(ar);
            _socketClient = new SocketClient(curClient);//有连接就初始化一个
            Debug.Log("客户端" + curClient.Client.RemoteEndPoint.ToString() + "已经连接");
            //开启接收
            _socketClient.ReceiveMsg();

            server.BeginAcceptTcpClient(OnConnect, null);//开始监听
        }
        catch (Exception)
        {

        }
    }

    public void SendToClients(string _str)//消息发送
    {
        string sendMsg = _str;
        string[] keys = new string[Clients.Count];
        Clients.Keys.CopyTo(keys, 0);
        foreach (string key in keys)
        {
            try
            {
                Clients[key].SendMsg(sendMsg);
            }
            catch (Exception ex)
            {
                Debug.Log("客户端" + key + "出现异常，" + ex.Message);
                if (Clients.ContainsKey(key))
                {
                    CloseClientConnect(Clients[key]);
                }
            }
        }
    }

    /// <summary>
    /// 制定客户端发送消息
    /// </summary> NetworkManager.GetInstance.SendToClient("Client0", "消息头#"  + "消息" + "#E\r\n");

    /// <param name="_clientName"></param>
    /// <param name="_data"></param>
    public void SendToClient(string _clientName, string _data)
    {
        Debug.Log("<color=green>" + "发送信息=============" + _data + "</color>");
        if (Clients.ContainsKey(_clientName))
        {
            Clients[_clientName].SendMsg(_data);
        }
    }

    /// <summary>
    /// 根据客户端名称发送消息
    /// </summary> SocketServerManager.GetInstance.SendToClient("消息头#" + "消息" + "#E\r\n", "Client0", "Client1", "Client2");
    /// <param name="_data">消息</param>
    /// <param name="_clientNames">客户端名称</param>
    public void SendToClient(string _data, params string[] _clientNames)
    {
        for (int i = 0; i < _clientNames.Length; i++)
        {
            if (Clients.ContainsKey(_clientNames[i]))
            {
                Clients[_clientNames[i]].SendMsg(_data);
            }
        }
    }
    public void CloseClientConnect(SocketClient client)//关闭连接
    {
        if (client.IfConnect)//如果是连接状态，再执行移除
        {
            client.CloseClient();
            client.IfConnect = false;
            //从字典中移除
            Clients.Remove(client.MenuNos);
            Console.WriteLine("移除了客户端" + client.MenuNos);
        }
    }
    public void InitClient(SocketClient client)//连接初始化
    {
        if (Clients.ContainsKey(client.MenuNos))
        {
            Clients[client.MenuNos] = client;
        }
        else
        {
            Clients.Add(client.MenuNos, client);
        }
       
    }
    protected override void OnDestroy()
    {
        base.OnDestroy();
        string[] keys = new string[Clients.Count];
        Clients.Keys.CopyTo(keys, 0);
        foreach (string key in keys)
        {
            CloseClientConnect(Clients[key]);
        }
        if (server != null)
        {
            server.Stop();

        }
    }
}

public class SocketClient
{
    #region 字段
    private const int bufferSize = 8192;
    byte[] buffer = new byte[bufferSize];

    bool ifConnect;
    string serverIP;
    int serverPort;
    string menuNos;


    NetworkStream stream;
    TcpClient client;

    StreamReader sr;
    StreamWriter sw;
    #endregion

    #region 属性
    public NetworkStream Stream
    {
        get { return stream; }
        set { stream = value; }
    }
    public TcpClient Client
    {
        get { return client; }
        set { client = value; }
    }
    public bool IfConnect { get { return ifConnect; } set { ifConnect = value; } }
    public string ServerIP { get { return serverIP; } set { serverIP = value; } }
    public int ServerPort { get { return serverPort; } set { serverPort = value; } }
    public string MenuNos { get { return menuNos; } set { menuNos = value; } }
    #endregion

    public SocketClient(TcpClient client)
    {
        if (client != null)
        {
            this.client = client;
            stream = client.GetStream();
            sw = new StreamWriter(stream);
            sr = new StreamReader(stream);
            ifConnect = true;
        }

    }

    /// <summary>
    /// 开启异步接收消息
    /// </summary>
    public void ReceiveMsg()
    {
        if (client != null)
        {
            stream.BeginRead(buffer, 0, bufferSize, OnReceive, null);//开启一步接收
        }
    }

    /// <summary>
    /// 接收到消息的回调，用于处理消息
    /// </summary>
    /// <param name="ar"></param>
    private void OnReceive(IAsyncResult ar)
    {
        try
        {
            int count = stream.EndRead(ar);
            try
            {
                string msg = Encoding.UTF8.GetString(buffer, 0, count);//接收到消息

                string[] dataArr = Regex.Split(msg, "\r\n");
                Debug.Log("接收到Client客户端消息=====" + msg);
                for (int i = 0; i < dataArr.Length; i++)
                {
                    if (dataArr[i].Equals(""))
                    {
                        continue;
                    }
                    string[] msgArr = dataArr[i].Split('#');
                    if (msgArr.Length != 3)//验证消息
                    {
                        continue;
                    }

                    if (msgArr[1].Equals("Init"))//验证初始化
                    {
                        this.MenuNos = msgArr[0];
                        SocketServerManager.GetInstance.InitClient(this);

                    }
                    else if (msgArr[1].Equals("ApplicationQuit"))
                    {
                        SocketServerManager.GetInstance.CloseClientConnect(this);
                    }
                    else
                    {
                        //将消息进一步解析
                        if (this.MenuNos.Equals("Clitnt0"))//来自于客户端消息处理
                        {
                           
                        }
                    }
                }

            }
            catch (Exception ex)
            {
                Console.WriteLine("消息处理失败" + ex.StackTrace);
            }
            stream.BeginRead(buffer, 0, bufferSize, OnReceive, null);
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
            //消息接收失败，说明连接异常
            //    Console.WriteLine("消息接收异常，请检查客户端端{0}的连接",client.Client.RemoteEndPoint.ToString());
            Console.WriteLine("接收消息发生错误:" + this.MenuNos);
            //NetworkManager.Instance.CloseClientConnect(this);
        }

    }

    /// <summary>
    /// 发送消息
    /// </summary>
    /// <param name="msg">消息内容</param>
    public void SendMsg(string msg)
    {
        byte[] data = Encoding.UTF8.GetBytes(msg);
        stream.Write(data, 0, data.Length);
        stream.Flush();
    }

    /// <summary>
    /// 断开连接
    /// </summary>
    public void CloseClient()
    {
        if (client != null)
        {
            try
            {
                if (sr != null)
                {
                    sr.Close();
                }
                if (sw != null)
                {
                    sw.Close();
                }
                stream.Close();
                client.Close();
                client.Client.Close();
                ifConnect = false;
            }
            catch
            {
                Console.WriteLine("关闭");
                return;
            }
        }
        ifConnect = false;
    }
}

3.编辑NetworkStream客户端代码

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Text.RegularExpressions;
using UnityEngine;


public class SocketClient : SingleTon<SocketClient>
{
    //定义稳委托事件用来处理消息，其他脚本可调用 SocketHelperClient.GetInstance.CommonCallBack += MsgReceive;
    public delegate void CommonThreadCallBackDelegate(string type);
    public CommonThreadCallBackDelegate CommonCallBack;
    TcpClient clientTcp;
    NetworkStream ns;
    StreamReader sr;
    StreamWriter sw;
    bool ifRight = true;
    string ipAddress = "127.0.0.1"; 
    public string EXENAME = "Clitnt0";
    bool IsConnect = false;
    #region 通用
    void Start()
    {
        StartConnect(); 
        StartCoroutine(HertJump());
    }
    private void StartConnect()
    {
        Loom.RunAsync(ConnectToServer);
    }
//消息发送方法 ： string msg = EXENAME + "#" + msg + "#E\r\n"；
//SocketHelperClient.GetInstance.SendToServer(msg);
    public void SendToServer(string message)
    {
        if (ifRight)
        {
            try
            {
                sw.WriteLine(message);
                sw.Flush();
            }
            catch
            {
                ifRight = false;
            }
        }
    }
    IEnumerator HertJump()//检测
    {
        while (true)
        {
            yield return new WaitForSeconds(3f);
          //  Debug.Log("-----3s后检测----");
            if (!ifRight)
            {
                if (sw != null)
                {
                    sw.Close();
                    sw = null;
                }
                StartConnect();
            }
        }
    }
    private void ConnectToServer()//连接服务器
    {

        IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(ipAddress), 6000);


        clientTcp = new TcpClient();
        try
        {
            IsConnect = false;
			Debug.Log("-----尝试连接----" + ifRight);
			clientTcp.Connect(ipep);
			ifRight = true;
			IsConnect=true;
			Debug.Log("-----连接成功----" + ifRight);
        }
        catch (SocketException ex)
        {
        	 if (IsConnect) 
 			 {
     			return;
 			 }
            Debug.Log("--阻塞后连接失败失败失败----" + ifRight);
            ifRight = false;
            return;
        }
        catch (StackOverflowException ex)
        {
        }

        ns = clientTcp.GetStream();//数据流，读写
        sr = new StreamReader(ns);
        sw = new StreamWriter(ns);
        Loom.QueueOnMainThread(() =>
        {
            SendToServer(EXENAME + "#Init#E");
        });
        while (ifRight)
        {
            try
            {
               
                byte[] bytes = Encoding.UTF8.GetBytes(sr.ReadLine());
              //  Debug.LogError(Encoding.UTF8.GetString(bytes).ToString());
                if (bytes.Length > 0)
                {
                    Loom.QueueOnMainThread(() =>
                    {
                        
                        UpdCommonInfo(Encoding.UTF8.GetString(bytes).ToString());
                    });
                }
            }
            catch
            {
                ifRight = false;
            }
        }
    }

    private void UpdCommonInfo(string _data)
    {
     //   Debug.LogError(_data);
        string[] datas = Regex.Split(_data, "\r\n");
        for (int i = 0; i < datas.Length; i++)
        {
            if (datas[i].Equals(""))
            {
                continue;
            }
            string[] data1 = datas[i].Split('#');
            if (data1.Length != 3)
            {
                continue;
            }

            CommonCallBack(data1[1]);
        }
    }
    protected override void OnDestroy()
    {
        base.OnDestroy();
        SendToServer(EXENAME + "#ApplicationQuit#E\r\n");
        try
        {
            if (sr != null)
            {
                sr.Close();
                sw.Close();
                ns.Close();
            }
            clientTcp.Close();
        }
        catch
        {
        }
        Loom.CloseThread();
    }
    #endregion

}

4.其他所需要的代码，放入Unity场景中

using UnityEngine;
using System.Collections;
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 Thread[] curThreads = new Thread[maxThreads];
    private static Loom _current;
    private int _count;
    public static Loom Current
    {
        get
        {
            Initialize();
            return _current;
        }
    }

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

    static bool initialized;

    static void Initialize()
    {
        if (!initialized)
        {

            if (!Application.isPlaying)
                return;
            initialized = true;
            var g = new GameObject("Loom");
            _current = g.AddComponent<Loom>();
        }

    }

    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)
        {
            lock (Current._delayed)
            {
                Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = action });
            }
        }
        else
        {
            lock (Current._actions)
            {
                Current._actions.Add(action);
            }
        }
    }

    public static Thread RunAsync(Action a)   //异步运行
    {
        Initialize();
        while (numThreads >= maxThreads)
        {
            Thread.Sleep(1);
        }
        Interlocked.Increment(ref numThreads);
        int tIndex = -1;
        for (int i = 0; i < curThreads.Length; i++)
        {
            if (curThreads[i] == null || !curThreads[i].IsAlive)
            {
                tIndex = i;
                break;
            }
        }
        curThreads[tIndex] = new Thread(new ThreadStart(() => RunAction(a, tIndex)));
        curThreads[tIndex].Start();
        //ThreadPool.QueueUserWorkItem(RunAction, a);
        return curThreads[tIndex];
    }

    private static void RunAction(object action, int tIndex)
    {
        try
        {
            ((Action)action)();
        }
        catch (ThreadInterruptedException e)
        {
            Debug.Log("newThread cannot go to sleep - " +
                 "interrupted by main thread.");
        }
        finally
        {
            //			if(curThreads[tIndex]!=null)
            //			{
            //				curThreads[tIndex].Abort();
            //				curThreads[tIndex].Join();
            //				curThreads[tIndex]=null;
            //			}
            Interlocked.Decrement(ref numThreads);
            //curThreads.Remove(thread1);
        }
    }
    void OnDisable()
    {
        //	CommonInfo.ifClosing = true;
        //CloseThread();
        if (_current == this)
        {
            _current = null;
        }
    }
    // Use this for initialization
    void Start()
    {

    }

    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();
        }



    }

    public static void CloseThread()
    {
        for (int i = 0; i < curThreads.Length; i++)
        {
            if (curThreads[i] != null && curThreads[i].IsAlive)
            {
                //curThreads[i].Interrupt();
                curThreads[i].Abort();
                curThreads[i].Join();


            }
        }
    }
}


using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Net;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Drawing.Drawing2D;

namespace PreviewDemo.Scripts
{
    internal class TcpClientConnect : SingleTon<TcpClientConnect>
    {
        public delegate void ReceiveServerInfo(string serverinfo);
        public event ReceiveServerInfo ReceiveServerInfoEvent;


        string serverIP = "";
        string serverPort = "";

        bool timerEnable = false;
        bool ifRight = false;
        bool ifConnecting = false;//是否正在连接

        Thread clientThread;
        TcpClient clientTcp;
        NetworkStream ns;
        StreamReader sr;
        StreamWriter sw;
        List<string> sendMessageList = new List<string>();
        public void TcpClientConnect_Load()
        {
            this.serverIP = "127.0.0.1";
            // this.serverIP = "192.168.13.122";
            //this.serverPort = "6000";

            Connect();
            timerEnable = true;
        }
        public void Connect()
        {
         //   ifConnecting = true;//正在连接

            clientThread = new Thread(new ThreadStart(ConnectToServer));
            clientThread.Start();
        }
        private void ConnectToServer()
        {

            IPEndPoint ipep = new IPEndPoint(IPAddress.Parse(serverIP), 6000);
            clientTcp = new TcpClient();

            //将套接字与远程服务器地址相连
            try
            {
                clientTcp.Connect(ipep);
              //  ifConnecting = false;
                ifRight = true;


                ns = clientTcp.GetStream();
                sr = new StreamReader(ns);
                sw = new StreamWriter(ns);

                SendToServer("WinformExe#Init#E\r\n");
                //CommonInfo.dicParas.Clear();
            }
            catch (SocketException ex)
            {
                ifRight = false;
              //  CanData.isSend = false;
              //  ifConnecting = false;
                return;
            }
            catch (StackOverflowException ex)
            {
                //堆栈溢出
            }
            catch (Exception ex)
            {

            }
            //while (sendMessageList.Count > 0)
            //{
            //    sw.WriteLine(sendMessageList[0]);
            //    sw.Flush();
            //    sendMessageList.RemoveAt(0);
            //    if (sendMessageList.Count > 0)
            //        Thread.Sleep(100);
            //}
            string data = string.Empty;
            while (ifRight)
            {
                //接收服务器信息
                try
                {
                    
                        data = sr.ReadLine();
                        if (data!=null&&data.Length > 0)
                        {
                            Console.WriteLine("接收的数据是：" + data);
                            string[] dataStr = Regex.Split(data, "\r\n");
                        for (int i = 0; i < dataStr.Length; i++)
                        {
                            if (dataStr[i].Length > 0)//Server#V1!0,V2!1#E
                            {
                                string[] getData = dataStr[i].Split('#');
                                if (getData.Length == 3 && getData[0].Equals("Server") && getData[2].Equals("E"))
                                {
                                    ReceiveServerInfoEvent?.Invoke(getData[1]);
                                }

                            }

                        }
                    }//线程锁

                }
                catch (Exception ex)
                {
                    ifRight = false;
                    ifConnecting = false;
                    return;
                }
            }
            ifRight = false;
        }


        public void TcpClientConnect_Tick()
        {
            if (!timerEnable)
            {
                return;
            }

            if ((!ifRight || !clientTcp.Connected) && !ifConnecting)
            {
                this.serverIP = "127.0.0.1"; 
                Connect();
            }
        }

        public void SendToServer(string message)
        {

            sendMessageList.Add(message);
            if (sw == null)
                return;

            Console.WriteLine("发送的数据是：" + message);
            //向服务器发送信息
            try
            {
                while (sendMessageList.Count > 0)
                {
                    sw.WriteLine(sendMessageList[0]);
                    sw.Flush();
                    sendMessageList.RemoveAt(0);
                    if (sendMessageList.Count > 0)
                        Thread.Sleep(100);
                }
            }
            catch (Exception ex)
            {
                ifRight = false;
                sw.Close();
                sw = null;
            }
        }
    }
}

5.WindowsForms版本Socket

winform版本可以做一个简单的服务器后台运行处理数据，与Unity能够连接相互通信。

6.WindowsForms项目源文件

https://download.youkuaiyun.com/download/ForKnowledgeMe/89569929?spm=1001.2014.3001.5503
如果对您能够起到帮助的话，希望大家能够多多支持，点点关注，十分感谢！

开启服务
连接成功

总结

以上就是所有的内容，具体的使用方式和方法作用都注释出来了，有使用错误或者不对的地方还请大家多多指正。

ET 之网络框架
TxNet
01-28 3455
一.前言 阅读这篇文章要求对ET框架的ECS结构有所了解 ET框架简介： ET是一个开源的游戏客户端（基于unity3d）服务端双端框架，服务端是使用C# .net core开发的分布式游戏服务端，其特点是开发效率高，性能强，双端共享逻辑代码，客户端服务端热更机制完善，同时支持可靠udp tcp websocket协议，支持服务端3D recast寻路等等 ET是主要以双端框架著称，所以可以想象一下网络其实是它的核心，我相信，应该是是作者付出了最多心血的杰作，下面我们就来拆解一下ET的网络框架 ET包含
UnityC#常见面试题
sinat_39871869的博客
08-22 4164
Unity技术面试题 一：什么是协同程序？ 答：在主线程运行时同时开启另一段逻辑处理，来协助当前程序的执行。换句话说，开启协程就是开启一个可以与程序并行的逻辑。可以用来控制运动、序列以及对象的行为。  二：Unity3D中的碰撞器和触发器的区别？ 答：碰撞器是触发器的载体，而触发器只是碰撞器身上的一个属性。 当Is Trigger=false时，碰撞器根据物理引擎引发碰撞，产生碰撞的效果
(2025)Unity局域网多客户端Socket通信
m0_70478643的博客
01-20 595
在开发一些展览馆项目时需要Pad通过局域网控制馆内各个设备的状态，但展览馆又不允许连接外网，故需要局域网多客户端Socket通信。
Unity C# socket客户端框架
03-22
应用于unity的C# Socket客户端框架，包含完整的通用逻辑与常见的异常处理，可供新人学习使用。该代码并不能够直接运行，仅供阅读和参考。
Unity-Socket通信实例详解
最新发布
lastXuanGod的博客
05-07 1196
今天我们来讲解socket通信。首先我们需要知道什么是socket通信：Socket本质上就是一个个进程之间网络通信的基础，每一个Socket由IP+端口组成，熟悉计网的同学应该知道IP主要是应用于IP协议而端口主要应用于TCP协议，这也证明了Socket通信是一个多个层共同工作的过程。总结：Socket是网络编程的基石，通过简单API抽象底层协议，实现进程间灵活高效的数据交换。
Socket网络模块（Unity c#）
09-23
介绍Socket网络连接模块： 主要分为四部分： 一、套接字管理器（SocketManager.cs） 1)、连接 2)、断开 3)、接收（线程） 4)、发送（携程） 二、消息中心：（MessageCenter.cs） 1)、游戏逻辑事件 2)、网络数据事件（线程） 三、数据封装： 1)、网络数据缓冲器（DataBuff.cs） 2)、二进制字节流（ByteStreamBuffer.cs)
unity socket编程
873149745
11-01 793
一、第一步开始连接 1、创建socket privateSocketsocket; socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); 2、创建ip和端口号 IPAddress address = IPAddress.Parse (“192.168.1.1”); ...
Unity笔记——C#的Socket基础
掩扉Blog
04-13 2837
总的来说TCP通信大致就是六步，建立socket->绑定Bind->监听Listen->通过Accept()与客户端建立连接->客户端Connect()连接服务器->Send()给服务器发送消息->通过Receive()方法来建立连接，从而实现可靠传输。4）通过ReciveFrom()方法接收指定主机发送的消息（需要提供主机IP地址及端口）3）通过SendTo()方法向建立连接的主机发送消息（需要提供IP地址及端口）7）利用Receive()方法接受来自建立连接主机的消息（实现可靠连接）
【Unity Socket】Unity Socket TCP网络编程基础
zhoutao2333的博客
04-03 1889
【代码】【Unity Socket】Unity Socket TCP网络编程基础。
Unity客户端与后台通信
子者不语的专栏
11-22 5208
在做Unity游戏开发时，与后台的通信是必不可少的。我们可以用c#自带的WebRequest来与后台通信，但是这种通信方式效率是比较低的，特别是当游戏需要多人在线时，用c#来进行网络通信会完全无法满足要求。这个时候就需要用C或者C++来与后台进行通信了。所以在这儿，我主要讲一下Unity客户端如何通过C与后台服务器进行通信。生成DLL文件Unity中调用C的方法是通过调用用C生成的DLL库来实现的，
Unity利用C++ DLL实现单客户端TCP通信
c++ 的dll 实现 tcpserver,只接收一个客户端,实现跟客户端的数据交流" 暗示了一系列相关的知识点，它们涉及Unity游戏引擎与C++动态链接库（DLL）的交互，以及TCP服务器（TcpServer）的实现与客户端通信。让我们逐项...
C#编程精华：多年积累的实用类库代码
- "unity"：尽管标题中没有明确提及，但标签的出现表明这些类库代码可能也适用于Unity游戏引擎的开发，Unity支持使用C#作为脚本语言，因此这些类库在Unity开发中也可能是可用的。 - "代码"：指的是具体的编程源代码...
Socket c#服务器 unity客户端
04-12
Socket C#编写服务器，unity创建客户端，可以多个客户端交互。
简单的基于Unity3D的Socket通讯
09-06
简单的基于Unity的客户端连接服务器端，相互发送一次数据，文档描述位于http://blog.sina.com.cn/s/blog_1322690230102y3l4.html
Unity使用Socket进行服务器与客户端通讯
qq_42345116的博客
11-25 4495
一、服务器 1.服务器场景布局 由 显示提示信息、保存信息、清空消息按钮和信息提示Text、Scroll View组成。 信息提示：添加Content Size Fitter Scroll View下的Content：添加Text 和Content Size Fitter 2.Loom脚本： 因为GetCompent组件必须在unity主线程下运行，使用线程进行Socket连接，返回的数据要在Text组件中显示，所以需要使用Loom脚本。 Loom脚本 ...
Unity中Socket编程（TCP协议）
qq_38721111的博客
03-27 1400
服务器端： using System.Collections.Generic; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; using UnityEngine; public class TCPServer : MonoBehaviour { publi...
Unity 之Socket编程
Edwin Lee的博客
03-20 943
Hello,我是KitStar。 以下文章整理的不对。还请见谅。 注：其中服务端在VS中写。客户端为U3D. 本人是新手，但是找了很久都找不到类似的通讯源码，后来终于在一个网站上看到有关于Socket的通讯事例，所以就抄过来希望能够帮助更多像我一样的初学者！嘻嘻 首先创建一个C# 控制台应用程序， 直接服务器端代码丢进去，然后
Unity Socket 初级入门
qq_43016637的博客
02-02 915
在unity运行socket类收发消息的踩雷
Unity平台C# Socket客户端框架解析与学习
开发者在Unity中可以利用C#语言编写脚本，控制游戏逻辑、用户界面及网络通信等方面的功能。 2. C#编程语言：C#（发音为“看井”）是一种面向对象的编程语言，由微软公司开发，是.NET框架的一部分。C#简洁、现代，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杰尼杰尼丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值