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

Eine umfassende Sammlung von Funktionalitäten wird von C#'s StreamJsonRpc bereitgestellt, die darauf abzielt, die Kommunikation von Client-Server-Anwendungen auf Basis des JSON-RPC-Protokolls zu erleichtern und zu verbessern.

Remote Procedure Calls (RPC)

Durch die Betrachtung von Remote-Operationen, als wären sie lokale Funktionsaufrufe, ermöglicht StreamJsonRpc den Clients, Methoden auf einem Server über Remote-Prozeduraufrufe aufzurufen. Indem es die Komplexitäten der Netzwerkkommunikation verschleiert, erleichtert diese Abstraktion die Erstellung von verteilten Anwendungen.

Bidirektionale Kommunikation

Die Bibliothek unterstützt bidirektionale Client-Server-Kommunikation. Echtzeitkommunikation und -aktualisierungen werden durch die Möglichkeit ermöglicht, dass Clients Anfragen an Server senden können, die wiederum mit Benachrichtigungen oder Ergebnissen antworten können.

Transport Layer Agnostizismus

Da es transportlagenunabhängig ist, kann StreamJsonRpc über eine Vielzahl von Transportprotokollen, einschließlich HTTP, Named Pipes und TCP/IP, funktionieren. Durch diese Anpassungsfähigkeit können Entwickler die beste Transportmethode gemäß den Anforderungen ihrer Anwendungen und den Netzwerkeinstellungen auswählen.

Serialisierung und Deserialisierung

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

Fortschrittsberichte

StreamJsonRpc unterstützt Methoden zur Berichterstattung über den Fortschritt für lang andauernde Aktivitäten. Diese Funktion verbessert die Benutzererfahrung und Transparenz, indem sie es Servern ermöglicht, Clients über den Status laufender Prozesse zu informieren.

Fehlerbehandlung

Um Ausnahmen und Probleme zu behandeln, die während der Ausführung von Remote-Methoden auftreten, weist die Bibliothek umfangreiche Fehlerbehandlungsfunktionen auf. Dies garantiert die Stabilität und Zuverlässigkeit von verteilten Systemen.

Erweiterungspunkte

StreamJsonRpc kann von Entwicklern erweitert werden, um seine Funktionalität zu ändern oder es mit bereits vorhandenen Anwendungsarchitekturen zu integrieren. Aufgrund seiner Vielseitigkeit kann es an eine Vielzahl von Integrationsanforderungen und Anwendungsszenarien angepasst werden.

Leistungsoptimierung

Durch effektives benutzerdefiniertes Nachrichtenhandling und Transport-Schichten-Management maximiert StreamJsonRpc den Durchsatz in der Client-Server-Kommunikation und gewährleistet dabei geringen Overhead.

Asynchrone Unterstützung

Durch die Nutzung asynchroner Operationen ermöglicht es Anwendungen, verbesserte Reaktionsfähigkeit und Skalierbarkeit zu erzielen. Es unterstützt vollständig asynchrone Kommunikationsmuster.

Interoperabilität

Durch die Einhaltung des JSON-RPC-Standards erleichtert StreamJsonRpc die nahtlose Integration in unterschiedliche Kontexte, indem es die Interoperabilität zwischen C#-Anwendungen und in anderen JSON-unterstützenden Sprachen entwickelten Diensten fördert.

Neben diesen Hauptfunktionen gibt es einige Bonusfunktionen über die JSON-RPC-Spezifikation hinaus, wie Unterstützung für kompakte binäre Serialisierung und dynamische Client-Proxy.

Erstellen einer Dienstklasse

Stellen Sie Methoden in der Serviceklasse PdfService.cs bereit, die PDFs aus den empfangenen Daten erstellen. Als Beispiel:

using IronPdf;
using System.IO;
using System.Threading.Tasks;

public class PdfService
{
    // Asynchronously generates a PDF from HTML content
    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
{
    // Asynchronously generates a PDF from HTML content
    public async Task<byte[]> GeneratePdfAsync(string htmlContent)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        return await pdf.BinaryDataAsync();
    }
}

StreamJsonRpc-Server konfigurieren

Verwenden Sie Program.cs als Interface auf dem Server für StreamJsonRpc, um die GeneratePdfAsync-Methode ü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)
    {
        // Initialize PdfService which generates PDFs
        var service = new PdfService();

        // Create JSON-RPC server listening on websockets
        var jsonRpc = new JsonRpc(new WebSocketRpcServerMessageHandler(new Uri("ws://localhost:8080")));

        // Add the PdfService as an RPC target
        jsonRpc.AddLocalRpcTarget(service);

        // Start listening for incoming JSON-RPC requests
        jsonRpc.StartListening();

        Console.WriteLine("JsonRpc server listening on ws://localhost:8080");
        Console.WriteLine("Press any key to stop the server...");

        // Wait for user input to stop the server
        Console.ReadKey();

        // Gracefully stop listening and dispose resources when done
        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)
    {
        // Initialize PdfService which generates PDFs
        var service = new PdfService();

        // Create JSON-RPC server listening on websockets
        var jsonRpc = new JsonRpc(new WebSocketRpcServerMessageHandler(new Uri("ws://localhost:8080")));

        // Add the PdfService as an RPC target
        jsonRpc.AddLocalRpcTarget(service);

        // Start listening for incoming JSON-RPC requests
        jsonRpc.StartListening();

        Console.WriteLine("JsonRpc server listening on ws://localhost:8080");
        Console.WriteLine("Press any key to stop the server...");

        // Wait for user input to stop the server
        Console.ReadKey();

        // Gracefully stop listening and dispose resources when done
        await jsonRpc.StopListeningAsync();
        jsonRpc.Dispose();
    }
}

IronPDF-Client erstellen

Um eine Verbindung zum Server herzustellen und die Erstellung eines PDFs anzufordern, implementieren Sie den StreamJsonRpc-Client (ClientProgram.cs):

using StreamJsonRpc;
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading.Tasks;
using System.IO;

class ClientProgram
{
    static async Task Main(string[] args)
    {
        // Create JSON-RPC client connected to WebSocket server endpoint
        var proxy = new JsonRpc(new WebSocketRpcClientMessageHandler(new Uri("ws://localhost:8080")));

        // Start listening for incoming messages from the server
        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 resulted PDF to a file
        File.WriteAllBytes("GeneratedPdf.pdf", pdfBytes);

        Console.WriteLine("PDF generated: GeneratedPdf.pdf");

        // Dispose the proxy when done
        proxy.Dispose();
    }
}

using StreamJsonRpc;
using System;
using System.Net.WebSockets;
using System.Text;
using System.Threading.Tasks;
using System.IO;

class ClientProgram
{
    static async Task Main(string[] args)
    {
        // Create JSON-RPC client connected to WebSocket server endpoint
        var proxy = new JsonRpc(new WebSocketRpcClientMessageHandler(new Uri("ws://localhost:8080")));

        // Start listening for incoming messages from the server
        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 resulted PDF to a file
        File.WriteAllBytes("GeneratedPdf.pdf", pdfBytes);

        Console.WriteLine("PDF generated: GeneratedPdf.pdf");

        // Dispose the proxy when done
        proxy.Dispose();
    }
}

Die PdfService.cs-Klasse ist ein fundamentaler Bestandteil einer StreamJsonRpc-Server-Implementierung, die es einer C#-Anwendung erleichtert, PDF-Dokumente mit IronPDF zu generieren. Durch die Nutzung von IronPDF's RenderHtmlAsPdf enthält diese Serviceklasse Methoden zur Handhabung der Umwandlung von HTML-Material in das PDF-Format. HTML-Inhalte werden über die asynchrone (async Task<byte[]> GeneratePdfAsync(string htmlContent)) Methode GeneratePdfAsync als Eingabe akzeptiert.

Diese Methode erstellt eine Instanz von ChromePdfRenderer zur Durchführung der Umwandlung und erzeugt ein PDF-Dokument mit RenderHtmlAsPdf(htmlContent). Die binären Daten des erstellten PDFs werden dann von der Methode asynchron abgerufen (pdf.BinaryDataAsync()), die anschließend die Daten als byte[]-Array zurückgibt.

Diese Methode gewährleistet eine schnelle und reaktionsfähige PDF-Erzeugung, was sie für Anwendungen geeignet macht, die schnell Dokumente erstellen müssen. Die PDF-Erzeugungslogik ist in PdfService.cs enthalten, was es Entwicklern einfach macht, diese Funktionalität über StreamJsonRpc zu integrieren und bereitzustellen. Dies ermöglicht es entfernten Clients, PDF-Erzeugungsaufgaben nahtlos auszuführen und dabei die Modularität und Klarheit ihres serverseitigen Designs zu bewahren.