快速体验

在开始今天关于 .NET Core WebSocket 从入门到实战：构建实时通信应用 的探讨之前，我想先分享一个最近让我觉得很有意思的全栈技术挑战。

我们常说 AI 是未来，但作为开发者，如何将大模型（LLM）真正落地为一个低延迟、可交互的实时系统，而不仅仅是调个 API？

这里有一个非常硬核的动手实验：基于火山引擎豆包大模型，从零搭建一个实时语音通话应用。它不是简单的问答，而是需要你亲手打通 ASR（语音识别）→ LLM（大脑思考）→ TTS（语音合成）的完整 WebSocket 链路。对于想要掌握 AI 原生应用架构的同学来说，这是个绝佳的练手项目。

从0到1构建生产级别应用，脱离Demo，点击打开 从0打造个人豆包实时通话AI动手实验

.NET Core WebSocket 从入门到实战：构建实时通信应用

为什么需要WebSocket？

在开发实时应用时，传统的HTTP轮询方式存在明显短板。想象一下这样的场景：你正在做一个在线聊天室，如果使用轮询，客户端需要不断向服务器发送"有新消息吗？"的请求，即使没有数据更新也会产生网络开销。

相比之下，WebSocket就像开通了一条专用电话线：

• 全双工通信：双方可以随时主动发送消息
• 低延迟：建立连接后无需重复握手
• 高效传输：没有HTTP头部的冗余信息

基础搭建：服务端实现

在.NET Core中使用WebSocket非常简单，我们从中间件开始：

1. 首先在Startup.cs中配置WebSocket中间件：

public void Configure(IApplicationBuilder app)
{
    app.UseWebSockets();
    app.Use(async (context, next) =>
    {
        if (context.WebSockets.IsWebSocketRequest)
        {
            WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync();
            await HandleWebSocketConnection(webSocket);
        }
        else
        {
            await next();
        }
    });
}

1. 核心连接处理方法：

private async Task HandleWebSocketConnection(WebSocket webSocket)
{
    var buffer = new byte[1024 * 4];
    try
    {
        WebSocketReceiveResult result = await webSocket.ReceiveAsync(
            new ArraySegment<byte>(buffer), CancellationToken.None);

        while (!result.CloseStatus.HasValue)
        {
            // 处理接收到的消息
            string message = Encoding.UTF8.GetString(buffer, 0, result.Count);
            Console.WriteLine($"收到消息: {message}");

            // 发送响应
            byte[] response = Encoding.UTF8.GetBytes($"已收到: {message}");
            await webSocket.SendAsync(
                new ArraySegment<byte>(response),
                result.MessageType,
                result.EndOfMessage,
                CancellationToken.None);

            // 继续接收下一条消息
            result = await webSocket.ReceiveAsync(
                new ArraySegment<byte>(buffer), 
                CancellationToken.None);
        }

        await webSocket.CloseAsync(
            result.CloseStatus.Value, 
            result.CloseStatusDescription, 
            CancellationToken.None);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"连接异常: {ex.Message}");
    }
}

客户端实现：JavaScript示例

服务端准备好后，我们需要一个能与之通信的客户端：

const socket = new WebSocket('ws://localhost:5000');

// 连接状态管理
socket.onopen = () => {
    console.log('连接已建立');
    socket.send('你好，服务器！');
};

socket.onmessage = (event) => {
    console.log(`收到消息: ${event.data}`);
};

socket.onclose = (event) => {
    console.log(`连接关闭: ${event.code} ${event.reason}`);
    // 实现自动重连逻辑
    setTimeout(() => connect(), 5000);
};

socket.onerror = (error) => {
    console.error('连接错误:', error);
};

进阶话题：生产环境考量

多连接管理

在实际应用中，我们需要管理多个并发连接：

// 使用线程安全集合存储所有连接
private static readonly ConcurrentDictionary<string, WebSocket> _sockets = new();

// 在HandleWebSocketConnection方法中添加连接管理
string connId = Guid.NewGuid().ToString();
_sockets.TryAdd(connId, webSocket);

// 广播消息给所有客户端
public async Task Broadcast(string message)
{
    var buffer = Encoding.UTF8.GetBytes(message);
    foreach (var socket in _sockets.Values)
    {
        if (socket.State == WebSocketState.Open)
        {
            await socket.SendAsync(
                new ArraySegment<byte>(buffer),
                WebSocketMessageType.Text,
                true,
                CancellationToken.None);
        }
    }
}

心跳机制

为了防止连接意外断开，我们需要实现心跳检测：

// 服务端心跳检测
private async Task HeartbeatCheck(WebSocket webSocket)
{
    var heartbeatMsg = Encoding.UTF8.GetBytes("ping");
    while (webSocket.State == WebSocketState.Open)
    {
        await Task.Delay(30000); // 每30秒发送一次心跳
        try
        {
            await webSocket.SendAsync(
                new ArraySegment<byte>(heartbeatMsg),
                WebSocketMessageType.Text,
                true,
                CancellationToken.None);
        }
        catch
        {
            // 心跳失败，关闭连接
            await webSocket.CloseAsync(
                WebSocketCloseStatus.NormalClosure,
                "心跳失败",
                CancellationToken.None);
            break;
        }
    }
}

生产环境避坑指南

1. 连接泄漏问题
2. 症状：内存持续增长，最终导致服务器崩溃

3. 解决方案：确保所有连接都有正确的关闭逻辑，使用using语句或try-finally块

4. 缓冲区溢出

5. 症状：大消息导致内存异常

6. 解决方案：设置合理的消息大小限制，分片处理大消息

7. 线程安全问题

8. 症状：并发操作导致数据损坏

9. 解决方案：使用ConcurrentDictionary等线程安全集合

10. 跨域问题

11. 症状：浏览器拒绝连接

12. 解决方案：配置正确的CORS策略

13. Nginx代理问题

14. 症状：连接频繁断开
15. 解决方案：配置适当的代理超时设置

性能优化建议

对于高性能场景，可以考虑以下优化：

1. 使用ArrayPool<byte>重用缓冲区
2. 对于二进制数据，避免不必要的编码转换
3. 考虑使用Memory<T>和Span<T>减少内存分配
4. 实现消息压缩（如Gzip）减少带宽使用

扩展思考

当你的应用需要扩展到多台服务器时，如何实现WebSocket集群？可以考虑：

1. 使用Redis Pub/Sub进行服务器间消息转发
2. 实现粘性会话（Sticky Session）
3. 考虑专业的消息代理如RabbitMQ或Kafka

如果你想进一步探索实时通信的可能性，可以尝试从0打造个人豆包实时通话AI实验，将WebSocket与AI语音技术结合，打造更丰富的交互体验。我在实际操作中发现，这种端到端的实时通信架构非常有趣且实用，即使是新手也能通过清晰的文档快速上手。

实验介绍

这里有一个非常硬核的动手实验：基于火山引擎豆包大模型，从零搭建一个实时语音通话应用。它不是简单的问答，而是需要你亲手打通 ASR（语音识别）→ LLM（大脑思考）→ TTS（语音合成）的完整 WebSocket 链路。对于想要掌握 AI 原生应用架构的同学来说，这是个绝佳的练手项目。

你将收获：

• 架构理解：掌握实时语音应用的完整技术链路（ASR→LLM→TTS）
• 技能提升：学会申请、配置与调用火山引擎AI服务
• 定制能力：通过代码修改自定义角色性格与音色，实现“从使用到创造”

从0到1构建生产级别应用，脱离Demo，点击打开 从0打造个人豆包实时通话AI动手实验