第67章 实战项目3：实时聊天系统
一、我踩过的聊天系统坑：从“轮询导致延迟3秒”到“服务器重启丢失3天聊天记录”
做内部办公聊天系统时，一开始用AJAX轮询，每隔1秒发一次请求问服务器有没有新消息，结果服务器CPU直接100%，聊天延迟高达3秒，用户吐槽“发消息后要等半天对方才收到”——后来换成SignalR+WebSocket，延迟直接降到100毫秒以内，CPU使用率降到10%以下！还有一次没做消息持久化，服务器重启后所有聊天记录都丢了，用户找我要之前的会议纪要，我只能尴尬地说“不好意思，记录没了”——后来用Redis做缓存+SQL Server做持久化，聊天记vb.net教程C#教程python教程SQL教程access 2010教程录永久保存，再也没出过这种问题。这节我把这些血泪经验揉进去，用大白话讲透实时聊天系统的核心原理，结合ASP.NET Core SignalR实战代码逐行拆解，拓展生产级优化技巧，让你写出低延迟、高可用、易维护的实时聊天系统！
二、实时聊天系统核心原理：用WebSocket“打通客户端和服务器的双向管道”
大白话解释：把实时聊天系统比作“微信群”
1.WebSocket：客户端和服务器之间的双向管道，一旦建立连接，双方可以随时发消息，不用每次都发起新请求，就像视频通话一样，实时性高；
2.轮询：客户端每隔一段时间发一次请求问服务器有没有新消息，就像每隔1分钟发消息问“有没有新消息？”，实时性差，服务器压力大；
3.SignalR：ASP.NET Core的实时通信框架，自动选择最佳传输方式（WebSocket优先，不支持的话用Server-Sent Events或Long Polling），还提供房间管理、心跳机制、消息广播等功能；
4.房间管理：把用户分到不同的房间（比如群聊、部门群），服务器只把消息发给房间里的用户，不用发给所有用户，节省带宽；
5.消息持久化：把聊天记录存在数据库或Redis里，服务器重启后聊天记录不丢失，用户可以查看历史消息。
我踩过的坑：一开始没做心跳机制，客户端网络波动后连接断开但服务器不知道，导致用户发消息失败——后来加了SignalR的自动重连和心跳机制，连接稳定性提升到99.9%！
三、实战：ASP.NET Core SignalR实时聊天系统（WebSocket+Redis+SQL Server）
技术栈：ASP.NET Core 8 + SignalR + Redis + Entity Framework Core + JWT + Serilog + Swagger
项目结构（分层架构，解耦易维护）

	RealTimeChatSystem/
	├── Hubs/ # SignalR Hub，处理实时通信
	├── Controllers/ # API控制器，处理登录、注册、历史消息查询
	├── Services/ # 业务逻辑层，处理用户、消息、房间业务
	├── Repositories/ # 数据访问层，封装数据库操作
	├── Models/ # 数据模型和DTO
	├── Middlewares/ # 中间件，比如日志、限流
	├── Configurations/ # 配置类
	├── Program.cs # 启动类
	├── appsettings.json # 配置文件
	└── wwwroot/ # 前端静态文件（HTML/JS/CSS）

步骤1：创建ASP.NET Core Web App项目
bash
# 用.NET CLI创建项目
dotnet new webapp -n RealTimeChatSystem -f net8.0
cd RealTimeChatSystem
# 安装必要的NuGet包
dotnet add package Microsoft.AspNetCore.SignalR
dotnet add package StackExchange.Redis
dotnet add package Microsoft.EntityFrameworkCore.SqlServer
dotnet add package Microsoft.AspNetCore.Authentication.JwtBearer
dotnet add package Serilog.AspNetCore
四、核心代码逐行讲解

1. 数据模型和DTO（Models/）
   数据模型（ChatMessage.cs）：聊天记录数据模型
   csharp

	using System.ComponentModel.DataAnnotations;
	
	namespace RealTimeChatSystem.Models;
	
	/// <summary>
	/// 聊天记录数据模型，对应数据库ChatMessages表
	/// </summary>
	public class ChatMessage
	{
	[Key]
	public int Id { get; set; }
	
	[Required]
	public string SenderId { get; set; } = string.Empty; // 发送者用户ID
	
	[Required]
	public string SenderName { get; set; } = string.Empty; // 发送者用户名
	
	[Required]
	public string RoomId { get; set; } = string.Empty; // 房间ID（群聊ID或一对一聊天ID）
	
	[Required]
	public string Content { get; set; } = string.Empty; // 消息内容
	
	public DateTime SendTime { get; set; } = DateTime.UtcNow; // 发送时间（UTC）
	
	public bool IsRead { get; set; } = false; // 是否已读
	}

逐行拆解：
RoomId：用来区分不同的聊天场景，比如群聊用房间ID，一对一聊天用两个用户ID拼接（比如user1-user2）；
IsRead：标记消息是否已读，用于实现“未读消息提醒”功能；
SendTime：用UTC时间，避免时区问题，前端显示时转成用户本地时间。
DTO（ChatMessageDto.cs）：聊天消息DTO
csharp

	namespace RealTimeChatSystem.Models.DTOs;
	
	/// <summary>
	/// 聊天消息DTO，用于客户端和服务器之间传输
	/// </summary>
	public class ChatMessageDto
	{
	public string SenderId { get; set; } = string.Empty;
	public string SenderName { get; set; } = string.Empty;
	public string RoomId { get; set; } = string.Empty;
	public string Content { get; set; } = string.Empty;
	public DateTime SendTime { get; set; }
	public bool IsRead { get; set; }
	}
	
	/// <summary>
	/// 发送消息DTO，客户端发送消息时用
	/// </summary>
	public class SendMessageDto
	{
	public string RoomId { get; set; } = string.Empty;
	public string Content { get; set; } = string.Empty;
	}
	
	/// <summary>
	/// 房间DTO，用于返回房间信息
	/// </summary>
	public class RoomDto
	{
	public string RoomId { get; set; } = string.Empty;
	public string RoomName { get; set; } = string.Empty;
	public int UserCount { get; set; } // 房间内用户数
	}

逐行拆解：
DTO和数据模型分离，避免暴露数据库字段（比如Id）；
SendMessageDto：客户端发送消息时只需要传RoomId和Content，SenderId从Token中获取，不用客户端传，更安全；
RoomDto：返回房间信息，包括房间ID、名称、用户数，用于前端显示房间列表。
2. 数据访问层（Repositories/）
聊天消息仓储接口（IChatMessageRepository.cs）
csharp

	using RealTimeChatSystem.Models;
	
	namespace RealTimeChatSystem.Repositories;
	
	/// <summary>
	/// 聊天消息仓储接口，定义数据访问方法
	/// </summary>
	public interface IChatMessageRepository
	{
	Task<ChatMessage> CreateAsync(ChatMessage message);
	Task<IEnumerable<ChatMessage>> GetHistoryMessagesAsync(string roomId, int page, int pageSize);
	Task<int> GetUnreadCountAsync(string roomId, string userId);
	Task MarkAsReadAsync(string roomId, string userId);
	}

逐行拆解：
GetHistoryMessagesAsync：分页查询历史消息，避免一次性查询所有消息导致性能问题；
GetUnreadCountAsync：查询用户在某个房间的未读消息数，用于未读提醒；
MarkAsReadAsync：标记消息为已读，用户进入房间时调用。
聊天消息仓储实现（ChatMessageRepository.cs）
csharp
using Microsoft.EntityFrameworkCore;
using RealTimeChatSystem.Models;

namespace RealTimeChatSystem.Repositories;

/// <summary>
/// 聊天消息仓储实现，用Entity Framework Core操作SQL Server
/// </summary>
public class ChatMessageRepository : IChatMessageRepository
{
private readonly AppDbContext _dbContext;

public ChatMessageRepository(AppDbContext dbContext)
{
_dbContext = dbContext;
}

public async Task<ChatMessage> CreateAsync(ChatMessage message)
{
_dbContext.ChatMessages.Add(message);
await _dbContext.SaveChangesAsync();
return message;
}

public async Task<IEnumerable<ChatMessage>> GetHistoryMessagesAsync(string roomId, int page, int pageSize)
{
return await _dbContext.ChatMessages
.Where(m => m.RoomId == roomId)
.OrderByDescending(m => m.SendTime)
.Skip((page - 1) * pageSize)
.Take(pageSize)
.OrderBy(m => m.SendTime) // 转成正序，前端显示时从旧到新
.ToListAsync();
}

public async Task<int> GetUnreadCountAsync(string roomId, string userId)
{
return await _dbContext.ChatMessages
.CountAsync(m => m.RoomId == roomId && !m.IsRead && m.SenderId != userId);
}

public async Task MarkAsReadAsync(string roomId, string userId)
{
var unreadMessages = await _dbContext.ChatMessages
.Where(m => m.RoomId == roomId && !m.IsRead && m.SenderId != userId)
.ToListAsync();

foreach (var message in unreadMessages)
{
message.IsRead = true;
}

await _dbContext.SaveChangesAsync();
}
}

逐行拆解：
GetHistoryMessagesAsync：先按SendTime倒序，分页后再转成正序，这样前端显示时是从旧到新的顺序；
GetUnreadCountAsync：只统计发送者不是当前用户的未读消息，避免统计自己发的消息；
MarkAsReadAsync：批量标记未读消息为已读，减少数据库操作次数。
3. 业务逻辑层（Services/）
聊天服务接口（IChatService.cs）
csharp
using RealTimeChatSystem.Models.DTOs;

namespace RealTimeChatSystem.Services;

/// <summary>
/// 聊天服务接口，定义业务逻辑方法
/// </summary>
public interface IChatService
{
Task<ChatMessageDto> SendMessageAsync(string senderId, string senderName, SendMessageDto sendMessageDto);
Task<IEnumerable<ChatMessageDto>> GetHistoryMessagesAsync(string roomId, int page, int pageSize);
Task<int> GetUnreadCountAsync(string roomId, string userId);
Task MarkAsReadAsync(string roomId, string userId);
Task<RoomDto> CreateRoomAsync(string roomName, string creatorId);
Task<IEnumerable<RoomDto>> GetUserRoomsAsync(string userId);
}

逐行拆解：
SendMessageAsync：发送消息，业务层负责验证消息内容（比如长度限制）、持久化消息；
CreateRoomAsync：创建房间，支持群聊；
GetUserRoomsAsync：获取用户加入的房间列表。
聊天服务实现（ChatService.cs）
csharp

	using RealTimeChatSystem.Models;
	using RealTimeChatSystem.Models.DTOs;
	using RealTimeChatSystem.Repositories;
	
	namespace RealTimeChatSystem.Services;
	
	/// <summary>
	/// 聊天服务实现，处理核心业务逻辑
	/// </summary>
	public class ChatService : IChatService
	{
	private readonly IChatMessageRepository _messageRepository;
	private readonly IUserRepository _userRepository;
	private readonly IConnectionMultiplexer _redis; // Redis连接，用于房间用户数统计
	
	public ChatService(IChatMessageRepository messageRepository, IUserRepository userRepository, IConnectionMultiplexer redis)
	{
	_messageRepository = messageRepository;
	_userRepository = userRepository;
	_redis = redis;
	}
	
	public async Task<ChatMessageDto> SendMessageAsync(string senderId, string senderName, SendMessageDto sendMessageDto)
	{
	// 验证消息内容
	if (string.IsNullOrWhiteSpace(sendMessageDto.Content))
	{
	throw new ArgumentException("消息内容不能为空");
	}
	if (sendMessageDto.Content.Length > 1000)
	{
	throw new ArgumentException("消息内容不能超过1000字符");
	}
	
	// 持久化消息到数据库
	var message = new ChatMessage
	{
	SenderId = senderId,
	SenderName = senderName,
	RoomId = sendMessageDto.RoomId,
	Content = sendMessageDto.Content
	};
	var createdMessage = await _messageRepository.CreateAsync(message);
	
	// 转成DTO返回
	return new ChatMessageDto
	{
	SenderId = createdMessage.SenderId,
	SenderName = createdMessage.SenderName,
	RoomId = createdMessage.RoomId,
	Content = createdMessage.Content,
	SendTime = createdMessage.SendTime,
	IsRead = createdMessage.IsRead
	};
	}
	
	public async Task<IEnumerable<ChatMessageDto>> GetHistoryMessagesAsync(string roomId, int page, int pageSize)
	{
	var messages = await _messageRepository.GetHistoryMessagesAsync(roomId, page, pageSize);
	return messages.Select(m => new ChatMessageDto
	{
	SenderId = m.SenderId,
	SenderName = m.SenderName,
	RoomId = m.RoomId,
	Content = m.Content,
	SendTime = m.SendTime,
	IsRead = m.IsRead
	});
	}
	
	public async Task<int> GetUnreadCountAsync(string roomId, string userId)
	{
	return await _messageRepository.GetUnreadCountAsync(roomId, userId);
	}
	
	public async Task MarkAsReadAsync(string roomId, string userId)
	{
	await _messageRepository.MarkAsReadAsync(roomId, userId);
	}
	
	public async Task<RoomDto> CreateRoomAsync(string roomName, string creatorId)
	{
	// 房间ID用GUID生成
	var roomId = Guid.NewGuid().ToString("N");
	// 把房间信息存在Redis里，方便快速查询
	var db = _redis.GetDatabase();
	await db.StringSetAsync($"room:{roomId}:name", roomName);
	await db.SetAddAsync($"room:{roomId}:users", creatorId);
	
	return new RoomDto
	{
	RoomId = roomId,
	RoomName = roomName,
	UserCount = 1
	};
	}
	
	public async Task<IEnumerable<RoomDto>> GetUserRoomsAsync(string userId)
	{
	var db = _redis.GetDatabase();
	// 这里简化处理，实际项目中应该把用户加入的房间存在Redis或数据库里
	// 比如用Redis的Set存储用户的房间列表：user:{userId}:rooms
	var roomIds = await db.SetMembersAsync($"user:{userId}:rooms");
	var rooms = new List<RoomDto>();
	foreach (var roomId in roomIds)
	{
	var roomName = await db.StringGetAsync($"room:{roomId}:name");
	var userCount = await db.SetLengthAsync($"room:{roomId}:users");
	rooms.Add(new RoomDto
	{
	RoomId = roomId.ToString(),
	RoomName = roomName.ToString(),
	UserCount = (int)userCount
	});
	}
	return rooms;
	}
	}

逐行拆解：
消息验证：业务层验证消息内容的长度和非空，避免无效消息；
Redis使用：用Redis存储房间信息和用户列表，因为Redis的Set和String操作比数据库快，适合实时统计房间用户数；
房间创建：房间ID用GUID生成，保证唯一性，房间信息存在Redis里，方便快速查询。
4. SignalR Hub（Hubs/）
聊天Hub（ChatHub.cs）：处理实时通信核心逻辑
csharp

	using Microsoft.AspNetCore.Authorization;
	using Microsoft.AspNetCore.SignalR;
	using RealTimeChatSystem.Models.DTOs;
	using RealTimeChatSystem.Services;
	
	namespace RealTimeChatSystem.Hubs;
	
	/// <summary>
	/// SignalR聊天Hub，处理实时通信
	/// </summary>
	[Authorize] // 所有Hub方法需要授权，用户必须登录
	public class ChatHub : Hub
	{
	private readonly IChatService _chatService;
	private readonly IConnectionMultiplexer _redis;
	
	public ChatHub(IChatService chatService, IConnectionMultiplexer redis)
	{
	_chatService = chatService;
	_redis = redis;
	}
	
	/// <summary>
	/// 发送消息到房间
	/// </summary>
	/// <param name="sendMessageDto">发送消息DTO</param>
	public async Task SendMessage(SendMessageDto sendMessageDto)
	{
	// 从Token中获取用户ID和用户名（需要在Program.cs中配置JWT认证）
	var userId = Context.UserIdentifier!;
	var userName = Context.User?.FindFirst("Name")?.Value!;
	
	try
	{
	// 业务层处理消息（验证、持久化）
	var messageDto = await _chatService.SendMessageAsync(userId, userName, sendMessageDto);
	
	// 发送消息到房间里的所有用户（除了发送者自己）
	await Clients.Group(sendMessageDto.RoomId).SendAsync("ReceiveMessage", messageDto);
	// 发送消息给自己，确认消息发送成功
	await Clients.Caller.SendAsync("MessageSent", messageDto);
	}
	catch (ArgumentException ex)
	{
	// 发送错误消息给发送者
	await Clients.Caller.SendAsync("Error", ex.Message);
	}
	}
	
	/// <summary>
	/// 加入房间
	/// </summary>
	/// <param name="roomId">房间ID</param>
	public async Task JoinRoom(string roomId)
	{
	var userId = Context.UserIdentifier!;
	var userName = Context.User?.FindFirst("Name")?.Value!;
	
	// 加入SignalR Group，SignalR自动管理Group的用户
	await Groups.AddToGroupAsync(Context.ConnectionId, roomId);
	
	// 把用户加入Redis的房间用户列表
	var db = _redis.GetDatabase();
	await db.SetAddAsync($"room:{roomId}:users", userId);
	await db.SetAddAsync($"user:{userId}:rooms", roomId);
	
	// 通知房间里的其他用户，有新用户加入
	await Clients.Group(roomId).SendAsync("UserJoined", new { UserId = userId, UserName = userName, RoomId = roomId });
	
	// 查询未读消息数
	var unreadCount = await _chatService.GetUnreadCountAsync(roomId, userId);
	await Clients.Caller.SendAsync("UnreadCount", new { RoomId = roomId, Count = unreadCount });
	
	// 标记消息为已读
	await _chatService.MarkAsReadAsync(roomId, userId);
	}
	
	/// <summary>
	/// 离开房间
	/// </summary>
	/// <param name="roomId">房间ID</param>
	public async Task LeaveRoom(string roomId)
	{
	var userId = Context.UserIdentifier!;
	var userName = Context.User?.FindFirst("Name")?.Value!;
	
	// 离开SignalR Group
	await Groups.RemoveFromGroupAsync(Context.ConnectionId, roomId);
	
	// 从Redis的房间用户列表中移除用户
	var db = _redis.GetDatabase();
	await db.SetRemoveAsync($"room:{roomId}:users", userId);
	await db.SetRemoveAsync($"user:{userId}:rooms", roomId);
	
	// 通知房间里的其他用户，有用户离开
	await Clients.Group(roomId).SendAsync("UserLeft", new { UserId = userId, UserName = userName, RoomId = roomId });
	}
	
	/// <summary>
	/// 连接断开时自动离开所有房间
	/// </summary>
	public override async Task OnDisconnectedAsync(Exception? exception)
	{
	var userId = Context.UserIdentifier;
	if (userId == null) return;
	
	var db = _redis.GetDatabase();
	// 获取用户加入的所有房间
	var roomIds = await db.SetMembersAsync($"user:{userId}:rooms");
	foreach (var roomId in roomIds)
	{
	await Groups.RemoveFromGroupAsync(Context.ConnectionId, roomId.ToString());
	await db.SetRemoveAsync($"room:{roomId}:users", userId);
	}
	await db.KeyDeleteAsync($"user:{userId}:rooms");
	
	await base.OnDisconnectedAsync(exception);
	}
	
	/// <summary>
	/// 获取房间用户数
	/// </summary>
	/// <param name="roomId">房间ID</param>
	public async Task<int> GetRoomUserCount(string roomId)
	{
	var db = _redis.GetDatabase();
	return (int)await db.SetLengthAsync($"room:{roomId}:users");
	}
	}

逐行拆解：
[Authorize]：所有Hub方法需要授权，用户必须登录，Context.UserIdentifier是用户ID（从JWT Token中获取）；
SendMessage：发送消息到房间，业务层处理消息后，用Clients.Group(roomId).SendAsync把消息发给房间里的所有用户，用Clients.Caller.SendAsync通知发送者消息发送成功；
JoinRoom：加入房间，SignalR的Group自动管理房间用户，同时把用户加入Redis的房间用户列表，方便统计用户数；
OnDisconnectedAsync：连接断开时自动离开所有房间，清理Redis和SignalR Group的用户信息；
GetRoomUserCount：从Redis获取房间用户数，比数据库快，适合实时统计。
5. API控制器（Controllers/）
聊天控制器（ChatController.cs）：处理历史消息、房间管理
csharp

	using Microsoft.AspNetCore.Authorization;
	using Microsoft.AspNetCore.Mvc;
	using RealTimeChatSystem.Models.DTOs;
	using RealTimeChatSystem.Services;
	
	namespace RealTimeChatSystem.Controllers;
	
	[ApiController]
	[Route("api/[controller]")]
	[Authorize]
	public class ChatController : ControllerBase
	{
	private readonly IChatService _chatService;
	
	public ChatController(IChatService chatService)
	{
	_chatService = chatService;
	}
	
	/// <summary>
	/// 获取历史消息
	/// </summary>
	/// <param name="roomId">房间ID</param>
	/// <param name="page">页码，从1开始</param>
	/// <param name="pageSize">每页大小</param>
	[HttpGet("history")]
	public async Task<ActionResult<IEnumerable<ChatMessageDto>>> GetHistoryMessages(string roomId, int page = 1, int pageSize = 20)
	{
	if (page < 1) page = 1;
	if (pageSize > 100) pageSize = 100; // 限制每页最大100条
	var messages = await _chatService.GetHistoryMessagesAsync(roomId, page, pageSize);
	return Ok(messages);
	}
	
	/// <summary>
	/// 获取未读消息数
	/// </summary>
	/// <param name="roomId">房间ID</param>
	[HttpGet("unread-count")]
	public async Task<ActionResult<int>> GetUnreadCount(string roomId)
	{
	var userId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value!;
	var count = await _chatService.GetUnreadCountAsync(roomId, userId);
	return Ok(count);
	}
	
	/// <summary>
	/// 创建房间
	/// </summary>
	/// <param name="roomName">房间名称</param>
	[HttpPost("room")]
	public async Task<ActionResult<RoomDto>> CreateRoom(string roomName)
	{
	var userId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value!;
	var room = await _chatService.CreateRoomAsync(roomName, userId);
	return CreatedAtAction(nameof(GetUserRooms), new { userId }, room);
	}
	
	/// <summary>
	/// 获取用户房间列表
	/// </summary>
	[HttpGet("rooms")]
	public async Task<ActionResult<IEnumerable<RoomDto>>> GetUserRooms()
	{
	var userId = User.FindFirst(System.Security.Claims.ClaimTypes.NameIdentifier)?.Value!;
	var rooms = await _chatService.GetUserRoomsAsync(userId);
	return Ok(rooms);
	}
	}

逐行拆解：
历史消息分页：限制每页最大100条，避免一次性查询太多数据导致性能问题；
用户ID获取：从JWT Token中获取用户ID，不用客户端传，更安全；
CreatedAtAction：创建房间后返回201 Created状态码，Location头包含房间列表的URL，符合RESTful规范。
6. 前端页面（wwwroot/chat.html）：简单的聊天界面
html

	<!DOCTYPE html>
	<html lang="zh-CN">
	<head>
	<meta charset="UTF-8">
	<title>实时聊天系统</title>
	<style>
	body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
	#messages { height: 400px; overflow-y: auto; border: 1px solid #ccc; padding: 10px; margin-bottom: 10px; }
	.message { margin: 5px 0; padding: 8px; border-radius: 4px; }
	.sender { background-color: #e3f2fd; text-align: right; }
	.receiver { background-color: #f5f5f5; text-align: left; }
	#messageInput { width: 80%; padding: 8px; }
	#sendBtn { width: 18%; padding: 8px; }
	</style>
	</head>
	<body>
	<h1>实时聊天系统</h1>
	<div id="messages"></div>
	<input type="text" id="messageInput" placeholder="输入消息...">
	<button id="sendBtn">发送</button>
	
	<script src="/lib/signalr/dist/browser/signalr.js"></script>
	<script>
	// 从localStorage获取JWT Token（登录后存在localStorage里）
	const token = localStorage.getItem('token');
	if (!token) {
	alert('请先登录');
	window.location.href = '/login.html';
	}
	
	// 创建SignalR连接
	const connection = new signalR.HubConnectionBuilder()
	.withUrl('/chatHub', {
	accessTokenFactory: () => token
	})
	.withAutomaticReconnect() // 自动重连
	.build();
	
	// 接收消息
	connection.on('ReceiveMessage', (message) => {
	addMessage(message, false);
	});
	
	// 消息发送成功
	connection.on('MessageSent', (message) => {
	addMessage(message, true);
	});
	
	// 错误提示
	connection.on('Error', (error) => {
	alert(`错误：${error}`);
	});
	
	// 用户加入房间
	connection.on('UserJoined', (data) => {
	addSystemMessage(`${data.UserName} 加入了房间`);
	});
	
	// 用户离开房间
	connection.on('UserLeft', (data) => {
	addSystemMessage(`${data.UserName} 离开了房间`);
	});
	
	// 未读消息数
	connection.on('UnreadCount', (data) => {
	document.title = `聊天系统（${data.Count}条未读）`;
	});
	
	// 加入房间（房间ID可以从URL参数获取，这里固定为test-room）
	connection.start().then(() => {
	connection.invoke('JoinRoom', 'test-room').catch(err => console.error(err));
	}).catch(err => console.error(err));
	
	// 发送消息
	document.getElementById('sendBtn').addEventListener('click', () => {
	const content = document.getElementById('messageInput').value.trim();
	if (content) {
	connection.invoke('SendMessage', { RoomId: 'test-room', Content: content })
	.then(() => {
	document.getElementById('messageInput').value = '';
	})
	.catch(err => console.error(err));
	}
	});
	
	// 按Enter键发送消息
	document.getElementById('messageInput').addEventListener('keypress', (e) => {
	if (e.key === 'Enter') {
	document.getElementById('sendBtn').click();
	}
	});
	
	// 添加消息到页面
	function addMessage(message, isSender) {
	const messagesDiv = document.getElementById('messages');
	const messageDiv = document.createElement('div');
	messageDiv.className = `message ${isSender ? 'sender' : 'receiver'}`;
	messageDiv.innerHTML = `
	<strong>${message.SenderName}</strong>
	<p>${message.Content}</p>
	<small>${new Date(message.SendTime).toLocaleString()}</small>
	`;
	messagesDiv.appendChild(messageDiv);
	messagesDiv.scrollTop = messagesDiv.scrollHeight;
	}
	
	// 添加系统消息
	function addSystemMessage(content) {
	const messagesDiv = document.getElementById('messages');
	const messageDiv = document.createElement('div');
	messageDiv.style.textAlign = 'center';
	messageDiv.style.color = '#666';
	messageDiv.style.fontSize = '12px';
	messageDiv.textContent = content;
	messagesDiv.appendChild(messageDiv);
	messagesDiv.scrollTop = messagesDiv.scrollHeight;
	}
	</script>
	</body>
	</html>

逐行拆解：
SignalR连接：用withUrl指定Hub的URL，accessTokenFactory返回JWT Token，用于授权；
自动重连：withAutomaticReconnect()自动处理网络波动后的重连，提升连接稳定性；
事件监听：监听ReceiveMessage、MessageSent、Error等事件，更新页面；
加入房间：连接启动后自动加入房间，房间ID可以从URL参数获取，这里固定为test-room；
消息发送：点击发送按钮或按Enter键发送消息，调用Hub的SendMessage方法。
7. 启动类（Program.cs）：配置服务和中间件
csharp

	using Microsoft.AspNetCore.Authentication.JwtBearer;
	using Microsoft.EntityFrameworkCore;
	using Microsoft.IdentityModel.Tokens;
	using Microsoft.OpenApi.Models;
	using RealTimeChatSystem.Hubs;
	using RealTimeChatSystem.Repositories;
	using RealTimeChatSystem.Services;
	using Serilog;
	using StackExchange.Redis;
	
	var builder = WebApplication.CreateBuilder(args);
	
	// 配置Serilog日志
	Log.Logger = new LoggerConfiguration()
	.ReadFrom.Configuration(builder.Configuration)
	.CreateLogger();
	builder.Host.UseSerilog();
	
	// 添加SignalR服务
	builder.Services.AddSignalR();
	
	// 添加数据库上下文
	builder.Services.AddDbContext<AppDbContext>(options =>
	{
	options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection"));
	});
	
	// 添加Redis连接
	builder.Services.AddSingleton<IConnectionMultiplexer>(sp =>
	{
	var configuration = builder.Configuration.GetConnectionString("Redis");
	return ConnectionMultiplexer.Connect(configuration!);
	});
	
	// 添加仓储和服务
	builder.Services.AddScoped<IChatMessageRepository, ChatMessageRepository>();
	builder.Services.AddScoped<IUserRepository, UserRepository>();
	builder.Services.AddScoped<IChatService, ChatService>();
	
	// 添加JWT认证
	builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
	.AddJwtBearer(options =>
	{
	options.TokenValidationParameters = new TokenValidationParameters
	{
	ValidateIssuerSigningKey = true,
	IssuerSigningKey = new SymmetricSecurityKey(System.Text.Encoding.ASCII.GetBytes(builder.Configuration["Jwt:Secret"]!)),
	ValidateIssuer = false,
	ValidateAudience = false,
	ClockSkew = TimeSpan.Zero
	};
	// 配置SignalR的JWT认证
	options.Events = new JwtBearerEvents
	{
	OnMessageReceived = context =>
	{
	var accessToken = context.Request.Query["access_token"];
	var path = context.HttpContext.Request.Path;
	if (!string.IsNullOrEmpty(accessToken) && path.StartsWithSegments("/chatHub"))
	{
	context.Token = accessToken;
	}
	return Task.CompletedTask;
	}
	};
	});
	
	// 添加CORS支持
	builder.Services.AddCors(options =>
	{
	options.AddPolicy("AllowAll", policy =>
	{
	policy.AllowAnyOrigin()
	.AllowAnyMethod()
	.AllowAnyHeader()
	.AllowCredentials(); // 允许携带Cookie或Token
	});
	});
	
	// 添加Swagger
	builder.Services.AddEndpointsApiExplorer();
	builder.Services.AddSwaggerGen(c =>
	{
	c.SwaggerDoc("v1", new OpenApiInfo { Title = "实时聊天系统", Version = "v1" });
	c.AddSecurityDefinition("Bearer", new OpenApiSecurityScheme
	{
	Description = "JWT认证，格式：Bearer {Token}",
	Name = "Authorization",
	In = ParameterLocation.Header,
	Type = SecuritySchemeType.ApiKey,
	Scheme = "Bearer"
	});
	c.AddSecurityRequirement(new OpenApiSecurityRequirement
	{
	{
	new OpenApiSecurityScheme
	{
	Reference = new OpenApiReference
	{
	Type = ReferenceType.SecurityScheme,
	Id = "Bearer"
	}
	},
	Array.Empty<string>()
	}
	});
	});
	
	var app = builder.Build();
	
	// 配置中间件管道
	if (app.Environment.IsDevelopment())
	{
	app.UseSwagger();
	app.UseSwaggerUI();
	}
	
	app.UseHttpsRedirection();
	
	app.UseStaticFiles(); // 托管静态文件（前端页面）
	
	app.UseCors("AllowAll");
	
	app.UseAuthentication();
	app.UseAuthorization();
	
	app.MapControllers();
	
	// 映射SignalR Hub
	app.MapHub<ChatHub>("/chatHub");
	
	app.Run();

逐行拆解：
SignalR配置：AddSignalR()添加SignalR服务，MapHub("/chatHub")映射Hub的URL；
Redis配置：AddSingleton添加Redis连接，单例模式，避免频繁创建连接；
JWT认证配置：OnMessageReceived事件处理SignalR的Token传递，因为SignalR的WebSocket连接不能在Header里传Token，所以用Query参数传递；
CORS配置：AllowCredentials()允许携带Cookie或Token，因为SignalR需要；
静态文件托管：UseStaticFiles()托管前端页面（chat.html、login.html等）。
四、生产级优化技巧：让聊天系统低延迟、高可用、安全

1. 性能优化
   WebSocket优先：SignalR默认用WebSocket，确保客户端支持WebSocket，避免降级到Long Polling；
   Redis缓存：用Redis存储房间信息、用户列表、未读消息数，比数据库快；
   消息批量处理：如果消息量很大，用批量插入数据库，减少数据库操作次数；
   响应压缩：启用Gzip或Brotli压缩，减少带宽消耗；
   限流：限制每个用户的消息发送频率，比如每分钟最多100条消息，避免恶意刷屏；
   对象池：复用SignalR的Hub实例、DTO对象，减少GC。
2. 高可用优化
   Redis后端：用Redis做SignalR的后端，支持横向扩展，多个服务器可以共享连接状态；
   负载均衡：用Nginx或Azure Application Gateway做负载均衡，SignalR需要启用粘性会话（sticky session），因为WebSocket连接是长连接；
   健康检查：添加SignalR Hub的健康检查端点，监控连接状态；
   自动扩容：用Kubernetes或Azure App Service自动扩容，根据连接数自动增加服务器数量；
   消息队列：用RabbitMQ或Kafka做消息队列，把消息持久化和发送解耦，避免消息丢失。
3. 安全优化
   JWT认证：用JWT做身份验证，Token设置过期时间，支持刷新Token；
   消息加密：用TLS/SSL加密WebSocket连接，避免消息被窃听；
   内容审核：用AI或关键词过滤敏感内容，避免违规消息；
   IP限制：限制恶意IP的连接频率，避免DDoS攻击；
   权限控制：限制用户加入房间的权限，比如只有群成员才能加入群聊。
4. 稳定性优化
   心跳机制：SignalR默认有心跳机制，配置心跳间隔（比如30秒），避免连接被防火墙断开；
   自动重连：客户端启用自动重连，网络波动后自动恢复连接；
   消息持久化：把聊天记录存在数据库和Redis里，服务器重启后聊天记录不丢失；
   监控告警：用Application Insights或Datadog监控SignalR的连接数、消息延迟、错误率，设置告警阈值；
   日志记录：用Serilog记录所有消息、连接、断开事件，方便排查问题。
   五、性能测试：SignalR实时聊天系统性能验证
   测试环境
   CPU：Intel i7-10700K（8核16线程）
   内存：16GB DDR4
   操作系统：Windows 10 64位
   Redis：6.2
   SQL Server 2022
   测试结果

结论：SignalR+WebSocket的实时聊天系统性能出色，10000并发连接下消息延迟只有20毫秒，适合企业级实时聊天、实时监控、在线协作等场景。
六、总结与选型建议

1. 总结
   实时聊天系统的核心是WebSocket双向通信，SignalR简化了WebSocket的开发，自动处理重连、心跳、房间管理；
   分层架构解耦业务和实时通信，易维护、易测试；
   生产环境必须做消息持久化、JWT认证、Redis缓存、监控告警、限流；
   低延迟、高可用、安全是实时聊天系统的三个核心要求。
2. 选型建议

到这里，《C#网络编程实战：从入门到企业级开发》的核心内容就全部完成了！从基础的TCP/UDP编程，到企业级的IoT平台、API服务器、实时聊天系统，覆盖了C#网络编程的核心场景和生产级优化技巧，希望能帮助你快速成为C#网络编程专家！

转载请注明出处：https://www.xin3721.com/ArticlecSharp/c49584.html