streamjsonrpc c# (So funktioniert es für Entwickler)

Einführung

Verwendung des JSON-RPC-Protokolls, StreamJsonRpc in C# ermöglicht eine effektive Kommunikation zwischen Clients und Servern über verschiedene Transportebenen hinweg. Mit Hilfe dieser Bibliothek können Remote Procedure Calls einfacher implementiert werden, so dass Entwickler zuverlässige verteilte Systeme erstellen können, in denen Programme Methoden auf entfernten Servern genauso aufrufen können wie lokal. Durch die Möglichkeit der dynamischen PDF-Erstellung auf der Grundlage von Daten, die über JSON-RPC anfragen verbessert StreamJsonRpc die Anwendungsmöglichkeiten in Verbindung mit IronPDF, einem kompletten .NET-Framework für die PDF-Erzeugung und -Bearbeitung. Für Entwickler, die den Prozess der Erstellung von benutzerdefinierten Berichten, Rechnungen oder anderen dokumentenzentrierten Anwendungen, die PDFs bei Bedarf generieren müssen, rationalisieren möchten, ist diese Schnittstelle sehr hilfreich.

IronPDF bietet Entwicklern Flexibilität und Effizienz bei der Organisation und Bereitstellung von Inhalten, indem es die Konvertierung von HTML-, ASPX- und Rohdaten in hochwertige PDF-Publikationen unterstützt. StreamJsonRpc und IronPDF arbeiten zusammen, um C#-Entwicklern die Erstellung reaktionsschneller, skalierbarer Anwendungen zu ermöglichen, die auf einfache Weise komplexe PDF-Dateien mit Remote Procedure Calls kombinieren.

Was ist StreamJsonRpc?

StreamJsonRpc ist eine plattformübergreifende Bibliothek zur Erleichterung von Remote Procedure Calls (RPC) über ein leichtgewichtiges und effizientes Leitungsprotokoll. Sie nutzt einen zugrunde liegenden Transportmechanismus, der verschiedene Kommunikationskanäle wie TCP/IP, Named Pipes und HTTP unterstützt. Die Bibliothek nutzt .NET-Ereignisse für die Verarbeitung eingehender Anfragen und Antworten und bietet so einen robusten Mechanismus für asynchrone Kommunikation. Entwickler können Methodenimplementierungen anhängen, um RPC-Anforderungen zu verarbeiten und benutzerdefinierte Verhaltensweisen mithilfe der StreamJsonRpc-API zu definieren. StreamJsonRpc ist als .NET Portable Library verfügbar, die Kompatibilität über verschiedene Plattformen hinweg gewährleistet und eine nahtlose Integration in diverse .NET-Anwendungen ermöglicht.

Eine starke Unterstützung für bidirektionale Kommunikation, einschließlich Benachrichtigungen und Fortschrittsberichte, ist eines der Hauptmerkmale von StreamJsonRpc. Durch die Unterstützung verschiedener Transportprotokolle, darunter HTTP, Named Pipes und TCP/IP, bietet es Programmen mehr Kommunikationsmöglichkeiten. Die Serialisierung und Deserialisierung von JSON-RPC-Nachrichten wird von StreamJsonRpc durchgeführt, wodurch die Kompatibilität mit vielen Plattformen und JSON-unterstützenden Computersprachen gewährleistet wird.

StreamJsonRpc wurde im Hinblick auf Leistung und Erweiterbarkeit entwickelt. Es ist mit bestehenden C#-Programmen kompatibel und kann zum Aufbau von Client-Server-Anwendungen, Microservices-Architekturen, verteilten Systemen und anderen Anwendungen verwendet werden, bei denen eine zuverlässige und effiziente Kommunikation entscheidend ist. Bei der Integration von Remote Procedure Calls in C#-Projekte entscheiden sich Entwickler in der Regel für diese Methode, weil sie zuverlässig und einfach zu handhaben ist.

Eigenschaften von StreamJsonRpc

Eine umfassende Sammlung von Funktionen bietet StreamJsonRpc von C#, das die JSON-RPC-Protokoll-basierte Client-Server-Anwendungskommunikation erleichtern und verbessern soll.

Entfernte Prozeduraufrufe (RPC)

Da StreamJsonRpc Remote-Operationen wie lokale Funktionsaufrufe betrachtet, können Clients Methoden auf einem Server über Remote-Prozeduraufrufe aufrufen. Indem sie die Feinheiten der Netzwerkkommunikation verschleiert, erleichtert diese Abstraktion die Erstellung verteilter Anwendungen.

Bidirektionale Kommunikation

Bidirektionale Client-Server-Kommunikation wird von der Bibliothek unterstützt. Kommunikation und Aktualisierungen in Echtzeit werden dadurch ermöglicht, dass die Clients Anfragen an die Server richten können, die ihrerseits mit Benachrichtigungen oder Ergebnissen antworten können.

Agnostizismus der Transportschicht

Da StreamJsonRpc unabhängig von der Transportschicht ist, kann es über eine Vielzahl von Transportprotokollen funktionieren, darunter HTTP, Named Pipes und TCP/IP. Aufgrund dieser Anpassungsfähigkeit können Entwickler die beste Transportmethode je nach den Anforderungen ihrer Anwendungen und den Netzwerkeinstellungen auswählen.

Serialisierung und Deserialisierung

Es verwaltet die Serialisierung und Deserialisierung von JSON-RPC-Nachrichten und garantiert eine reibungslose Kommunikation über verschiedene Plattformen und JSON-fähige Computersprachen hinweg.

Fortschrittsberichte

StreamJsonRpc unterstützt Techniken zur Fortschrittsmeldung bei lang laufenden Aktivitäten. Diese Funktion verbessert die Benutzerfreundlichkeit und Transparenz, indem sie es den Servern ermöglicht, die Clients über den Status der laufenden Prozesse zu informieren.

Fehlerbehandlung

Zur Behandlung von Ausnahmen und Problemen, die während des Aufrufs von Remote-Methoden auftreten, verfügt die Bibliothek über umfangreiche Fehlerbehandlungsfunktionen. Dies garantiert die Widerstandsfähigkeit und Zuverlässigkeit verteilter Systeme.

Erweiterungspunkte

StreamJsonRpc kann von Entwicklern erweitert werden, um seine Funktionalität zu verändern oder es in bereits bestehende Anwendungsarchitekturen einzubinden. Aufgrund seiner Vielseitigkeit kann es auf eine Vielzahl von Integrationsanforderungen und Anwendungsszenarien zugeschnitten werden.

Optimierung der Leistung

Durch eine effektive benutzerdefinierte Nachrichtenverarbeitung und Transportschichtverwaltung maximiert StreamJsonRpc den Durchsatz bei der Client-Server-Kommunikation und garantiert gleichzeitig einen geringen Overhead.

Asynchrone Unterstützung

Durch den Einsatz asynchroner Operationen können Anwendungen eine bessere Reaktionsfähigkeit und Skalierbarkeit erreichen. Es unterstützt vollständig asynchrone Kommunikationsmuster.

Interoperabilität

Durch die Konformität mit dem JSON-RPC-Standard erleichtert StreamJsonRpc die reibungslose Integration in verschiedenen Kontexten, indem es die Interoperabilität zwischen C#-Anwendungen und Diensten fördert, die in anderen Sprachen mit JSON-Unterstützung erstellt wurden.

Neben diesen Hauptmerkmalen enthält die JSON-RPC-Spezifikation noch einige zusätzliche Merkmale, wie z. B. Unterstützung für kompakte binäre Serialisierung und dynamischen Client-Proxy.

Erstellen und Konfigurieren von StreamJsonRpc C#

Um StreamJsonRpc in einer C#-Anwendung erstellen und konfigurieren zu können, müssen ein Client und ein Server eingerichtet werden. Die detaillierten Anweisungen für jedes Teil finden Sie unten:

Ihr Projekt einrichten

Stellen Sie zunächst sicher, dass Ihr .NET-Projekt fertig ist. Sie können eine neue mit Visual Studio oder der .NET CLI erstellen.

dotnet new console -n StreamjsonrpcExample
cd StreamjsonrpcExample

dotnet new console -n StreamjsonrpcExample
cd StreamjsonrpcExample

IRON VB CONVERTER ERROR developers@ironsoftware.com

StreamJsonRpc-Paket installieren

Um JSON-RPC-Kommunikation zu implementieren, installieren Sie das StreamJsonRpc-Paket von NuGet. Sie enthält die erforderlichen Bibliotheken.

dotnet add package StreamJsonRpc

dotnet add package StreamJsonRpc

IRON VB CONVERTER ERROR developers@ironsoftware.com

Implementierung des JSON-RPC-Servers

Erstellen Sie eine Klasse, die als Server für JSON-RPC fungieren wird. Betrachten Sie dieses einfache Beispiel:

using Microsoft.AspNetCore.Hosting;
using StreamJsonRpc;
using System;
using System.Threading.Tasks;
public class MyService
{
    public Task<int> AddAsync(int a, int b)
    {
        return Task.FromResult(a + b);
    }
    public Task<string> GreetAsync(string name)
    {
        return Task.FromResult($"Hello, {name}!");
    }
}
class Program
{
    static void Main(string[] args)
    {
        var service = new MyService();
    //initializes a new instance
        var jsonRpc = new JsonRpc(new ServerWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
        jsonRpc.AddLocalRpcTarget(service);
        jsonRpc.StartListening();
        Console.WriteLine("JsonRpc server listening on ws://localhost:8080");
        Console.WriteLine("Press any key to stop the server...");
        Console.ReadKey();
        jsonRpc.Dispose();
    }
}

using Microsoft.AspNetCore.Hosting;
using StreamJsonRpc;
using System;
using System.Threading.Tasks;
public class MyService
{
    public Task<int> AddAsync(int a, int b)
    {
        return Task.FromResult(a + b);
    }
    public Task<string> GreetAsync(string name)
    {
        return Task.FromResult($"Hello, {name}!");
    }
}
class Program
{
    static void Main(string[] args)
    {
        var service = new MyService();
    //initializes a new instance
        var jsonRpc = new JsonRpc(new ServerWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
        jsonRpc.AddLocalRpcTarget(service);
        jsonRpc.StartListening();
        Console.WriteLine("JsonRpc server listening on ws://localhost:8080");
        Console.WriteLine("Press any key to stop the server...");
        Console.ReadKey();
        jsonRpc.Dispose();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

MyService-Klasse: Gibt die Methoden an, die der Client aus der Ferne aufrufen kann, z. B. AddAsync und GreetAsync.

Dadurch wird eine neue JsonRpc-Instanz gestartet, MyService initialisiert und ein WebSocket-Nachrichten-Handler konfiguriert, der auf ws://localhost:8080 hört. Der Server stellt MyService als neues lokales RPC-Ziel dar und beginnt, auf JSON-RPC-Anfragen zu warten. Er drückt eine Taste, um das Abhören zu beenden und verwirft die Ressourcen.

Client-Konfiguration

Erstellen Sie eine Klasse, die als Client für JSON-RPC fungieren wird. Betrachten Sie dieses einfache Beispiel:

using StreamJsonRpc;
using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        var proxy = new JsonRpc(new ClientWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
    // client proxy
        await proxy.StartListeningAsync();
        var resultAdd = await proxy.InvokeAsync<int>("AddAsync", 10, 20);
        Console.WriteLine($"AddAsync result: {resultAdd}");
        var resultGreet = await proxy.InvokeAsync<string>("GreetAsync", "John");
        Console.WriteLine($"GreetAsync result: {resultGreet}");
        proxy.Dispose();
    }
}

using StreamJsonRpc;
using System;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        var proxy = new JsonRpc(new ClientWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
    // client proxy
        await proxy.StartListeningAsync();
        var resultAdd = await proxy.InvokeAsync<int>("AddAsync", 10, 20);
        Console.WriteLine($"AddAsync result: {resultAdd}");
        var resultGreet = await proxy.InvokeAsync<string>("GreetAsync", "John");
        Console.WriteLine($"GreetAsync result: {resultGreet}");
        proxy.Dispose();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

In diesem Beispiel wird eine Verbindung zu ws://localhost:8080 hergestellt, um eine JsonRpc-Instanz mit einem WebSocket-Nachrichten-Handler zu starten. Anschließend werden die Methoden AddAsync und GreetAsync aktiviert, die auf dem Server definiert sind (MeinDienst) indem eine Verbindung mit dem JSON-RPC-Server hergestellt wird. Schließlich zeigt er die Ergebnisse an, die der Server zurückgegeben hat, und gibt die Ressourcen frei, nachdem die RPC-Aufrufe beendet sind.

Erste Schritte

PDF-Seiten können in C#-Anwendungen dynamisch erzeugt werden, indem StreamJsonRpc in IronPDF integriert wird und die über JSON-RPC-Abfragen ausgetauschten Daten verwendet werden. Dies ist eine grundlegende Anleitung zum Einrichten von IronPDF und StreamJsonRpc:

Was ist IronPDF?

Die funktionsreiche .NET-Bibliothek IronPDF kann von C#-Programmen zum Erstellen, Lesen und Bearbeiten von PDF-Dokumenten verwendet werden. Mit diesem Tool können Entwickler auf einfache Weise HTML-, CSS- und JavaScript-Informationen in druckfertige, hochwertige PDF-Dateien umwandeln. Zu den wichtigsten Aufgaben gehören das Hinzufügen von Kopf- und Fußzeilen, das Teilen und Zusammenführen von PDFs, das Anbringen von Wasserzeichen in Dokumenten und die Konvertierung von HTML in PDF. IronPDF ist für eine Vielzahl von Anwendungen hilfreich, da es sowohl .NET-Framework als auch .NET Core unterstützt.

Da PDFs einfach zu verwenden sind und eine Fülle von Inhalten bieten, können Entwickler sie problemlos in ihre Produkte integrieren. Da IronPDF komplexe Layouts und Formatierungen mühelos verarbeiten kann, entsprechen die erzeugten PDF-Ausgaben nahezu dem ursprünglichen HTML-Text.

Merkmale von IronPDF

PDF-Erzeugung aus HTML

Konvertieren Sie JavaScript, HTML und CSS in PDF. IronPDF unterstützt Media-Queries und Responsive Design, zwei moderne Webstandards. Es ist ein nützliches Werkzeug zur dynamischen Gestaltung von PDF-Dokumenten, Berichten und Rechnungen mit HTML und CSS.

PDF-Bearbeitung

Vorhandene PDF-Dateien können mit Text, Fotos und anderen Inhalten ergänzt werden. Entfernen Sie Text und Bilder aus PDF-Dateien. Die Entwickler können zahlreiche PDF-Dateien in einer Datei zusammenfassen oder PDF-Dateien in mehrere separate Dokumente aufteilen. Fügen Sie Wasserzeichen, Anmerkungen, Kopf- und Fußzeilen ein.

PDF-Konvertierung

Mit IronPDF ist es möglich, eine Vielzahl von Dateiformaten, darunter Word-, Excel- und Bilddateien, in PDF zu konvertieren. Damit können Sie auch die Konvertierung von PDF in ein Bild durchführen (PNG, JPEG, usw.).

Leistung und Verlässlichkeit

Hohe Leistung und Zuverlässigkeit sind erwünschte Konstruktionsmerkmale in industriellen Umgebungen. IronPDF verwaltet große Dokumentenmengen mit Leichtigkeit.

IronPDF installieren

Um die Werkzeuge zu erhalten, die Sie für die Arbeit mit PDFs in .NET-Projekten benötigen, installieren Sie das IronPDF-Paket.

dotnet add package IronPdf

dotnet add package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'dotnet add package IronPdf

StreamJsonRpc mit IronPDF

Erstellen einer Serviceklasse

Stellen Sie in der Dienstklasse PdfService.cs Methoden bereit, die aus den empfangenen Daten PDF-Dateien erstellen. Zur Veranschaulichung:

using IronPdf;
using System.IO;
using System.Threading.Tasks;
public class PdfService
{
    public async Task<byte[]> GeneratePdfAsync(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return await pdf.BinaryDataAsync();
    }
}

using IronPdf;
using System.IO;
using System.Threading.Tasks;
public class PdfService
{
    public async Task<byte[]> GeneratePdfAsync(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return await pdf.BinaryDataAsync();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

StreamJsonRpc-Server konfigurieren

Verwenden Sie Program.cs als Schnittstelle auf dem Server für StreamJsonRpc, um die Methode GeneratePdfAsync über einen Stream JSON-RPC anzubieten:

using StreamJsonRpc;
using System;
using System.Net.WebSockets;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        var service = new PdfService();
        var jsonRpc = new JsonRpc(new WebSocketRpcServerMessageHandler(new Uri("ws://localhost:8080")));
        jsonRpc.AddLocalRpcTarget(service);
        jsonRpc.StartListening();
        Console.WriteLine("JsonRpc server listening on ws://localhost:8080");
        Console.WriteLine("Press any key to stop the server...");
        Console.ReadKey();
        await jsonRpc.StopListeningAsync();
        jsonRpc.Dispose();
    }
}

using StreamJsonRpc;
using System;
using System.Net.WebSockets;
using System.Threading.Tasks;
class Program
{
    static async Task Main(string[] args)
    {
        var service = new PdfService();
        var jsonRpc = new JsonRpc(new WebSocketRpcServerMessageHandler(new Uri("ws://localhost:8080")));
        jsonRpc.AddLocalRpcTarget(service);
        jsonRpc.StartListening();
        Console.WriteLine("JsonRpc server listening on ws://localhost:8080");
        Console.WriteLine("Press any key to stop the server...");
        Console.ReadKey();
        await jsonRpc.StopListeningAsync();
        jsonRpc.Dispose();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

IronPDF-Client erstellen

Um sich mit dem Server zu verbinden und die Erstellung einer PDF-Datei anzufordern, implementieren Sie den StreamJsonRpc-Client (ClientProgramm.cs):

using StreamJsonRpc;
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading.Tasks;
class ClientProgram
{
    static async Task Main(string[] args)
    {
        var proxy = new JsonRpc(new WebSocketRpcClientMessageHandler(new Uri("ws://localhost:8080")));
        await proxy.StartListeningAsync();
        // Example HTML content
        string htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
        // Invoke GeneratePdfAsync method on the server
        var pdfBytes = await proxy.InvokeAsync<byte[]>("GeneratePdfAsync", htmlContent);
        // Save the PDF to a file
        File.WriteAllBytes("GeneratedPdf.pdf", pdfBytes);
        Console.WriteLine("PDF generated: GeneratedPdf.pdf");
        proxy.Dispose();
    }
}

using StreamJsonRpc;
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading.Tasks;
class ClientProgram
{
    static async Task Main(string[] args)
    {
        var proxy = new JsonRpc(new WebSocketRpcClientMessageHandler(new Uri("ws://localhost:8080")));
        await proxy.StartListeningAsync();
        // Example HTML content
        string htmlContent = "<html><body><h1>Hello, IronPDF!</h1></body></html>";
        // Invoke GeneratePdfAsync method on the server
        var pdfBytes = await proxy.InvokeAsync<byte[]>("GeneratePdfAsync", htmlContent);
        // Save the PDF to a file
        File.WriteAllBytes("GeneratedPdf.pdf", pdfBytes);
        Console.WriteLine("PDF generated: GeneratedPdf.pdf");
        proxy.Dispose();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Die Klasse PdfService.cs ist ein grundlegender Bestandteil einer StreamJsonRpc-Serverimplementierung, die es einer C#-Anwendung erleichtert, PDF-Dokumente mit IronPDF zu erzeugen. Unter Verwendung von IronPDFs RenderHtmlAsPdf enthält diese Serviceklasse Methoden für die Konvertierung von HTML-Material in das PDF-Format. HTML-Inhalt wird als Eingabe über die Methode GeneratePdfAsync akzeptiert, die als asynchron bezeichnet wird (async-Aufgabe GeneratePdfAsync(string htmlInhalt)).

Diese Methode erzeugt eine Instanz von HtmlToPdf, um die Konvertierung durchzuführen und ein PDF-Dokument mit RenderHtmlAsPdf zu erzeugen(htmlInhalt). Die Binärdaten der erzeugten PDF-Datei werden dann asynchron mit der Methode (pdf.BinaryDataAsync())die anschließend die Daten als Byte zurückgibt[] array.

Diese Methode garantiert eine schnelle und reaktionsschnelle PDF-Erzeugung und eignet sich daher für Anwendungen, bei denen Dokumente schnell erstellt werden müssen. Die PDF-Erzeugungslogik ist in PdfService.cs enthalten, was es für Entwickler einfach macht, diese Funktionalität über StreamJsonRpc zu integrieren und bereitzustellen. Dies ermöglicht entfernten Clients den reibungslosen Aufruf von PDF-Generierungsaufträgen unter Beibehaltung der Modularität und Übersichtlichkeit ihres serverseitigen Designs.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass Entwickler zuverlässige und effektive .NET-Anwendungen erstellen können, die Remote Procedure Calls unterstützen (RPC) und durch die Kombination von StreamJsonRpc mit IronPDF starke PDF-Produktionsfähigkeiten zu nutzen. Mit JSON-RPC, einem leichtgewichtigen Protokoll für Remote Procedure Calls, ermöglicht StreamJsonRpc eine reibungslose Kommunikation zwischen Client- und Server-Komponenten. Entwickler können dies in Verbindung mit IronPDF nutzen, um dynamische, datengesteuerte PDFs zu erzeugen, die von den Ergebnissen dieser Remote-Aufrufe abhängig sind.

Bei der Erstellung von Berichten, Rechnungen oder anderen Dokumenten, die die aktuellsten verfügbaren Daten enthalten müssen, ist diese Integration sehr hilfreich, da sie den Datenabruf in Echtzeit und die PDF-Ausgabe ermöglicht. Die Integration dieser Technologien optimiert den Entwicklungsprozess, steigert die Leistung und stärkt die Fähigkeit der Anwendung, komplexe Geschäftsanforderungen effektiv zu erfüllen.

Mit IronPDF und IronSoftwarekönnen Entwickler mehr Webanwendungen und Funktionen schneller erstellen, und das alles zu einem Einstiegspreis von 749 US-Dollar. Erreicht wird dies durch die Verschmelzung der Kernkonzepte mit der immens flexiblen Toolbox von Iron Software.

Für die Entwickler ist es einfacher, das optimale Modell auszuwählen, wenn alle für das Projekt relevanten Lizenzoptionen klar beschrieben sind. Die oben genannten Vorteile erleichtern es den Entwicklern, Lösungen für eine Reihe von Problemen rechtzeitig, koordiniert und effizient zu entwickeln.