Signalr C# (Wie es für Entwickler funktioniert)

Das moderne Web lebt von Interaktivität und Echtzeit-Feedback. Bei der Entwicklung von reaktionsfähigen Anwendungen ist die Echtzeit-Webfunktionalität ein Muss. Hier glänzt SignalR. ASP.NET Core SignalR ist eine Bibliothek, die das Hinzufügen von Echtzeit-Webfunktionen zu Ihren Anwendungen einfacher macht, als Sie vielleicht denken.

In diesem Tutorial begeben wir uns auf eine Reise durch die Grundlagen und Feinheiten von SignalR. Tauchen wir ein!

Einführung in SignalR in ASP.NET Core

ASP.NET Core SignalR bietet eine API zur Erstellung von Echtzeit-Webfunktionen unter Verwendung von WebSockets und anderen Technologien, wie z. B. vom Server gesendete Ereignisse. Es ist nicht nur auf ASP.NET Core beschränkt. Sie können SignalR mit verschiedenen Clients verwenden, z. B. mit einem Browser oder einer mobilen App, um sicherzustellen, dass verbundene Clients sofort aktualisiert werden.

Einrichten Ihrer Entwicklungsumgebung

Für die ersten Schritte benötigen Sie:

• ASP.NET Core SDK
• Visual Studio

Aufbau des SignalR-Hubs

Im Kern dreht sich SignalR um einen SignalR-Hub, einen zentralen Punkt für die Interaktion zwischen dem Client und dem Server.

Erstellen Sie ein neues ASP.NET Core-Projekt. Fügen Sie nun eine neue Klasse hinzu und nennen Sie sie ChatHub. Dieser wird als unser SignalR-Hub fungieren.

using Microsoft.AspNetCore.SignalR;

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

using Microsoft.AspNetCore.SignalR;

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

Imports Microsoft.AspNetCore.SignalR

Public Class ChatHub
	Inherits Hub

	Public Async Function SendMessage(ByVal user As String, ByVal message As String) As Task
		Await Clients.All.SendAsync("ReceiveMessage", user, message)
	End Function
End Class

In der öffentlichen Klasse Startup binden wir unseren Hub ein.

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapHub<ChatHub>("/chatHub");
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapHub<ChatHub>("/chatHub");
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddSignalR()
End Sub

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseEndpoints(Sub(endpoints)
		endpoints.MapHub(Of ChatHub)("/chatHub")
	End Sub)
End Sub

Client-seitige Implementierung

SignalR ist vielseitig. Während sich dieses Tutorial auf ASP.NET Core und die JavaScript-Client-Bibliothek konzentriert, unterstützt SignalR verschiedene Clients, von .NET bis Java.

Verwendung der SignalR-Client-Bibliothek

Mit der SignalR-Client-Bibliothek kann Ihr clientseitiger Code direkt mit der Serverseite verbunden werden und kommunizieren. Für unser Beispiel wollen wir JavaScript verwenden.

Fügen Sie zunächst die SignalR JavaScript-Client-Bibliothek hinzu:

<script src="https://cdn.jsdelivr.net/npm/@microsoft/signalr@3.1.8/dist/browser/signalr.js"></script>

<script src="https://cdn.jsdelivr.net/npm/@microsoft/signalr@3.1.8/dist/browser/signalr.js"></script>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<script src="https://cdn.jsdelivr.net/npm/@microsoft/signalr@3.1.8/dist/browser/signalr.js"></script>

Jetzt können Sie eine Verbindung mit dem Hub herstellen:

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub")
    .build();

connection.start();

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

const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub")
    .build();

connection.start();

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

const connection = (New signalR.HubConnectionBuilder()).withUrl("/chatHub").build()

connection.start()

connection.on("ReceiveMessage", Sub(user, message)
	console.log(`${user} says:= ${message}`)
End Sub)

Dieser einfache client-seitige Code stellt eine Verbindung zum Hub her und wartet auf alle gesendeten Nachrichten.

Echtzeit-Funktionalität in Aktion

Versenden von Nachrichten

Mit unseren früheren client- und serverseitigen Codeschnipseln ist das Senden von Nachrichten ganz einfach. Sowohl der Server als auch der Client können eine Kommunikation initiieren.

Server-seitig:

await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!");

await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!");

Await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!")

Und vom Kunden:

connection.send("SendMessage", "Client", "Hello from client!");

connection.send("SendMessage", "Client", "Hello from client!");

connection.send("SendMessage", "Client", "Hello from client!")

Erweiterte Echtzeit-Kommunikation

ASP.NET Core SignalR bietet erweiterte Echtzeit-Kommunikationsfunktionen:

1. Verbindungen gruppieren: Segmentieren Sie verbundene Clients in Gruppen und senden Sie Nachrichten an bestimmte Segmente.

2. Umgang mit Verbindungsabbrüchen: Automatisches Management von Client-Verbindungen und -Trennungen.

3. Binäres Protokoll: Obwohl SignalR standardmäßig ein textbasiertes Protokoll verwendet, unterstützt es auch ein binäres Protokoll.

SignalR mit Azure SignalR Service

Für skalierbare Echtzeitfunktionen integrieren Sie Azure SignalR Dienst. Dieser vollständig verwaltete Dienst unterstützt eine große Anzahl gleichzeitiger Verbindungen und ist daher ideal für Anwendungen mit hohem Bedarf.

Integration des Azure SignalR Service:

1. Installieren Sie die Azure SignalR SDK.

2. Verwenden Sie Azure Service Bus für die Backplane-Unterstützung.

3. Passen Sie die öffentliche Klasse Startup an die Verwendung von Azure SignalR an.

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR().AddAzureSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseAzureSignalR(routes =>
    {
        routes.MapHub<ChatHub>("/chatHub");
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddSignalR().AddAzureSignalR();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseAzureSignalR(routes =>
    {
        routes.MapHub<ChatHub>("/chatHub");
    });
}

Public Sub ConfigureServices(ByVal services As IServiceCollection)
	services.AddSignalR().AddAzureSignalR()
End Sub

Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
	app.UseAzureSignalR(Sub(routes)
		routes.MapHub(Of ChatHub)("/chatHub")
	End Sub)
End Sub

Iron Suite Verbessert SignalR mit hochwertigen .NET-Tools

Während ASP.NET Core SignalR eine hervorragende Grundlage für Echtzeit-Webfunktionen bietet, suchen Entwickler häufig nach Tools, um das Gesamterlebnis und die Funktionalität zu verbessern. Das ist der Ort, an dem Iron Suite kommt ins Spiel.

Iron Suite ist eine Reihe von hochwertigen .NET-Bibliotheken, die Ihre ASP.NET Core-Anwendungen, einschließlich derjenigen, die SignalR verwenden, aufwerten. Jedes Produkt in dieser Suite bietet einzigartige Funktionen, die eine reichhaltige Anwendungserfahrung gewährleisten. Schauen wir uns die Angebote genauer an:

IronPDF

IronPDF können Sie PDF-Dateien in Ihren .NET-Anwendungen erzeugen, bearbeiten und lesen. Stellen Sie sich die Integration von SignalR in einem Szenario vor, in dem ein Team in Echtzeit an einem Dokument zusammenarbeitet. Wenn Änderungen vorgenommen werden, kann das Dokument sofort in eine PDF-Datei umgewandelt werden, wobei die Aktualisierungen nahtlos an alle verbundenen Clients weitergeleitet werden. Die Echtzeitfunktionalität von SignalR gepaart mit den Möglichkeiten von IronPDF könnte die Tools für die Zusammenarbeit revolutionieren.

IronXL

Wenn es um die Arbeit mit Excel-Tabellen geht, IronXL ist ein Champion. In der Geschäftswelt spielen Tabellenkalkulationen eine wichtige Rolle. Die Einbindung von SignalR in IronXL bedeutet, dass die Finanzteams in Echtzeit an den Haushaltsplänen arbeiten und die Änderungen sofort sehen können. Stellen Sie sich ein Szenario vor, in dem Dateneingaben aus verschiedenen Abteilungen in ein zentrales Excel-Blatt fließen, das alle Beteiligten in Echtzeit aktualisiert. Die Verschmelzung von Echtzeitkommunikation und dynamischer Tabellenkalkulation wird mit dieser Kombination zur Realität.

IronOCR

Optische Zeichenerkennung (OCR) hat sich zu einem Grundnahrungsmittel in modernen Anwendungen entwickelt. IronOCR befähigt .NET-Entwickler, Text aus Bildern und Dokumenten zu extrahieren. In Verbindung mit der Echtzeitfunktionalität von SignalR kann dies einen entscheidenden Unterschied ausmachen. Nehmen wir eine Plattform, auf die Nutzer Bilder mit Textdaten hochladen. SignalR könnte verwendet werden, um die Nutzer in Echtzeit zu benachrichtigen, sobald IronOCR die Bilder verarbeitet hat, so dass die Datenextraktion interaktiv und unmittelbar erfolgt.

IronBarcode

Die Strichcodierung ist ein wesentlicher Bestandteil der Bestandsverwaltung, von Ticketingsystemen und vielem mehr. IronBarcode vereinfacht die Erstellung und das Lesen von Barcodes. Stellen Sie sich nun vor, dies mit SignalR in ein Lagerverwaltungssystem zu integrieren. Wenn Artikel gescannt werden, wird der Bestand in Echtzeit aktualisiert, so dass die angeschlossenen Kunden über die Lagerbestände informiert werden und ein reibungsloser logistischer Ablauf gewährleistet ist.

Schlussfolgerung

Die Verschmelzung von ASP.NET Core SignalR mit den leistungsstarken Tools der Iron Suite verspricht ein verbessertes Erlebnis für Entwickler und Endbenutzer. Die Echtzeit-Webfunktionalität wird nicht nur zur Kommunikation, sondern zu einem transformativen Werkzeug, das in Verbindung mit den richtigen Ressourcen wie Iron Suite interaktive Anwendungen neu definieren kann.

Es ist erwähnenswert, welchen Mehrwert Iron Suite bietet. Jede Produktlizenz beginnt bei $749 und bietet Entwicklern eine Reihe von Premium-Funktionen. Wenn Sie jedoch unsicher sind, ob Sie sich sofort binden wollen, bietet jedes Produkt eine großzügige kostenloser Test. So können Sie die Funktionen testen, bevor Sie eine Entscheidung treffen.

Und wenn Sie die Integration mehrerer Tools in Betracht ziehen, gibt es fantastische Neuigkeiten: Sie können kauf der gesamten Iron Suite für den Preis von nur zwei Produkten! Dies stellt nicht nur sicher, dass Sie das Beste für Ihr Geld bekommen, sondern stattet Sie auch mit einem umfassenden Toolkit aus, um Ihre ASP.NET Core SignalR-Anwendungen zu revolutionieren.