Unity 2020集成讯飞星火大模型：C# WebSocket流式对话实战指南

1. 项目概述：Unity与星火大模型的握手

最近在做一个Unity项目，需要接入一个智能对话系统来驱动游戏内的NPC或者作为玩家的智能助手。市面上大模型API选择不少，但综合考虑成本、响应速度和中文支持，讯飞星火成了我的首选。Unity 2020作为当前一个非常稳定且应用广泛的LTS版本，自然是开发环境的基础。然而，当我把“Unity 2020”、“讯飞星火API”、“C#”这几个词组合在一起时，发现网上的资料要么是零散的片段，要么就是直接搬运官方文档，真正能跑通、能避坑的完整指南少之又少。特别是涉及到WebSocket这种长连接通信，在Unity这个游戏引擎里处理起来，和普通的控制台或Web应用差别巨大。

这个项目的核心目标很明确：在Unity 2020中，使用C#通过WebSocket协议，稳定、高效地接入讯飞星火大模型的对话能力。这不仅仅是调通一个API那么简单，它涉及到Unity的生命周期管理、WebSocket的异步消息处理、星火API特有的数据格式（如role、content、temperature等参数），以及如何将流式返回的文本数据平滑地呈现在UI上。整个过程就像是在两个不同“语言体系”的系统间搭建一座桥梁，Unity主攻实时渲染和交互，而大模型API则处理自然语言理解与生成，WebSocket就是这座桥上双向行驶的车道。

如果你也在尝试类似的事情，无论是为了游戏内的智能对话、虚拟主播的实时互动，还是任何需要AI文本生成能力的Unity应用，这篇指南就是为你准备的。我会从环境准备、核心代码拆解、到实战中那些官方文档不会告诉你的“坑”，手把手带你走一遍。最终，你会得到一个可以直接集成到你项目中的、健壮的C# WebSocket客户端类，以及一个清晰的使用范例。

2. 核心思路与方案选型：为什么是WebSocket？

在开始敲代码之前，我们必须先理清思路：为什么选择WebSocket，而不是更常见的HTTP？在Unity里又有哪些实现WebSocket的选项？

2.1 HTTP与WebSocket的抉择

讯飞星火API的对话接口支持两种模式：HTTP轮询和WebSocket流式。对于大模型对话这种可能持续多轮、且每次回复内容较长的场景，WebSocket的优势是压倒性的。

• HTTP轮询：你需要自己管理对话的chat_id，每次发送用户消息后，需要不断地向服务器发送查询请求，直到获取完整回复。这种方式不仅延迟高（需要等待服务器生成完毕），而且浪费网络资源，在Unity中频繁发起HTTP请求还可能对帧率造成影响。
• WebSocket流式：建立一次连接，就可以在这个连接上持续收发消息。最关键的是，星火API支持流式返回，这意味着模型生成文本是“一个字一个字”或“一个词一个词”地实时推送回来的。这对于需要实时显示对话内容的游戏UI体验至关重要，用户能立刻看到AI的“思考”过程，交互感极强。

因此，为了实现低延迟、高实时的对话体验，WebSocket流式接口是我们的不二之选。

2.2 Unity中的WebSocket实现方案

Unity本身并没有内置原生的WebSocket支持。在Unity 2020中，我们主要有以下几种选择：

1. Unity WebGL的WebSocket类：仅在WebGL平台可用，对于需要发布到PC、移动端的项目不通用。
2. .NET Standard 2.0/2.1中的ClientWebSocket：这是最“正统”的.NET方案。Unity 2020基于.NET Standard 2.0（或通过兼容层支持部分2.1特性）。ClientWebSocket功能强大，但它在Unity中使用有一个致命问题：其异步方法（如ConnectAsync,ReceiveAsync）依赖于特定的SynchronizationContext来将回调抛回主线程，而Unity的旧版.NET运行时环境对此支持不完善，极易导致回调丢失、卡死或不在主线程执行，进而引发UI更新崩溃。
3. 第三方WebSocket库：这是社区实践下来最稳定、最推荐的选择。它们通常用纯C#实现，不依赖特定平台的Socket API，并且更好地处理了多线程与Unity主线程的同步问题。

经过大量测试和社区反馈，WebSocketSharp和NativeWebSocket是两个主流选择。WebSocketSharp成熟稳定，但近年来更新不频繁；NativeWebSocket则更轻量，对Unity的集成更友好，其API设计也更容易理解。在本指南中，我将选择NativeWebSocket作为我们的通信基础库，因为它能很好地规避ClientWebSocket的线程陷阱，并且使用起来非常直观。

注意：无论选择哪个库，核心原则是确保WebSocket的消息接收回调能在Unity的主线程中被执行，这样才能安全地操作GameObject、UI.Text等Unity引擎对象。

2.3 讯飞星火API的关键概念准备

在编码前，还需要理解星火API的几个关键参数，它们将构成我们发送的请求体（JSON格式）：

• header: 包含app_id（你的应用ID）、uid（用户标识，用于区分不同用户）。
• parameter: 包含chat字段，其中domain指定模型版本（如generalv3），temperature控制随机性（0~1，值越高回答越随机），max_tokens限制单次回复最大长度。
• payload: 包含message字段，其下text数组存放对话历史。每条历史记录是一个对象，包含role（user或assistant）和content。API需要完整的上下文历史来实现多轮对话。

理解这些，我们就能构建出符合API要求的JSON数据了。

3. 环境准备与核心库集成

理论清晰了，现在开始动手搭建环境。这一步的稳定性直接决定了后续开发是否会步履维艰。

3.1 创建Unity 2020项目与导入NativeWebSocket

首先，创建一个新的3D或2D Unity项目（2020.3.x LTS版本均可）。接着，我们需要导入WebSocket库。

推荐使用Unity的Package Manager从Git URL安装NativeWebSocket：

1. 打开Window -> Package Manager。
2. 点击左上角的+号，选择Add package from git URL...。
3. 输入NativeWebSocket的Git仓库地址：https://github.com/endel/NativeWebSocket.git#upm
4. 点击Add。Unity会自动下载并导入该包。这种方式比直接下载.unitypackage更便于版本管理。

导入成功后，你可以在Packages目录下看到Native WebSocket。现在，你的C#脚本中就可以使用using NativeWebSocket;来引用相关类了。

3.2 获取讯飞星火API密钥

前往讯飞开放平台官网，注册并登录。在控制台中创建一个新应用，选择“星火认知大模型”相关能力。创建成功后，你将获得三个至关重要的凭证：

• APPID: 应用唯一标识。
• APISecret: API密钥。
• APIKey: API密钥。

请妥善保管APISecret和APIKey，它们将用于生成WebSocket连接所需的鉴权URL。绝对不要将这些敏感信息硬编码在客户端代码中，尤其是准备发布的项目。对于开发测试，可以暂时放在脚本的公共变量里，但最终应通过安全的服务器端进行中转，或使用Unity的PlayerPrefs进行简单加密存储。

3.3 构建WebSocket连接URL

讯飞星火WebSocket接口的URL不是固定的，需要根据APISecret和APIKey动态生成，其中包含一个基于HMAC-SHA256算法的签名。这个过程稍显复杂，但我们可以将其封装成一个工具方法。

核心步骤是：

1. 生成RFC1123格式的当前时间。
2. 拼接签名字符串：host: date + "\n" + GET + path。
3. 使用APISecret对签名字符串进行HMAC-SHA256加密，然后进行Base64编码。
4. 将编码后的签名进行URL编码。
5. 最终组装URL：wss://host + path + ?authorization=Base64Encode(api_key:signature)&date=date&host=host

这里提供一个C#实现片段：

using System; using System.Security.Cryptography; using System.Text; public static class SparkAuthHelper { public static string GenerateWebSocketUrl(string host, string path, string apiKey, string apiSecret) { var date = DateTime.UtcNow.ToString("r"); // RFC1123格式时间 var signatureOrigin = $"host: {host}\ndate: {date}\nGET {path} HTTP/1.1"; var signatureSha = HMACSHA256(Encoding.UTF8.GetBytes(apiSecret), Encoding.UTF8.GetBytes(signatureOrigin)); var signature = Convert.ToBase64String(signatureSha); var authorizationOrigin = $"api_key=\"{apiKey}\", algorithm=\"hmac-sha256\", headers=\"host date request-line\", signature=\"{signature}\""; var authorization = Convert.ToBase64String(Encoding.UTF8.GetBytes(authorizationOrigin)); // URL编码 var url = $"wss://{host}{path}?authorization={Uri.EscapeDataString(authorization)}&date={Uri.EscapeDataString(date)}&host={Uri.EscapeDataString(host)}"; return url; } private static byte[] HMACSHA256(byte[] key, byte[] data) { using (var hmac = new HMACSHA256(key)) { return hmac.ComputeHash(data); } } }

在Unity中调用时，host是spark-api.xf-yun.com，path是/v3.1/chat（以V3.0版本为例）。将生成的URL用于WebSocket连接。

4. 核心WebSocket客户端类实现

这是整个项目的核心。我们将创建一个名为SparkWebSocketClient的类，它负责管理WebSocket连接的生命周期、发送消息、接收并处理流式响应。

4.1 类结构与初始化

首先定义必要的字段和属性，并在Start或一个明确的初始化方法中创建连接。

using NativeWebSocket; using System; using UnityEngine; using System.Text; using System.Collections.Generic; public class SparkWebSocketClient : MonoBehaviour { public string appId; // 从Inspector面板赋值或从配置读取 public string apiKey; public string apiSecret; private WebSocket websocket; private string host = "spark-api.xf-yun.com"; private string path = "/v3.1/chat"; // 用于存储对话历史，实现上下文 private List<Message> conversationHistory = new List<Message>(); // 定义消息结构，对应星火API的role和content [System.Serializable] public class Message { public string role; // "user" or "assistant" public string content; } // 定义一个委托和事件，用于将收到的文本片段通知给UI public event Action<string> OnTextFragmentReceived; public event Action<string> OnFullResponseReceived; async void Start() { // 生成鉴权URL string url = SparkAuthHelper.GenerateWebSocketUrl(host, path, apiKey, apiSecret); // 创建WebSocket实例 websocket = new WebSocket(url); // 订阅事件 websocket.OnOpen += OnWebSocketOpen; websocket.OnMessage += OnWebSocketMessageReceived; websocket.OnError += OnWebSocketError; websocket.OnClose += OnWebSocketClosed; // 开始连接 await websocket.Connect(); } void OnWebSocketOpen() { Debug.Log("WebSocket连接成功！"); } void OnWebSocketError(string errorMsg) { Debug.LogError($"WebSocket错误: {errorMsg}"); } void OnWebSocketClosed(WebSocketCloseCode closeCode) { Debug.Log($"WebSocket连接关闭，代码: {closeCode}"); } }

这里的关键是使用async void Start()并await websocket.Connect()。NativeWebSocket内部会处理好异步操作，确保连接过程不阻塞主线程。

4.2 构建与发送请求报文

我们需要一个方法来构建符合星火API格式的JSON请求，并通过WebSocket发送。这个方法需要接收用户输入的字符串，并将其加入到历史记录中，然后组装完整请求。

public void SendMessage(string userInput) { if (websocket.State != WebSocketState.Open) { Debug.LogWarning("WebSocket未连接，无法发送消息。"); return; } // 1. 将用户输入加入历史 conversationHistory.Add(new Message { role = "user", content = userInput }); // 2. 构建请求JSON var request = new { header = new { app_id = appId }, parameter = new { chat = new { domain = "generalv3", temperature = 0.5f, max_tokens = 2048 } }, payload = new { message = new { text = conversationHistory // 发送全部历史上下文 } } }; string jsonRequest = JsonUtility.ToJson(request); // JsonUtility可能需要配合[Serializable]类，对于复杂嵌套，可以使用Newtonsoft.Json（需额外导入） // 这里为简化，假设使用处理过的类结构。实际中，你可能需要定义完整的可序列化类。 // 3. 发送 websocket.SendText(jsonRequest); Debug.Log("已发送用户消息。"); }

实操心得：直接使用JsonUtility处理这种深度嵌套的匿名对象可能会遇到问题。一个更稳健的做法是定义完整的可序列化数据类（如SparkRequestHeader,SparkRequestParameter等），或者引入像Newtonsoft.Json（即Json.NET）这样的第三方库，它在Unity社区非常流行，能更灵活地处理JSON序列化。你可以通过Package Manager搜索com.unity.nuget.newtonsoft-json来安装。

4.3 处理流式响应与数据解析

这是最复杂也最关键的一步。OnWebSocketMessageReceived事件会接收到服务器推送的二进制数据（byte[]），我们需要将其转换为文本，并解析出其中的内容。

void OnWebSocketMessageReceived(byte[] bytes) { // NativeWebSocket的回调可能在非主线程，使用Dispatcher确保在主线程处理UI更新 #if !UNITY_WEBGL || UNITY_EDITOR MainThreadDispatcher.RunOnMainThread(() => { ProcessWebSocketMessage(bytes); }); #else // WebGL环境下，回调默认在主线程 ProcessWebSocketMessage(bytes); #endif } void ProcessWebSocketMessage(byte[] bytes) { string message = Encoding.UTF8.GetString(bytes); Debug.Log($"收到原始消息: {message}"); // 解析JSON响应 // 这里同样需要对应的响应数据类 var response = JsonUtility.FromJson<SparkStreamResponse>(message); if (response != null && response.header.code == 0) { // 成功响应 foreach (var choice in response.payload.choices.text) { // 流式响应中，content是逐步返回的 string fragment = choice.content; if (!string.IsNullOrEmpty(fragment)) { // 触发事件，通知UI更新（例如，追加到文本框） OnTextFragmentReceived?.Invoke(fragment); } } // 检查是否为结束标志 if (response.payload.choices.status == 2) { // 本轮对话结束，将AI回复完整内容加入历史记录 string fullResponse = GetFullResponseFromCurrentStream(); // 你需要一个方法来拼接本次流式返回的所有片段 conversationHistory.Add(new Message { role = "assistant", content = fullResponse }); // 触发完整响应事件 OnFullResponseReceived?.Invoke(fullResponse); Debug.Log("本轮对话AI回复完成。"); } } else { // 处理错误 Debug.LogError($"API返回错误: code={response?.header.code}, message={response?.header.message}"); } }

你需要定义SparkStreamResponse类来映射API返回的JSON结构。流式响应中，status字段为0或1表示还在生成，为2表示生成结束。每次收到消息，content字段都包含当前生成的新文本片段。

避坑指南：线程安全是重中之重！OnWebSocketMessageReceived回调很可能不在Unity的主线程。直接在其中操作GameObject或UI组件会导致运行时错误。NativeWebSocket提供了WebSocket.DispatchMessageQueue()方法，你需要在Update()中调用它，将消息队列抛到主线程处理。或者，像上面代码一样，使用一个简单的MainThreadDispatcher单例（自己实现或使用Asset Store现有方案）来安全地调度任务到主线程。这是Unity集成WebSocket时最常见的崩溃点。

4.4 管理连接生命周期与资源清理

WebSocket连接是持久性的，需要妥善管理。

void Update() { #if !UNITY_WEBGL || UNITY_EDITOR // 非WebGL平台，需要手动分发消息队列 if (websocket != null) { websocket.DispatchMessageQueue(); } #endif } // 当对象禁用或销毁时，关闭连接 async void OnDestroy() { if (websocket != null && websocket.State == WebSocketState.Open) { await websocket.Close(); } } // 提供一个公共方法用于手动重连 public async void Reconnect() { if (websocket != null) { await websocket.Close(); } // 重新初始化连接（可以封装一个独立的Connect方法） Start(); }

在Update中调用DispatchMessageQueue()确保了所有网络事件在主线程被处理。在OnDestroy中异步关闭连接是好习惯，能避免资源泄漏。

5. Unity UI集成与对话流展示

有了稳定的后端客户端，前端UI集成就是水到渠成。我们创建一个简单的UI来展示对话。

5.1 创建基础UI界面

在Unity场景中，创建一个Canvas，并添加以下UI元素：

• 一个ScrollRect作为对话滚动视图，其下有一个Text或TextMeshPro - Text组件用于显示全部对话历史。
• 一个InputField用于用户输入。
• 一个Button用于发送消息。

5.2 编写UI控制器脚本

创建一个ChatUIController脚本，挂载到Canvas上。

using UnityEngine; using UnityEngine.UI; using System.Text; public class ChatUIController : MonoBehaviour { public SparkWebSocketClient sparkClient; // 拖拽赋值 public Text historyText; // 显示对话历史的Text组件 public InputField inputField; public Button sendButton; private StringBuilder dialogueHistoryBuilder = new StringBuilder(); void Start() { sendButton.onClick.AddListener(OnSendButtonClicked); inputField.onEndEdit.AddListener((str) => { if (Input.GetKeyDown(KeyCode.Return)) OnSendButtonClicked(); }); if (sparkClient != null) { // 订阅事件 sparkClient.OnTextFragmentReceived += AppendAIFragment; sparkClient.OnFullResponseReceived += OnAIResponseComplete; } } void OnSendButtonClicked() { string userMessage = inputField.text.Trim(); if (string.IsNullOrEmpty(userMessage) || sparkClient == null) return; // 在UI上显示用户消息 AppendDialogueLine($"你: {userMessage}"); inputField.text = ""; inputField.ActivateInputField(); // 重新聚焦输入框 // 发送给星火API sparkClient.SendMessage(userMessage); // 在UI上显示“AI正在思考...”的提示 AppendDialogueLine("AI: "); } void AppendDialogueLine(string line) { dialogueHistoryBuilder.AppendLine(line); historyText.text = dialogueHistoryBuilder.ToString(); // 可选：自动滚动到底部 Canvas.ForceUpdateCanvases(); // 这里需要获取ScrollRect组件并设置verticalNormalizedPosition = 0f; } void AppendAIFragment(string fragment) { // 移除上次的“AI正在思考...”提示行，替换为逐步增长的AI回复 // 这里需要一些逻辑来更新最后一行（即AI的回复行），而不是追加新行。 // 一种简单做法：记录AI回复开始的位置索引，然后不断替换该位置之后的文本。 // 以下为简化示例，假设我们每次收到片段都更新整个“AI: ”行。 UpdateLastAILine(fragment); } void UpdateLastAILine(string currentContent) { // 实现逻辑：找到历史字符串中最后一个“AI: ”开头的位置，将其之后的内容替换为currentContent // 这里涉及字符串操作，具体实现略。可以使用TextMeshPro更强大的文本处理能力。 // 临时简单方案：每次收到片段都重写最后一行 int lastLineIndex = dialogueHistoryBuilder.ToString().LastIndexOf("AI: "); if (lastLineIndex != -1) { dialogueHistoryBuilder.Remove(lastLineIndex + 4, dialogueHistoryBuilder.Length - (lastLineIndex + 4)); dialogueHistoryBuilder.Append(currentContent); historyText.text = dialogueHistoryBuilder.ToString(); } } void OnAIResponseComplete(string fullResponse) { // 流式接收完毕，可以做一些清理或状态更新，比如将输入框重新设为可交互。 Debug.Log($"AI回复完成: {fullResponse}"); } void OnDestroy() { if (sparkClient != null) { sparkClient.OnTextFragmentReceived -= AppendAIFragment; sparkClient.OnFullResponseReceived -= OnAIResponseComplete; } } }

这个控制器将用户界面与我们的SparkWebSocketClient连接起来。当用户发送消息时，它先更新本地UI，然后调用客户端发送请求。当收到AI的流式回复片段时，通过事件回调实时更新UI上的文本，创造出“逐字打印”的效果。

注意事项：实时更新UI文本，尤其是在每一帧都可能收到多个网络回调的情况下，需要注意性能。避免在Update中频繁进行复杂的字符串操作。上述示例中的UpdateLastAILine方法在历史记录很长时可能效率不高。对于生产环境，建议使用StringBuilder来管理当前正在接收的AI回复行，或者使用TextMeshPro的textInfo相关API进行更精细的文本操作。

6. 实战避坑与优化技巧实录

按照上面的步骤，一个基础的对话系统应该能跑起来了。但在实际开发中，你肯定会遇到一些“坑”。下面是我在多次实践中总结出来的关键问题和解决方案。

6.1 连接不稳定与断线重连

网络环境复杂，WebSocket连接可能会意外断开（代码1006常见）。一个健壮的客户端必须具备重连机制。

解决方案：在SparkWebSocketClient中增加重连逻辑。可以在OnWebSocketClosed事件中判断，如果是非正常关闭（如网络错误），则触发一个延迟重连协程。

private bool shouldReconnect = false; private float reconnectDelay = 3f; // 重连等待时间 void OnWebSocketClosed(WebSocketCloseCode closeCode) { Debug.Log($"连接关闭，代码: {closeCode}"); if (closeCode != WebSocketCloseCode.Normal) { Debug.Log("非正常关闭，尝试重连..."); shouldReconnect = true; StartCoroutine(ReconnectCoroutine()); } } System.Collections.IEnumerator ReconnectCoroutine() { while (shouldReconnect) { yield return new WaitForSeconds(reconnectDelay); if (shouldReconnect) { Debug.Log("正在重连..."); // 调用重连方法，注意清理旧连接 _ = Reconnect(); // 使用 discard _ 忽略Task警告 } } } // 在连接成功时，停止重连循环 void OnWebSocketOpen() { Debug.Log("连接成功！"); shouldReconnect = false; }

6.2 流式响应乱序与拼接

在高频接收或网络波动时，理论上可能存在数据包乱序（虽然WebSocket本身保证有序，但Unity主线程调度仍需注意）。此外，如何优雅地拼接多个文本片段，并在收到结束标志status==2时得到完整回复，也需要设计。

解决方案：

• 顺序保证：由于我们是在单一线程（主线程）的消息队列中顺序处理OnWebSocketMessageReceived，所以乱序问题基本不会发生。确保不要在多个线程中同时处理接收到的bytes。
• 片段拼接：在客户端类中维护一个StringBuilder currentAiResponseBuilder。每次收到status为0或1的消息时，将其content追加到builder中。当收到status为2的消息时，将builder中的内容取出作为完整回复，触发完成事件，然后清空builder以备下次使用。这样逻辑清晰，且能处理多轮对话。

6.3 多轮对话上下文管理

我们的conversationHistory列表会随着对话进行而增长。星火API的max_tokens参数限制了请求的总长度。如果历史对话太长，会导致API调用失败。

解决方案：实现一个简单的上下文窗口管理。

1. 在每次发送请求前，检查conversationHistory的总字符数或估算的token数。
2. 如果超出某个阈值（例如，max_tokens的70%，为AI回复留出空间），则从历史记录中移除最老的一对（或几对）user和assistant对话，直到长度符合要求。
3. 也可以采用更智能的“摘要”方式，但最简单的截断旧对话在大多数场景下是有效的。

6.4 性能与内存优化

• UI频繁更新：如果AI回复速度很快，OnTextFragmentReceived事件会高频触发，导致UI频繁重绘。可以通过设置一个计时器或计数器，累积一定数量的字符（例如10个字符）或经过一定时间（如0.1秒）后再一次性更新UI，减少Canvas.ForceUpdateCanvases()的调用。
• 大历史记录：conversationHistory列表如果存储非常长的对话，会占用内存。除了上述的上下文截断，对于不再需要的对话，可以考虑序列化后存储到磁盘，只在需要时加载最近的部分。
• 对象池：如果对话UI是动态生成的GameObject（例如每个气泡是一个预制体），务必使用对象池来管理创建和销毁，避免频繁的实例化操作引发GC。

6.5 错误处理与用户反馈

网络请求充满不确定性，良好的错误处理能提升用户体验。

• 连接失败：在OnWebSocketError和OnWebSocketClosed中，不仅记录日志，还应通过UI提示用户（如“连接断开，正在重试...”）。
• API返回错误：星火API的header.code不为0时，表示业务错误（如额度不足、参数错误）。应解析header.message，并将其转换为对用户友好的提示。
• 超时处理：可以为每次发送的请求设置一个超时计时器。如果在规定时间内没有收到status==2的结束信号，可以认为本次请求超时，主动关闭当前连接并提示用户，同时触发重连。

7. 完整代码整合与测试

将上述所有模块整合到一个Unity场景中：

1. 创建一个空GameObject，命名为SparkClient，挂载SparkWebSocketClient脚本，并在Inspector中填入你的appId,apiKey,apiSecret。
2. 设置好UI Canvas，并将ChatUIController脚本挂载到Canvas或一个管理器对象上。
3. 在ChatUIController的Inspector中，将SparkClient对象拖拽到sparkClient字段，并将对应的UI组件（historyText,inputField,sendButton）一一关联。
4. 运行游戏。在输入框中打字，点击发送或按回车键。你应该能看到你的消息出现在历史框中，紧接着AI的回复会以流式的方式，逐字逐句地显示出来。

测试要点：

• 基础功能：发送、接收、流式显示是否正常。
• 多轮对话：连续发送多条消息，AI是否能基于上文进行回复。
• 网络容错：在对话过程中，手动断开电脑的网络，观察是否会触发错误处理和重连机制。
• 内存泄漏：长时间运行，在Profiler中观察WebSocket连接和事件委托是否有不当引用导致无法被垃圾回收。

通过以上步骤，你已经成功在Unity 2020中搭建了一个通过C# WebSocket连接讯飞星火大模型的完整对话系统。这个过程涵盖了从环境搭建、核心通信、UI集成到错误处理和性能优化的全链路。希望这份详尽的指南和附带的思路解析，能帮你避开我当年踩过的那些坑，顺利地将大模型的智能融入你的Unity项目之中。记住，关键永远是理解原理（为什么用WebSocket）、处理好线程安全（主线程更新UI）、以及设计健壮的错误恢复机制。剩下的，就是发挥你的创意，去打造更丰富的交互体验了。