Unity网络通信基础：手把手实现稳定可靠的Socket TCP客户端

1. 项目概述：为什么Unity开发者绕不开Socket通信？

如果你刚开始接触Unity网络功能，可能会被Unity自带的UNet（已弃用）、Mirror、Netcode for GameObjects这些框架搞得眼花缭乱。但无论上层框架如何封装，底层通信的基石，尤其是在需要与自定义后端、硬件设备或非Unity服务通信时，往往还是最经典的Socket TCP。我见过不少新手朋友，一上来就想搞复杂的房间同步、状态同步，结果在连接服务器这个最基础的环节就卡住了，连不上、收不到数据、连接异常断开，问题层出不穷。其实，搞定一个稳定可靠的TCP客户端，是解锁一切高级网络功能的第一步。

这个“5分钟”的标题，不是说让你囫囵吞枣抄完代码就跑，而是指在理解核心流程后，搭建一个可工作的基础通信模块确实很快。关键在于，你得知道每一行代码在干什么，以及背后可能埋着哪些“坑”。今天，我就以一个Unity老鸟的身份，带你从零开始，手把手拆解Socket TCP客户端的每一个环节，并附上我实战中打磨过的、带完整错误处理的代码。我们不止于连接成功，更要追求连接稳定、数据收发可靠。

2. 核心思路与架构设计：告别“黑盒”，理解通信生命周期

在动手写代码之前，我们必须像建筑师看蓝图一样，看清整个TCP客户端通信的生命周期。这能帮你未来在调试“为什么收不到数据？”或“为什么突然断开了？”这种问题时，快速定位到问题环节。

2.1 TCP通信的核心四步曲

一个完整的TCP客户端通信流程，可以抽象为四个核心阶段，它们构成了一个清晰的闭环：

1. 建立连接：客户端主动向服务器指定的IP地址和端口发起连接请求。这背后是经典的TCP三次握手，确保双方都准备好通信。在代码层面，就是创建Socket对象并调用Connect方法。
2. 发送数据：将你要传输的信息（比如玩家的移动指令、聊天消息）从内存中的字节数组（byte[]），通过已建立的连接通道发送出去。这里的关键是处理“粘包”问题。
3. 接收数据：持续监听来自服务器的数据流，将接收到的原始字节流，按照约定的规则解析成有意义的应用层数据。这里的关键是处理“拆包”和异步非阻塞。
4. 关闭连接：通信结束或发生错误时，有序地关闭Socket，释放系统资源。粗暴地关闭可能导致对端收到异常。

2.2 Unity中的线程安全考量：为什么不能用Update直接收发？

这是新手最容易踩的坑。Socket的Receive方法是阻塞的：如果调用时没有数据可读，它会一直卡在那里等待，直到有数据到来或超时。如果你在主线程（比如Update函数里）直接调用Receive，游戏画面就会“卡住”，直到收到数据为止，这是绝对不允许的。

因此，必须使用多线程或异步编程模型，将耗时的网络IO操作放到后台去执行。在Unity中，我们有几种选择：

• 传统多线程：使用System.Threading.Thread。功能强大但需要手动管理线程生命周期和与主线程的通信（通过UnityEngine.Dispatcher或共享队列）。
• 基于任务的异步模式：使用System.Threading.Tasks.Task配合async/await。代码可读性更好，是C#的现代推荐做法。
• Unity协程：协程（IEnumerator）本质上是单线程的，它无法真正解决Receive阻塞主线程的问题，因此不适合用于核心的网络数据接收循环。它更适合用于处理接收后的数据解析、UI更新等主线程工作。

在本教程中，为了清晰展示原理，我们将使用Thread来创建独立的接收线程。在实际项目中，你可能会选择Task或更高级的库。

2.3 数据协议设计：解决“粘包/拆包”的灵魂

TCP是流式协议，它只保证字节流的顺序和可靠性，不维护消息边界。这意味着你发送的“Hello”和“World”两个数据包，在接收端可能被一次性收到“HelloWorld”。这就是“粘包”。反之，一个大数据包也可能被拆分成多次收到。

解决方案是定义应用层协议。最简单常用的两种方式是：

• 长度前缀法：在每条实际数据前，固定添加一个头部（比如4个字节的int），用来声明后面跟着的数据体的长度。接收方先读固定长度的头部，解析出长度N，再精确读取后续N个字节，这就构成了一条完整消息。
• 分隔符法：用特殊的字符（如换行符\n）作为消息结束标记。适用于文本协议。

我们将采用长度前缀法，因为它更通用、更高效，能完美处理二进制数据。

3. 核心代码模块拆解与逐行精讲

下面，我们开始构建TcpClientManager类。我会将完整代码分段展示，并穿插最重要的“注意事项”和“实操心得”。

3.1 连接管理：稳健地握手与告别

首先，定义必要的字段和属性。

using System; using System.Net; using System.Net.Sockets; using System.Threading; using UnityEngine; public class TcpClientManager : MonoBehaviour { // 服务器配置 public string serverIP = "127.0.0.1"; // 默认本地回环地址 public int serverPort = 8080; // Socket核心对象 private Socket _clientSocket = null; // 接收线程 private Thread _receiveThread = null; // 控制接收线程循环的标志 private bool _isReceiving = false; // 用于主线程与网络线程安全通信的队列（简易版，生产环境建议用ConcurrentQueue或自定义锁） private System.Collections.Queue _messageQueue = System.Collections.Queue.Synchronized(new System.Collections.Queue()); // 定义委托和事件，用于将接收到的数据通知给其他游戏组件 public delegate void OnMessageReceived(byte[] data); public event OnMessageReceived MessageReceived; // 连接状态事件，便于UI更新 public delegate void OnConnectionStateChanged(bool isConnected); public event OnConnectionStateChanged ConnectionStateChanged; }

连接服务器的核心方法：

public bool ConnectToServer() { // 如果已连接，先断开 if (_clientSocket != null && _clientSocket.Connected) { Debug.LogWarning("已存在连接，正在断开旧连接..."); Disconnect(); } try { // 1. 创建Socket实例 // AddressFamily.InterNetwork 表示IPv4 // SocketType.Stream 表示流式Socket，对应TCP // ProtocolType.Tcp 表示TCP协议 _clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); // 2. 设置Socket选项（非必需，但推荐） // 启用Nagle算法（默认true）。小数据包会合并发送，降低网络负载但增加延迟。 // 对于实时性要求高的游戏（如FPS），可以考虑设置为false禁用。 _clientSocket.NoDelay = false; // 3. 将字符串IP地址转换为IPAddress对象 IPAddress ipAddress = IPAddress.Parse(serverIP); // 创建包含IP和端口号的终端节点 IPEndPoint remoteEndPoint = new IPEndPoint(ipAddress, serverPort); // 4. 发起同步连接 _clientSocket.Connect(remoteEndPoint); // 5. 连接成功，启动接收线程 _isReceiving = true; _receiveThread = new Thread(new ThreadStart(ReceiveDataLoop)); _receiveThread.IsBackground = true; // 设置为后台线程，主程序退出时会尝试终止它 _receiveThread.Start(); Debug.Log($"成功连接到服务器 {serverIP}:{serverPort}"); ConnectionStateChanged?.Invoke(true); // 触发连接成功事件 return true; } catch (SocketException socketEx) { // Socket异常是最常见的网络异常 Debug.LogError($"连接失败 (SocketError): {socketEx.SocketErrorCode} - {socketEx.Message}"); _clientSocket?.Close(); _clientSocket = null; } catch (ArgumentNullException anEx) { Debug.LogError($"IP地址格式错误: {anEx.Message}"); } catch (FormatException fEx) { Debug.LogError($"IP地址格式错误: {fEx.Message}"); } catch (Exception ex) { // 捕获其他所有异常 Debug.LogError($"连接发生未知异常: {ex.Message}"); _clientSocket?.Close(); _clientSocket = null; } ConnectionStateChanged?.Invoke(false); // 触发连接失败事件 return false; }

注意：异常处理是网络编程的命门。上述代码中，我们捕获了SocketException、ArgumentNullException、FormatException和通用的Exception。SocketException的SocketErrorCode属性尤其重要，它能告诉你具体的错误原因，如连接被拒绝、超时、主机不可达等，是调试的核心依据。

断开连接的方法：

public void Disconnect() { // 1. 停止接收线程循环 _isReceiving = false; // 2. 关闭Socket（这会中断任何阻塞的Receive或Send操作） if (_clientSocket != null) { if (_clientSocket.Connected) { try { // 优雅关闭：先Shutdown，再Close _clientSocket.Shutdown(SocketShutdown.Both); } catch (Exception ex) { Debug.LogWarning($"调用Shutdown时发生异常（可能已断开）: {ex.Message}"); } } _clientSocket.Close(); _clientSocket = null; Debug.Log("Socket已关闭"); } // 3. 等待接收线程结束（可选，但更安全） if (_receiveThread != null && _receiveThread.IsAlive) { // 给线程一点时间自然结束 if (!_receiveThread.Join(1000)) // 等待最多1秒 { Debug.LogWarning("接收线程未在指定时间内结束，将被强制终止。"); _receiveThread.Abort(); // 强制终止，谨慎使用，可能引发资源未释放问题 } _receiveThread = null; } // 4. 清空消息队列 lock (_messageQueue.SyncRoot) { _messageQueue.Clear(); } ConnectionStateChanged?.Invoke(false); // 触发断开连接事件 }

实操心得：关于Shutdown和Close的顺序。Shutdown(SocketShutdown.Both)通知对端“我不再发送也不再接收数据了”，这是一个礼貌的告别，确保缓冲区里的数据被处理完。然后再Close释放本地资源。直接Close虽然也行，但可能让对方感到突然。在OnDestroy或游戏退出时，务必调用Disconnect。

3.2 数据发送：解决“粘包”问题的关键实现

发送数据不是简单调用Send。我们必须实现前面提到的“长度前缀法”来封装消息。

public bool SendMessage(byte[] data) { if (_clientSocket == null || !_clientSocket.Connected) { Debug.LogError("无法发送数据：Socket未连接或为空。"); return false; } if (data == null || data.Length == 0) { Debug.LogWarning("尝试发送空数据，已忽略。"); return false; } try { // 1. 构建带长度头的完整数据包 // 假设我们使用4字节（Int32）存储长度信息 int totalLength = sizeof(int) + data.Length; // 包头长度 + 数据体长度 byte[] packet = new byte[totalLength]; // 2. 将数据体长度写入包头的4个字节 // BitConverter.GetBytes 将int转换为字节数组 byte[] lengthBytes = BitConverter.GetBytes(data.Length); // 将长度字节数组拷贝到packet数组的开头 Buffer.BlockCopy(lengthBytes, 0, packet, 0, lengthBytes.Length); // 将实际数据拷贝到packet数组的后面 Buffer.BlockCopy(data, 0, packet, lengthBytes.Length, data.Length); // 3. 发送完整数据包 // Send方法返回实际发送的字节数。在阻塞模式下，它会尝试发送所有数据。 int bytesSent = _clientSocket.Send(packet); // 4. 检查是否全部发送（在非阻塞模式下尤其重要） if (bytesSent != totalLength) { Debug.LogError($"数据发送不完整，预期发送{totalLength}字节，实际发送{bytesSent}字节。"); // 在实际项目中，这里可能需要重试发送剩余部分 return false; } // Debug.Log($"已发送数据包，长度: {totalLength} (头:{lengthBytes.Length}, 体:{data.Length})"); return true; } catch (SocketException socketEx) { Debug.LogError($"发送数据时发生Socket异常: {socketEx.SocketErrorCode}"); // 发送失败通常意味着连接已出问题，可以考虑触发重连 Disconnect(); return false; } catch (ObjectDisposedException) { // Socket已被关闭时调用Send会抛出此异常 Debug.LogWarning("尝试在已关闭的Socket上发送数据。"); return false; } catch (Exception ex) { Debug.LogError($"发送数据时发生未知异常: {ex.Message}"); return false; } } // 为了方便，提供一个发送字符串的重载方法 public bool SendMessage(string message) { if (string.IsNullOrEmpty(message)) return false; // 将字符串转换为UTF-8编码的字节数组 byte[] data = System.Text.Encoding.UTF8.GetBytes(message); return SendMessage(data); }

核心原理：BitConverter与字节序。BitConverter.GetBytes得到的字节数组，其字节序（是大端序还是小端序）取决于当前计算机的CPU架构。大多数Windows和Intel/AMD PC是小端序。为了保证跨平台通信（比如Unity客户端连接Linux服务器），发送方和接收方必须约定并使用同一种字节序。一个常见的做法是，无论本地字节序如何，我们都统一使用网络字节序（大端序）。可以使用IPAddress.HostToNetworkOrder方法将主机序整数转换为网络序，接收端再用IPAddress.NetworkToHostOrder转换回来。上面的示例为了简化，使用了主机序，你在实际项目中与服务器端协商一致即可。

3.3 数据接收：异步循环与“拆包”逻辑

这是最复杂的部分，接收线程在一个循环中工作，不断尝试读取数据，并按照长度头来解析出完整的应用层消息。

private void ReceiveDataLoop() { // 接收缓冲区，大小需要合理设置。太小会导致频繁读取，太大会浪费内存。 // 通常设置为略大于你预期的单条最大消息长度。 byte[] receiveBuffer = new byte[1024 * 4]; // 4KB缓冲区 // 用于暂存可能不完整的消息的“缓存区” System.Collections.Generic.List<byte> dataCache = new System.Collections.Generic.List<byte>(); // 下一条消息的预期长度，-1表示正在等待消息头 int nextMessageLength = -1; while (_isReceiving && _clientSocket != null && _clientSocket.Connected) { try { // 1. 从Socket接收数据到缓冲区 // Receive方法是阻塞的，会一直等待直到有数据可读或Socket关闭 int bytesRead = _clientSocket.Receive(receiveBuffer); // 2. 检查连接是否已关闭（对端优雅关闭） if (bytesRead == 0) { Debug.Log("服务器已主动关闭连接。"); break; // 退出接收循环 } // 3. 将本次读取到的数据添加到缓存 byte[] receivedData = new byte[bytesRead]; Buffer.BlockCopy(receiveBuffer, 0, receivedData, 0, bytesRead); dataCache.AddRange(receivedData); // 4. 循环处理缓存中的数据，可能一次收到多个包或半个包 bool hasProcessedData; do { hasProcessedData = false; // 情况A：正在等待消息头（4字节长度信息） if (nextMessageLength == -1 && dataCache.Count >= sizeof(int)) { // 从缓存中取出前4个字节作为长度头 byte[] lengthHeader = dataCache.GetRange(0, sizeof(int)).ToArray(); // 将字节数组转换回int（注意字节序问题，需与发送端匹配） nextMessageLength = BitConverter.ToInt32(lengthHeader, 0); // 从缓存中移除这4个字节 dataCache.RemoveRange(0, sizeof(int)); hasProcessedData = true; } // 情况B：已经知道消息长度，并且缓存中的数据足够组成一条完整消息 if (nextMessageLength > 0 && dataCache.Count >= nextMessageLength) { // 取出完整消息体 byte[] completeMessage = dataCache.GetRange(0, nextMessageLength).ToArray(); // 从缓存中移除这部分数据 dataCache.RemoveRange(0, nextMessageLength); // **将消息放入线程安全的队列，供主线程处理** _messageQueue.Enqueue(completeMessage); // 重置状态，准备读取下一条消息 nextMessageLength = -1; hasProcessedData = true; } // 情况C：数据不够一条完整消息，什么也不做，等待下次Receive } while (hasProcessedData); // 如果本次处理了数据，可能缓存里还有下一条消息的头或体，继续循环处理 } catch (SocketException socketEx) { // 10054: Connection reset by peer. 对方强制关闭连接。 // 10053: Software caused connection abort. 软件导致连接中止。 if (socketEx.SocketErrorCode == SocketError.ConnectionReset || socketEx.SocketErrorCode == SocketError.ConnectionAborted) { Debug.LogWarning($"连接被对端重置或中止: {socketEx.SocketErrorCode}"); } else { Debug.LogError($"接收数据时发生Socket异常: {socketEx.SocketErrorCode}"); } break; // 发生严重错误，退出接收循环 } catch (ObjectDisposedException) { // Socket在Receive过程中被关闭了 Debug.Log("Socket在接收时被释放，接收循环结束。"); break; } catch (ThreadAbortException) { // 线程被强制终止 Debug.Log("接收线程被终止。"); // Thread.ResetAbort(); // 如果需要阻止终止，可以调用这个，但通常我们允许终止 break; } catch (Exception ex) { Debug.LogError($"接收数据时发生未知异常: {ex.Message}"); break; } } // 循环结束，意味着连接已断开 Debug.Log("接收数据循环结束。"); _isReceiving = false; // 注意：这里不要直接调用Disconnect()，因为Disconnect会操作线程，可能引发死锁。 // 更好的做法是设置一个标志，由主线程在Update中检查并处理断开逻辑。 }

避坑指南：接收循环的“状态机”思维。上面的nextMessageLength和dataCache构成了一个简单的状态机。-1状态代表“等待消息头”，一旦凑够4字节就解析出长度并进入“等待消息体”状态。在“等待消息体”状态下，一旦缓存中的数据量达到预期长度，就提取出一条完整消息，并重置状态。这个逻辑是处理TCP流式数据、解决粘包拆包问题的核心，务必理解透彻。

3.4 主线程同步：Unity中安全处理网络消息

接收线程不能直接操作Unity对象（如GameObject、UI Text），否则会引发异常。我们需要将接收到的数据“桥接”回主线程。

void Update() { // 在主线程中，每帧检查并处理消息队列 if (_messageQueue != null && _messageQueue.Count > 0) { // 由于我们使用了Synchronized包装，这里也需要在锁内操作以确保绝对安全（虽然Enqueue/Dequeue本身是线程安全的） lock (_messageQueue.SyncRoot) { while (_messageQueue.Count > 0) { byte[] message = (byte[])_messageQueue.Dequeue(); // 触发事件，通知订阅者（其他脚本） MessageReceived?.Invoke(message); // 也可以在这里直接处理，例如打印日志 // ProcessReceivedMessage(message); } } } // 检查连接状态（简易版，可通过心跳包等机制增强） if (_clientSocket != null && !_clientSocket.Connected && _isReceiving) { Debug.Log("检测到连接已断开。"); _isReceiving = false; // 可以在这里触发重连逻辑 } } // 一个处理消息的示例方法 private void ProcessReceivedMessage(byte[] data) { // 示例：假设服务器发来的是UTF-8字符串 string messageString = System.Text.Encoding.UTF8.GetString(data); Debug.Log($"收到服务器消息: {messageString}"); // 你可以根据不同的消息类型（可以定义消息ID）进行分发处理 // 例如：处理玩家位置更新、聊天消息、游戏状态同步等。 }

重要提醒：Update中的性能考量。如果消息量非常大，每帧处理整个队列可能会造成主线程卡顿。一个优化方案是限制每帧处理的消息数量，例如while (_messageQueue.Count > 0 && processedCountThisFrame < 10)。对于实时性要求极高的游戏，可能需要更复杂的线程间通信机制。

3.5 在Unity中使用：一个完整的MonoBehaviour示例

将上面的代码整合到一个MonoBehaviour中，并提供一个简单的测试UI。

using UnityEngine; using UnityEngine.UI; public class NetworkTestUI : MonoBehaviour { public TcpClientManager tcpClient; // 拖拽赋值或GetComponent public InputField ipInputField; public InputField portInputField; public InputField messageInputField; public Text logText; public Button connectButton; public Button sendButton; public Button disconnectButton; private System.Text.StringBuilder _logBuilder = new System.Text.StringBuilder(); void Start() { // 初始化UI ipInputField.text = tcpClient.serverIP; portInputField.text = tcpClient.serverPort.ToString(); // 绑定按钮事件 connectButton.onClick.AddListener(OnConnectClicked); sendButton.onClick.AddListener(OnSendClicked); disconnectButton.onClick.AddListener(OnDisconnectClicked); sendButton.interactable = false; disconnectButton.interactable = false; // 订阅网络事件 tcpClient.ConnectionStateChanged += OnConnectionStateChanged; tcpClient.MessageReceived += OnMessageReceived; } void OnConnectClicked() { tcpClient.serverIP = ipInputField.text; if (int.TryParse(portInputField.text, out int port)) { tcpClient.serverPort = port; } bool success = tcpClient.ConnectToServer(); AddLog($"尝试连接...结果: {success}"); } void OnSendClicked() { string msg = messageInputField.text; if (!string.IsNullOrEmpty(msg)) { bool success = tcpClient.SendMessage(msg); AddLog($"发送消息: {msg} -> {success}"); messageInputField.text = ""; } } void OnDisconnectClicked() { tcpClient.Disconnect(); AddLog("主动断开连接"); } void OnConnectionStateChanged(bool isConnected) { // UI更新必须在主线程，而事件可能从接收线程触发，所以用委托或直接在这里更新是安全的（因为我们在Update中调用事件） // 更安全的方式是使用Unity主线程调度器，这里简化处理，假设事件是通过主线程的某个机制触发的。 // 实际上，我们的ConnectionStateChanged事件是在ConnectToServer和Disconnect的主线程部分触发的，所以安全。 connectButton.interactable = !isConnected; sendButton.interactable = isConnected; disconnectButton.interactable = isConnected; AddLog($"连接状态变化: {(isConnected ? "已连接" : "已断开")}"); } void OnMessageReceived(byte[] data) { string msg = System.Text.Encoding.UTF8.GetString(data); // 注意：这个事件可能在子线程触发，所以不能直接操作UI // 我们将消息加入一个队列，在Update中处理，或者使用Unity的MainThreadDispatcher。 // 这里为了简单，我们假设事件发布者已经确保它在主线程调用（我们的TcpClientManager通过Update队列机制做到了这一点）。 AddLog($"收到: {msg}"); } void AddLog(string log) { _logBuilder.AppendLine($"[{System.DateTime.Now:HH:mm:ss}] {log}"); // 限制日志行数，避免UI卡顿 if (_logBuilder.Length > 10000) { int firstNewLine = _logBuilder.ToString().IndexOf('\n'); if (firstNewLine > 0) { _logBuilder.Remove(0, firstNewLine + 1); } } logText.text = _logBuilder.ToString(); } void OnDestroy() { // 清理时断开连接 tcpClient.Disconnect(); tcpClient.ConnectionStateChanged -= OnConnectionStateChanged; tcpClient.MessageReceived -= OnMessageReceived; } }

4. 常见问题、调试技巧与进阶优化

即使代码写对了，在实际网络环境中你依然会遇到各种问题。下面是我总结的“排错清单”和优化建议。

4.1 连接失败问题排查表

4.2 数据收发异常问题排查

4.3 进阶优化与生产环境建议

1. 心跳机制：长时间空闲的连接可能被中间路由器或防火墙断开。客户端应定时（如每30秒）向服务器发送一个心跳包（内容为特定的小数据包），服务器回应，以保持连接活跃。
2. 自动重连：在Disconnect方法或检测到连接断开后，不要立即重连。实现一个带退避策略的重连机制（例如，第一次等待1秒后重连，失败后等待2秒，4秒...直到最大间隔）。
3. 使用async/await重构：将Thread改为Task和async/await，配合Socket的*Async方法（如ConnectAsync,SendAsync,ReceiveAsync），代码结构会更清晰，更容易处理取消和超时。
4. 连接池与多路复用：如果需要同时管理多个服务器连接或高频短连接，考虑使用连接池。对于大量并发连接，可以研究Select、Poll或IOCP（I/O完成端口）等高性能模型，不过在Unity C#中更常见的是使用基于事件的异步模型。
5. 协议升级：长度前缀法是最基础的。复杂项目可以定义更丰富的协议头，包含消息ID、版本号、校验和等字段。可以考虑使用像Google Protobuf或MessagePack这样的二进制序列化库，它们能自动处理序列化/反序列化，并生成高效的二进制数据。
6. 资源清理：确保在OnApplicationQuit和场景切换时正确调用Disconnect。Thread.Abort()是最后手段，因为它可能使线程无法正常清理资源。

5. 完整代码整合与测试指南

将上述所有代码片段整合到两个C#脚本中：TcpClientManager.cs和NetworkTestUI.cs。在Unity中：

1. 创建一个空GameObject，挂载TcpClientManager组件。
2. 搭建一个简单的UI Canvas，包含输入框和按钮，并挂载NetworkTestUI脚本，将对应的UI元素和TcpClientManager实例拖拽赋值。
3. 你需要一个TCP服务器来测试。可以快速用C#写一个控制台程序作为服务器，或者使用网络调试助手（如NetAssist、SocketTool）来模拟服务器。
4. 先运行服务器，然后在Unity编辑器中运行，点击连接、发送消息，观察日志。

测试服务器示例代码（C# Console App）：

using System; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; class SimpleTcpServer { static void Main() { TcpListener listener = new TcpListener(IPAddress.Any, 8080); // 监听所有IP的8080端口 listener.Start(); Console.WriteLine("服务器已启动，等待连接..."); TcpClient client = listener.AcceptTcpClient(); // 阻塞直到有客户端连接 Console.WriteLine($"客户端已连接: {((IPEndPoint)client.Client.RemoteEndPoint).Address}"); NetworkStream stream = client.GetStream(); byte[] buffer = new byte[1024]; // 模拟回声服务器：收到什么就发回什么 try { while (client.Connected) { // 读取长度头（4字节） byte[] lengthBytes = new byte[4]; int headerRead = stream.Read(lengthBytes, 0, 4); if (headerRead == 0) break; // 客户端断开 int messageLength = BitConverter.ToInt32(lengthBytes, 0); // 读取消息体 byte[] messageBytes = new byte[messageLength]; int totalRead = 0; while (totalRead < messageLength) { int read = stream.Read(messageBytes, totalRead, messageLength - totalRead); if (read == 0) break; totalRead += read; } string received = Encoding.UTF8.GetString(messageBytes); Console.WriteLine($"收到: {received}"); // 原样发回 byte[] lengthPrefix = BitConverter.GetBytes(messageLength); stream.Write(lengthPrefix, 0, lengthPrefix.Length); stream.Write(messageBytes, 0, messageBytes.Length); Console.WriteLine($"已回声"); } } catch (Exception ex) { Console.WriteLine($"通信错误: {ex.Message}"); } finally { client.Close(); listener.Stop(); Console.WriteLine("服务器已关闭。"); } } }

通过这个从原理到实现，从代码到调试的完整流程，你应该已经不再是那个对Unity网络通信感到迷茫的新手了。记住，网络编程三分靠写，七分靠调。多动手测试，善用日志和抓包工具，理解每一个异常背后的含义，你就能搭建出稳定可靠的游戏网络模块。