Das moderne Web gedeiht durch Interaktivität und Echtzeit-Feedback. Beim Erstellen von responsive Anwendungen sind Echtzeit-Webfunktionen 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 beginnen wir eine Reise durch die Grundlagen und Nuancen von SignalR. Lassen Sie uns starten!

Einführung in SignalR in ASP.NET Core

ASP.NET Core SignalR bietet eine API zum Erstellen von Echtzeit-Webfunktionen mit WebSockets und anderen Technologien wie serverseitigen Ereignissen. Es ist nicht nur auf ASP.NET Core beschränkt. Sie können SignalR mit verschiedenen Clients verwenden, wie einem Browser oder einer mobilen App, und sicherstellen, dass verbundene Clients sofort aktualisiert werden.

Einrichten Ihrer Entwicklungsumgebung

Um anzufangen, benötigen Sie:

• ASP.NET Core SDK
• Visual Studio

Aufbau des SignalR-Hubs

Im Kern dreht sich bei SignalR alles um einen SignalR-Hub, einen zentralen Punkt, bei dem sowohl der Client als auch der Server interagieren.

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

using Microsoft.AspNetCore.SignalR;
using System.Threading.Tasks;

// Define a SignalR Hub class named ChatHub
public class ChatHub : Hub
{
    // Asynchronous method to send messages
    public async Task SendMessage(string user, string message)
    {
        // Send a message to all connected clients
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

using Microsoft.AspNetCore.SignalR;
using System.Threading.Tasks;

// Define a SignalR Hub class named ChatHub
public class ChatHub : Hub
{
    // Asynchronous method to send messages
    public async Task SendMessage(string user, string message)
    {
        // Send a message to all connected clients
        await Clients.All.SendAsync("ReceiveMessage", user, message);
    }
}

Imports Microsoft.AspNetCore.SignalR
Imports System.Threading.Tasks

' Define a SignalR Hub class named ChatHub
Public Class ChatHub
	Inherits Hub

	' Asynchronous method to send messages
	Public Async Function SendMessage(ByVal user As String, ByVal message As String) As Task
		' Send a message to all connected clients
		Await Clients.All.SendAsync("ReceiveMessage", user, message)
	End Function
End Class

Imports Microsoft.AspNetCore.SignalR
Imports System.Threading.Tasks

' Define a SignalR Hub class named ChatHub
Public Class ChatHub
	Inherits Hub

	' Asynchronous method to send messages
	Public Async Function SendMessage(ByVal user As String, ByVal message As String) As Task
		' Send a message to all connected clients
		Await Clients.All.SendAsync("ReceiveMessage", user, message)
	End Function
End Class

In der Startup Klasse integrieren wir unseren Hub.

public class Startup
{
    // Configure services and add SignalR
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSignalR(); // Add SignalR services
    }

    // Configure the app to use SignalR and map the hub
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Setup endpoint to route to ChatHub
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHub<ChatHub>("/chatHub");
        });
    }
}

public class Startup
{
    // Configure services and add SignalR
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSignalR(); // Add SignalR services
    }

    // Configure the app to use SignalR and map the hub
    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Setup endpoint to route to ChatHub
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapHub<ChatHub>("/chatHub");
        });
    }
}

Public Class Startup
	' Configure services and add SignalR
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddSignalR() ' Add SignalR services
	End Sub

	' Configure the app to use SignalR and map the hub
	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		' Setup endpoint to route to ChatHub
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapHub(Of ChatHub)("/chatHub")
		End Sub)
	End Sub
End Class

Public Class Startup
	' Configure services and add SignalR
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		services.AddSignalR() ' Add SignalR services
	End Sub

	' Configure the app to use SignalR and map the hub
	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		' Setup endpoint to route to ChatHub
		app.UseEndpoints(Sub(endpoints)
			endpoints.MapHub(Of ChatHub)("/chatHub")
		End Sub)
	End Sub
End Class

Client-seitige Implementierung

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

Verwendung der SignalR-Client-Bibliothek

Die SignalR-Clientbibliothek ermöglicht es Ihrem Client-seitigen Code, direkt mit der Serverseite zu verbinden und zu kommunizieren. Für unser Beispiel verwenden wir JavaScript.

Fügen Sie zuerst die SignalR-JavaScript-Clientbibliothek 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>

Jetzt können Sie sich mit dem Hub verbinden:

// Create a connection to the SignalR hub
const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub") // The hub URL
    .build();

// Start the connection
connection.start().catch(err => console.error(err.toString()));

// Setup a listener for receiving messages
connection.on("ReceiveMessage", (user, message) => {
    console.log(`${user} says: ${message}`);
});

// Create a connection to the SignalR hub
const connection = new signalR.HubConnectionBuilder()
    .withUrl("/chatHub") // The hub URL
    .build();

// Start the connection
connection.start().catch(err => console.error(err.toString()));

// Setup a listener for receiving messages
connection.on("ReceiveMessage", (user, message) => {
    console.log(`${user} says: ${message}`);
});

Dieser einfache Client-seitige Code verbindet sich mit dem Hub und lauscht auf alle gesendeten Nachrichten.

Echtzeit-Funktionalität in Aktion

Nachrichten versenden

Mit unseren früheren Code-Snippets auf der Client- und Serverseite ist das Senden von Nachrichten einfach. Sowohl der Server als auch der Client können die Kommunikation initiieren.

Von der Serverseite:

// Send a message from the server to all connected clients
await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!");

// Send a message from the server to all connected clients
await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!");

' Send a message from the server to all connected clients
Await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!")

' Send a message from the server to all connected clients
Await Clients.All.SendAsync("ReceiveMessage", "Server", "Hello from server!")

Und vom Client:

// Send a message from the client to the server
connection.send("SendMessage", "Client", "Hello from client!")
    .catch(err => console.error(err.toString()));

// Send a message from the client to the server
connection.send("SendMessage", "Client", "Hello from client!")
    .catch(err => console.error(err.toString()));

Fortgeschrittene Echtzeit-Kommunikation

ASP.NET Core SignalR bietet erweiterte Echtzeit-Kommunikationsfunktionen:

1. Gruppierung von Verbindungen: Segmentierung der verbundenen Clients in Gruppen, wobei Nachrichten an bestimmte Segmente gesendet werden.
2. Umgang mit Verbindungsabbrüchen: Automatische Verwaltung von Clientverbindungen und -abbrüchen.
3. Binärprotokoll: SignalR verwendet standardmäßig ein textbasiertes Protokoll, unterstützt aber auch ein Binärprotokoll.

SignalR mit Azure SignalR Service

Für skalierbare Echtzeit-Funktionalitäten integrieren Sie den Azure SignalR-Dienst. Dieser vollständig verwaltete Dienst unterstützt eine massive Anzahl gleichzeitiger Verbindungen und ist ideal für Anwendungen mit hoher Nachfrage.

Integration des Azure SignalR-Dienstes:

1. Installieren Sie das Azure SignalR SDK.
2. Azure Service Bus für Backplane-Unterstützung verwenden.
3. Passen Sie die Startup Klasse an, um Azure SignalR zu verwenden.

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Azure SignalR services
        services.AddSignalR().AddAzureSignalR();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Use Azure SignalR and map hub with routes
        app.UseAzureSignalR(routes =>
        {
            routes.MapHub<ChatHub>("/chatHub");
        });
    }
}

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Azure SignalR services
        services.AddSignalR().AddAzureSignalR();
    }

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        // Use Azure SignalR and map hub with routes
        app.UseAzureSignalR(routes =>
        {
            routes.MapHub<ChatHub>("/chatHub");
        });
    }
}

Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		' Add Azure SignalR services
		services.AddSignalR().AddAzureSignalR()
	End Sub

	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		' Use Azure SignalR and map hub with routes
		app.UseAzureSignalR(Sub(routes)
			routes.MapHub(Of ChatHub)("/chatHub")
		End Sub)
	End Sub
End Class

Public Class Startup
	Public Sub ConfigureServices(ByVal services As IServiceCollection)
		' Add Azure SignalR services
		services.AddSignalR().AddAzureSignalR()
	End Sub

	Public Sub Configure(ByVal app As IApplicationBuilder, ByVal env As IWebHostEnvironment)
		' Use Azure SignalR and map hub with routes
		app.UseAzureSignalR(Sub(routes)
			routes.MapHub(Of ChatHub)("/chatHub")
		End Sub)
	End Sub
End Class

Iron Suite erweitert SignalR mit hochwertigen .NET-Tools

Während ASP.NET Core SignalR eine hervorragende Grundlage für Echtzeit-Webfunktionen bietet, suchen Entwickler oft nach Tools, um das Gesamterlebnis und die Funktionalitäten zu verbessern. Hier kommt die Iron Software Suite of Libraries ins Spiel.

Iron Suite ist ein Paket von Premium .NET-Bibliotheken, das darauf ausgelegt ist, Ihre ASP.NET Core-Anwendungen zu stärken, einschließlich derjenigen, die SignalR verwenden. Jedes Produkt in dieser Suite bietet einzigartige Fähigkeiten und sorgt für ein reichhaltigeres Anwendungserlebnis. Lassen Sie uns die Angebote näher betrachten:

IronPDF

Erfahren Sie mehr über IronPDF-Funktionen ermöglicht es Ihnen, PDF-Dateien innerhalb Ihrer .NET-Anwendungen zu erstellen, zu bearbeiten und zu lesen. Stellen Sie sich vor, Sie integrieren SignalR in ein Szenario, in dem ein Team in Echtzeit an einem Dokument zusammenarbeitet. Während Änderungen vorgenommen werden, kann das Dokument im Handumdrehen in ein PDF konvertiert werden, mit Aktualisierungen, die nahtlos an alle verbundenen Clients übertragen werden. Die Echtzeitfunktion von SignalR gepaart mit den Funktionen von IronPDF könnte kollaborative Tools revolutionieren.

IronPDF konvertiert HTML, URLs und vollständige Webseiten in atemberaubende PDFs wie das Original. Es eignet sich perfekt zum Speichern von Online-Berichten, Rechnungen oder jeder webbasierten Information, die Sie aufbewahren möchten. Möchten Sie HTML in PDF umwandeln? Testen Sie IronPDF heute!

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

IronXL

Wenn es um die Arbeit mit Excel-Tabellen geht, ist Erkunden Sie die Features von IronXL ein Meister. In Unternehmen sind Tabellenkalkulationen entscheidend. Das Zusammenführen von SignalR und IronXL bedeutet, dass Finanzteams in Echtzeit an Budgetblättern arbeiten können und Änderungen sehen, während sie passieren. Stellen Sie sich ein Szenario vor, in dem Dateneinträge verschiedener Abteilungen in ein zentrales Excel-Blatt fließen, mit Echtzeit-Updates für alle Beteiligten. Die Kombination von Echtzeitkommunikation und dynamischem Tabellenmanagement wird mit dieser Kombination Wirklichkeit.

IronOCR

Optische Zeichenerkennung (OCR) ist in modernen Anwendungen zum Standard geworden. Sehen Sie IronOCR in Aktion befähigt .NET-Entwickler, Text aus Bildern und Dokumenten zu extrahieren. Die Kombination mit der Echtzeitfunktion von SignalR kann bahnbrechend sein. Stellen Sie sich eine Plattform vor, auf der Benutzer Bilder mit Textdaten hochladen. SignalR könnte verwendet werden, um Benutzer in Echtzeit zu benachrichtigen, sobald IronOCR die Bilder verarbeitet hat, wodurch die Datenauswertung interaktiv und augenblicklich wird.

IronBarcode

Barcodes sind integraler Bestandteil der Bestandsverwaltung, Ticketingsystemen und mehr. Entdecken Sie die Möglichkeiten von IronBarcode vereinfacht die Erstellung und das Lesen von Barcodes. Denken Sie nun daran, dies mit SignalR in einem Lagerverwaltungssystem zu integrieren. Wenn Artikel gescannt werden, wird der Lagerbestand in Echtzeit aktualisiert, was verbundene Clients über den Lagerbestand informiert und einen reibungslosen logistischen Betrieb gewährleistet.

Abschluss

Die Kombination von ASP.NET Core SignalR mit den leistungsstarken Tools der Iron Suite verspricht ein verbessertes Erlebnis für Entwickler und Endnutzer. Echtzeit-Webfunktionen bedeuten nicht nur Kommunikation, sondern ein transformatives Werkzeug, das, wenn es mit den richtigen Ressourcen wie der Iron Suite kombiniert wird, interaktive Anwendungen neu definieren kann.

Es ist erwähnenswert, welches Wertangebot die Iron Suite bietet. Jede Produktlizenz beginnt bei $999 und bietet Entwicklern ein Premium-Set von Funktionen. Wenn Sie sich jedoch nicht sicher sind, ob Sie sich unmittelbar binden möchten, bietet jedes Produkt großzügig eine kostenlose Testversion der Iron Software Produkte an. Dies ermöglicht es Ihnen, die Funktionen zu testen, bevor Sie eine Entscheidung treffen.

Und wenn Sie erwägen, mehrere Tools zu integrieren, gibt es fantastische Neuigkeiten: Sie können die gesamte Iron Suite zum Preis von nur zwei Produkten erwerben! Das stellt nicht nur sicher, dass Sie den besten Gegenwert für Ihr Geld erhalten, sondern stellt Ihnen auch ein umfassendes Toolkit zur Verfügung, um Ihre ASP.NET Core SignalR-Anwendungen zu revolutionieren.