Usando el protocolo JSON-RPC, StreamJsonRpc en C# permite una comunicación efectiva entre clientes y servidores a través de varios niveles de transporte. Con la ayuda de esta biblioteca, las llamadas a procedimientos remotos se pueden implementar más fácilmente, lo que permite a los desarrolladores crear sistemas distribuidos confiables en los que los programas pueden llamar a métodos en servidores distantes tal como lo harían localmente. Al permitir la creación dinámica de PDF basados en datos transferidos a través de solicitudes JSON-RPC, StreamJsonRpc mejora las capacidades de la aplicación cuando se utiliza con IronPDF, un completo marco .NET para la generación y manipulación de PDF. Para los desarrolladores que buscan optimizar el proceso de creación de informes personalizados, facturas o cualquier aplicación centrada en documentos que necesite generar PDFs bajo demanda, esta interfaz es bastante útil.

IronPDF ofrece a los desarrolladores flexibilidad y eficiencia al organizar y entregar contenido al admitir la conversión de HTML, ASPX y datos en bruto en publicaciones PDF de alta calidad. StreamJsonRpc e IronPDF trabajan juntos para permitir que los desarrolladores de C# construyan aplicaciones receptivas y escalables que combinan fácilmente complejos PDFs con llamadas a procedimientos remotos.

¿Qué es StreamJsonRpc?

StreamJsonRpc es una biblioteca multiplataforma diseñada para facilitar las llamadas a procedimientos remotos (RPC) utilizando un protocolo de cableado ligero y eficiente. Utiliza un mecanismo de transporte subyacente que admite varios canales de comunicación como TCP/IP, pipes con nombre y HTTP. La biblioteca aprovecha los eventos .NET para manejar solicitudes y respuestas entrantes, proporcionando un mecanismo robusto para la comunicación asincrónica. Los desarrolladores pueden adjuntar implementaciones de métodos para manejar solicitudes RPC y definir comportamientos personalizados utilizando la API de StreamJsonRpc. StreamJsonRpc está disponible como una biblioteca portátil .NET, asegurando compatibilidad entre diferentes plataformas y permitiendo una integración sin problemas en diversas aplicaciones .NET.

Un fuerte soporte para la comunicación bidireccional, incluidas notificaciones e informes de progreso, es una de las características clave de StreamJsonRpc. Al admitir varios protocolos de transporte, incluidos HTTP, Pipes con Nombre y TCP/IP, ofrece a los programas más opciones de comunicación. La serialización y deserialización de mensajes JSON-RPC son manejadas por StreamJsonRpc, garantizando la compatibilidad entre muchas plataformas e idiomas informáticos que soportan JSON.

StreamJsonRpc fue diseñado teniendo en cuenta el rendimiento y la extensibilidad. Es compatible con los programas C# existentes y puede usarse para construir aplicaciones cliente-servidor, arquitecturas de microservicios, sistemas distribuidos y otras aplicaciones donde la comunicación confiable y eficiente es crucial. Al integrar llamadas a procedimientos remotos en proyectos C#, los desarrolladores tienden a elegirla debido a su confiabilidad y facilidad de uso.

Características de StreamJsonRpc

Una colección completa de funcionalidades es proporcionada por StreamJsonRpc de C#, que está diseñada para facilitar y mejorar la comunicación de aplicaciones cliente-servidor basadas en el protocolo JSON-RPC.

Llamadas a procedimientos remotos (RPC)

Al considerar operaciones remotas como si fueran llamadas a funciones locales, StreamJsonRpc permite a los clientes llamar a métodos en un servidor a través de llamadas a procedimientos remotos. Al disfrazar las complejidades de la comunicación de red, esta abstracción hace más fácil la creación de aplicaciones distribuidas.

Comunicación bidireccional

La comunicación cliente-servidor bidireccional es compatible con la biblioteca. La comunicación en tiempo real y las actualizaciones son posibles gracias a la capacidad de los clientes para enviar solicitudes a los servidores, que a su vez pueden responder con notificaciones o resultados.

Agnóstico de la capa de transporte

Debido a que es neutral en cuanto a la capa de transporte, StreamJsonRpc puede funcionar sobre una variedad de protocolos de transporte, incluidos HTTP, Pipes con Nombre y TCP/IP. Debido a esta adaptabilidad, los desarrolladores pueden seleccionar el mejor método de transporte de acuerdo con las necesidades de sus aplicaciones y los entornos de red.

Serialización y deserialización

Gestiona la serialización y deserialización de mensajes JSON-RPC, garantizando una comunicación fluida en diversas plataformas y lenguajes de computación capaces de usar JSON.

Informe de progreso

StreamJsonRpc admite técnicas de reporte de progreso para actividades de larga duración. Esta característica mejora la experiencia del usuario y la transparencia al permitir que los servidores actualicen a los clientes sobre el estado de los procesos actuales.

Manejo de errores

La biblioteca tiene amplias características de manejo de errores para abordar excepciones y problemas que surgen durante la invocación de métodos remotos. Esto garantiza la resiliencia y confiabilidad de los sistemas dispersos.

Puntos de ampliación

StreamJsonRpc puede ser extendido por desarrolladores para alterar su funcionalidad o incluirlo en arquitecturas de aplicación ya existentes. Debido a su versatilidad, puede adaptarse para cumplir con una variedad de necesidades de integración y escenarios de aplicación.

Optimización del rendimiento

A través del manejo efectivo de mensajes personalizados y la gestión de la capa de transporte, StreamJsonRpc maximiza el rendimiento en la comunicación cliente-servidor mientras garantiza un bajo overhead.

Soporte asíncrono

A través del uso de operaciones asincrónicas, permite a las aplicaciones lograr mayor capacidad de respuesta y escalabilidad. Admite completamente los patrones de comunicación asincrónica.

Interoperabilidad

A través de la conformidad con el estándar JSON-RPC, StreamJsonRpc facilita una integración sin problemas en diversos contextos al fomentar la interoperabilidad entre aplicaciones y servicios C# construidos en otros lenguajes que soportan JSON.

Junto con estas características principales, hay algunas características adicionales más allá de la especificación JSON-RPC que incluyen soporte para serialización binaria compacta y proxy dinámico del cliente.

Create and Config StreamJsonRpc C#

Un cliente y un servidor deben configurarse para crear y configurar StreamJsonRpc en una aplicación C#. Las instrucciones detalladas para cada parte se proporcionan a continuación:

Configure su proyecto

Primero, asegúrese de que su proyecto .NET está listo. Puede crear uno nuevo con Visual Studio o la CLI de .NET.

dotnet new console -n StreamjsonrpcExample
cd StreamjsonrpcExample

dotnet new console -n StreamjsonrpcExample
cd StreamjsonrpcExample

Instalar el paquete StreamJsonRpc

Para implementar la comunicación JSON-RPC, instale el paquete StreamJsonRpc desde NuGet. Contiene las bibliotecas necesarias.

dotnet add package StreamJsonRpc

dotnet add package StreamJsonRpc

Implementar el servidor JSON-RPC

Cree una clase que actuará como el servidor para JSON-RPC. Observe este sencillo ejemplo:

using Microsoft.AspNetCore.Hosting;
using StreamJsonRpc;
using System;
using System.Threading.Tasks;

public class MyService
{
    // Asynchronous method to add two integers
    public Task<int> AddAsync(int a, int b)
    {
        return Task.FromResult(a + b);
    }

    // Asynchronous method to greet a user
    public Task<string> GreetAsync(string name)
    {
        return Task.FromResult($"Hello, {name}!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Initialize the service offering RPC methods
        var service = new MyService();

        // Create a StreamJsonRpc server listening on websockets
        var jsonRpc = new JsonRpc(new ServerWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
        
        // Add service as 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();
        
        // Dispose resources when done
        jsonRpc.Dispose();
    }
}

using Microsoft.AspNetCore.Hosting;
using StreamJsonRpc;
using System;
using System.Threading.Tasks;

public class MyService
{
    // Asynchronous method to add two integers
    public Task<int> AddAsync(int a, int b)
    {
        return Task.FromResult(a + b);
    }

    // Asynchronous method to greet a user
    public Task<string> GreetAsync(string name)
    {
        return Task.FromResult($"Hello, {name}!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Initialize the service offering RPC methods
        var service = new MyService();

        // Create a StreamJsonRpc server listening on websockets
        var jsonRpc = new JsonRpc(new ServerWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
        
        // Add service as 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();
        
        // Dispose resources when done
        jsonRpc.Dispose();
    }
}

Imports Microsoft.AspNetCore.Hosting
Imports StreamJsonRpc
Imports System
Imports System.Threading.Tasks

Public Class MyService
    ' Asynchronous method to add two integers
    Public Function AddAsync(a As Integer, b As Integer) As Task(Of Integer)
        Return Task.FromResult(a + b)
    End Function

    ' Asynchronous method to greet a user
    Public Function GreetAsync(name As String) As Task(Of String)
        Return Task.FromResult($"Hello, {name}!")
    End Function
End Class

Module Program
    Sub Main(args As String())
        ' Initialize the service offering RPC methods
        Dim service = New MyService()
        
        ' Create a StreamJsonRpc server listening on websockets
        Dim jsonRpc = New JsonRpc(New ServerWebSocketJsonRpcMessageHandler("ws://localhost:8080"))
        
        ' Add service as 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()
        
        ' Dispose resources when done
        jsonRpc.Dispose()
    End Sub
End Module

Imports Microsoft.AspNetCore.Hosting
Imports StreamJsonRpc
Imports System
Imports System.Threading.Tasks

Public Class MyService
    ' Asynchronous method to add two integers
    Public Function AddAsync(a As Integer, b As Integer) As Task(Of Integer)
        Return Task.FromResult(a + b)
    End Function

    ' Asynchronous method to greet a user
    Public Function GreetAsync(name As String) As Task(Of String)
        Return Task.FromResult($"Hello, {name}!")
    End Function
End Class

Module Program
    Sub Main(args As String())
        ' Initialize the service offering RPC methods
        Dim service = New MyService()
        
        ' Create a StreamJsonRpc server listening on websockets
        Dim jsonRpc = New JsonRpc(New ServerWebSocketJsonRpcMessageHandler("ws://localhost:8080"))
        
        ' Add service as 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()
        
        ' Dispose resources when done
        jsonRpc.Dispose()
    End Sub
End Module

Clase MyService: Especifica los métodos que el cliente puede llamar remotamente, como AddAsync y GreetAsync.

Esto inicia una nueva instancia de JsonRpc, inicializa MyService, y configura un manejador de mensajes WebSocket para escuchar en ws://localhost:8080. El servidor expone MyService como un nuevo objetivo RPC local y comienza a esperar que lleguen consultas JSON-RPC. Presiona una tecla para dejar de escuchar y descartar recursos.

Configuración del cliente

Cree una clase que funcionará como el cliente para JSON-RPC. Observe este sencillo ejemplo:

using StreamJsonRpc;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Create a JSON-RPC client connected to the WebSocket server endpoint
        var proxy = new JsonRpc(new ClientWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
        
        // Start listening for incoming messages from the server
        await proxy.StartListeningAsync();
        
        // Invoke the AddAsync method on the server
        var resultAdd = await proxy.InvokeAsync<int>("AddAsync", 10, 20);
        Console.WriteLine($"AddAsync result: {resultAdd}");
        
        // Invoke the GreetAsync method on the server
        var resultGreet = await proxy.InvokeAsync<string>("GreetAsync", "John");
        Console.WriteLine($"GreetAsync result: {resultGreet}");
        
        // Dispose the proxy when done
        proxy.Dispose();
    }
}

using StreamJsonRpc;
using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Create a JSON-RPC client connected to the WebSocket server endpoint
        var proxy = new JsonRpc(new ClientWebSocketJsonRpcMessageHandler("ws://localhost:8080"));
        
        // Start listening for incoming messages from the server
        await proxy.StartListeningAsync();
        
        // Invoke the AddAsync method on the server
        var resultAdd = await proxy.InvokeAsync<int>("AddAsync", 10, 20);
        Console.WriteLine($"AddAsync result: {resultAdd}");
        
        // Invoke the GreetAsync method on the server
        var resultGreet = await proxy.InvokeAsync<string>("GreetAsync", "John");
        Console.WriteLine($"GreetAsync result: {resultGreet}");
        
        // Dispose the proxy when done
        proxy.Dispose();
    }
}

Imports StreamJsonRpc
Imports System
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        ' Create a JSON-RPC client connected to the WebSocket server endpoint
        Dim proxy = New JsonRpc(New ClientWebSocketJsonRpcMessageHandler("ws://localhost:8080"))
        
        ' Start listening for incoming messages from the server
        Await proxy.StartListeningAsync()
        
        ' Invoke the AddAsync method on the server
        Dim resultAdd = Await proxy.InvokeAsync(Of Integer)("AddAsync", 10, 20)
        Console.WriteLine($"AddAsync result: {resultAdd}")
        
        ' Invoke the GreetAsync method on the server
        Dim resultGreet = Await proxy.InvokeAsync(Of String)("GreetAsync", "John")
        Console.WriteLine($"GreetAsync result: {resultGreet}")
        
        ' Dispose the proxy when done
        proxy.Dispose()
    End Function
End Module

Imports StreamJsonRpc
Imports System
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        ' Create a JSON-RPC client connected to the WebSocket server endpoint
        Dim proxy = New JsonRpc(New ClientWebSocketJsonRpcMessageHandler("ws://localhost:8080"))
        
        ' Start listening for incoming messages from the server
        Await proxy.StartListeningAsync()
        
        ' Invoke the AddAsync method on the server
        Dim resultAdd = Await proxy.InvokeAsync(Of Integer)("AddAsync", 10, 20)
        Console.WriteLine($"AddAsync result: {resultAdd}")
        
        ' Invoke the GreetAsync method on the server
        Dim resultGreet = Await proxy.InvokeAsync(Of String)("GreetAsync", "John")
        Console.WriteLine($"GreetAsync result: {resultGreet}")
        
        ' Dispose the proxy when done
        proxy.Dispose()
    End Function
End Module

Este ejemplo establece una conexión a ws://localhost:8080 para iniciar una instancia de JsonRpc con un manejador de mensajes WebSocket. Luego habilita los métodos AddAsync y GreetAsync que están definidos en el servidor (MyService) estableciendo una conexión con el servidor JSON-RPC. Finalmente, muestra los resultados que ha devuelto el servidor y libera los recursos después de que las llamadas RPC se han completado.

Empezando

Las páginas PDF pueden generarse dinámicamente en aplicaciones C# integrando StreamJsonRpc con IronPDF y usando los datos intercambiados a través de consultas JSON-RPC. Esta es una guía básica para configurar IronPDF y StreamJsonRpc:

¿Qué es IronPDF?

IronPDF puede ser usado por programas C# para crear, leer y editar documentos PDF. Esta herramienta facilita a los desarrolladores convertir información de HTML, CSS y JavaScript en PDF de alta calidad listos para imprimir. Entre las tareas cruciales están agregar encabezados y pies de página, dividir y fusionar PDFs, añadir marcas de agua a documentos y convertir HTML a PDF. IronPDF es útil para una variedad de aplicaciones porque soporta tanto .NET Framework como .NET Core.

Debido a que los PDFs son fáciles de usar y ofrecen una multitud de contenido, los desarrolladores pueden integrarlos fácilmente en sus productos. Debido a que IronPDF puede manejar con facilidad diseños complejos y formateo, los PDFs de salida que genera coinciden casi con el texto HTML original.

Características de IronPDF

Generación de PDF desde HTML

Convierte JavaScript, HTML y CSS a PDF. IronPDF soporta consultas de medios y diseño responsivo, dos estándares web contemporáneos. Es una herramienta útil para adornar dinámicamente documentos PDF, informes y facturas utilizando HTML y CSS.

Edición de PDF

A los PDFs preexistentes se les pueden agregar textos, fotos y otros contenidos. Extraiga texto e imágenes de archivos PDF. Los desarrolladores pueden combinar numerosos PDFs en un solo archivo, o dividir archivos PDF en múltiples documentos separados. Incluya marcas de agua, anotaciones, encabezados y pies de página.

Conversión de PDF

Es posible convertir una variedad de formatos de archivo, incluidos archivos Word, Excel y de imagen, a PDF utilizando IronPDF. Con él, también puede llevar a cabo la conversión de PDF a imagen (PNG, JPEG, etc.).

Rendimiento y Fiabilidad

Se desean características de diseño de alto rendimiento y fiabilidad en los entornos industriales. IronPDF maneja conjuntos de documentos grandes con facilidad.

Instalar IronPDF

Para obtener las herramientas que necesitas para trabajar con PDFs en proyectos .NET, instala el paquete IronPDF.

dotnet add package IronPdf

dotnet add package IronPdf

StreamJsonRpc con IronPDF

Crear una clase de servicio

Proporcione métodos en la clase de servicio PdfService.cs que creará PDFs a partir de los datos que se reciben. Como ilustración:

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

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 el servidor StreamJsonRpc

Utilice Program.cs como la interfaz en el servidor para que StreamJsonRpc ofrezca el método GeneratePdfAsync sobre un stream 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

Module Program
    Async Function Main(args As String()) As Task
        ' Initialize PdfService which generates PDFs
        Dim service As 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 Module

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

Module Program
    Async Function Main(args As String()) As Task
        ' Initialize PdfService which generates PDFs
        Dim service As 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 Module

Crear cliente IronPDF

Para conectarse al servidor y solicitar la creación de un PDF, implemente el 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

Module ClientProgram
    Async Function Main(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 As Byte() = 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 Module

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

Module ClientProgram
    Async Function Main(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 As Byte() = 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 Module

La clase PdfService.cs es una parte fundamental de una implementación de servidor StreamJsonRpc que facilita a una aplicación C# generar documentos PDF usando IronPDF. Utilizando RenderHtmlAsPdf de IronPDF, esta clase de servicio contiene métodos para manejar la conversión de material HTML a formato PDF. El contenido HTML se acepta como entrada a través del método GeneratePdfAsync, que está designado como asincrónico (async Task<byte[]> GeneratePdfAsync(string htmlContent)).

Este método crea una instancia de ChromePdfRenderer para llevar a cabo la conversión, produciendo un documento PDF con RenderHtmlAsPdf(htmlContent). Los datos binarios del PDF creado se recuperan luego de manera asincrónica por el método (pdf.BinaryDataAsync()), que posteriormente devuelve los datos como un arreglo byte[].

Este método garantiza una rápida y receptiva generación de PDF, lo que lo hace apropiado para aplicaciones que necesitan crear documentos rápidamente. La lógica de generación de PDF se encuentra en PdfService.cs, lo que facilita a los desarrolladores integrar y exponer esta funcionalidad a través de StreamJsonRpc. Esto permite a los clientes distantes invocar labores de generación de PDF de manera fluida, mientras preserva la modularidad y claridad de su diseño del lado del servidor.

Conclusión

En resumen, los desarrolladores pueden crear aplicaciones .NET confiables y efectivas que soportan llamadas a procedimientos remotos (RPC) y utilizan fuertes capacidades de producción de PDF al combinar StreamJsonRpc con IronPDF. Usando JSON-RPC, un protocolo ligero para llamadas a procedimientos remotos, StreamJsonRpc permite una comunicación fluida entre componentes de cliente y servidor. Los desarrolladores pueden usar esto junto con IronPDF para generar PDFs dinámicos, impulsados por datos, que dependen de los resultados de estas llamadas remotas.

Al preparar informes, facturas o cualquier otro documento que deba representar los datos más recientes disponibles, esta integración es muy útil ya que permite la recuperación de datos en tiempo real y la salida de PDF. La integración de estas tecnologías optimiza el proceso de desarrollo, aumenta el rendimiento y fortalece la capacidad de la aplicación para satisfacer eficazmente las necesidades empresariales complejas.

Con IronPDF y las Herramientas de Desarrollo de Iron Software, los desarrolladores pueden crear más aplicaciones web y funciones más rápidamente, todo por un precio inicial de $999. Lo logra fusionando sus conceptos centrales con la caja de herramientas de Iron Software, inmensamente flexible.

A los desarrolladores les será más fácil seleccionar el modelo óptimo si todas las opciones de licencia relevantes para el proyecto se describen claramente. Los beneficios enumerados anteriormente facilitan que los desarrolladores creen soluciones para una variedad de problemas de manera oportuna, coordinada y eficiente.