streamjsonrpc c# (Jak to dziala dla programistow)

Kompleksowy zestaw funkcjonalności jest oferowany przez StreamJsonRpc w C#, który ma ułatwić i usprawnić komunikację aplikacyjną opartą na protokole JSON-RPC.

Zdalne Wywołania Procedur (RPC)

Traktując operacje zdalne tak, jakby były lokalnymi wywołaniami funkcji, StreamJsonRpc umożliwia klientom wywoływanie metod na serwerze za pomocą zdalnych wywołań procedur. Ukrywając złożoności komunikacji sieciowej, to uproszczenie ułatwia tworzenie aplikacji rozproszonych.

Dwukierunkowa Komunikacja

Biblioteka wspiera komunikację dwukierunkową klient-serwer. Komunikacja w czasie rzeczywistym i aktualizacje są możliwe dzięki zdolności klientów do przesyłania żądań do serwerów, które z kolei mogą odpowiadać powiadomieniami lub wynikami.

Agnostycyzm Warstwy Transportowej

Ponieważ jest niezależna od warstwy transportowej, StreamJsonRpc może działać przez wiele protokołów transportowych, w tym HTTP, nazwane potoki i TCP/IP. Dzięki tej elastyczności, deweloperzy mogą wybrać najlepszą metodę transportu w zależności od potrzeb swoich aplikacji i ustawień sieciowych.

Serializacja i Deserializacja

Zarządza serializacją i deserializacją wiadomości JSON-RPC, gwarantując płynną komunikację na różnych platformach i w językach komputerowych zdolnych do obsługi JSON.

Raportowanie Postępu

Techniki raportowania postępu są wspierane przez StreamJsonRpc dla długo trwających czynności. Ta funkcja poprawia doświadczenie użytkownika i przejrzystość, umożliwiając serwerom aktualizowanie klientów na temat stanu bieżących procesów.

Obsługa Błędów

Aby obsługiwać wyjątki i problemy powstające podczas wywoływania zdalnych metod, biblioteka posiada rozbudowane funkcje obsługi błędów. Zapewnia to odporność i niezawodność systemów rozproszonych.

Punkty Rozszerzeń

StreamJsonRpc można rozszerzać przez deweloperów w celu zmiany jego funkcjonalności lub integracji z już istniejącymi architekturami aplikacyjnymi. Dzięki swojej wszechstronności, można go dostosować do różnych potrzeb integracyjnych i scenariuszy aplikacyjnych.

Optymalizacja Wydajności

Poprzez efektywne przetwarzanie komunikatów niestandardowych i zarządzanie warstwą transportową, StreamJsonRpc maksymalizuje przepustowość w komunikacji klient-serwer, jednocześnie gwarantując niskie obciążenie.

Obsługa Asynchroniczna

Dzięki wykorzystaniu operacji asynchronicznych umożliwia aplikacjom osiąganie lepszej responsywności i skalowalności. Kompletnie wspiera asynchroniczne wzorce komunikacyjne.

Interoperacyjność

Poprzez zgodność ze standardem JSON-RPC, StreamJsonRpc ułatwia płynną integrację w różnorodnych kontekstach, pielęgnując interoperacyjność między aplikacjami C# a usługami zbudowanymi w innych językach, które obsługują JSON.

Obok tych głównych funkcji, są pewne dodatkowe funkcje poza specyfikacją JSON-RPC, które obejmują wsparcie dla kompaktowej binarnej serializacji i dynamicznego klienta proxy.

Stwórz Klasę Serwisu

Dostarcz metody w klasie serwisu PdfService.cs, które będą tworzyć PDF na podstawie otrzymanych danych. Jako ilustracja:

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

Konfiguruj Serwer StreamJsonRpc

Użyj Program.cs jako interfejsu na serwerze dla StreamJsonRpc, aby oferować metodę GeneratePdfAsync nad strumieniem 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

Stwórz Klienta IronPDF

Aby połączyć się z serwerem i zażądać stworzenia PDF, zaimplementuj klienta 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

Klasa PdfService.cs jest fundamentalną częścią implementacji serwera StreamJsonRpc, co ułatwia aplikacji C# generowanie dokumentów PDF za pomocą IronPDF. Wykorzystując RenderHtmlAsPdf z IronPDF, ta klasa usługi zawiera metody do obsługi konwersji treści HTML do formatu PDF. Treści HTML przyjmowane są jako dane wejściowe przez metodę GeneratePdfAsync, która jest oznaczona jako asynchroniczna (async Task<byte[]> GeneratePdfAsync(string htmlContent)).

Ta metoda tworzy instancję ChromePdfRenderer w celu przeprowadzenia konwersji, tworząc dokument PDF z RenderHtmlAsPdf(htmlContent). Generowane binarne dane PDF są następnie pobierane asynchronicznie przez metodę (pdf.BinaryDataAsync()), która następnie zwraca dane jako tablicę byte[].

Ta metoda zapewnia szybkie i responsywne generowanie PDF, czyniąc je odpowiednim dla aplikacji, które muszą szybko tworzyć dokumenty. Logika generowania PDF jest zawarta w PdfService.cs, co ułatwia deweloperom integrację i udostępnienie tej funkcjonalności przez StreamJsonRpc. To pozwala odległym klientom płynnie inicjować zadania generowania PDF, jednocześnie zachowując modułowość i przejrzystość ich projektu po stronie serwera.