Unity3D TCP聊天应用开发：从Socket通信到C/S架构实战

1. 项目概述：为什么选择Unity3D与TCP构建聊天应用？

在游戏开发或者需要实时交互的应用程序中，网络通信是核心骨架。你可能见过很多基于Unity的多人游戏，它们背后都有一套复杂的网络同步逻辑。今天我们不谈那些庞然大物，而是从一个最基础、也最经典的模块入手：TCP聊天应用。这听起来简单，但它就像学编程时的“Hello, World!”，是理解网络通信原理、掌握Unity网络编程、乃至后续构建更复杂联机功能的基石。

为什么是Unity3D？因为它不仅仅是一个游戏引擎，更是一个强大的跨平台内容创作工具。无论是PC、移动端还是Web，Unity都能帮你轻松打包部署。用Unity来做聊天应用，你实际上是在学习如何将游戏逻辑与网络通信结合，这个技能可以直接迁移到任何需要实时数据交换的Unity项目中，比如排行榜更新、玩家间文字/语音交流、甚至是简单的指令同步。

为什么是TCP？在网络协议的家族里，TCP和UDP是两兄弟。UDP快，但可能丢包、不保证顺序，适合射击游戏里频繁的位置更新。TCP则相反，它通过“三次握手”建立可靠连接，确保数据包按顺序、完整地送达，这正是聊天应用所需要的——你总不希望自己打的字顺序错乱或者丢了一半吧？虽然“三次握手四次挥手”听起来有点学术，但理解它对于调试网络连接问题至关重要。简单来说，握手是为了建立连接，挥手是为了优雅地断开，确保没有数据丢失。

这个教程的目标，就是带你从零开始，在Unity中搭建一个C/S（客户端/服务器）架构的TCP聊天室。你将亲手编写服务器端程序来管理所有客户端连接和消息转发，并编写Unity客户端来连接服务器、发送和接收消息。最终，你会得到一个可以运行在局域网甚至公网（需要内网穿透）上的简易聊天程序。无论你是想为你的游戏增加一个聊天频道，还是单纯想深入理解网络编程，这都是绝佳的起点。

2. 核心架构与通信协议设计

在动手写代码之前，我们必须把蓝图规划好。一个基于TCP的聊天应用，其核心架构是经典的客户端-服务器（Client-Server）模型。所有客户端不直接相互通信，而是连接到一个中心服务器，由服务器负责消息的路由和广播。

2.1 客户端-服务器模型详解

在这个模型中，服务器扮演着“交通警察”和“邮局”的双重角色。它的核心职责包括：

1. 监听与接入：持续在一个指定的网络端口（例如 9050）上监听，等待客户端的连接请求。
2. 连接管理：维护一个所有已连接客户端的列表。每个客户端连接成功时，服务器会为其创建一个独立的网络流（NetworkStream）或套接字（Socket）对象进行处理，确保彼此隔离。
3. 消息中转：当服务器从某个客户端A收到一条聊天消息时，它会遍历客户端列表，将这条消息原样发送给除A以外的所有其他客户端，从而实现群聊（广播）功能。如果需要私聊，则可以根据消息头部的标识，只转发给特定客户端。

这种模型的优势在于逻辑集中、易于管理和扩展。所有复杂的连接状态、消息解析和转发逻辑都放在服务器端，客户端只需要关心连接、发送和接收。

2.2 TCP Socket通信基础

TCP通信的基石是Socket（套接字）。你可以把它想象成电话系统：IP地址是电话号码，端口号是分机号，Socket就是你的电话听筒。

在C#（Unity使用的语言）中，我们主要使用System.Net.Sockets命名空间下的类：

• TcpListener：服务器端使用，用于在特定IP和端口上监听传入的连接请求。
• TcpClient：客户端和服务器端都会用到。客户端用它来连接服务器；服务器端在接受到连接后，会用一个TcpClient实例来代表那个远端的客户端。
• NetworkStream：从TcpClient获取的数据流对象。我们通过它来读取（Read）和写入（Write）字节数据，这是实际进行网络IO的通道。

通信的基本单位是字节（byte）。我们发送的字符串、数字等都需要转换为字节数组（byte[]）才能通过网络流传输，接收方则需要将字节数组还原回可读的数据。这个过程就涉及到编码（Encoding），最常用的是Encoding.UTF8.GetBytes()和Encoding.UTF8.GetString()。

注意：网络通信是异步且耗时的操作。如果在Unity的主线程中直接进行Read或AcceptTcpClient这类阻塞调用，会导致游戏画面卡死。因此，我们必须使用多线程或异步编程（async/await）来处理网络操作，确保主线程流畅。

2.3 应用层消息协议设计

TCP保证了字节流的可靠传输，但它不管这些字节代表什么含义。我们需要自己定义一套简单的应用层协议，让服务器和客户端能理解彼此发送的数据。

对于一个基础聊天应用，最简单的协议可以这样设计：

1. 消息结构：[消息长度][消息内容]。这是一种很常见的处理TCP粘包问题的方法。
2. 实现方式：先发送一个固定长度（例如4个字节的int）来表示后续消息内容的字节长度，然后再发送实际的消息内容。接收方先读取这4个字节，知道接下来要读多少字节，然后一次性读取完整内容。
3. 消息内容：可以就是一个简单的UTF-8编码的字符串，比如“用户小明：大家好！”。

对于更复杂的需求，比如区分系统消息、用户消息、私聊指令等，可以在消息内容里加入更结构化的数据，例如使用JSON：{"type":"chat", "sender":"小明", "content":"大家好！", "target":"all"}。服务器解析JSON后，根据type和target字段决定如何处理。

在本教程中，我们将从最简单的字符串广播开始，然后扩展到结构化消息。

3. 服务器端实现详解

我们将先创建一个独立的C#控制台应用项目作为服务器。这可以让服务器逻辑更清晰，并且能独立于Unity运行和调试。

3.1 创建服务器项目与初始化监听

首先，在Visual Studio或任何C# IDE中新建一个“控制台应用(.NET Core或.NET Framework)”项目。

using System; using System.Collections.Generic; using System.Net; using System.Net.Sockets; using System.Text; using System.Threading; namespace UnityChatServer { class Program { // 存储所有客户端连接的列表。使用线程安全的集合，因为多个线程可能同时访问它。 static List<TcpClient> clientList = new List<TcpClient>(); static TcpListener serverListener; static void Main(string[] args) { Console.WriteLine("=== Unity TCP 聊天服务器启动 ==="); // 设置服务器IP和端口。IPAddress.Any 表示监听所有网络接口。 IPAddress ip = IPAddress.Any; int port = 9050; try { serverListener = new TcpListener(ip, port); serverListener.Start(); Console.WriteLine($"服务器已启动，正在监听 {ip}:{port}..."); // 开始异步接受客户端连接 AcceptClientAsync(); } catch (Exception ex) { Console.WriteLine($"服务器启动失败: {ex.Message}"); } // 保持主线程运行，等待控制台输入退出 Console.WriteLine("\n输入 'exit' 并按回车键关闭服务器。"); while (Console.ReadLine()?.ToLower() != "exit") { } serverListener?.Stop(); Console.WriteLine("服务器已关闭。"); } } }

3.2 异步接受客户端连接

在AcceptClientAsync方法中，我们需要循环等待客户端连接。为了避免阻塞主线程，我们使用async/await。

static async void AcceptClientAsync() { while (true) { try { // 异步等待客户端连接。这是一个非阻塞调用。 TcpClient newClient = await serverListener.AcceptTcpClientAsync(); // 将新客户端加入列表 lock (clientList) // 使用锁确保线程安全 { clientList.Add(newClient); } Console.WriteLine($"客户端 [{newClient.Client.RemoteEndPoint}] 已连接。当前在线: {clientList.Count}"); // 为新客户端启动一个独立的线程或任务来处理其消息 _ = Task.Run(() => HandleClientAsync(newClient)); } catch (Exception ex) { // 当服务器被停止时，AcceptTcpClientAsync会抛出异常，这是正常的退出路径。 Console.WriteLine($"接受客户端连接时出现异常: {ex.Message}"); break; } } }

实操心得：这里使用lock (clientList)是关键。因为AcceptClientAsync可能在主线程，而每个客户端的处理线程HandleClientAsync都会访问clientList（例如广播消息时需要遍历它）。不加锁会导致在修改集合时被其他线程同时读写，引发InvalidOperationException。这是多线程编程中最常见的坑之一。

3.3 处理客户端消息与广播

HandleClientAsync方法是服务器与单个客户端通信的核心。它需要持续读取该客户端发送来的数据。

static async Task HandleClientAsync(TcpClient client) { NetworkStream stream = client.GetStream(); byte[] buffer = new byte[1024]; // 数据缓冲区 string clientEndPoint = client.Client.RemoteEndPoint.ToString(); try { while (client.Connected) { // 1. 先读取消息长度（假设前4个字节是int类型的长度信息） byte[] lengthBuffer = new byte[4]; int bytesRead = await stream.ReadAsync(lengthBuffer, 0, 4); if (bytesRead == 0) break; // 客户端已断开连接 int messageLength = BitConverter.ToInt32(lengthBuffer, 0); // 2. 根据长度读取实际消息内容 byte[] messageBuffer = new byte[messageLength]; int totalRead = 0; while (totalRead < messageLength) { bytesRead = await stream.ReadAsync(messageBuffer, totalRead, messageLength - totalRead); if (bytesRead == 0) break; totalRead += bytesRead; } // 3. 解码消息 string receivedMessage = Encoding.UTF8.GetString(messageBuffer, 0, totalRead); Console.WriteLine($"来自 [{clientEndPoint}] 的消息: {receivedMessage}"); // 4. 构建广播消息（附加上发送者信息） string broadcastMessage = $"[{clientEndPoint}] 说: {receivedMessage}"; byte[] broadcastData = Encoding.UTF8.GetBytes(broadcastMessage); // 5. 广播给其他所有客户端 lock (clientList) { foreach (var otherClient in clientList) { if (otherClient != client && otherClient.Connected) { try { NetworkStream otherStream = otherClient.GetStream(); // 先发送长度，再发送内容 otherStream.Write(BitConverter.GetBytes(broadcastData.Length), 0, 4); otherStream.Write(broadcastData, 0, broadcastData.Length); } catch { // 如果发送失败，可能是该客户端已断开，稍后清理 } } } } } } catch (Exception ex) { Console.WriteLine($"处理客户端 [{clientEndPoint}] 时出错: {ex.Message}"); } finally { // 客户端断开连接后的清理工作 lock (clientList) { clientList.Remove(client); } client.Close(); Console.WriteLine($"客户端 [{clientEndPoint}] 已断开。当前在线: {clientList.Count}"); } }

关键点解析：

1. 粘包处理：代码中先读4字节长度，再读内容的方式，是解决TCP粘包/拆包问题的经典方法。TCP是流式协议，它不保证一次Send对应一次Receive。可能多条小消息被合并（粘包），也可能一条大消息被拆分（拆包）。固定长度头法能让我们准确地读取一条完整消息。
2. 循环读取：while (totalRead < messageLength)这段代码确保了即使消息内容被分成多个TCP包到达，我们也能把它们完整地收集起来。
3. 广播逻辑：遍历clientList时，跳过了消息发送者自身（otherClient != client），并检查了客户端是否仍处于连接状态，避免了向已断开的连接发送数据导致的异常。
4. 资源清理：finally块中的操作至关重要。它确保在客户端异常断开时，能将其从列表中移除并关闭连接，释放系统资源。

至此，一个功能完整的TCP聊天服务器就完成了。你可以运行它，它会显示在控制台，等待客户端连接。

4. Unity客户端开发全流程

现在，我们切换到Unity项目，构建聊天客户端。在Unity中，所有网络操作都必须在非主线程进行，否则会阻塞游戏循环。我们将使用System.Threading.Tasks.Task或System.Threading.Thread来包装Socket操作。

4.1 创建UI界面与网络管理器

首先，在Unity中创建一个简单的UI。

1. 创建一个Canvas。
2. 在Canvas下创建：
   • Scroll View(命名为ChatScrollView)：作为聊天消息显示区域。其子对象Viewport/Content上添加Vertical Layout Group组件，方便自动排列消息。
   • InputField(命名为MessageInputField)：用于输入聊天消息。
   • Button(命名为SendButton)：发送消息按钮。
   • InputField(命名为ServerIPInputField)：用于输入服务器IP。
   • InputField(命名为ServerPortInputField)：用于输入服务器端口（默认9050）。
   • Button(命名为ConnectButton)：连接服务器按钮。
   • Text(命名为StatusText)：显示连接状态。

接下来，创建一个空的GameObject，命名为NetworkManager，并为其挂载一个C#脚本，也命名为NetworkManager。

4.2 实现网络连接与数据收发

NetworkManager脚本将负责所有核心网络逻辑。

using UnityEngine; using UnityEngine.UI; using System.Net.Sockets; using System.Text; using System.Threading; using System.Threading.Tasks; public class NetworkManager : MonoBehaviour { [Header("UI References")] public InputField serverIPInput; public InputField serverPortInput; public InputField messageInput; public Button connectButton; public Button sendButton; public Text statusText; public Transform chatContent; // ScrollView Content 的 Transform [Header("Prefab")] public GameObject messageTextPrefab; // 一个简单的Text预制体，用于实例化每一条消息 private TcpClient client; private NetworkStream stream; private Thread receiveThread; private bool isConnected = false; private string serverIP = "127.0.0.1"; private int serverPort = 9050; void Start() { // 加载保存的IP和端口（可选） serverIPInput.text = PlayerPrefs.GetString("LastServerIP", "127.0.0.1"); serverPortInput.text = PlayerPrefs.GetString("LastServerPort", "9050"); connectButton.onClick.AddListener(OnConnectButtonClicked); sendButton.onClick.AddListener(OnSendButtonClicked); sendButton.interactable = false; // 未连接时不能发送 } void OnConnectButtonClicked() { if (!isConnected) { serverIP = serverIPInput.text; int.TryParse(serverPortInput.text, out serverPort); // 保存设置 PlayerPrefs.SetString("LastServerIP", serverIP); PlayerPrefs.SetString("LastServerPort", serverPort.ToString()); ConnectToServer(); } else { DisconnectFromServer(); } } async void ConnectToServer() { statusText.text = "正在连接..."; connectButton.interactable = false; try { // 在后台线程中建立连接，避免阻塞主线程 await Task.Run(() => { client = new TcpClient(); client.Connect(serverIP, serverPort); // 这是一个阻塞调用，所以在Task中运行 }); stream = client.GetStream(); isConnected = true; // 更新UI必须在主线程进行 MainThreadDispatcher.ExecuteOnMainThread(() => { statusText.text = $"已连接到 {serverIP}:{serverPort}"; connectButton.GetComponentInChildren<Text>().text = "断开连接"; connectButton.interactable = true; sendButton.interactable = true; }); // 启动接收消息的线程 receiveThread = new Thread(new ThreadStart(ReceiveData)); receiveThread.IsBackground = true; // 设置为后台线程，当主线程退出时自动终止 receiveThread.Start(); } catch (System.Exception ex) { MainThreadDispatcher.ExecuteOnMainThread(() => { statusText.text = $"连接失败: {ex.Message}"; connectButton.interactable = true; }); Debug.LogError($"连接失败: {ex.Message}"); } } }

这里出现了一个关键组件：MainThreadDispatcher。由于Unity的UI操作（如更新Text、实例化预制体）必须在主线程执行，而我们的网络接收线程是工作线程，不能直接调用UI相关代码。我们需要一个中介来将任务派发回主线程。

创建一个简单的MainThreadDispatcher脚本：

using UnityEngine; using System.Collections.Generic; using System; public class MainThreadDispatcher : MonoBehaviour { private static readonly Queue<Action> executionQueue = new Queue<Action>(); private static MainThreadDispatcher instance; public static MainThreadDispatcher Instance { get { if (instance == null) { GameObject go = new GameObject("MainThreadDispatcher"); instance = go.AddComponent<MainThreadDispatcher>(); DontDestroyOnLoad(go); } return instance; } } void Update() { lock (executionQueue) { while (executionQueue.Count > 0) { executionQueue.Dequeue().Invoke(); } } } public static void ExecuteOnMainThread(Action action) { lock (executionQueue) { executionQueue.Enqueue(action); } } }

在场景中确保有一个MainThreadDispatcher实例（上面的Instance属性会在第一次访问时自动创建）。

4.3 实现消息接收与发送

回到NetworkManager脚本，继续补充接收和发送方法。

// 在NetworkManager类中继续添加 private void ReceiveData() { byte[] buffer = new byte[1024]; while (isConnected && client != null && client.Connected) { try { // 1. 读取消息长度 byte[] lengthBuffer = new byte[4]; int bytesRead = stream.Read(lengthBuffer, 0, 4); if (bytesRead == 0) break; // 连接已关闭 int messageLength = BitConverter.ToInt32(lengthBuffer, 0); // 2. 读取消息内容 byte[] messageBuffer = new byte[messageLength]; int totalRead = 0; while (totalRead < messageLength) { bytesRead = stream.Read(messageBuffer, totalRead, messageLength - totalRead); if (bytesRead == 0) break; totalRead += bytesRead; } string receivedMessage = Encoding.UTF8.GetString(messageBuffer, 0, totalRead); // 3. 将消息显示到UI（必须在主线程） MainThreadDispatcher.ExecuteOnMainThread(() => { AddMessageToChat(receivedMessage); }); } catch (System.Exception ex) { if (isConnected) // 只有连接状态下出错才打印 { Debug.LogWarning($"接收数据出错: {ex.Message}"); } break; } } // 循环结束，意味着连接已断开 MainThreadDispatcher.ExecuteOnMainThread(() => { OnDisconnected(); }); } private void AddMessageToChat(string message) { if (messageTextPrefab && chatContent) { GameObject newMessageObj = Instantiate(messageTextPrefab, chatContent); Text messageText = newMessageObj.GetComponent<Text>(); if (messageText) { messageText.text = message; } // 可选：自动滚动到底部 Canvas.ForceUpdateCanvases(); // 这里需要获取ScrollRect组件并设置verticalNormalizedPosition = 0 } } void OnSendButtonClicked() { if (!isConnected || string.IsNullOrWhiteSpace(messageInput.text)) return; string msgToSend = messageInput.text; messageInput.text = ""; // 清空输入框 SendMessageToServer(msgToSend); } async void SendMessageToServer(string message) { if (!isConnected || stream == null) return; try { byte[] messageData = Encoding.UTF8.GetBytes(message); byte[] lengthData = BitConverter.GetBytes(messageData.Length); // 发送操作也可以放在Task中，避免偶尔的卡顿 await Task.Run(() => { stream.Write(lengthData, 0, 4); stream.Write(messageData, 0, messageData.Length); stream.Flush(); // 确保数据被发送出去 }); Debug.Log($"消息已发送: {message}"); } catch (System.Exception ex) { Debug.LogError($"发送消息失败: {ex.Message}"); MainThreadDispatcher.ExecuteOnMainThread(() => { statusText.text = "发送失败，连接可能已断开"; }); DisconnectFromServer(); } } private void OnDisconnected() { isConnected = false; statusText.text = "连接已断开"; connectButton.GetComponentInChildren<Text>().text = "连接"; sendButton.interactable = false; if (client != null) { client.Close(); client = null; } } void DisconnectFromServer() { isConnected = false; if (receiveThread != null && receiveThread.IsAlive) { receiveThread.Abort(); // 强制终止接收线程（谨慎使用，这里为了简单演示） } OnDisconnected(); } void OnApplicationQuit() { DisconnectFromServer(); }

4.4 客户端功能测试与整合

将UI元素拖拽到NetworkManager脚本的对应公开字段上。创建一个简单的Text预制体，作为messageTextPrefab。

1. 运行服务器：首先启动之前编写的控制台服务器程序。
2. 运行Unity客户端：在Unity编辑器中点击Play。在UI中输入服务器IP（本地测试用127.0.0.1或localhost），端口9050，点击连接。
3. 测试聊天：连接成功后，在消息输入框打字，点击发送。消息会出现在服务器的控制台，并且会被广播给所有连接的客户端（你可以打开多个Unity客户端实例进行测试）。

注意事项：在Unity编辑器中运行多个客户端实例测试时，每个实例都是一个独立的进程。你需要确保MainThreadDispatcher在场景中是唯一的，或者每个客户端场景都有自己独立的调度器。我们的实现中使用了单例模式，但在编辑器多开时，每个播放实例是隔离的，所以没问题。

5. 功能增强与实战优化

基础功能跑通后，我们可以从实用性、健壮性和扩展性角度进行一系列优化。

5.1 心跳机制与连接保活

TCP连接在长时间空闲后，可能会被中间的路由器或防火墙断开。为了维持连接，需要实现心跳机制。客户端定期（比如每30秒）向服务器发送一个很小的、无业务含义的数据包（心跳包），服务器收到后可以回复一个确认包，或者至少知道这个连接还活着。

客户端心跳实现思路： 在NetworkManager中增加一个心跳协程或线程。

// 在NetworkManager类中添加 private CancellationTokenSource heartbeatCts; private async void StartHeartbeat() { heartbeatCts = new CancellationTokenSource(); while (isConnected && !heartbeatCts.Token.IsCancellationRequested) { await Task.Delay(30000); // 等待30秒 if (isConnected) { try { // 发送一个特殊的心跳消息，例如 “HEARTBEAT” byte[] heartbeatMsg = Encoding.UTF8.GetBytes("HEARTBEAT"); byte[] lengthData = BitConverter.GetBytes(heartbeatMsg.Length); await Task.Run(() => { stream.Write(lengthData, 0, 4); stream.Write(heartbeatMsg, 0, heartbeatMsg.Length); }); } catch { // 发送失败，连接可能已断 MainThreadDispatcher.ExecuteOnMainThread(OnDisconnected); break; } } } }

在ConnectToServer成功连接后，调用StartHeartbeat()。在DisconnectFromServer中，调用heartbeatCts?.Cancel()。

服务器端处理心跳： 在服务器的HandleClientAsync方法中，收到消息后先判断是否是心跳包“HEARTBEAT”，如果是，则可以不广播，只记录或更新该客户端的最后活动时间。服务器也可以定期检查所有客户端的最后活动时间，踢掉长时间无响应的“僵尸连接”。

5.2 用户身份与私聊功能

目前所有消息都是广播。要实现私聊，我们需要引入用户标识。

1. 连接时注册：客户端连接后，首先发送一条包含用户名（或ID）的注册消息到服务器。服务器将其与TcpClient对象关联起来，可以存储在一个字典里：Dictionary<string, TcpClient>。
2. 消息协议升级：定义更结构化的消息格式。使用JSON非常方便。

   // 客户端发送的消息 { "type": "chat", // 消息类型：chat, private, system, register "sender": "UserA", "content": "你好！", "target": "all" // 或 "UserB" 用于私聊 }

3. 服务器路由逻辑：服务器解析JSON，根据type和target字段决定处理方式。如果是“private”且target是某个用户名，则从字典中找到对应的TcpClient，只向它发送消息。

5.3 数据序列化与协议扩展

随着功能增加，手动拼接和解析字符串会变得非常繁琐且容易出错。引入一个序列化库是更好的选择。对于轻量级需求，Unity自带的JsonUtility或第三方库如Newtonsoft.Json(需导入) 是很好的选择。

定义一个消息类：

[System.Serializable] public class ChatMessage { public string type; // "chat", "private", "system", "register" public string sender; public string content; public string target; public long timestamp; // 时间戳 }

发送时：string json = JsonUtility.ToJson(msg); byte[] data = Encoding.UTF8.GetBytes(json);接收时：ChatMessage msg = JsonUtility.FromJson<ChatMessage>(receivedJsonString);

5.4 错误处理与断线重连

网络环境不稳定，断线是常事。一个健壮的客户端应该具备断线检测和自动重连的能力。

1. 检测断线：在ReceiveData循环中，如果stream.Read返回0，或者抛出异常（如IOException），就表示连接已断开。
2. 自动重连：在OnDisconnected方法中，不要立即清理所有资源，可以启动一个重连协程。

   private bool isReconnecting = false; private int reconnectDelay = 3; // 重连等待秒数 private async void TryReconnect() { if (isReconnecting) return; isReconnecting = true; int attempts = 0; while (attempts < 5 && !isConnected) // 最多尝试5次 { attempts++; Debug.Log($"尝试重连 ({attempts}/5)..."); await Task.Delay(reconnectDelay * 1000); ConnectToServer(); // 调用之前的连接方法 // 需要在ConnectToServer成功或失败后更新isConnected状态 await Task.Delay(1000); // 等待连接结果 if (isConnected) break; reconnectDelay *= 2; // 指数退避，避免频繁请求 } isReconnecting = false; if (!isConnected) { MainThreadDispatcher.ExecuteOnMainThread(() => statusText.text = "无法连接到服务器"); } }

   在OnDisconnected中调用TryReconnect()。注意，重连逻辑需要小心设计，避免无限循环和资源泄漏。

6. 部署测试与性能考量

6.1 局域网与公网测试

• 局域网测试：最简单。确保服务器和客户端在同一个Wi-Fi或网络下。服务器运行时，查看本机IP地址（在命令行输入ipconfig），让客户端连接这个IP即可。
• 公网测试：这需要将服务器部署在具有公网IP的机器上（如云服务器）。更常见的情况是，开发者没有固定公网IP，这就需要内网穿透工具，如 ngrok、frp 等。这些工具会在公网提供一个地址，将流量转发到你本地运行的服务器。（注意：使用此类工具需遵守其服务条款，并用于合法合规的测试目的）。

重要提示：将服务器暴露到公网前，务必考虑安全性。我们这个示例服务器没有任何认证和加密，消息明文传输。生产环境必须使用TLS/SSL（即TCP的加密版本，常被称为SSL/TLS over TCP）来加密通信，并对用户进行身份验证。

6.2 性能优化要点

1. 对象池：频繁地实例化和销毁UI消息文本（Instantiate和Destroy）会产生GC（垃圾回收）压力。可以使用对象池来复用GameObject。
2. 消息队列：接收线程将收到的消息添加到一个线程安全的队列中，主线程的Update方法每帧从队列中取出并处理显示。这比每收到一条消息就通过MainThreadDispatcher派发一次更高效。
3. 服务器异步优化：我们的服务器使用了async/await，这对于IO密集型操作是合适的。但对于需要支持成千上万个连接的场景，可能需要考虑更高效的I/O模型，如异步Socket (SocketAsyncEventArgs) 或基于事件的库。
4. 流量控制：防止客户端恶意或意外发送超大消息。可以在服务器读取长度头后，检查messageLength是否在一个合理的范围内（例如，小于10KB），如果超出则直接断开连接。

6.3 常见问题排查表

这个项目虽然是一个简单的聊天应用，但它涵盖了Unity网络编程的核心概念：Socket通信、异步处理、线程安全、协议设计、UI与逻辑分离。当你理解了这些，再去学习Unity官方的Netcode、Photon PUN等高级网络方案，或者自己设计游戏的状态同步，都会有一个坚实的基础。网络编程的调试往往比较麻烦，善用日志输出，分模块测试，是解决问题的关键。