23 Jan 2025 - Matthias Voigt
Echtzeitkommunikation im Web ist heutzutage ein entscheidender Bestandteil moderner Webentwicklung. Sie ermöglicht es Webanwendungen, Daten in Echtzeit zu senden und zu empfangen, wodurch eine reaktionsfähigere und interaktivere Benutzererfahrung geschaffen wird.
SignalR ist eine .NET-Bibliothek, die die Implementierung von Echtzeitfunktionen in Webanwendungen erheblich vereinfacht. In diesem Beitrag werden wir die Grundlagen von SignalR in .NET 8 erkunden und lernen, wie es in eine Webanwendung integriert werden kann.
Wir beginnen mit der Einrichtung eines neuen SignalR-Projekts in .NET 8 und gehen auf die grundlegende Struktur eines SignalR-Projekts ein. Danach sehen wir uns an, wie Nachrichten zwischen Client und Server ausgetauscht werden können.
Nach der Lektüre dieses Beitrags wirst du verstehen, wie du Echtzeitkommunikation mit SignalR in deinen .NET-8-Projekten umsetzt.
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.
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 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.
Nun setzen wir das theoretische Wissen in die Praxis um. Wir erstellen zwei Projekte: einen Server (Web-API) und einen Client (Konsolenanwendung).
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.
Program.csJetzt 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:
builder.Services.AddSignalR(); → Fügt die SignalR-Dienste zur Dependency Injection hinzu.app.MapHub<MessageHub>("/messagehub"); → Registriert den Hub unter der URL /messagehub.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.
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}");
}
await connection.StartAsync(); → Verbindet den Client mit dem Hub.connection.On<Message>("ReceiveMessage", (message) => { ... }); → Registriert einen Event-Handler für eingehende Nachrichten.await connection.InvokeAsync("SendMessage", notifyMessage); → Sendet eine Nachricht an den Server.✅ Echtzeit-Kommunikation ohne manuelle Aktualisierung
✅ Einfache Implementierung durch hohe Abstraktion
✅ Unterstützung für verschiedene Protokolle (WebSockets, SSE, Long Polling)
✅ Cross-Platform-Unterstützung für verschiedene Clients
✅ Skalierbarkeit mit Redis oder Azure SignalR Service
SignalR ist ideal für Anwendungen, die:
🚫 Wenn eine Anwendung keine Echtzeitkommunikation benötigt
🚫 Bei schlechten oder instabilen Netzwerkverbindungen
🚫 Falls ältere Browser oder Geräte unterstützt werden müssen, die keine modernen Web-Technologien nutzen
SignalR ist eine leistungsstarke und einfach zu verwendende Lösung für Echtzeitkommunikation in .NET 8. Mit wenigen Zeilen Code lassen sich interaktive Web- und Desktop-Anwendungen erstellen, die nahtlos Daten in Echtzeit austauschen.
Wenn du eine Webanwendung mit Echtzeit-Funktionalität benötigst, ist SignalR definitiv eine Technologie, die du in Betracht ziehen solltest!