SignalR 101 - Eine Einführung für .NET 8

SignalR 101 - Eine Einführung für .NET 8

- Matt

Sobald eine Anwendung Daten anzeigen soll, die sich von außen ändern, reicht das übliche Anfrage-Antwort-Muster nicht mehr. Der Browser müsste ständig nachfragen, ob es etwas Neues gibt.

Einführung in SignalR und Echtzeitkommunikation

SignalR dreht das um: Der Server schickt von sich aus. Hier die Grundlagen unter .NET 8 und wie man es in eine Anwendung einbaut.

Zuerst das Aufsetzen eines Projekts und dessen Struktur, danach der Nachrichtenaustausch zwischen Client und Server.

Was ist Echtzeitkommunikation und warum SignalR?

Echtzeitkommunikation ermöglicht es Webanwendungen, Daten sofort zu senden und zu empfangen, ohne dass ein manuelles Neuladen der Seite erforderlich ist. Dies ist besonders nützlich für Anwendungen wie:

SignalR ist eine von Microsoft entwickelte Open-Source-Bibliothek, die WebSockets, Server-Sent Events (SSE) oder Long Polling verwendet, um eine Echtzeitverbindung zwischen Client und Server herzustellen. Dabei wählt SignalR automatisch das beste verfügbare Protokoll, um eine zuverlässige Verbindung sicherzustellen.

Hubs und Clients in SignalR

Hubs (Server-Seite)

In SignalR werden Server-seitige Komponenten als Hubs bezeichnet. Ein Hub ist eine C#-Klasse, die von Microsoft.AspNetCore.SignalR.Hub erbt und Methoden enthält, die Clients aufrufen können. Außerdem kann der Server über den Hub Nachrichten an einzelne Clients oder Gruppen von Clients senden.

Clients (Client-Seite)

Clients sind die Webanwendungen oder Anwendungen, die sich mit einem Hub verbinden, um Daten zu senden oder zu empfangen. Clients können mit JavaScript, C# oder anderen Sprachen implementiert werden. Die SignalR-Clientbibliothek stellt die Verbindung zum Hub her und verwaltet die Kommunikation automatisch.

SignalR-Demo: Einfache Server- und Client-Implementierung

Nun setzen wir das theoretische Wissen in die Praxis um. Wir erstellen zwei Projekte: einen Server (Web-API) und einen Client (Konsolenanwendung).

1. Einrichtung des Servers

Erstelle zunächst ein neues leeres Web-API-Projekt in .NET 8. Dann fügen wir die SignalR-Bibliothek hinzu:

dotnet add package Microsoft.AspNetCore.SignalR

Jetzt erstellen wir eine Hub-Klasse namens MessageHub:

public class Message
{
    public string? Username { get; set; }
    public string? Message { get; set; }
    public DateTime Timestamp { get; set; }
}

using Microsoft.AspNetCore.SignalR;

public class MessageHub : Hub
{
    public async Task SendMessage(Message message)
    {
        await Clients.All.SendAsync("ReceiveMessage", message);
    }
}

Die Zeile:

await Clients.All.SendAsync("ReceiveMessage", message);

bedeutet, dass die Nachricht an alle verbundenen Clients gesendet wird, die das Ereignis ReceiveMessage abonniert haben.

2. Registrierung des Hubs in Program.cs

Jetzt muss der Hub im Program.cs registriert werden:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddCors();
builder.Services.AddSignalR();

var app = builder.Build();

app.UseHttpsRedirection();
app.UseCors(builder => builder
    .AllowAnyOrigin()
    .AllowAnyMethod()
    .AllowAnyHeader());

app.MapHub<MessageHub>("/messagehub");

app.Run();

Hier passiert Folgendes:

3. Einrichtung des Clients

Nun erstellen wir eine Konsolenanwendung, die mit dem Server kommuniziert. Dazu fügen wir das SignalR-Client-Paket hinzu:

dotnet add package Microsoft.AspNetCore.SignalR.Client

Dann erstellen wir eine Verbindung zum Hub:

using Microsoft.AspNetCore.SignalR.Client;

var connection = new HubConnectionBuilder()
    .WithUrl("http://localhost:5038/messagehub")
    .Build();

Hier wird eine neue HubConnection erstellt, die sich mit http://localhost:5038/messagehub verbindet.

4. Empfang und Senden von Nachrichten

Jetzt starten wir die Verbindung und abonnieren das ReceiveMessage-Ereignis:

try
{
    await connection.StartAsync();
    Console.WriteLine("Verbunden mit SignalR-Hub");

    connection.On<Message>("ReceiveMessage", (message) =>
    {
        Console.WriteLine($"{message.Username}: {message.Message}");
    });

    var notifyMessage = new Message
    {
        Username = "John Doe"
    };

    while (true)
    {
        Console.WriteLine("Gib eine Nachricht ein:");
        var messageText = Console.ReadLine();
        notifyMessage.Message = messageText;

        await connection.InvokeAsync("SendMessage", notifyMessage);
        Console.WriteLine("Nachricht gesendet");
    }
}
catch (Exception ex)
{
    Console.WriteLine($"Fehler: {ex.Message}");
}

Erklärung:

Vorteile von SignalR

Wann sollte man SignalR nutzen?

Naheliegend ist SignalR für Anwendungen, die:

Wann ist SignalR nicht geeignet?

Fazit

SignalR nimmt einem die Wahl des Transports ab: WebSockets, wenn der Client mitspielt, sonst Server-Sent Events oder Long Polling. Für Chat, Benachrichtigungen und Live-Daten spart das eine Menge eigener Infrastruktur.

Für alles darunter tut es auch ein regelmäßiger Abruf. Der Aufwand lohnt sich erst, wenn die Verzögerung wirklich stört.

Die Referenz mit allen Hub-Optionen: Übersicht über ASP.NET Core SignalR.