Cos'è SignalR?

SignalR è una libreria per ASP.NET Core che consente di aggiungere funzionalità WebSocket e Long Polling nelle applicazioni web per creare scenari interattivi in tempo reale.

Fornisce comunicazione bidirezionale tra server e client.

I principali scenari di utilizzo:

• Applicazioni di chat.
• Giochi online.
• Aggiornamento dei dati in tempo reale (ad esempio, grafici, notifiche).
• Monitoraggio dell'attività degli utenti.

Componenti principali:

• Hub: Classi che gestiscono le chiamate in ingresso dai client e inviano messaggi ai client.
• Connessioni: Rappresentano le connessioni dei client. Possono essere stabilite tramite WebSocket, Server-Sent Events o Long Polling (a seconda del supporto del client e del server).

Esempio di creazione di un hub:

// MyHub.cs
using Microsoft.AspNetCore.SignalR;
using System.Threading.Tasks;

public class MyHub : Hub
{
    // Metodo che può essere chiamato dal client
    public async Task SendMessage(string user, string message)
    {
        // Inviare messaggi a tutti i client connessi
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

Configurazione in Startup.cs:

// In ConfigureServices
services.AddSignalR();

// In Configure
app.UseRouting();
app.UseEndpoints(endpoints =>
{
    endpoints.MapHub<MyHub>("/myhub"); // Mappatura dell'hub all'URL
});

Sul lato client (JavaScript):

// Opzione con npm
// npm install @microsoft/signalr

const hubConnection = new signalR.HubConnectionBuilder()
    .withUrl("/myhub") // URL dell'hub
    .build();

// Gestione dei messaggi in arrivo dal server
hubConnection.on("ReceiveMessage", (user, message) => {
    // Logica di gestione del messaggio ricevuto
    console.log(`${user}: ${message}`);
});

// Apertura della connessione
hubConnection.start()
    .then(() => console.log("Connessione avviata"))
    .catch(err => console.error(err.toString()));

// Invio di un messaggio al server
// hubConnection.invoke("SendMessage", "Cliente", "Ciao dal client!");

SignalR sceglie automaticamente il trasporto ottimale in base alle capacità del client e del server, iniziando con WebSocket e passando a protocolli più vecchi se non disponibili. Ciò garantisce ampia compatibilità.