streamjsonrpc c# (How It Works For Developers)

A comprehensive collection of functionality is provided by C#'s StreamJsonRpc, which is intended to facilitate and improve JSON-RPC protocol-based client-server application communication.

Remote Procedure Calls (RPC)

By considering remote operations as though they were local function calls, StreamJsonRpc enables clients to call methods on a server via remote procedure calls. By disguising the intricacies of network communication, this abstraction makes the creation of distributed applications easier.

Bidirectional Communication

Bidirectional client-server communication is supported by the library. Real-time communication and updates are made possible by the ability for clients to submit requests to servers, which in turn can reply with notifications or results.

Transport Layer Agnosticism

Because it is transport layer agnostic, StreamJsonRpc can function over a variety of transport protocols, including HTTP, Named Pipes, and TCP/IP. Because of this adaptability, developers can select the best transport method according to the needs of their applications and the network settings.

Serialization and Deserialization

It manages JSON-RPC message serialization and deserialization, guaranteeing smooth communication across various platforms and JSON-capable computer languages.

Progress Reporting

Progress reporting techniques are supported by StreamJsonRpc for long-running activities. This feature improves user experience and transparency by enabling servers to update clients on the status of current processes.

Error Handling

To handle exceptions and problems that arise during the invocation of remote methods, the library has extensive error-handling features. This guarantees dispersed systems' resilience and dependability.

Extension Points

StreamJsonRpc can be extended by developers to alter its functionality or include it with already existing application architectures. Because of its versatility, it may be tailored to meet a variety of integration needs and application scenarios.

Performance Optimization

Through effective custom message handling and transport layer management, StreamJsonRpc maximizes throughput in client-server communication while guaranteeing low overhead.

Asynchronous Support

Through the use of asynchronous operations, it enables applications to achieve improved responsiveness and scalability. It completely supports asynchronous communication patterns.

Interoperability

Through conformance to the JSON-RPC standard, StreamJsonRpc facilitates smooth integration in diverse contexts by fostering interoperability between C# applications and services built in other languages that support JSON.

Along with these main features, there are some bonus features past the JSON-RPC spec which include features such as support for compact binary serialization and dynamic client proxy.

Create a Service Class

Provide methods in the service class PdfService.cs that will create PDFs from the data that is received. As an 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();
    }
}

Configure StreamJsonRpc Server

Use Program.cs as the interface on the server for StreamJsonRpc to offer the GeneratePdfAsync method over a 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();
    }
}

Create IronPDF Client

To connect to the server and request the creation of a PDF, implement the 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();
    }
}

The PdfService.cs class is a fundamental part of a StreamJsonRpc server implementation that makes it easier for a C# application to generate PDF documents using IronPDF. By utilizing IronPDF's RenderHtmlAsPdf, this service class contains methods for handling the conversion of HTML material into PDF format. HTML content is accepted as input via the GeneratePdfAsync method, which is designated as asynchronous (async Task<byte[]> GeneratePdfAsync(string htmlContent)).

This method creates an instance of ChromePdfRenderer to carry out the conversion, producing a PDF document with RenderHtmlAsPdf(htmlContent). The created PDF's binary data is then retrieved asynchronously by the method (pdf.BinaryDataAsync()), which subsequently returns the data as a byte[] array.

This method guarantees quick and responsive PDF generation, making it appropriate for applications that need to create documents quickly. The PDF generation logic is contained in PdfService.cs, which makes it simple for developers to integrate and expose this functionality over StreamJsonRpc. This allows distant clients to smoothly invoke PDF generation jobs while preserving the modularity and clarity of their server-side design.