Hubs e conexões do SignalR

O que é SignalR

Configurando o SignalR

builder.Services.AddSignalR();

var app = builder.Build();

app.UseCors("AllowAll");
app.MapHub<ChatHub>("/hubs/chat");

app.Run();

Criando um hub

using Microsoft.AspNetCore.SignalR;

public class ChatHub : Hub
{
    public async Task SendMessage(string user, string message)
    {
        // Broadcast to ALL connected clients
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }

    public override async Task OnConnectedAsync()
    {
        await Clients.Caller.SendAsync("Welcome",
            $"Connected as {Context.ConnectionId}");
        await base.OnConnectedAsync();
    }
}

Cliente JavaScript

// npm install @microsoft/signalr
import * as signalR from "@microsoft/signalr";

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/hubs/chat")
    .withAutomaticReconnect()
    .build();

connection.on("ReceiveMessage", (user, message) => {
    console.log(`${user}: ${message}`);
});

await connection.start();
await connection.invoke("SendMessage", "Alice", "Hello!");

Cliente SignalR do .NET

// dotnet add package Microsoft.AspNetCore.SignalR.Client

var connection = new HubConnectionBuilder()
    .WithUrl("https://myapp.com/hubs/chat")
    .WithAutomaticReconnect()
    .Build();

connection.On<string, string>("ReceiveMessage", (user, msg) =>
    Console.WriteLine($"{user}: {msg}"));

await connection.StartAsync();
await connection.InvokeAsync("SendMessage", "Bot", "Connected!");

Enviando para clientes específicos

// To the caller only
await Clients.Caller.SendAsync("YouSaid", message);

// To a specific connection
await Clients.Client(connectionId).SendAsync("PrivateMsg", msg);

// To all except caller
await Clients.Others.SendAsync("ReceiveMessage", user, message);

// To multiple specific connections
await Clients.Clients(new[] { id1, id2 })
             .SendAsync("DirectMsg", msg);

Contexto do hub: enviando de fora do hub

public class NotificationService
{
    private readonly IHubContext<ChatHub> _hub;

    public NotificationService(IHubContext<ChatHub> hub) => _hub = hub;

    public async Task BroadcastAlertAsync(string alert)
    {
        // Send to all clients from a background service
        await _hub.Clients.All.SendAsync("SystemAlert", alert);
    }
}

Eventos do ciclo de vida da conexão

public override async Task OnConnectedAsync()
{
    _connections.TryAdd(Context.ConnectionId, GetUserName());
    await Clients.All.SendAsync("UserJoined", GetUserName());
    await base.OnConnectedAsync();
}

public override async Task OnDisconnectedAsync(Exception? ex)
{
    _connections.TryRemove(Context.ConnectionId, out var user);
    await Clients.All.SendAsync("UserLeft", user);
    await base.OnDisconnectedAsync(ex);
}

private string GetUserName() =>
    Context.User?.Identity?.Name ?? Context.ConnectionId;

Reconexão automática

// JavaScript client
const conn = new signalR.HubConnectionBuilder()
    .withUrl("/hubs/chat")
    .withAutomaticReconnect([0, 2000, 5000, 10000, 30000]) // retry delays in ms
    .build();

conn.onreconnecting(err => console.warn("Reconnecting...", err));
conn.onreconnected(id  => console.log("Reconnected:",    id));
conn.onclose(err       => console.error("Disconnected:", err));

Autenticação com SignalR

[Authorize]
public class PrivateHub : Hub
{
    public Task SendMessage(string msg)
    {
        var user = Context.User!.Identity!.Name;
        return Clients.All.SendAsync("Msg", user, msg);
    }
}

// JWT via query string (WebSocket requirement):
builder.Services.AddAuthentication().AddJwtBearer(opt =>
{
    opt.Events = new JwtBearerEvents
    {
        OnMessageReceived = ctx =>
        {
            var token = ctx.Request.Query["access_token"];
            if (!string.IsNullOrEmpty(token))
                ctx.Token = token;
            return Task.CompletedTask;
        }
    };
});

Verificação rápida

Recapitulação: hubs e conexões do SignalR