streamjsonrpc c# (Como funciona para desenvolvedores)

O StreamJsonRpc do C# oferece um conjunto abrangente de funcionalidades, projetado para facilitar e aprimorar a comunicação entre aplicações cliente-servidor baseadas no protocolo JSON-RPC.

Chamadas de Procedimento Remoto (RPC)

Ao tratar as operações remotas como se fossem chamadas de funções locais, o StreamJsonRpc permite que os clientes chamem métodos em um servidor por meio de chamadas de procedimento remoto. Ao disfarçar as complexidades da comunicação em rede, essa abstração facilita a criação de aplicações distribuídas.

Comunicação bidirecional

A biblioteca oferece suporte à comunicação bidirecional cliente-servidor. A comunicação e as atualizações em tempo real são possíveis graças à capacidade dos clientes de enviar solicitações aos servidores, que por sua vez podem responder com notificações ou resultados.

Agnosticismo da camada de transporte

Por ser agnóstico em relação à camada de transporte, o StreamJsonRpc pode funcionar em diversos protocolos de transporte, incluindo HTTP, Named Pipes e TCP/IP. Devido a essa adaptabilidade, os desenvolvedores podem selecionar o melhor método de transporte de acordo com as necessidades de seus aplicativos e as configurações de rede.

Serialização e Desserialização

Ele gerencia a serialização e desserialização de mensagens JSON-RPC, garantindo uma comunicação fluida entre diversas plataformas e linguagens de computador compatíveis com JSON.

Relatórios de progresso

O StreamJsonRpc oferece suporte a técnicas de relatório de progresso para atividades de longa duração. Essa funcionalidade melhora a experiência do usuário e a transparência, permitindo que os servidores atualizem os clientes sobre o status dos processos em andamento.

Tratamento de erros

Para lidar com exceções e problemas que surgem durante a invocação de métodos remotos, a biblioteca possui amplos recursos de tratamento de erros. Isso garante a resiliência e a confiabilidade dos sistemas dispersos.

Pontos de extensão

O StreamJsonRpc pode ser estendido por desenvolvedores para alterar sua funcionalidade ou ser incluído em arquiteturas de aplicativos já existentes. Devido à sua versatilidade, pode ser adaptado para atender a uma variedade de necessidades de integração e cenários de aplicação.

Otimização de desempenho

Por meio do gerenciamento eficaz de mensagens personalizadas e da gestão da camada de transporte, o StreamJsonRpc maximiza a taxa de transferência na comunicação cliente-servidor, garantindo ao mesmo tempo baixa sobrecarga.

Suporte assíncrono

Por meio do uso de operações assíncronas, permite que os aplicativos alcancem maior capacidade de resposta e escalabilidade. Suporta completamente padrões de comunicação assíncrona.

Interoperabilidade

Ao estar em conformidade com o padrão JSON-RPC, o StreamJsonRpc facilita a integração perfeita em diversos contextos, promovendo a interoperabilidade entre aplicativos C# e serviços criados em outras linguagens que suportam JSON.

Além dessas funcionalidades principais, existem alguns recursos adicionais que vão além da especificação JSON-RPC, incluindo funcionalidades como suporte para serialização binária compacta e proxy de cliente dinâmico.

Criar uma classe de serviço

Forneça métodos na classe de serviço PdfService.cs que criarão PDFs a partir dos dados recebidos. A título de exemplo:

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

Configurar o servidor StreamJsonRPC

Use Program.cs como a interface no servidor para StreamJsonRpc para oferecer o método GeneratePdfAsync sobre um fluxo 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

Criar cliente IronPDF

Para conectar-se ao servidor e solicitar a criação de um PDF, implemente o cliente 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

A classe PdfService.cs é uma parte fundamental da implementação de um servidor StreamJsonRpc que facilita a geração de documentos PDF por uma aplicação C# usando o IronPDF. Ao utilizar o RenderHtmlAsPdf do IronPDF, esta classe de serviço contém métodos para lidar com a conversão de material HTML em formato PDF. O conteúdo HTML é aceito como entrada através do método GeneratePdfAsync, que é designado como assíncrono (async Task<byte[]> GeneratePdfAsync(string htmlContent)).

Este método cria uma instância de ChromePdfRenderer para realizar a conversão, produzindo um documento PDF com RenderHtmlAsPdf(htmlContent). Os dados binários do PDF criado são então recuperados de forma assíncrona pelo método (pdf.BinaryDataAsync()), que posteriormente retorna os dados como uma matriz byte[].

Este método garante a geração rápida e eficiente de PDFs, sendo adequado para aplicações que necessitam criar documentos com rapidez. A lógica de geração de PDF está contida em PdfService.cs, o que facilita aos desenvolvedores a integração e a exposição dessa funcionalidade por meio do StreamJsonRpc. Isso permite que clientes remotos invoquem tarefas de geração de PDF sem problemas, preservando a modularidade e a clareza do design do lado do servidor.