SignalR构建实时应用

using Microsoft.AspNetCore.SignalR;

namespace SignalRChat.Hubs;

public class ChatHub : Hub
{
    public async Task Login(string user)
    {
        // AllExcept：除了指定ConnectionId的其他用户
        await Clients.AllExcept(Context.ConnectionId)
            .SendAsync("Online", $"{user} 进入了群聊!");
    }

    public async Task Logout(string user)
    {
        // AllExcept：除了指定ConnectionId的其他用户
        await Clients.AllExcept(Context.ConnectionId)
            .SendAsync("Online", $"{user} 退出了群聊!");
    }

    public async Task SendMessage(string user, string message)
    {
        // All：所有用户
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

using SignalRChat.Hubs;

var builder = WebApplication.CreateBuilder(args);

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

var app = builder.Build();

if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Error");
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

app.MapRazorPages();
// 配置ChatHub
app.MapHub<ChatHub>("/chatHub");

app.Run();

public class NotificationController : Controller
{
    private readonly IHubContext<ChatHub> _hubContext;

    public NotificationController(IHubContext<ChatHub> hubContext)
    {
        _hubContext = hubContext;
    }

    [HttpPost]
    public async Task<IActionResult> Notify(string message)
    {
        // 使用 IHubContext 发送消息给所有客户端
        await _hubContext.Clients.All.SendAsync("NotificationMessage", message);
        return Ok();
    }
}

Install-Package Microsoft.AspNetCore.SignalR.StackExchangeRedis

public class ClientConnected
{
    public string Id { get; set; }
    public string Email { get; set; }
    public string ConnectionId { get; set; }
}

public class ChatHub : Hub
{
    private readonly UserManager<IdentityUser> _userManager;
    private readonly IDistributedCache _distributedCache;
    private readonly IRedisDirectConnection _redisDirectConnection;

    public ChatHub(UserManager<IdentityUser> userManager, IDistributedCache distributedCache, IRedisDirectConnection redisDirectConnection)
    {
        _userManager = userManager;
        _distributedCache = distributedCache;
        _redisDirectConnection = redisDirectConnection;
    }

    
    public override async Task OnConnectedAsync()
    {
        var hostName = Dns.GetHostName();
        await Clients.Caller.SendAsync("LogHostName", hostName);
        var email = Context.User?.Identity?.Name;
        if (string.IsNullOrEmpty(email))
            return;
        var redisKeys = _redisDirectConnection.SearchKeys("SignalR:User:*");

        var listClients = new List<ClientConnected>();
        foreach (var keyStr in redisKeys.Select(key => key.ToString().Replace("master", string.Empty)))
        {
            var json = await _distributedCache.GetStringAsync(keyStr);
            if (string.IsNullOrEmpty(json)) continue;
            
            var clientConnected =
                JsonConvert.DeserializeObject<ClientConnected>(json);
            
            listClients.Add(clientConnected);
        }
        
        foreach (var clientConnected in listClients.Where(a => a.Email != email).ToList())
        {
            await Clients.Caller.SendAsync("OnUserConnect", clientConnected);            
        }
        
        var user = await _userManager.Users.FirstOrDefaultAsync(a => a.Email == email);

        var client = new ClientConnected()
        {
            Id = user.Id,
            Email = user.Email,
            ConnectionId = Context.ConnectionId
        };
        listClients.Add(client);
        await _distributedCache.SetStringAsync($"SignalR:User:user-{client.Id}", JsonConvert.SerializeObject(client));
        //_clientsConnected.Add(client);

        //cache to individual not the full tself
        await Groups.AddToGroupAsync(Context.ConnectionId, $"user-{client.Id}"); //Mandar para os outros connectionid da plataforma nao 
        
        await Clients.AllExcept(listClients.Where(a => a.Email == email).Select(a => a.ConnectionId)).SendAsync("OnUserConnect", client);

        await  base.OnConnectedAsync();
    }

    public override async Task OnDisconnectedAsync(Exception? exception)
    {
        var email = Context.User?.Identity?.Name;
        if (!string.IsNullOrEmpty(email))
        {
            var user = await _userManager.Users.FirstOrDefaultAsync(a => a.Email == email);
            var cacheKey = $"SignalR:User:user-{user.Id}";
            
            var client =  await _distributedCache.GetStringAsync(cacheKey);
            if (client != null)
            {
                await Groups.RemoveFromGroupAsync(Context.ConnectionId, $"user-{user.Id}");
                await Clients.All.SendAsync("OnUserDisconnect", JsonConvert.DeserializeObject<ClientConnected>(client));
            }
            
            await _distributedCache.RemoveAsync(cacheKey);
        }
        
        //In this case ALL is ok.. but in a case of a full page, subscription would be recommended
        await base.OnDisconnectedAsync(exception);
    }

    public async Task SendMessage(string toUser, string message)
    {
     /*   await Clients.All.SendAsync("OnReceiveMessage", toUser,  message);

        
        await Clients.Caller.SendAsync("OnReceiveMessage", toUser,  message);*/
     
        var email = Context.User?.Identity?.Name;
        var user = await _userManager.Users.FirstOrDefaultAsync(a => a.Email == email);
        var fromName = user.Email;
        
        await Clients.Group($"user-{toUser}").SendAsync("OnReceiveMessage", user.Id,  fromName, message);
    }
}

var redisConnectionString = builder.Configuration.GetConnectionString("RedisConnection");

builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = redisConnectionString;
    options.InstanceName = "master";
});

builder.Services.AddSignalR().AddStackExchangeRedis(redisConnectionString);
builder.Services.AddSingleton<IRedisDirectConnection, RedisDirectConnection>();

...

app.MapHub<ChatHub>("/chathub");