【Unity网络通讯】

已于 2022-06-27 09:37:18 修改
阅读量1.2k 收藏 3
点赞数
分类专栏： Unity3D 文章标签： 服务器 c# 运维
于 2022-06-23 14:31:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43317534/article/details/125402946
版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

网络通讯

前言

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、了解编写服务器demo

一、基础知识
请添加图片描述
Server:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;

namespace Server1._0
{
    class Program
    {
        static void Main(string[] args)
        {
            //Socket:套接字 ：一个集合，IP地址和端口号、双方都需要同时满足的协议，地址族
            //AddressFamily:地址族
            // SocketType:传输类型，如果使用TCP协议的话，就选用Stream流式传输，如果使用UDP协议，就选择Dgram
            // ProtocolType:协议类型
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //IP地址
            IPAddress IP = IPAddress.Parse("192.168.1.96");
            int port = 8888;//端口号，1-65535 ，一般1-1024系统端口，BSD保留端口 1024-5000临时端口，剩余的为用户自定义的端口

            //重点掌握：使用服务器进行数据传输
            serverSocket.Bind(new IPEndPoint(IP,port));
            serverSocket.Listen(10);//参数表示同一时间内能处理的最大消息数
            Console.WriteLine("服务器启动了");
            
            //接受，接受一个客户端的连接
            Socket clientSocket = serverSocket.Accept(); //阻塞函数
            Console.WriteLine("服务器接受了一个客户端的连接，客户端的详细数据为："+clientSocket.RemoteEndPoint.ToString());
            byte[] msgArr = new byte[1024];
            clientSocket.Receive(msgArr);
            string msg = Encoding.UTF8.GetString(msgArr);
            Console.WriteLine("从客户端接受到的数据为："+msg);


            Console.ReadKey();
        }
    }
}

Client:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;

namespace Client1_0
{
    class Program
    {
        static void Main(string[] args)
        {
            Socket clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //客户端不需要绑定自己的IP地址和端口号
            //而是去连接服务器的IP地址和端口号
            IPAddress IP = IPAddress.Parse("192.168.1.96");
            int port = 8888;
            //Connect 连接，连接到一个终端（）
            clientSocket.Connect(new IPEndPoint(IP, port));
            Console.WriteLine("连接到了服务器");

            string connect = "666666"; //简体中文的编码格式：UTF-8，GB2312

            byte[] msg = Encoding.UTF8.GetBytes(connect);
            clientSocket.Send(msg);

            Console.ReadLine();
        }
    }
}

二、一之中的不足：只能接受一个客户端发送的消息，如何改进？

利用多线程：
改进之后的server代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace Server1._0
{
    class Program
    {
        static void Main(string[] args)
        {
            //Socket:套接字 ：一个集合，IP地址和端口号、双方都需要同时满足的协议，地址族
            //AddressFamily:地址族
            // SocketType:传输类型，如果使用TCP协议的话，就选用Stream流式传输，如果使用UDP协议，就选择Dgram
            // ProtocolType:协议类型
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //IP地址
            IPAddress IP = IPAddress.Parse("192.168.1.96");
            int port = 8888;//端口号，1-65535 ，一般1-1024系统端口，BSD保留端口 1024-5000临时端口，剩余的为用户自定义的端口

            //重点掌握：使用服务器进行数据传输
            serverSocket.Bind(new IPEndPoint(IP,port));
            serverSocket.Listen(10);//参数表示同一时间内能处理的最大消息数
            Console.WriteLine("服务器启动了");

            Thread thread = new Thread(AcceptClient);
            thread.Start(serverSocket);

            Console.ReadKey();
        }

        //接受客户端发送的连接请求
        private static void AcceptClient(object obj)
        {
            Socket serverSocket = obj as Socket;//父类转为子类
            if(serverSocket == null)
            {
                return;
            }
            //Accept接受，接受一个客户端的连接
            Socket clientSocket = serverSocket.Accept(); //阻塞函数
            Console.WriteLine("服务器接受了一个客户端的连接，客户端的详细数据为：" + clientSocket.RemoteEndPoint.ToString());

            //开启接受客户端发送消息的线程
            Thread thread = new Thread(ReceiveMessage);
            thread.Start(clientSocket);
            //递归调用
            AcceptClient(serverSocket);
        }

        //接受客户端发送的消息
        private static void ReceiveMessage(object obj)
        {
            Socket clientSocket = obj as Socket;
            if(clientSocket == null)
            {
                return;
            }
            byte[] msgArr = new byte[1024];
            clientSocket.Receive(msgArr);
            string msg = Encoding.UTF8.GetString(msgArr);
            Console.WriteLine("从客户端接受到的数据为：" + msg);

            ReceiveMessage(clientSocket);
        }
    }
}

1.消息的广播

server:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net.Sockets;
using System.Net;
using System.Threading;

namespace Server1._0
{
    class Program
    {
        //用来存放连接进来的客户端
        static List<Socket> clientList = new List<Socket>();

        static void Main(string[] args)
        {
            //Socket:套接字 ：一个集合，IP地址和端口号、双方都需要同时满足的协议，地址族
            //AddressFamily:地址族
            // SocketType:传输类型，如果使用TCP协议的话，就选用Stream流式传输，如果使用UDP协议，就选择Dgram
            // ProtocolType:协议类型
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //IP地址
            IPAddress IP = IPAddress.Parse("192.168.1.96");
            int port = 8888;//端口号，1-65535 ，一般1-1024系统端口，BSD保留端口 1024-5000临时端口，剩余的为用户自定义的端口

            //重点掌握：使用服务器进行数据传输
            serverSocket.Bind(new IPEndPoint(IP,port));
            serverSocket.Listen(10);//参数表示同一时间内能处理的最大消息数
            Console.WriteLine("服务器启动了");

            Thread thread = new Thread(AcceptClient);
            thread.Start(serverSocket);

            Console.ReadKey();
        }

        //接受客户端发送的连接请求
        private static void AcceptClient(object obj)
        {
            Socket serverSocket = obj as Socket;//父类转为子类
            if(serverSocket == null)
            {
                return;
            }
            
            //Accept接受，接受一个客户端的连接
            Socket clientSocket = serverSocket.Accept(); //阻塞函数
            Console.WriteLine("服务器接受了一个客户端的连接，客户端的详细数据为：" + clientSocket.RemoteEndPoint.ToString());
            clientList.Add(clientSocket);//加入List容器

            //开启接受客户端发送消息的线程
            Thread thread = new Thread(ReceiveMessage);
            thread.Start(clientSocket);
         
            //递归调用
            AcceptClient(serverSocket);
        }

        //接受客户端发送的消息
        private static void ReceiveMessage(object obj)
        {
            Socket clientSocket = obj as Socket;
            if(clientSocket == null)
            {
                return;
            }
            byte[] msgArr = new byte[1024];

            try
            {
                //Receive的返回值类型为int,返回的是这个数据的长度
                int length = clientSocket.Receive(msgArr);
                if(length == 0)
                {
                    clientSocket.Close();
                    return;
                }
                string msg = Encoding.UTF8.GetString(msgArr, 0, length);
                Console.WriteLine("从客户端接受到的数据为：" + msg);
                byte[] messge = new byte[length];
                Array.Copy(msgArr, 0, messge, 0, length);
                for (int i = 0; i < clientList.Count; i++)
                {
                    if(clientList[i] == clientSocket)
                    {
                        continue;
                    }
                    clientList[i].Send(messge);
                }
            }
            catch (Exception e)
            {
                clientSocket.Close();
                return;
            }
            ReceiveMessage(clientSocket);
        }
    }
}

client:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;
using System.Threading;

namespace Client1_0
{
    class Program
    {
        static Socket clientSocket;
        static string name="我是朱思焱";
        static void Main(string[] args)
        {
            clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //客户端不需要绑定自己的IP地址和端口号
            //而是去连接服务器的IP地址和端口号
            IPAddress IP = IPAddress.Parse("192.168.1.96");
            int port = 8888;
            //Connect 连接，连接到一个终端（）
            clientSocket.Connect(new IPEndPoint(IP, port));
            Console.WriteLine("连接到了服务器");

            Thread thread = new Thread(ReceiveMessage);
            thread.Start();

            while (true)
            {
                string connect = name+":"+Console.ReadLine(); //简体中文的编码格式：UTF-8，GB2312

                byte[] msg = Encoding.UTF8.GetBytes(connect);
                clientSocket.Send(msg);
            }
           
        }

        //消息的广播
        /// <summary>
        /// 客户端接受服务器发送的信息
        /// </summary>
        private static void ReceiveMessage()
        {
            //需要一个接受数据的数组
            byte[] msgArr = new byte[1024];

            //使用循环一直接受消息
            while (true)
            {
                //需要知道信息的长度
                int length = clientSocket.Receive(msgArr);
                //解析消息
                string msg = Encoding.UTF8.GetString(msgArr, 0, length);
                //打印
                Console.WriteLine("从服务器接收到的消息为："+msg);
                
            }

        }
    }
}

2.异步服务器

异步：Async,本质上仍然是一个多线程，异步连接必须
同步：程序由上而下的执行

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;

namespace AsyncChatSocket
{
    class Program
    {
        //用于存放连接的客户端
        static List<Socket> clientList = new List<Socket>();
        static void Main(string[] args)
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //IP地址
            IPAddress IP = IPAddress.Parse("192.168.1.96");
            int port = 8888;//端口号，1-65535 ，一般1-1024系统端口，BSD保留端口 1024-5000临时端口，剩余的为用户自定义的端口
            serverSocket.Bind(new IPEndPoint(IP, port));//重点掌握：使用服务器进行数据传输
            serverSocket.Listen(10);//参数表示同一时间内能处理的最大消息数
            Console.WriteLine("服务器启动了");

            //异步的写法和开启新线程不一样
            serverSocket.BeginAccept(AsyncAccept, serverSocket);

            Console.ReadLine();
        }

       static byte[] msgArr = new byte[1024];
        private static void AsyncAccept(IAsyncResult ar)
        {
            Socket serverSocket = ar.AsyncState as Socket;
            if(serverSocket == null)
            {
                return;
            }
            //获取连接客户端
            Socket clientSocket = serverSocket.EndAccept(ar);
            clientList.Add(clientSocket);

            Console.WriteLine(clientSocket.RemoteEndPoint.ToString());

            //开启异步监听接受数据的方法
            clientSocket.BeginReceive(msgArr, 0, msgArr.Length, SocketFlags.None, AsyncReceive,clientSocket);

            serverSocket.BeginAccept(AsyncAccept, serverSocket);
        }

        private static void AsyncReceive(IAsyncResult ar)
        {
            Socket clientSocket = ar.AsyncState as Socket;
            if (clientSocket == null)
            {
                return;
            }

            try
            {
                //Receive的返回值类型为int,返回的是这个数据的长度
                int length = clientSocket.Receive(msgArr); //也是阻塞函数
                if (length == 0)
                {
                    clientSocket.Close();
                    clientList.Remove(clientSocket);
                    return;
                }
                string msg = Encoding.UTF8.GetString(msgArr, 0, length);
                Console.WriteLine("从客户端接受到的数据为：" + msg);

                byte[] messge = new byte[length];
                Array.Copy(msgArr, 0, messge, 0, length);
                for (int i = 0; i < clientList.Count; i++)
                {
                    if (clientList[i] == clientSocket)
                    {
                        continue;
                    }
                    clientList[i].Send(messge);
                }
            }
            catch (Exception e)
            {
                clientList.Remove(clientSocket);
                return;
            }
            clientSocket.BeginReceive(msgArr, 0, msgArr.Length, SocketFlags.None, AsyncReceive, clientSocket);
        }
    }
}

3.使用面向对象思想改进异步服务器

请添加图片描述
客服代码：

using System.Text;
using System.Threading.Tasks;

namespace AsyncChatSocket
{
    class ClientPeer
    {
        Socket ClientSocket = null;
        byte[] msgArr = new byte[1024];
        public ClientPeer(Socket clientSocket)
        {
            //初始化
            this.ClientSocket = clientSocket;
            clientSocket.BeginReceive(msgArr,0,msgArr.Length,SocketFlags.None,AsyncReceive,null);
        }

        
        //仅仅只做客户端消息的接受
        private void AsyncReceive(IAsyncResult ar)
        {
            try
            {
                int length = ClientSocket.EndReceive(ar);
                if(length == 0)
                {
                    ClientSocket.Close();
                    return;
                }
                string msg = Encoding.UTF8.GetString(msgArr, 0, length);
                Console.WriteLine(msg);
                NetManager.Instance.BoardCastMessage(msg);

            }
            catch (Exception e)
            {
                ClientSocket.Close();
                return;
            }
            ClientSocket.BeginReceive(msgArr, 0, msgArr.Length, SocketFlags.None, AsyncReceive, null);
        }

        //给自己管理的客户端发送消息
        public void SendMessage(byte[] message)
        {
            ClientSocket.Send(message);
        }
        public void SendMessage(string message)
        {
            ClientSocket.Send(Encoding.UTF8.GetBytes(message));
        }
    }
}

客服管理者：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AsyncChatSocket
{
    class NetManager
    {
        private static NetManager _instance = null;
        private NetManager() { }
        public static NetManager Instance
        {
            get
            {
                if(_instance == null)
                {
                    _instance = new NetManager();
                }
                return _instance;
            }
        }

        List<ClientPeer> clientList = new List<ClientPeer>();
        public void AddClient(ClientPeer client)
        {
            clientList.Add(client);
        }

        public void RemoveClient(ClientPeer client)
        {
            clientList.Remove(client);
        }

        //广播消息
        public void BoardCastMessage(string message,ClientPeer client=null)
        {
            for (int i = 0; i < clientList.Count; i++)
            {
                if (clientList[i] == client)
                {
                    continue;
                }
                //通知客服给客户端发送消息
                clientList[i].SendMessage(message);
            }
        }
        public void BoardCastMessage(byte[] message, ClientPeer client = null)
        {
            for (int i = 0; i < clientList.Count; i++)
            {
                if (clientList[i] == client)
                {
                    continue;
                }
                //通知客服给客户端发送消息
                clientList[i].SendMessage(message);
            }
        }

        //单独发送消息
        public void SendMessage(byte[] message,ClientPeer client)
        {
            client.SendMessage(message);
        }
        public void SendMessage(string message, ClientPeer client)
        {
            client.SendMessage(message);
        }
    }
}

服务器代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Net;
using System.Net.Sockets;

namespace AsyncChatSocket
{
    class Program
    {
        //用于存放连接的客户端
        //static List<Socket> clientList = new List<Socket>();
        static void Main(string[] args)
        {
            Socket serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            //IP地址
            IPAddress IP = IPAddress.Parse("192.168.1.96");
            int port = 8888;//端口号，1-65535 ，一般1-1024系统端口，BSD保留端口 1024-5000临时端口，剩余的为用户自定义的端口
            serverSocket.Bind(new IPEndPoint(IP, port));//重点掌握：使用服务器进行数据传输
            serverSocket.Listen(10);//参数表示同一时间内能处理的最大消息数
            Console.WriteLine("服务器启动了");

            //异步的写法和开启新线程不一样
            serverSocket.BeginAccept(AsyncAccept, serverSocket);

            Console.ReadLine();
        }

       static byte[] msgArr = new byte[1024];
        private static void AsyncAccept(IAsyncResult ar)
        {
            Socket serverSocket = ar.AsyncState as Socket;
            if(serverSocket == null)
            {
                return;
            }
            //获取连接客户端
            Socket clientSocket = serverSocket.EndAccept(ar);
            //clientList.Add(clientSocket);
            ClientPeer client = new ClientPeer(clientSocket);

            NetManager.Instance.AddClient(client);

            Console.WriteLine(clientSocket.RemoteEndPoint.ToString());

            //开启异步监听接受数据的方法
            //clientSocket.BeginReceive(msgArr, 0, msgArr.Length, SocketFlags.None, AsyncReceive,clientSocket);

            serverSocket.BeginAccept(AsyncAccept, serverSocket);
        }

        //private static void AsyncReceive(IAsyncResult ar)
        //{
        //    Socket clientSocket = ar.AsyncState as Socket;
        //    if (clientSocket == null)
        //    {
        //        return;
        //    }

        //    try
        //    {
        //        //Receive的返回值类型为int,返回的是这个数据的长度
        //        int length = clientSocket.Receive(msgArr); //也是阻塞函数
        //        if (length == 0)
        //        {
        //            clientSocket.Close();
        //            clientList.Remove(clientSocket);
        //            return;
        //        }
        //        string msg = Encoding.UTF8.GetString(msgArr, 0, length);
        //        Console.WriteLine("从客户端接受到的数据为：" + msg);

        //        byte[] messge = new byte[length];
        //        Array.Copy(msgArr, 0, messge, 0, length);
        //        for (int i = 0; i < clientList.Count; i++)
        //        {
        //            if (clientList[i] == clientSocket)
        //            {
        //                continue;
        //            }
        //            clientList[i].Send(messge);
        //        }
        //    }
        //    catch (Exception e)
        //    {
        //        clientList.Remove(clientSocket);
        //        return;
        //    }
        //    clientSocket.BeginReceive(msgArr, 0, msgArr.Length, SocketFlags.None, AsyncReceive, clientSocket);
        //}
    }
}

总结

提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。

学点没用的
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity3D网络通讯
01-01
在Unity3D中实现Http，Socket TCP、UDP，WebService，WebApi通讯方式
UNity网络通讯实例组件，可以联网使用
02-14
UNity网络通讯实例组件，可以联网使用
【Unity】网络通信（TCP&UDP）
DevFrank的博客
10-20 9340
Socket 接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，用以开发TCP/IP网络上的应用程序。也就是说Socket是TCP/UDP通讯的实现方式。TCP和UDP是传输层协议，使用IP协议从一个网络传送数据包到另一个网络。把IP想像成一种高速公路，它允许其它协议在上面行驶并找到到其它电脑的出口。两者的不同是：TCP能提供有保证的数据传输，而UDP不提供，即UDP的数据容易丢失。
Unity使用webSocket与服务器通信（三）——C#服务端（Fleck）与Unity客户端（ NativeWebSocket）传输多种数据数据
穿裤子的云
03-22 5289
Unity(NativeWebSocket)和C#服务端(Fleck)通信的简单实现:登录，验证登录，上传文件，下载文件...
UNITY-网络通信（TCP/UDP)
最新发布
m0_65357206的博客
05-13 1084
学习笔记 以后复习使用
socket通信，TCP协议，有多个客户端，服务器怎么向指定IP及端口的客户端发送数据！
热门推荐
YEYUANGEN的专栏
09-19 1万+
1.服务器是在等待中，当得到socket连接时，就得到了对端的端点地址。每个客户端是不同的端点地址。 2.如果不用bind直接connect,系统分给客户端的端口是随机的
Unity socket UDP 网络连接
Move_Cat的博客
05-11 653
记录在unity 网络连接中，对UDP socket学习过程。 服务端 UDP服务端，绑定了固定端口，知道自己的固定IP。 using UnityEngine; using System.Collections; //引入库 using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; public class UdpServer:MonoBehaviour { Socket sock
Unity 与C#服务器 Socket的UDP通信
王王王渣渣的博客
07-13 6663
前言这几天简单的研究了下Unity和服务器有关Socket的UDP通信，因为帧同步当中，UDP相比TCP是更适合的那种，因为UDP在网络环境较差时，波动更小，实时性也更高，可以更好的解决卡顿的问题（具体的小伙伴们可自行查阅资料）。当然使用UDP造成的开发量与开发难度会更大。在这里，我就先记录下自己这几天实现的udp简单的客户端与服务器的发送与接收功能的demo代码。注意1.本文是接着之前Socke...
Unity websocket http 通讯插件
11-07
Unity Best HTTP2 2.6.2 插件 帮助开发者快速构建WebSocket，Http通讯模块 亲测可用 放心下载
unity3d网络通讯的封包，解包与简单的异或加密
05-24
unity3d网络通讯的封包，解包与简单的异或异或加密的简单示例.里面有两工程，一个是U3D工程，一个是c#服务端。打开就可以直接运行。
unity UDP通讯 包含心跳机制
03-18
unity UDP通讯 包含心跳机制
【Unity】Socket网络通信（TCP） - 实现简单的多人聊天功能
weixin_43453797的博客
10-14 7495
unity实现非常简单的多人聊天功能，内含工程文件下载地址，免积分下载！
【基于Unity3D实现TCP网络通信】
一个有梦想的Fighter
12-27 1215
基于Unity3D实现TCP/IP网络通信
【Unity】UnityWebRequest学习——Unity中的HTTP网络通信
Sig的博客
12-07 8731
Unity中的HTTP网络通信
Unity从零开始制作多人回合制对战游戏（1）——网络通讯
weixin_43010844的博客
12-27 3398
考虑到我们的教程是网络游戏，所以还是得先写个服务器，本篇教程会向你科普什么是网络通讯、实现网络通讯需要的工具protobuf及其使用方法，最后，其主要内容是教你运用这些知识来开发一个使用c#作为后端的服务器，并完成通讯功能
【Unity】(Socket)TCP 实现同一局域网 一台主机控制多台主机
weixin_39348384的博客
05-24 3744
源文件链接：链接：https://pan.baidu.com/s/1pTwGj37ozMlq58OHcIJPIg。前几天博主接到一个任务：5台HTCVIVEPro设备，其中一台设备进行演示，另外四台设备画面同步。如果需要其它的一些TCP操作流程，请看这个博主大大的文章，很详细。PS:博主参考了其它博主大大的文章，感觉很有用！谨以此文记录博主自己的个人历程，希望对大家有所帮助。以下开始了博主操作的具体流程，希望对你有所帮助。下面是我最终的运行效果图​​​​​​​。--来自百度网盘超级会员V5的分享。
Unity——网络游戏通信方案
m0_51743362的博客
05-22 2882
目录 弱联网和强联网游戏 弱联网游戏 强联网游戏 弱联网游戏代表 强联网游戏代表 长连接和短连接游戏 短连接游戏 通信特点 通信方式 长连接游戏 通信特点 通信方式 Socket、HTTP、FTP Socket Http/Ht...
【Unity网络通讯】一招教你使用TCP、UDP协议
憨辰
11-04 591
【Unity网络通讯】一招教你使用TCP、UDP协议
unity tcpip通讯
02-27
Unity中的TCP/IP通信是指使用TCP/IP协议进行网络通信的一种方式。通过TCP/IP通信，可以实现不同设备之间的数据传输和交互。 在Unity中，可以使用C#的Socket类来实现TCP/IP通信。以下是一个简单的示例代码，演示了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值