Unity3D:TCPSocket模块

最新推荐文章于 2022-12-30 06:15:00 发布
最新推荐文章于 2022-12-30 06:15:00 发布
阅读量2.8k 收藏
点赞数
分类专栏： unity 文章标签： unity3d unity c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46324811/article/details/124145262
版权
该博客介绍了如何使用C#实现一个TCP服务器，包括`IServerSocket`接口定义，`SocketInfo`类用于保存客户端信息，以及`TCPServer_Socket`类的具体实现。服务器能监听指定IP和端口，接收客户端连接，处理接收和发送数据，并支持关闭操作。代码详细展示了连接建立、数据接收回调和发送数据的完整流程。
摘要由CSDN通过智能技术生成

服务端Socket-
上接口

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

namespace YDB.TCPSocket
{
    public interface IServerSocket
    {
        /// <summary>
        /// 连接并接收数据
        /// </summary>
        void StartAccept(string receiveIP_str, string receivePort_str, Action<byte[]> action);
        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="sendIP_Str"></param>
        /// <param name="sendPort_int"></param>
        /// <param name="data"></param>
        void SendPackage(byte[] data);
        /// <summary>
        /// 关闭
        /// </summary>
        void ShutDown();
    }
}

在实现前，因为服务器需要接收客户端，所以定义一个类来保存客户端



using System;
using System.Net;
using System.Net.Sockets;

namespace YDB.TCPSocket
{
    public class SocketInfo
    {
        public Socket ClientSocket { get; private set; }
        public string ServerIP { get; private set; }
        public int ServerPort { get; private set; }
        public string ClientIP { get; private set; }
        public int ClientPort { get; private set; }
        public SocketAsyncEventArgs SocketAsyncEventArgs { get; private set; }
        public Action<byte[]> Callback { get; private set; }
        public static SocketInfo Create(Socket socket,Action<byte[]> callBack,SocketAsyncEventArgs socketAsyncEventArgs)
        {
            SocketInfo socketInfo = new SocketInfo();
            socketInfo.Callback = callBack;
            socketInfo.ClientSocket = socket;
            IPEndPoint iPEndPoint = socket.LocalEndPoint as IPEndPoint;
            socketInfo.ServerIP = iPEndPoint == null ? "" : iPEndPoint.Address.ToString();
            socketInfo.ServerPort = iPEndPoint == null ? -1 : iPEndPoint.Port;
            IPEndPoint remoteEndPoint = socket.RemoteEndPoint as IPEndPoint;
            socketInfo.ClientIP = remoteEndPoint == null ? "" : remoteEndPoint.Address.ToString();
            socketInfo.ClientPort = remoteEndPoint == null ? -1 : remoteEndPoint.Port;
            socketInfo.SocketAsyncEventArgs = socketAsyncEventArgs;
            return socketInfo;
        }
    }
}

接口具体实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using UnityEngine;
namespace YDB.TCPSocket
{
    public class TCPServer_Socket : IServerSocket
    {
        //接收数据容量大小
        private const int BufferSize = 1024;
        //Socket
        protected Socket mSocket;
        //连接进来的客户端列表
        private Dictionary<string,SocketInfo> mClientSockets = new Dictionary<string, SocketInfo>();

        public TCPServer_Socket()
        {
            mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        }
        /// <summary>
        /// 关闭
        /// </summary>
        public void ShutDown()
        {
            if (mSocket == null)
            {
                return;
            }
            try
            {
                mSocket.Shutdown(SocketShutdown.Both);
                mSocket.Close();
            }
            catch (Exception e)
            {
                throw new Exception(e.ToString());
            }
        }
        #region 接收数据
        /// <summary>
        /// 测试时，不能以127.0.0.1测试
        /// </summary>
        /// <param name="receiveIP_str">IP</param>
        /// <param name="receivePort_str">Port</param>
        /// <param name="messageConverter">数据转换，默认Json</param>
        public void StartAccept(string receiveIP_str, string receivePort_str,Action<byte[]> action)
        {
            if (string.IsNullOrEmpty(receiveIP_str) || string.IsNullOrEmpty(receivePort_str))
            {
                return;
            }
            int receivePort = int.Parse(receivePort_str);
            OnStartAccept(receiveIP_str, receivePort,action);
        }
        /// <summary>
        /// 接收数据
        /// </summary>
        /// <param name="eventArgs"></param>
        private void OnStartAccept(string receiveIP_str, int receivePort_str, Action<byte[]> action)
        {
            try
            {
                IPEndPoint receiveIPEndPoint = new IPEndPoint(IPAddress.Parse(receiveIP_str), receivePort_str);
                Debug.Log(string.Format("绑定IP:{0}和Port:{1}", receiveIP_str, receivePort_str));
                mSocket.Bind(receiveIPEndPoint);
                mSocket.Listen(10);

                SocketAsyncEventArgs receiveCompletedEventArgs = new SocketAsyncEventArgs();
                receiveCompletedEventArgs.Completed += AcceptCompolited;
                receiveCompletedEventArgs.UserToken = action;

                OnAccept(receiveCompletedEventArgs);
            }
            catch (Exception e)
            {
                throw new Exception(e.ToString());
            }
        }

        private void OnAccept(SocketAsyncEventArgs socketAsyncEventArgs)
        {
            Debug.Log("等待接收客户端");
            try
            {
                bool result = mSocket.AcceptAsync(socketAsyncEventArgs);
                if (result == false)
                {
                    ProcessAccept(socketAsyncEventArgs);
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.ToString());
            }
        }
        /// <summary>
        /// 接收数据完成回调事件
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void AcceptCompolited(object sender, SocketAsyncEventArgs e)
        {
            ProcessAccept(e);
        }
        /// <summary>
        /// 处理接收事件
        /// </summary>
        /// <param name="e"></param>
        private void ProcessAccept(SocketAsyncEventArgs e)
        {
            try
            {
                //接收到的Socket还是服务器的Socket，RemoteIP/Port被赋值
                Socket socket = e.AcceptSocket;
                Action<byte[]> callback = e.UserToken as Action<byte[]>;

                IPEndPoint point = socket.RemoteEndPoint as IPEndPoint;
                Console.WriteLine("接收到了" + point.Address.ToString() + ":" + point.Port.ToString());

                SocketAsyncEventArgs receiveAsyncEventArgs = new SocketAsyncEventArgs();
                receiveAsyncEventArgs.SetBuffer(new byte[BufferSize], 0, BufferSize);
                receiveAsyncEventArgs.Completed += ReceiveCompleted;
                SocketInfo receiveSocketInfo = SocketInfo.Create(socket, callback, receiveAsyncEventArgs);
                receiveAsyncEventArgs.UserToken = receiveSocketInfo;

                OnReceive(receiveSocketInfo);
                mClientSockets.Add(receiveSocketInfo.ClientIP+receiveSocketInfo.ClientPort, receiveSocketInfo);
                Debug.Log(receiveSocketInfo.ClientIP + ":" + receiveSocketInfo.ClientPort + "已连接");

                e.AcceptSocket = null;

                OnAccept(e);
            }
            catch (Exception exception)
            {

                throw new Exception(exception.ToString());
            }
        }

        /// <summary>
        /// 递归接收入口
        /// </summary>
        /// <param name="e"></param>
        private void OnReceive(SocketInfo socketInfo)
        {
            Socket socket = socketInfo.ClientSocket;
            bool result = socket.ReceiveAsync(socketInfo.SocketAsyncEventArgs);
            if (result == false)
            {
                ProcessReceive(socketInfo.SocketAsyncEventArgs);
            }
        }
        /// <summary>
        /// 接收完成
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void ReceiveCompleted(object sender, SocketAsyncEventArgs e)
        {
            ProcessReceive(e);
        }
        /// <summary>
        /// 接收完成后处理事件
        /// </summary>
        /// <param name="e"></param>
        private void ProcessReceive(SocketAsyncEventArgs e)
        {
            if (e.SocketError == SocketError.Success && e.BytesTransferred > 0)
            {
                byte[] data = new byte[BufferSize];
                Buffer.BlockCopy(e.Buffer, 0, data, 0, e.BytesTransferred);

                e.SetBuffer(new byte[BufferSize], 0, BufferSize);
                
                SocketInfo socketInfo = e.UserToken as SocketInfo;
                Action<byte[]> callback = socketInfo.Callback;
                callback(data);

                OnReceive(socketInfo);
            }
            else
            {
                if (e.BytesTransferred == 0)
                {
                    if (e.SocketError == SocketError.Success)
                    {
                        //客户端主动断开连接
                        Debug.LogError("客户端主动断开连接");
                    }
                    else
                    {
                        Debug.LogError("网络异常");
                    }
                }
            }
        }

        #endregion
        #region 发送数据

        /// <summary>
        /// 发送数据
        /// </summary>
        /// <param name="data"></param>
        public void SendPackage(byte[] data)
        {
            try
            {
                foreach (var item in mClientSockets.Values)
                {
                    EndPoint sendEndPoint = new IPEndPoint(IPAddress.Parse(item.ClientIP), item.ClientPort);
                    SocketAsyncEventArgs mSendAsyncEventArgs = new SocketAsyncEventArgs();
                    mSendAsyncEventArgs.UserToken = item;
                    mSendAsyncEventArgs.RemoteEndPoint = sendEndPoint;
                    mSendAsyncEventArgs.Completed += SendCompolited;
                    mSendAsyncEventArgs.SetBuffer(data, 0, data.Length);
                    bool result = item.ClientSocket.SendToAsync(mSendAsyncEventArgs);
                    if (result == false)
                    {
                        ProcessSend(mSendAsyncEventArgs);
                    }
                }
            }
            catch (Exception e)
            {
                throw new Exception(e.ToString());
            }
        }

        private void SendCompolited(object sender, SocketAsyncEventArgs e)
        {
            ProcessSend(e);
        }

        private void ProcessSend(SocketAsyncEventArgs async)
        {
            try
            {
                Debug.Log("TCP已发送");
            }
            catch (Exception e)
            {
                throw new Exception(e.ToString());
            }
        }
        #endregion
    }
}
言出必行小白鸟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Unity3D socket
仗剑为红颜
10-21 7609
1年前的unity3D项目里面之封装了引擎层。完全没涉及到服务器收发。 最近继续深入u3d了。打算弄个框架。自然这个socket要我自己写了。花了1天的时间大概写好了。自己写了一个服务器一个客户端测了一下。 还不错。哈哈哈。 废话不说上代码. 使用双线程收发。这里有个取巧。 我在每帧更新之前。在主线程调用收线程的数据。 在每帧更新之后。在主线程发送数据到发线程。 这样我收和发的过程中
tcp unity 图片_Unity3d中的Tcp socket通信（开源）
weixin_42356460的博客
12-30 262
HiSocket_unity如何使用可以从此链接下载最新的unity package: 功能Tcp socketUdp socket可伸缩字节表高性能字节块缓冲区消息注册和回调二进制字节消息封装Protobuf消息封装AES消息加密详情Tcp和Udp都是采用主线程异步连接的方式(避免主线程阻塞).启动发送线程和接收线程处理数据传输(提高性能).供用户调用发送或接受数据的API在主线程中(方便直接操...
unity3D中使用Socket进行数据通信（二）
老李与代码二三事
02-17 8453
上一篇博客主要介绍了使用socket搭建服务端和客户端程序，这一篇来说说socket的数据传输，我们使用socket的目的是解决点对点之间的数据传输，之前提到了socket中一个重要的概念：端口。而socket传输数据的方式就是端口与端口之间以流（stream）的方式传输数据，socket命名空间中提供了该流的一个功能类（NetworkStream），用起来很方便，因为任何可以转换为二进制的数据都
unity开发：TCP socket网络连接
踏莎行的博客
06-13 1万+
unity内部封装了一个很高层次的网络接口，不过有时候并不需要那么复杂的功能，只是想实现简单的TCP网络连接，可以在unity里面用C#写tcp socket。 以下TCP连接是同步模式。 建立两个unity工程，编写脚本。 服务端 using UnityEngine; using System.Collections; //引入库 using System.Net; us
简单的基于Unity3D的Socket通讯
09-06
简单的基于Unity的客户端连接服务器端，相互发送一次数据，文档描述位于http://blog.sina.com.cn/s/blog_1322690230102y3l4.html
Unity3D Best HTTP Pro
01-14
BestHTTP库是针对Unity3D的网络通信模块的增强，特别针对Http、WebSocket、Socket和SignalR这四种常见的网络协议进行了封装。下面将详细介绍这些通信方式及其在Unity3D中的应用： 1. **Http**：超文本传输协议...
Chat:简单客户端（Unity3D）-服务器（C#）聊天
06-30
在本项目中，我们探讨的是一个简单的聊天应用实现，它由Unity3D开发的客户端和C#编写的服务器端组成。这个系统的核心是通过网络通信技术实现用户之间的实时消息传递。接下来，我们将深入讨论其中涉及的关键知识点。 ...
unity网络传输 Best HTTP Pro
04-07
Best HTTP Pro提供了Socket接口，开发者可以直接进行TCP或UDP通信，实现更精细的控制。这对于需要高性能、低延迟的网络应用来说尤其重要，例如在线竞技游戏和实时策略游戏。 四、SignalR实时框架 SignalR是一个用于...
unity五子棋服务器端及客户端下载地址
08-31
2. **网络编程基础**：理解TCP/IP协议、Socket编程原理，有助于更好地掌握Unity网络通信机制。 3. **游戏逻辑设计**：研究五子棋游戏规则，设计高效的游戏逻辑处理算法。 4. **实践项目**：动手实现一个简单的五子棋...
UnityGameFramework案例源码.zip
05-31
网络 (Network) – 提供使用 Socket 长连接的功能，当前我们支持 TCP 协议，同时兼容 IPv4 和 IPv6 两个版本。用户可以同时建立多个连接与多个服务器同时进行通信，比如除了连接常规的游戏服务器，还可以连接语音...
Unity Socket网络模块
09-27
介绍Socket网络连接模块： 主要分为四部分： 一、套接字管理器（SocketManager.cs） 1)、连接 2)、断开 3)、接收（线程） 4)、发送（携程） 二、消息中心：（MessageCenter.cs） 1)、游戏逻辑事件 2)、网络数据事件（线程） 三、数据封装： 1)、网络数据缓冲器（DataBuff.cs） 2)、二进制字节流（ByteStreamBuffer.cs)
Socket网络模块（Unity c#）
09-14
介绍Socket网络连接模块： 主要分为四部分： 一、套接字管理器（SocketManager.cs） 1)、连接 2)、断开 3)、接收（线程） 4)、发送（携程） 二、消息中心：（MessageCenter.cs） 1)、游戏逻辑事件 2)、网络数据事件（线程） 三、数据封装： 1)、网络数据缓冲器（DataBuff.cs） 2)、二进制字节流（ByteStreamBuffer.cs)
Unity3DSocketDemo
03-30
原文地址：http://blog.csdn.net/genius840215/article/details/7411749
Unity3D教程：学习Socket(一)1
08-08
30 } 31 } 服务端：1）.用Socket()获得一个Socket描述2）.用Bind()
unity3D中使用Socket进行数据通信
qq_40544338的博客
03-03 696
一、目的 1、想：unity3D中使用Socket进行数据通信 二、参考 1、unity3D中使用Socket进行数据通信 https://blog.csdn.net/qq_38112703/article/details/82624469 待检测 1、 三、注意 1、 四、操作 1、 ...
Unity3D的Socket通信
林涵宇的博客
07-29 1289
我们知道两个进程如果需要进行通讯最基本的一个前提是有唯一的标示一个进程，在本地进程通讯中我们可以使用PID来唯一标示一个进程，但PID只在本地唯一，网络中的两个进程PID冲突几率很大，这时候我们需要另辟它径了，我们知道IP层的ip地址可以唯一标示主机，而TCP层协议和端口号可以唯一标示主机的一个进程，这样我们可以利用ip地址＋协议＋端口号唯一标示网络中的一个进程。 能够唯一标示网络中的进程后
Unity3D中的Socket通信
最新发布
小小姑娘
12-30 351
第一部分简单示例：连接服务器Ip 端口，发送请求，接收数据同理。
unity3D中使用Socket进行数据通信（一）
热门推荐
一个默默的游戏制作者......
09-11 3万+
今年3D产品的工作中心主要集中在提高产品深度上，通过对竞争产品的分析，发现我们的缺陷在于多人在线与后台管理部分，多人在线使用unity自带的Network可以搞定，后台部分前段时间主要研究了下Sqlite。由于sqlite本身不带服务器，作为数据库只是一个文件，sqlite放在服务器上与客户端通信的需求其实就是多个客户端访问同一个文件了，查了一些资料，有很多方法，个人感觉socket不错，一来应用...
Unity3D入门：基于Socket的公共聊天室实现详解
"本篇Unity3D教程详细介绍了如何在Unity3D中实现基于Socket通讯的公共聊天室功能。作者首先从网络基础知识出发，强调了Socket通讯在网络游戏中的重要性，特别适合初学者理解网游开发的基础架构。教程通过一个C#编写...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值