devbox
正经夜光杯
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【Unity Socket】Unity Socket TCP网络编程基础_unity网络编程

作者：正经夜光杯 | 2024-07-21 15:41:30

赞

踩

unity网络编程

Socket通讯基本流程图

1、服务端

1.1 创建服务器端Socket对象，负责监听客户端连接

  1. // 1.创建服务器端Socket对象，负责监听客户端连接
  2. socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

1.2 绑定IP与端口

  1. IPAddress ip = IPAddress.Parse(_ip);
  2. IPEndPoint point = new IPEndPoint(ip, _port);   //创建对象端口
  3. // 2.绑定IP与端口
  4. socketWatch.Bind(point);

 1.3 设置监听，设置最大监听数

  1. // 3.设置监听，设置最大监听数
  2. socketWatch.Listen(10);

1.4 等待接收客户端连接（返回用于和客户端通讯的Socket）

  1. // 4.等待接收客户端连接（返回用于和客户端通讯的Socket）
  2. while(true)
  3. {
  4.     socketSend = socketWatch.Accept();           //等待接收客户端连接
  5. }

 1.5 接收消息

  1. // 5.接收消息
  2. int len = socketSend.Receive(buffer);       //实际接收到的有效字节数

1.6 发送消息

  1. // 6.发送消息
  2. socketSend.Send(sendByte);

 1.7 关闭Socket

  1. // 7.关闭Socket
  2. socketWatch.Shutdown(SocketShutdown.Both);    //禁用Socket的发送和接收功能
  3. socketWatch.Close();                          //关闭Socket连接并释放所有相关资源
  4.  
  5. socketSend.Shutdown(SocketShutdown.Both);     //禁用Socket的发送和接收功能
  6. socketSend.Close();                           //关闭Socket连接并释放所有相关资源

2、客户端

2.1 创建一个Socket对象（和服务端进行通讯）

  1. // 1.创建一个Socket对象（和服务端进行通讯）
  2. socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

2.2 连接服务器

  1. IPAddress ip = IPAddress.Parse(_ip);
  2. IPEndPoint point = new IPEndPoint(ip, _port);
  3. // 2.连接服务器
  4. socketSend.Connect(point);

 2.3 接受消息

  1. // 3.接受消息
  2. int len = socketSend.Receive(buffer);

 2.4 发送消息

  1. // 4.发送消息
  2. socketSend.Send(buffer);

2.5 关闭Socket

  1. // 5.关闭Socket
  2. socketSend.Shutdown(SocketShutdown.Both);    //禁用Socket的发送和接收功能
  3. socketSend.Close();                          //关闭Socket连接并释放所有相关资源

 

 3、简单实现完整代码

3.1 服务端

  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Net;
  5. using System.Net.Sockets;	//调用socket
  6. using System.Text;
  7. using System.Threading;	//调用线程
  8. using UnityEngine;
  9. using System.IO;
  10.  
  11. public class TCPServer : MonoBehaviour
  12. {
  13.     //定义变量（与GUI一致）
  14.     private string info = "NULL";                          //状态信息
  15.     private string recMes = "NULL";                        //接收到的信息
  16.     private int recTimes = 0;                              //接收到的信息次数 
  17.  
  18.     private string inputIp = "127.0.0.1";                   //ip地址（本地）
  19.     private string inputPort = "8080";                     //端口值
  20.     private string inputMessage = "NULL";                  //用以发送的信息   
  21.  
  22.     private Socket socketWatch;                            //用以监听的套接字
  23.     private Socket socketSend;                             //用以和客户端通信的套接字
  24.  
  25.     private bool isSendData = false;                       //是否点击发送数据按钮
  26.     private bool clickConnectBtn = false;                  //是否点击监听按钮
  27.  
  28.     // Start is called before the first frame update
  29.     void Start()
  30.     {
  31.  
  32.     }
  33.  
  34.     // Update is called once per frame
  35.     void Update()
  36.     {
  37.  
  38.     }
  39.  
  40.     //建立tcp通信链接
  41.     private void ClickConnect()
  42.     {
  43.         try
  44.         {
  45.             int _port = Convert.ToInt32(inputPort);         //获取端口号（32位，4个字节）
  46.             string _ip = inputIp;                           //获取ip地址
  47.  
  48.             Debug.Log(" ip 地址是 ：" + _ip);
  49.             Debug.Log(" 端口号是 ：" + _port);
  50.  
  51.             clickConnectBtn = true;                         //点击了监听按钮，更改状态
  52.  
  53.             info = "ip地址是 ： " + _ip + "端口号是 ： " + _port;
  54.  
  55.             // 1.创建服务器端Socket对象，负责监听客户端连接
  56.             socketWatch = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  57.  
  58.             IPAddress ip = IPAddress.Parse(_ip);
  59.             IPEndPoint point = new IPEndPoint(ip, _port);   //创建对象端口
  60.             // 2.绑定IP与端口
  61.             socketWatch.Bind(point);                        //绑定端口号
  62.  
  63.             Debug.Log("监听成功!");
  64.             info = "监听成功";
  65.  
  66.             // 3.设置监听，设置最大监听数
  67.             socketWatch.Listen(10);                         //设置监听，最大同时连接10台
  68.  
  69.             //创建监听线程
  70.             Thread thread = new Thread(Listen);
  71.             thread.IsBackground = true;
  72.             thread.Start(socketWatch);
  73.         }
  74.         catch { }
  75.     }
  76.  
  77.     /// <summary>
  78.     /// 等待客户端的连接 并且创建与之通信的Socket
  79.     /// </summary>
  80.     void Listen(object o)
  81.     {
  82.         try
  83.         {
  84.             Socket socketWatch = o as Socket;
  85.             while (true)
  86.             {
  87.                 // 4.等待接收客户端连接（返回用于和客户端通讯的Socket）
  88.                 socketSend = socketWatch.Accept();           //等待接收客户端连接
  89.  
  90.                 Debug.Log(socketSend.RemoteEndPoint.ToString() + ":" + "连接成功!");
  91.                 info = socketSend.RemoteEndPoint.ToString() + "  连接成功!";
  92.  
  93.                 Thread r_thread = new Thread(Received);      //开启一个新线程，执行接收消息方法
  94.                 r_thread.IsBackground = true;
  95.                 r_thread.Start(socketSend);
  96.  
  97.                 Thread s_thread = new Thread(SendMessage);   //开启一个新线程，执行发送消息方法
  98.                 s_thread.IsBackground = true;
  99.                 s_thread.Start(socketSend);
  100.             }
  101.         }
  102.         catch { }
  103.     }
  104.  
  105.     // 服务器端不停的接收客户端发来的消息
  106.     void Received(object o)
  107.     {
  108.         try
  109.         {
  110.             Socket socketSend = o as Socket;
  111.             while (true)
  112.             {
  113.                 byte[] buffer = new byte[1024 * 6];         //客户端连接服务器成功后，服务器接收客户端发送的消息
  114.                 // 5.接收消息
  115.                 int len = socketSend.Receive(buffer);       //实际接收到的有效字节数
  116.                 if (len == 0)
  117.                 {
  118.                     break;
  119.                 }
  120.                 string str = Encoding.UTF8.GetString(buffer, 0, len);
  121.  
  122.                 Debug.Log("接收到的消息：" + socketSend.RemoteEndPoint + ":" + str);
  123.                 recMes = str;
  124.  
  125.                 recTimes++;
  126.                 info = "接收到一次数据，接收次数为：" + recTimes;
  127.                 Debug.Log("接收数据次数：" + recTimes);
  128.             }
  129.         }
  130.         catch { }
  131.     }
  132.  
  133.     // 服务器端不停的向客户端发送消息
  134.     void SendMessage(object o)
  135.     {
  136.         try
  137.         {
  138.             Socket socketSend = o as Socket;
  139.             while (true)
  140.             {
  141.                 if (isSendData)
  142.                 {
  143.                     isSendData = false;
  144.  
  145.                     byte[] sendByte = Encoding.UTF8.GetBytes(inputMessage);
  146.  
  147.                     Debug.Log("发送的数据为 :" + inputMessage);
  148.                     Debug.Log("发送的数据字节长度 :" + sendByte.Length);
  149.  
  150.                     // 6.发送消息
  151.                     socketSend.Send(sendByte);
  152.                 }
  153.             }
  154.         }
  155.         catch { }
  156.     }
  157.  
  158.     // 关闭连接，释放资源
  159.     private void OnDisable()
  160.     {
  161.         Debug.Log("begin OnDisable()");
  162.  
  163.         if (clickConnectBtn)
  164.         {
  165.             try
  166.             {
  167.                 // 7.关闭Socket
  168.                 socketWatch.Shutdown(SocketShutdown.Both);    //禁用Socket的发送和接收功能
  169.                 socketWatch.Close();                          //关闭Socket连接并释放所有相关资源
  170.  
  171.                 socketSend.Shutdown(SocketShutdown.Both);     //禁用Socket的发送和接收功能
  172.                 socketSend.Close();                           //关闭Socket连接并释放所有相关资源           
  173.             }
  174.             catch (Exception e)
  175.             {
  176.                 Debug.Log(e.Message);
  177.             }
  178.         }
  179.  
  180.         Debug.Log("end OnDisable()");
  181.     }
  182.  
  183.     //交互界面（代码创建）
  184.     void OnGUI()
  185.     {
  186.         GUI.color = Color.black;	//字体颜色
  187.  
  188.         GUI.Label(new Rect(65, 10, 80, 20), "状态信息");
  189.  
  190.         GUI.Label(new Rect(155, 10, 80, 70), info);
  191.  
  192.         GUI.Label(new Rect(65, 80, 80, 20), "接收到消息：");
  193.  
  194.         GUI.Label(new Rect(155, 80, 80, 20), recMes);
  195.  
  196.         GUI.Label(new Rect(65, 120, 80, 20), "发送的消息：");
  197.  
  198.         inputMessage = GUI.TextField(new Rect(155, 120, 100, 20), inputMessage, 20);
  199.  
  200.         GUI.Label(new Rect(65, 160, 80, 20), "本机ip地址：");
  201.  
  202.         inputIp = GUI.TextField(new Rect(155, 160, 100, 20), inputIp, 20);
  203.  
  204.         GUI.Label(new Rect(65, 200, 80, 20), "本机端口号：");
  205.  
  206.         inputPort = GUI.TextField(new Rect(155, 200, 100, 20), inputPort, 20);
  207.  
  208.         if (GUI.Button(new Rect(65, 240, 60, 20), "开始监听"))
  209.         {
  210.             ClickConnect();	//点击开始
  211.         }
  212.  
  213.         if (GUI.Button(new Rect(65, 280, 60, 20), "发送数据"))
  214.         {
  215.             isSendData = true;	//发送数据
  216.         }
  217.     }
  218. }
  219.

3.2 客户端

  1. using System;
  2. using System.Collections;
  3. using System.Collections.Generic;
  4. using System.Net;
  5. using System.Net.Sockets;
  6. using System.Text;
  7. using System.IO;
  8.  
  9. using System.Threading;
  10. using UnityEngine;
  11. using UnityEngine.UI;
  12.  
  13. public class TCPClient : MonoBehaviour
  14. {
  15.     public string staInfo = "NULL";             //状态信息
  16.     public string inputIp = "127.0.0.1";   //输入ip地址
  17.     public string inputPort = "8080";           //输入端口号
  18.     public string inputMes = "NULL";             //发送的消息
  19.     public int recTimes = 0;                    //接收到信息的次数
  20.     public string recMes = "NULL";              //接收到的消息
  21.     public Socket socketSend;                   //客户端套接字，用来链接远端服务器
  22.     public bool clickSend = false;              //是否点击发送按钮
  23.  
  24.     void Start()
  25.     {
  26.  
  27.     }
  28.  
  29.     // Update is called once per frame
  30.     void Update()
  31.     {
  32.  
  33.     }
  34.  
  35.     //建立链接
  36.     public void ClickConnect()
  37.     {
  38.         try
  39.         {
  40.             int _port = Convert.ToInt32(inputPort);             //获取端口号
  41.             string _ip = inputIp;                               //获取ip地址
  42.  
  43.             // 1.创建一个Socket对象（和服务端进行通讯）
  44.             socketSend = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  45.  
  46.             IPAddress ip = IPAddress.Parse(_ip);
  47.             IPEndPoint point = new IPEndPoint(ip, _port);
  48.             // 2.连接服务器
  49.             socketSend.Connect(point);
  50.             Debug.Log("连接成功 , " + " ip = " + ip + " port = " + _port);
  51.             staInfo = ip + ":" + _port + "  连接成功";
  52.  
  53.             Thread r_thread = new Thread(Received);             //开启新的线程，不停的接收服务器发来的消息
  54.             r_thread.IsBackground = true;
  55.             r_thread.Start();
  56.  
  57.             Thread s_thread = new Thread(SendMessage);          //开启新的线程，不停的给服务器发送消息
  58.             s_thread.IsBackground = true;
  59.             s_thread.Start();
  60.         }
  61.         catch (Exception)
  62.         {
  63.             Debug.Log("IP或者端口号错误......");
  64.             staInfo = "IP或者端口号错误......";
  65.         }
  66.     }
  67.  
  68.     /// <summary>
  69.     /// 接收服务端返回的消息
  70.     /// </summary>
  71.     void Received()
  72.     {
  73.         while (true)
  74.         {
  75.             try
  76.             {
  77.                 byte[] buffer = new byte[1024 * 6];
  78.                 //实际接收到的有效字节数
  79.                 // 3.接受消息
  80.                 int len = socketSend.Receive(buffer);
  81.                 if (len == 0)
  82.                 {
  83.                     break;
  84.                 }
  85.  
  86.                 recMes = Encoding.UTF8.GetString(buffer, 0, len);
  87.  
  88.                 Debug.Log("客户端接收到的数据 ： " + recMes);
  89.  
  90.                 recTimes++;
  91.                 staInfo = "接收到一次数据，接收次数为 ：" + recTimes;
  92.                 Debug.Log("接收次数为：" + recTimes);
  93.             }
  94.             catch { }
  95.         }
  96.     }
  97.  
  98.     /// <summary>
  99.     /// 向服务器发送消息
  100.     /// </summary>
  101.     /// <param name="sender"></param>
  102.     /// <param name="e"></param>
  103.     void SendMessage()
  104.     {
  105.         try
  106.         {
  107.             while (true)
  108.             {
  109.                 if (clickSend)                              //如果点击了发送按钮
  110.                 {
  111.                     clickSend = false;
  112.                     string msg = inputMes;
  113.                     byte[] buffer = new byte[1024 * 6];
  114.                     buffer = Encoding.UTF8.GetBytes(msg);
  115.  
  116.                     // 4.发送消息
  117.                     socketSend.Send(buffer);
  118.                     Debug.Log("发送的数据为：" + msg);
  119.                 }
  120.             }
  121.         }
  122.         catch { }
  123.     }
  124.  
  125.  
  126.     private void OnDisable()
  127.     {
  128.         Debug.Log("begin OnDisable()");
  129.         if (socketSend == null) return;
  130.         if (socketSend.Connected)
  131.         {
  132.             try
  133.             {
  134.                 // 5.关闭Socket
  135.                 socketSend.Shutdown(SocketShutdown.Both);    //禁用Socket的发送和接收功能
  136.                 socketSend.Close();                          //关闭Socket连接并释放所有相关资源
  137.             }
  138.             catch (Exception e)
  139.             {
  140.                 print(e.Message);
  141.             }
  142.         }
  143.  
  144.         Debug.Log("end OnDisable()");
  145.     }
  146.  
  147.     //用户界面
  148.     void OnGUI()
  149.     {
  150.         GUI.color = Color.black;
  151.  
  152.         GUI.Label(new Rect(65, 10, 60, 20), "状态信息");
  153.  
  154.         GUI.Label(new Rect(135, 10, 80, 60), staInfo);
  155.  
  156.         GUI.Label(new Rect(65, 70, 50, 20), "服务器ip地址");
  157.  
  158.         inputIp = GUI.TextField(new Rect(125, 70, 100, 20), inputIp, 20);
  159.  
  160.         GUI.Label(new Rect(65, 110, 50, 20), "服务器端口");
  161.  
  162.         inputPort = GUI.TextField(new Rect(125, 110, 100, 20), inputPort, 20);
  163.  
  164.         GUI.Label(new Rect(65, 150, 80, 20), "接收到消息：");
  165.  
  166.         GUI.Label(new Rect(155, 150, 80, 20), recMes);
  167.  
  168.         GUI.Label(new Rect(65, 190, 80, 20), "发送的消息：");
  169.  
  170.         inputMes = GUI.TextField(new Rect(155, 190, 100, 20), inputMes, 20);
  171.  
  172.         if (GUI.Button(new Rect(65, 230, 60, 20), "开始连接"))
  173.         {
  174.             ClickConnect();
  175.         }
  176.  
  177.         if (GUI.Button(new Rect(65, 270, 60, 20), "发送信息"))
  178.         {
  179.             clickSend = true;
  180.         }
  181.     }
  182. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/正经夜光杯/article/detail/861350
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号