一、实时通信的那些事儿

说到实时通信，大家可能第一时间想到微信、QQ这类即时通讯软件。但你知道吗，在企业级应用中，实时通信的需求同样旺盛。比如在线客服系统、协同办公工具、物联网设备监控等场景，都需要稳定高效的实时通信能力。

作为一个在.NET生态混迹多年的老码农，今天就跟大家聊聊如何用DotNetCore搭建一个靠谱的实时通信架构。咱们不整那些虚的，直接上干货！

二、技术选型与核心组件

在DotNetCore生态中，实现实时通信主要有以下几种方案：

  1. SignalR：微软亲儿子，专为实时Web应用设计
  2. WebSocket：底层协议，更灵活但需要自己造轮子
  3. gRPC：适合服务间通信，但对浏览器支持有限

经过多年实战，我个人最推荐SignalR。它不仅功能完善，而且上手简单，下面我们就以SignalR为例展开讲解。

先来看一个最简单的SignalR服务端示例（技术栈：DotNetCore 6 + SignalR）：

// 引入必要的命名空间
using Microsoft.AspNetCore.SignalR;

// 1. 创建Hub类，这是SignalR的核心
public class ChatHub : Hub
{
    // 客户端调用这个方法来发送消息
    public async Task SendMessage(string user, string message)
    {
        // 向所有客户端广播消息
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
    
    // 当客户端连接时触发
    public override async Task OnConnectedAsync()
    {
        await base.OnConnectedAsync();
        await Clients.Caller.SendAsync("Notify", "连接成功！");
    }
}

// 2. 在Program.cs中配置
var builder = WebApplication.CreateBuilder(args);

// 添加SignalR服务
builder.Services.AddSignalR();

var app = builder.Build();

// 配置SignalR路由
app.MapHub<ChatHub>("/chatHub");

app.Run();

这个示例虽然简单，但包含了SignalR最核心的概念 - Hub。Hub就像是服务端和客户端之间的通信枢纽，负责消息的接收和转发。

三、架构设计与性能优化

实际项目中，我们还需要考虑更多因素。下面分享几个关键优化点：

3.1 水平扩展方案

单个SignalR节点扛不住高并发怎么办？这时就需要引入Redis作为背板：

// 在Program.cs中添加Redis背板
builder.Services.AddSignalR().AddStackExchangeRedis("localhost:6379", options => {
    options.Configuration.ChannelPrefix = "MyApp_"; // 避免key冲突
});

3.2 消息压缩与二进制协议

默认情况下SignalR使用JSON，但在传输大量数据时效率不高。我们可以切换到MessagePack：

// 服务端配置
builder.Services.AddSignalR()
    .AddMessagePackProtocol();

// 客户端配置（JavaScript示例）
const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub")
    .withHubProtocol(new signalR.protocols.msgpack.MessagePackHubProtocol())
    .build();

3.3 连接管理与心跳检测

防止僵尸连接占用资源：

// 在Hub中实现心跳检测
public class ChatHub : Hub
{
    private readonly ILogger<ChatHub> _logger;
    
    public ChatHub(ILogger<ChatHub> logger)
    {
        _logger = logger;
    }
    
    public override async Task OnConnectedAsync()
    {
        _logger.LogInformation($"客户端 {Context.ConnectionId} 已连接");
        await base.OnConnectedAsync();
    }
    
    public override async Task OnDisconnectedAsync(Exception exception)
    {
        _logger.LogInformation($"客户端 {Context.ConnectionId} 已断开");
        await base.OnDisconnectedAsync(exception);
    }
    
    // 心跳方法
    public async Task Heartbeat()
    {
        await Clients.Caller.SendAsync("HeartbeatResponse", DateTime.UtcNow);
    }
}

四、实战案例：在线协作白板

让我们通过一个实际案例把前面讲的内容串起来。假设我们要开发一个在线协作白板，允许多用户实时绘制。

4.1 服务端实现

public class WhiteboardHub : Hub
{
    // 保存所有绘图动作
    private static readonly List<DrawAction> _drawActions = new();
    
    // 新用户加入时发送历史绘图
    public override async Task OnConnectedAsync()
    {
        await Clients.Caller.SendAsync("InitWhiteboard", _drawActions);
        await base.OnConnectedAsync();
    }
    
    // 处理绘图动作
    public async Task AddDrawing(DrawAction action)
    {
        _drawActions.Add(action);
        await Clients.Others.SendAsync("NewDrawing", action);
    }
}

// 绘图动作模型
public class DrawAction
{
    public string Type { get; set; } // line, circle, rect等
    public string Color { get; set; }
    public Point Start { get; set; }
    public Point End { get; set; }
    public DateTime Timestamp { get; set; }
}

public class Point
{
    public double X { get; set; }
    public double Y { get; set; }
}

4.2 客户端实现（JavaScript）

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/whiteboardHub")
    .configureLogging(signalR.LogLevel.Information)
    .build();

// 初始化白板
connection.on("InitWhiteboard", (actions) => {
    actions.forEach(action => renderAction(action));
});

// 处理新绘图
connection.on("NewDrawing", (action) => {
    renderAction(action);
});

// 发送绘图动作
function sendDrawing(action) {
    connection.invoke("AddDrawing", action)
        .catch(err => console.error(err));
}

// 启动连接
async function start() {
    try {
        await connection.start();
        console.log("SignalR Connected.");
    } catch (err) {
        console.log(err);
        setTimeout(start, 5000);
    }
}

start();

五、注意事项与常见坑点

在实际开发中，有几个坑需要特别注意：

  1. 跨域问题：记得在服务端配置CORS

    builder.Services.AddCors(options => {
    options.AddPolicy("CorsPolicy", builder => 
        builder.AllowAnyHeader()
               .AllowAnyMethod()
               .AllowCredentials()
               .SetIsOriginAllowed(_ => true));
});

  2. 连接稳定性：客户端需要实现自动重连

    connection.onclose(async () => {
    await start(); // 重新连接
});

  3. 消息大小限制：默认限制32KB，大文件需要调整

    builder.Services.AddSignalR(options => {
    options.MaximumReceiveMessageSize = 1024 * 1024; // 1MB
});

  4. 性能监控：建议集成Application Insights

    builder.Services.AddApplicationInsightsTelemetry();
builder.Services.AddSignalR().AddAzureSignalR();

六、总结与展望

通过上面的讲解，相信大家对DotNetCore实现实时通信已经有了比较全面的认识。SignalR确实是个好东西，它帮我们封装了底层细节，让开发者可以专注于业务逻辑。

不过技术总是在发展，这里也分享几个值得关注的方向：

  1. WebTransport：新一代传输协议，可能会取代WebSocket
  2. Blazor Server：结合SignalR实现全双工通信
  3. QUIC协议：HTTP/3带来的新可能

最后提醒大家，架构设计没有银弹，一定要根据实际业务需求来选择合适的技术方案。希望这篇文章能帮你在实时通信的道路上少走弯路！