Unity网络编程实战：从零构建TCP Socket聊天系统

1. 项目概述：为什么要在Unity里自己搭聊天系统？

最近在社区里看到不少朋友在问Unity网络通信的问题，尤其是想做一个带聊天功能的联机小游戏或者社交应用。市面上虽然有Photon、Mirror这些成熟的网络方案，但如果你真想搞懂数据是怎么从你键盘敲下的字符，变成别人屏幕上跳出来的消息，自己从Socket开始撸一个客户端和服务器端的聊天系统，绝对是性价比最高的学习路径。这不仅仅是实现一个“发送-接收”的功能，它会逼着你去思考连接管理、数据序列化、协议设计、状态同步这些网络编程的核心概念，而这些经验在你以后做更复杂的多人游戏逻辑（比如位置同步、状态广播）时，是直接可以复用的。

这个项目实战，我会带你用最“朴素”的方式，在Unity里实现一个完整的聊天系统。客户端负责漂亮的界面交互和本地逻辑，服务器端则用C#控制台程序来担当，处理多客户端的连接与消息转发。我们会避开那些重型框架，专注于TCP Socket和基础的多线程，确保你能看清每一个字节的流向。过程中，我会穿插很多我趟过的坑，比如Unity主线程与网络线程的通信、消息粘包的处理、以及如何设计一个既简单又够用的应用层协议。

2. 核心设计思路：从单机到联机的思维转变

2.1 技术栈选型与考量

首先明确我们的技术选型： TCP Socket + 自定义简单协议 + Unity（客户端） + .NET Console App（服务器端） 。

为什么不直接用Unity的UNet或者Transport API？对于学习而言，它们封装得太好了，反而像是一个黑盒，你很难理解底层发生了什么。而直接使用 System.Net.Sockets 命名空间下的 TcpClient 和 TcpListener ，能让你亲手触摸到“连接”和“数据流”。为什么不选UDP？因为聊天消息需要可靠、有序的送达，TCP的可靠性正好符合要求，虽然实时性稍逊，但对于聊天室场景完全足够。

服务器端为什么用控制台程序而不是另一个Unity实例？主要是为了专注和轻量。服务器端的核心职责是网络IO和业务逻辑，不需要渲染、物理等游戏引擎的开销。一个简单的控制台应用，启动快、资源占用少、日志清晰，是学习服务端逻辑的理想沙盒。

2.2 系统架构与数据流设计

整个系统的架构非常清晰，就是一个经典的C/S（客户端-服务器）模型。

1. 服务器端 ：作为一个常驻进程，在指定IP和端口上启动监听。它维护一个“已连接客户端列表”。当客户端A发送一条聊天消息时，服务器收到后，会遍历这个列表，将消息转发给除A以外的所有其他客户端（广播），或者根据协议指定发给某个客户端（私聊）。
2. 客户端 ：包含两部分。
   • 网络模块 ：负责与服务器建立TCP连接，在后台线程中持续监听来自服务器的数据，收到后通知主线程。
   • 表现与交互模块 ：基于Unity的UGUI构建聊天界面（输入框、发送按钮、聊天内容显示区域）。它将用户输入提交给网络模块发送，并接收网络模块的通知来更新UI显示。

数据流的核心在于 协议设计 。我们不可能把用户输入的原始字符串直接扔到网络流里，需要定义一种双方都能理解的格式。这里我们设计一个最简单的文本协议，例如，用换行符 \n 作为每条消息的结束分隔符。但更健壮的做法是使用“长度+内容”的二进制协议，这次我们先从简单的文本协议入手，后面会讨论其局限性和升级方案。

注意 ：在Unity中使用网络功能，请确保在 Player Settings -> Other Settings -> Configuration 中，将 .NET API Compatibility Level 设置为 .NET Framework （而非 .NET Standard 2.1 ），以确保完整的 System.Net.Sockets 支持。对于较新的Unity版本（如2021+），使用 .NET 6/8 的兼容性级别也可以。

3. 服务器端实现详解：稳固的消息中转站

服务器端是整个系统的中枢，它的稳定性和效率决定了聊天室的体验上限。我们一步步来构建它。

3.1 项目创建与基础监听循环

首先，在Visual Studio中创建一个新的C#控制台应用项目。核心类是 TcpListener 。

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

class ChatServer
{
    private static TcpListener _listener;
    // 用于存储所有已连接的客户端
    private static List<TcpClient> _clients = new List<TcpClient>();
    private static readonly object _clientsLock = new object(); // 用于线程安全地操作客户端列表

    static void Main(string[] args)
    {
        string ip = "127.0.0.1"; // 本地回环地址，测试用
        int port = 8888; // 选择一个未被占用的端口

        _listener = new TcpListener(IPAddress.Parse(ip), port);
        _listener.Start();
        Console.WriteLine($"聊天服务器已启动，监听 {ip}:{port}...");

        // 主循环，持续接受新客户端连接
        while (true)
        {
            TcpClient newClient = _listener.AcceptTcpClient(); // 这是一个阻塞调用，直到有新连接
            Console.WriteLine($"新的客户端连接来自: {newClient.Client.RemoteEndPoint}");

            lock (_clientsLock)
            {
                _clients.Add(newClient);
            }

            // 为新客户端创建一个独立的线程来处理其通信，避免阻塞主监听循环
            Thread clientThread = new Thread(() => HandleClient(newClient));
            clientThread.IsBackground = true; // 设置为后台线程，当主线程退出时自动结束
            clientThread.Start();
        }
    }
}

这里有几个关键点：

1. _clients 列表存储了所有连接的 TcpClient 对象。因为多个线程（每个客户端一个处理线程）可能同时操作这个列表（比如添加新客户端、移除断开连接的客户端、遍历发送广播），所以必须用 lock 关键字进行线程同步，防止数据竞争导致程序崩溃。
2. AcceptTcpClient() 是阻塞的，所以它在一个独立的 while (true) 循环中运行，专门负责“接客”。
3. 每接受一个新客户端，就为其创建一个新的后台线程 ( Thread ) 来执行 HandleClient 方法。这是经典的“一个连接一个线程”模型，对于学习和小规模并发是清晰的，但对于海量连接，则需要考虑线程池或异步IO（ async/await ），这是后话。

3.2 客户端连接处理与消息广播

HandleClient 方法是服务器与单个客户端对话的核心。

static void HandleClient(TcpClient client)
{
    NetworkStream stream = client.GetStream();
    byte[] buffer = new byte[1024]; // 数据缓冲区
    StringBuilder messageBuilder = new StringBuilder();
    string clientEndPoint = client.Client.RemoteEndPoint.ToString();

    try
    {
        int bytesRead;
        // 持续读取该客户端发送的数据
        while ((bytesRead = stream.Read(buffer, 0, buffer.Length)) != 0)
        {
            // 将接收到的字节转换为字符串
            string data = Encoding.UTF8.GetString(buffer, 0, bytesRead);
            messageBuilder.Append(data);

            // 检查是否收到了我们协议中定义的消息结束符（这里用换行符）
            string content = messageBuilder.ToString();
            int newlineIndex;
            while ((newlineIndex = content.IndexOf('\n')) >= 0)
            {
                // 提取一条完整消息
                string fullMessage = content.Substring(0, newlineIndex).TrimEnd('\r'); // 也去掉可能的回车符
                content = content.Substring(newlineIndex + 1); // 剩余部分
                Console.WriteLine($"来自 {clientEndPoint} 的消息: {fullMessage}");

                // **广播这条消息给所有其他客户端**
                BroadcastMessage(fullMessage, client);

                // 也可以在这里解析更复杂的协议，比如“/w [用户名] [消息]”表示私聊
            }
            messageBuilder.Clear();
            messageBuilder.Append(content); // 将未处理完的部分放回builder
        }
    }
    catch (IOException ex)
    {
        // 客户端断开连接时通常会引发IO异常
        Console.WriteLine($"客户端 {clientEndPoint} 断开连接 (IO异常): {ex.Message}");
    }
    catch (Exception ex)
    {
        Console.WriteLine($"处理客户端 {clientEndPoint} 时发生错误: {ex.Message}");
    }
    finally
    {
        // 客户端断开，清理资源
        lock (_clientsLock)
        {
            _clients.Remove(client);
        }
        client.Close();
        Console.WriteLine($"客户端 {clientEndPoint} 已从列表中移除。");
    }
}

BroadcastMessage 函数负责将消息转发给其他所有人：

static void BroadcastMessage(string message, TcpClient senderClient)
{
    byte[] msgBytes = Encoding.UTF8.GetBytes(message + "\n"); // 为每条消息添加结束符
    List<TcpClient> failedClients = new List<TcpClient>();

    lock (_clientsLock)
    {
        foreach (var client in _clients)
        {
            if (client != senderClient && client.Connected) // 不发给发送者自己，且只发给仍连接的
            {
                try
                {
                    NetworkStream stream = client.GetStream();
                    stream.Write(msgBytes, 0, msgBytes.Length);
                    stream.Flush(); // 确保数据被推送到网络
                }
                catch
                {
                    // 如果发送失败，记录该客户端，稍后清理
                    failedClients.Add(client);
                }
            }
        }

        // 清理发送失败的客户端连接
        foreach (var failedClient in failedClients)
        {
            _clients.Remove(failedClient);
            failedClient.Close();
            Console.WriteLine($"清理断开连接的客户端: {failedClient.Client.RemoteEndPoint}");
        }
    }
}

实操心得 ： stream.Read 是阻塞的，它会一直等待，直到有数据可读或连接关闭。 bytesRead 为0表示客户端已优雅地关闭了连接（调用 Close() ）。而异常断开（如直接关闭程序、网络故障）则会抛出 IOException 。在广播时，一定要检查 client.Connected 属性，但它并非100%实时准确，最可靠的方式还是像上面一样进行 try-catch ，发送失败即认为连接已失效。

3.3 文本协议的局限性与二进制协议升级

我们目前用的“换行符分隔”文本协议非常简单，但存在严重问题： 粘包与拆包 。TCP是流式协议，它只保证字节流的顺序，不保证“消息”的边界。比如客户端快速发送“Hello\nWorld\n”，服务器一次 Read 可能收到“Hello\nWorld\n”，也可能收到“He”，下次收到“llo\nWorld\n”。虽然我们的代码通过查找 \n 进行分割，在一定程度上解决了问题，但效率不高，且如果消息本身包含换行符就会产生歧义。

更专业的做法是使用 二进制协议 ，常用格式是： 消息长度（固定字节，如4字节int）+ 消息内容 。

1. 发送方：先计算消息内容的字节长度，转换成4字节的整数（ BitConverter.GetBytes(length) ），先发送这4个字节，再发送消息内容。
2. 接收方：先尝试读取固定的4个字节，解析出长度N，然后循环读取，直到收满N个字节的内容，这才算一条完整消息。

这种方式能明确界定每条消息，彻底解决粘包拆包。实现起来稍复杂，但却是生产级应用的标配。作为扩展，你可以尝试修改代码来实现这个二进制协议。

4. Unity客户端实现：让交互与网络共舞

Unity客户端的挑战在于如何将网络通信（通常运行在子线程）与Unity的对象和UI系统（必须在主线程操作）安全地结合起来。

4.1 网络管理器与线程安全通信

我们创建一个 NetworkManager 单例脚本来管理所有网络操作。

using UnityEngine;
using System;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using System.Collections.Concurrent; // 使用线程安全的集合

public class NetworkManager : MonoBehaviour
{
    public static NetworkManager Instance;

    private TcpClient _client;
    private NetworkStream _stream;
    private Thread _receiveThread;
    private bool _isConnected = false;

    // 线程安全的队列，用于存放从网络线程接收到的消息，供主线程消费
    private ConcurrentQueue<string> _messageQueue = new ConcurrentQueue<string>();

    // 定义事件，用于通知UI更新（另一种解耦方式）
    public event Action<string> OnMessageReceived;

    [SerializeField] private string serverIP = "127.0.0.1";
    [SerializeField] private int serverPort = 8888;

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void Start()
    {
        ConnectToServer();
    }

    void ConnectToServer()
    {
        try
        {
            _client = new TcpClient();
            // 使用异步连接避免卡顿，这里为了简化用同步连接
            _client.Connect(serverIP, serverPort);
            _stream = _client.GetStream();
            _isConnected = true;
            Debug.Log("已连接到服务器");

            // 启动接收消息的线程
            _receiveThread = new Thread(new ThreadStart(ReceiveData));
            _receiveThread.IsBackground = true;
            _receiveThread.Start();
        }
        catch (Exception e)
        {
            Debug.LogError($"连接服务器失败: {e.Message}");
        }
    }
}

ReceiveData 方法在后台线程中运行：

private void ReceiveData()
{
    byte[] buffer = new byte[4096];
    StringBuilder messageBuilder = new StringBuilder();

    while (_isConnected && _client != null && _client.Connected)
    {
        try
        {
            if (_stream.DataAvailable) // 检查是否有数据可读，非阻塞
            {
                int bytesRead = _stream.Read(buffer, 0, buffer.Length);
                if (bytesRead > 0)
                {
                    string data = Encoding.UTF8.GetString(buffer, 0, bytesRead);
                    messageBuilder.Append(data);

                    string content = messageBuilder.ToString();
                    int newlineIndex;
                    while ((newlineIndex = content.IndexOf('\n')) >= 0)
                    {
                        string fullMessage = content.Substring(0, newlineIndex).TrimEnd('\r');
                        content = content.Substring(newlineIndex + 1);
                        // 将消息放入队列，而不是直接调用Unity API
                        _messageQueue.Enqueue(fullMessage);
                        // 或者触发事件
                        // OnMessageReceived?.Invoke(fullMessage); // 注意：事件处理函数需在主线程
                    }
                    messageBuilder.Clear();
                    messageBuilder.Append(content);
                }
            }
            else
            {
                Thread.Sleep(10); // 短暂休眠，避免空转消耗CPU
            }
        }
        catch (Exception e)
        {
            Debug.LogWarning($"接收数据异常: {e.Message}");
            break;
        }
    }
    Debug.Log("接收线程结束");
}

关键在这里：我们 不能 在 _receiveThread 中直接调用 Debug.Log 或操作 GameObject / UI 。我们将收到的完整消息放入一个线程安全的 ConcurrentQueue<string> 中。

4.2 Unity主线程消费与UI更新

在 Update 方法中，主线程从队列中取出并处理消息：

void Update()
{
    // 在主线程中处理累积的消息
    while (_messageQueue.TryDequeue(out string msg))
    {
        // 现在可以安全地调用Unity的API了
        Debug.Log($"收到消息: {msg}");
        // 通知UI控制器更新聊天显示
        ChatUIController.Instance.AppendMessage(msg);
        // 或者使用事件
        // OnMessageReceived?.Invoke(msg);
    }
}

// 发送消息给服务器
public void SendMessageToServer(string message)
{
    if (!_isConnected || _stream == null) return;

    try
    {
        byte[] data = Encoding.UTF8.GetBytes(message + "\n");
        _stream.Write(data, 0, data.Length);
        _stream.Flush();
    }
    catch (Exception e)
    {
        Debug.LogError($"发送消息失败: {e.Message}");
        _isConnected = false;
    }
}

void OnDestroy()
{
    _isConnected = false;
    _receiveThread?.Join(500); // 等待接收线程结束，最多500ms
    _stream?.Close();
    _client?.Close();
}

踩坑记录 ：这里最大的坑就是 跨线程操作Unity对象 。早期我曾在接收线程里直接调用 GameObject.Find 或设置 Text.text ，在编辑器里跑几次可能没事，但发布后或在移动设备上极易引发随机崩溃。 ConcurrentQueue 是解决这个问题的经典模式。另外， OnDestroy 中的资源清理非常重要，要按顺序关闭流和客户端，并尝试优雅地结束线程，否则可能造成端口占用或资源泄漏。

4.3 UGUI聊天界面搭建与逻辑绑定

UI部分相对直观。创建一个Canvas，包含：

1. Scroll View ：作为聊天记录显示区域，里面放一个 Text 或 TextMeshPro - Text 组件用于显示所有聊天内容。为了性能，通常会使用 ScrollRect 配合 Content Size Fitter 和垂直布局组。
2. InputField ：用于输入消息。
3. Button ：发送按钮。

创建一个 ChatUIController 脚本：

using UnityEngine;
using UnityEngine.UI;
using TMPro; // 如果使用TextMeshPro

public class ChatUIController : MonoBehaviour
{
    public static ChatUIController Instance;

    [SerializeField] private TMP_Text _chatLogText; // 聊天记录显示文本
    [SerializeField] private TMP_InputField _inputField; // 消息输入框
    [SerializeField] private ScrollRect _scrollRect; // 用于自动滚动到底部

    void Awake()
    {
        Instance = this;
        // 也可以选择通过事件订阅，这里用静态实例直接调用
        // NetworkManager.Instance.OnMessageReceived += AppendMessage;
    }

    // 由NetworkManager在主线程调用
    public void AppendMessage(string message)
    {
        // 在主线程中执行，所以安全
        _chatLogText.text += $"\n[{System.DateTime.Now:HH:mm}] {message}";

        // 下一帧将滚动条滚到底部，以看到最新消息
        Canvas.ForceUpdateCanvases(); // 强制立即更新布局
        _scrollRect.verticalNormalizedPosition = 0f;
    }

    // 绑定到发送按钮的OnClick事件
    public void OnSendButtonClicked()
    {
        string msgToSend = _inputField.text.Trim();
        if (!string.IsNullOrEmpty(msgToSend))
        {
            NetworkManager.Instance.SendMessageToServer(msgToSend);
            _inputField.text = ""; // 清空输入框
            _inputField.ActivateInputField(); // 重新聚焦到输入框，方便连续输入
        }
    }

    // 绑定到InputField的OnSubmit事件（按回车发送）
    public void OnInputFieldSubmit(string text)
    {
        OnSendButtonClicked();
    }
}

这样，一个基础的、功能完整的聊天系统客户端和服务器端就搭建起来了。运行服务器控制台，然后运行一个或多个Unity客户端，你就能看到消息在彼此之间广播了。

5. 功能扩展与性能优化实战

基础功能跑通后，我们可以让它变得更实用、更健壮。

5.1 用户身份标识与私聊功能

目前我们不知道消息是谁发的。我们需要在连接建立后，让客户端发送一个登录消息，包含用户名。服务器端需要维护一个 Dictionary<TcpClient, string> 来映射连接和用户名。

协议升级 ：我们可以定义简单的命令格式。

• 登录： /login [username]
• 私聊： /w [targetUsername] [message]
• 列出在线用户： /list

服务器端的 HandleClient 方法在收到消息后，需要先解析命令。如果是 /login ，则将其用户名存入字典。如果是普通消息，则在广播时附上用户名，如 [张三]：大家好！ 。如果是 /w 命令，则从字典中找到目标用户名对应的 TcpClient ，进行定向发送。

5.2 心跳机制与连接健康检查

TCP连接在空闲时，中间的网络设备（如路由器、防火墙）可能会因为超时而将其断开。为了保持连接活跃，需要引入 心跳机制 。

客户端定期（如每30秒）向服务器发送一个特殊的小消息（例如，内容为“ <heartbeat> ”）。服务器端收到后，可以简单地忽略或回复一个确认。同时，服务器端也需要检查：如果一个客户端超过一定时间（如90秒）没有发送任何数据（包括心跳），则认为其已断开，主动清理其连接资源。

实现上，可以在客户端的 NetworkManager 中开启一个 Coroutine （协程）来定时发送心跳包。服务器端则在每个客户端的处理线程中记录最后一次收到数据的时间，并定期（或在广播前）检查这个时间戳。

5.3 使用异步API提升服务器性能

我们之前用的“一连接一线程”的同步阻塞模型，在连接数上百时，线程切换的开销会变得很大。.NET 提供了基于 async/await 的异步Socket API，可以极大地提升并发性能。

核心是将 AcceptTcpClient 、 stream.ReadAsync 、 stream.WriteAsync 改为异步方法。服务器端可以使用一个循环来异步接受连接，并为每个连接启动一个异步的消息处理循环，而不需要为每个连接创建独立的线程。这属于I/O多路复用模型，能用一个或少量线程处理大量连接。

// 异步版本的服务器监听循环示例
public static async Task StartAsync()
{
    TcpListener listener = new TcpListener(IPAddress.Any, port);
    listener.Start();
    while (true)
    {
        TcpClient client = await listener.AcceptTcpClientAsync();
        _ = HandleClientAsync(client); // 不等待，直接“发射后不管”
    }
}

static async Task HandleClientAsync(TcpClient client)
{
    using (client)
    using (NetworkStream stream = client.GetStream())
    {
        byte[] buffer = new byte[1024];
        while (true)
        {
            int bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length);
            if (bytesRead == 0) break; // 连接关闭
            // ... 处理数据 ...
            await stream.WriteAsync(responseBuffer, 0, responseBuffer.Length);
        }
    }
}

异步改造涉及整个编程模型的改变，是迈向高性能服务器的重要一步，但对于初学者，理解同步模型是基础。

5.4 数据序列化与复杂消息

目前我们只发送文本字符串。如果想发送更结构化的数据，比如一个包含发送者、消息类型、内容、时间戳的聊天消息对象，就需要序列化。

JSON 是一个简单通用的选择。我们可以定义一个 ChatMessage 类，使用 Newtonsoft.Json （需安装NuGet包）或 .NET 自带的 System.Text.Json 进行序列化和反序列化。

// 定义消息类
[System.Serializable]
public class ChatPacket
{
    public string Sender;
    public string Message;
    public MessageType Type; // 枚举：Normal, Whisper, System等
    public DateTime Timestamp;
}

// 发送时
ChatPacket packet = new ChatPacket { Sender = _username, Message = input, Type = MessageType.Normal };
string json = JsonUtility.ToJson(packet); // Unity内置的JsonUtility，或使用Newtonsoft.Json
byte[] data = Encoding.UTF8.GetBytes(json + "\n"); // 仍然可以加分隔符，或者使用长度前缀

// 接收时
string jsonString = /* 从流中解析出的字符串 */;
ChatPacket receivedPacket = JsonUtility.FromJson<ChatPacket>(jsonString);

使用JSON后，协议扩展性大大增强，可以轻松添加新的字段和消息类型。

6. 常见问题排查与调试技巧

在实际开发中，你肯定会遇到各种问题。这里记录一些典型的坑和排查手段。

6.1 连接失败与防火墙

• 问题 ：Unity客户端无法连接到服务器，提示“No connection could be made because the target machine actively refused it”。
• 排查 ：
  1. 确认服务器程序是否真的启动了，并且监听在正确的IP和端口上。可以在服务器启动后，在命令行用 netstat -ano | findstr :8888 （Windows）或 lsof -i :8888 （macOS/Linux）查看端口监听状态。
  2. 确认客户端连接的IP和端口号是否正确。如果服务器和客户端在同一台机器，用 127.0.0.1 。如果在局域网，需用服务器的局域网IP（如 192.168.1.xxx ），并确保防火墙允许该端口的入站连接（在Windows防火墙中添加入站规则）。
  3. 如果是云服务器，还需要在安全组/防火墙中开放对应端口。

6.2 消息乱码或截断

• 问题 ：收到的中文是乱码，或者长消息被截断。
• 排查 ：
  1. 编码一致 ：确保服务器和客户端都使用 Encoding.UTF8 。这是最通用的选择。
  2. 缓冲区大小 ：客户端的接收缓冲区（ byte[] buffer ）大小是固定的（如1024）。如果一条消息超过这个长度，需要多次 Read 才能读完。我们的 StringBuilder 和按 \n 分割的逻辑就是为了处理这种情况。如果消息非常长，要考虑增大缓冲区或使用更动态的读取方式。
  3. 粘包拆包 ：这是最可能的原因。务必确保你的协议能正确处理消息边界。强烈建议从文本协议升级到“长度前缀”的二进制协议。

6.3 Unity客户端卡顿或崩溃

• 问题 ：聊天时Unity编辑器变卡，或者打包后运行崩溃。
• 排查 ：
  1. 主线程阻塞 ：检查是否在 Update 或UI事件中执行了耗时的同步网络操作（如 client.Connect 、 stream.Read ）。必须将这些操作放到线程中。
  2. 跨线程操作 ：这是崩溃的主因。确保所有对 GameObject 、 Component 、 Debug.Log 以及设置UI属性的操作都在主线程执行。善用 ConcurrentQueue 或 UnityEngine.Dispatchers （如果有）。
  3. 内存泄漏 ： Thread 对象如果不设置为 IsBackground = true ，可能会阻止应用程序退出。确保在 OnDestroy 或 OnApplicationQuit 中正确关闭所有网络资源和线程。

6.4 多客户端测试时的异常

• 问题 ：当连接多个客户端时，服务器偶尔报错“集合已修改；可能无法执行枚举操作”。
• 排查 ：这几乎肯定是线程同步问题。当你在 foreach 循环中遍历 _clients 列表进行广播时，另一个线程（比如处理某个客户端断开连接的线程）可能正在修改这个列表（ _clients.Remove ）。 解决方案 ：在任何读写 _clients 的地方（添加、移除、遍历）都必须使用 lock (_clientsLock) 语句进行保护。

6.5 使用Wireshark进行网络抓包分析

当你对网络行为一头雾水时， Wireshark 是终极利器。它可以捕获你电脑上的所有网络流量。

1. 启动Wireshark，选择正确的网卡（如“Wi-Fi”或“以太网”）。
2. 在过滤栏输入 tcp.port == 8888 （你的服务器端口）。
3. 运行你的服务器和客户端，开始聊天。
4. 在Wireshark中，你可以清晰地看到TCP三次握手建立连接、每条消息的发送和接收（数据包内容）、以及TCP窗口、确认号等细节。这对于调试复杂的协议问题、验证数据是否正确发送/接收有无丢包，有不可替代的作用。

自己动手实现一遍这个系统，你会对网络编程、线程同步、客户端-服务器架构有非常深刻的理解。这远比单纯调用某个网络插件的API来得扎实。当你下次再看到那些成熟的网络框架时，你就能一眼看穿它们底层在做什么，以及它们为你解决了哪些复杂问题。