streamjsonrpc c# (Comment ça fonctionne pour les développeurs)

Une vaste collection de fonctionnalités est fournie par le StreamJsonRpc de C#, qui est conçu pour faciliter et améliorer la communication des applications client-serveur basées sur le protocole JSON-RPC.

Appels de procédures distantes (RPC)

En considérant les opérations distantes comme s'il s'agissait d'appels de fonctions locales, StreamJsonRpc permet aux clients d'appeler des méthodes sur un serveur via des appels de procédures distantes. En masquant les complexités de la communication réseau, cette abstraction facilite la création d'applications distribuées.

Communication bidirectionnelle

La communication client-serveur bidirectionnelle est prise en charge par la bibliothèque. La communication en temps réel et les mises à jour sont rendues possibles par la capacité des clients à envoyer des demandes aux serveurs, qui peuvent à leur tour répondre avec des notifications ou des résultats.

Agnosticisme de la couche de transport

Parce qu'il est agnostique de la couche de transport, StreamJsonRpc peut fonctionner sur une variété de protocoles de transport, y compris HTTP, les pipes nommés et TCP/IP. Grâce à cette adaptabilité, les développeurs peuvent sélectionner la meilleure méthode de transport en fonction des besoins de leurs applications et des configurations réseau.

Sérialisation et désérialisation

Il gère la sérialisation et la désérialisation des messages JSON-RPC, garantissant une communication fluide sur diverses plateformes et langages informatiques capables de JSON.

Rapport de progression

Des techniques de rapport de progression sont prises en charge par StreamJsonRpc pour les activités de longue durée. Cette fonction améliore l'expérience utilisateur et la transparence en permettant aux serveurs de mettre à jour les clients sur l'état des processus en cours.

Gestion des erreurs

Pour gérer les exceptions et les problèmes qui surgissent pendant l'invocation de méthodes distantes, la bibliothèque dispose de fonctions robustes de gestion des erreurs. Cela garantit la résilience et la fiabilité des systèmes dispersés.

Points d'Extension

StreamJsonRpc peut être étendu par les développeurs pour modifier sa fonctionnalité ou l'inclure dans des architectures d'applications existantes. Grâce à sa polyvalence, il peut être adapté pour répondre à une variété de besoins d'intégration et de scénarios d'application.

Optimisation des performances

Grâce à une gestion efficace des messages personnalisés et de la couche de transport, StreamJsonRpc maximise le débit dans la communication client-serveur tout en garantissant un faible surcoût.

Support asynchrone

Grâce à l'utilisation d'opérations asynchrones, il permet aux applications d'atteindre une meilleure réactivité et évolutivité. Il supporte entièrement les motifs de communication asynchrone.

Interopérabilité

Grâce à la conformité au standard JSON-RPC, StreamJsonRpc facilite l'intégration fluide dans divers contextes en favorisant l'interopérabilité entre les applications C# et les services construits dans d'autres langages qui supportent JSON.

En plus de ces principales caractéristiques, il y a quelques fonctionnalités bonus au-delà de la spécification JSON-RPC, notamment le support pour la sérialisation binaire compacte et le proxy client dynamique.

Créer une classe de service

Fournissez des méthodes dans la classe de service PdfService.cs qui créeront des PDF à partir des données reçues. À titre d'illustration :

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();
    }
}

Imports IronPdf
Imports System.IO
Imports System.Threading.Tasks

Public Class PdfService
	' Asynchronously generates a PDF from HTML content
	Public Async Function GeneratePdfAsync(ByVal htmlContent As String) As Task(Of Byte())
		Dim renderer = New ChromePdfRenderer()
		Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
		Return Await pdf.BinaryDataAsync()
	End Function
End Class

Configurer le serveur StreamJsonRpc

Utilisez Program.cs comme interface sur le serveur pour que StreamJsonRpc propose la méthode GeneratePdfAsync sur un flux JSON-RPC :

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();
    }
}

Imports StreamJsonRpc
Imports System
Imports System.Net.WebSockets
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Initialize PdfService which generates PDFs
		Dim service = New PdfService()

		' Create JSON-RPC server listening on websockets
		Dim jsonRpc As 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()
	End Function
End Class

Créer un client IronPDF

Pour se connecter au serveur et demander la création d'un PDF, implémentez le client StreamJsonRpc (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();
    }
}

Imports StreamJsonRpc
Imports System
Imports System.Net.WebSockets
Imports System.Text
Imports System.Threading.Tasks
Imports System.IO

Friend Class ClientProgram
	Shared Async Function Main(ByVal args() As String) As Task
		' Create JSON-RPC client connected to WebSocket server endpoint
		Dim proxy = New JsonRpc(New WebSocketRpcClientMessageHandler(New Uri("ws://localhost:8080")))

		' Start listening for incoming messages from the server
		Await proxy.StartListeningAsync()

		' Example HTML content
		Dim htmlContent As String = "<html><body><h1>Hello, IronPDF!</h1></body></html>"

		' Invoke GeneratePdfAsync method on the server
		Dim pdfBytes = Await proxy.InvokeAsync(Of 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()
	End Function
End Class

La classe PdfService.cs est un élément fondamental d'une implémentation de serveur StreamJsonRpc qui facilite la génération de documents PDF par une application C# à l'aide IronPDF. En using IronPDF's RenderHtmlAsPdf, cette classe de service contient des méthodes pour gérer la conversion de contenu HTML au format PDF. Le contenu HTML est accepté comme entrée via la méthode GeneratePdfAsync, qui est désignée comme asynchrone (async Task<byte[]> GeneratePdfAsync(string htmlContent)).

Cette méthode crée une instance de ChromePdfRenderer pour effectuer la conversion, produisant un document PDF avec RenderHtmlAsPdf(htmlContent). Les données binaires du PDF créé sont ensuite récupérées de manière asynchrone par la méthode (pdf.BinaryDataAsync()), qui renvoie ensuite les données sous forme de tableau byte[].

Cette méthode garantit une génération de PDF rapide et réactive, la rendant adaptée aux applications nécessitant de créer des documents rapidement. La logique de génération de PDF est contenue dans PdfService.cs, ce qui simplifie l'intégration et l'exposition de cette fonctionnalité par les développeurs via StreamJsonRpc. Cela permet aux clients distants d'invoquer de manière fluide des travaux de génération de PDF tout en préservant la modularité et la clarté de leur conception côté serveur.