streamjsonrpc c# (Jak to dziala dla programistow)

Kompletny zestaw funkcji jest dostarczany przez StreamJsonRpc w C#, ktore ma na celu ulatwic i ulepszyc komunikacje aplikacji klient-serwer oparta na protokole JSON-RPC.

Zdalne Wywolania Procedur (RPC)

Uznajac zdalne operacje jakby byly wywolaniami funkcji lokalnych, StreamJsonRpc umożliwia klientom wywolywanie metod na serwerze za pomoca zdalnych wywolan procedur. Maskujac zlozonosc komunikacji sieciowej, ta abstrakcja ułatwia tworzenie aplikacji rozproszonych.

Komunikacja dwukierunkowa

Dwukierunkowa komunikacja klient-serwer jest wspierana przez biblioteke. Komunikacja w czasie rzeczywistym i aktualizacje sa możliwe dzięki temu, ze klienci mogą wysylac zadania do serwerow, ktore z kolei mogą odpowiadać powiadomieniami lub wynikami.

Niezwiazalnosc Warstwy Transportowej

Poniewaz jest niezależna od warstwy transportowej, StreamJsonRpc może działać na różnych protokolach transportowych, takich jak HTTP, nazwane potoki i TCP/IP. Ta elastycznosc pozwala deweloperom wybrac najlepsza metode transportu zgodnie z potrzebami aplikacji i ustawieniami sieciowymi.

Serializacja i Deserializacja

Zarzadza serializacja i deserializacja wiadomosci JSON-RPC, zapewniając plynna komunikacje w różnych platformach i językach komputerowych obslugujacych JSON.

Raportowanie Postepow

Techniki raportowania postepow sa wspierane przez StreamJsonRpc dla dlugo trwajacych aktywnosci. Ta funkcja poprawia doswiadczenie użytkownika i przejrzystosc, pozwalając serwerom aktualizowac klientow o statusie biezacych procesów.

Obsługa błędów

Do obsługi wyjątków i problemów, które pojawiają się podczas wywołania zdalnych metod, biblioteka posiada rozbudowane funkcje obsługi błędów. To zapewnia odpornosc i niezawodność systemów rozproszonych.

Punkty Rozszerzenia

StreamJsonRpc może być rozszerzany przez deweloperow, aby zmieniac jego funkcjonalność lub integrowac go z istniejącymi architekturami aplikacji. Dzięki tej wszechstronnosci może być dostosowany do różnych potrzeb i scenariuszy integracji aplikacji.

Optymalizacja wydajności

Poprzez efektywna obsługę wiadomosci niestandardowych i zarządzanie warstwa transportowa, StreamJsonRpc maksymalizuje przepustowosc w komunikacji klient-serwer, zapewniając niskie obciazenie.

Wsparcie dla Asynchronizacji

Poprzez użycie operacji asynchronicznych, umożliwia aplikacjom osiagniecie lepszej responsywnośći i skalowalnosci. Calkowicie wspiera wzorce komunikacji asynchronicznej.

Interoperacyjnosc

Dzięki zgodności z standardem JSON-RPC, StreamJsonRpc ułatwia plynna integracje w różnych kontekstach poprzez wspieranie interoperacyjnosci miedzy aplikacjami C# a usługami zbudowanymi w innych językach, ktore wspierają JSON.

Oprocz tych głównych funkcji, istnieja dodatkowe funkcje poza specyfikacja JSON-RPC, ktore obejmuja takie funkcje, jak wsparcie dla kompaktowej binarnej serializacji i dynamicznego proxy klienta.

Tworzenie Klasy Serwisu

Dostarcz metody w klasie usługi PdfService.cs, które będą tworzyć pliki PDF z otrzymanych danych. Przykładowo:

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

Konfiguracja Serwera 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

Utworzenie Klienta IronPDF

Aby połączyć się z serwerem i zażądać utworzenia 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 podstawowym elementem implementacji serwera StreamJsonRpc, który ułatwia aplikacji C# generowanie dokumentów PDF za pomocą IronPDF. Wykorzystując RenderHtmlAsPdf z IronPDF, ta klasa usług zawiera metody do przetwarzania konwersji materiału HTML na format PDF. Zawartość HTML jest akceptowana jako wejście za pomocą metody GeneratePdfAsync, która jest oznaczona jako asynchroniczna (async Task<byte[]> GeneratePdfAsync(string htmlContent)).

Ta metoda tworzy instancję ChromePdfRenderer w celu przeprowadzenia konwersji, produkując dokument PDF za pomocą RenderHtmlAsPdf(htmlContent). Binarny dane utworzonego PDF są następnie asynchronicznie pobierane przez metodę (pdf.BinaryDataAsync()), która następnie zwraca dane jako tablica byte[].

Ta metoda zapewnia szybkie i responsywne generowanie PDF, co czyni ja odpowiednia dla aplikacji, ktore musza szybko tworzyć dokumenty. Logika generowania PDF jest zawarta w PdfService.cs, co ułatwia programistom integrację i udostępnianie tej funkcjonalności przez StreamJsonRpc. Dzięki temu odlegli klienci mogą plynnie wywoływać zadania generowania PDF, zachowujac modularnosc i przejrzystosc swojego projektu po stronie serwera.