Efektywna komunikacja między klientami a RESTful API jest kluczowa przy tworzeniu współczesnych aplikacji webowych. Lekki pakiet C# o nazwie RestEase ułatwia to zadanie, oferując prostą metodę definiowania interfejsu do współpracy z REST API. Abstrahując zawiłości komunikacji HTTP, umożliwia programistom koncentrację na logice aplikacji. RestEase może być używany w połączeniu z IronPDF, potężną biblioteką do tworzenia i modyfikowania dokumentów PDF, aby pobierać dane z API i generować dynamiczne dokumenty PDF na podstawie tych danych.

Aplikacje, które muszą tworzyć raporty, faktury lub inne dokumenty opierające się na danych w czasie rzeczywistym z usług online, uznają tę integrację za szczególnie przydatną. Ten tutorial przeprowadzi cię przez proces konfigurowania i używania RestEase z IronPDF w aplikacji C#. Pokaże ci, jak te narzędzia mogą poprawić funkcjonalność i wydajność twoich aplikacji, upraszczając procesy pobierania danych i generowania PDF przez API.

Czym jest RestEase C#?

Lekka, przyjazna dla użytkownika biblioteka o nazwie RestEase sprawia, że tworzenie i dostęp do RESTful API w C# jest proste, bez dodawania niepotrzebnej złożoności. Poprzez określanie interfejsów odpowiadających punktom końcowym API, oferuje prostą i naturalną metodę interakcji z usługami online. Programiści mogą znacznie zredukować kod szablonowy i uczynić bazę kodu bardziej przejrzystą i łatwiejszą do zarządzania, opisując żądania HTTP za pomocą atrybutów na metodach i parametrach w RestEase.

RestEase upraszcza integrację bibliotek klienckich REST API, oferując prostą metodę interakcji z zdalnymi punktami końcowymi REST. Używa generowania kodu w czasie rzeczywistym do tworzenia pełnomocników klienta, ułatwiając definiowanie właściwości ścieżki i określanie domyślnej metody serializacji do płynnej wymiany danych z API. To sprawia, że dostęp oraz konsumpcja zdalnych punktów końcowych REST jest łatwa i efektywna w aplikacjach .NET. Umożliwia kodowanie URL do zapytań REST API.

Główna korzyść z RestEase polega na tym, że abstrahuje on zbędną złożoność wysyłania żądań HTTP. Poprzez użycie atrybutów, RestEase pozwala programistom określić nagłówki, parametry zapytania, treść ciała, metody HTTP i URL żądań, unikając komplikacji związanych z komunikacją HTTP. Ta metoda poprawia zarówno produktywność, jak i czytelność.

Dzięki wsparciu zarówno dla operacji synchronicznych, jak i asynchronicznych, RestEase może być używany w różnych kontekstach. Ponadto, z łatwością integruje się w nowoczesne aplikacje .NET dzięki dobrej kompatybilności z frameworkami do wstrzykiwania zależności. Ponadto, dzięki bogatemu systemowi atrybutów RestEase i elastyczności, można go dostosować do różnych wzorców projektowych API i wymagań. Ponieważ zbudowany jest na bazie HttpClient, programistom łatwo jest uzyskać dostęp do pełni możliwości HttpClient.

W istocie, RestEase dostarcza stabilne i intuicyjne ramy, które czynią pracę z RESTful API w C# łatwiejszą, poprawiają jakość kodu i przyspieszają wdrażanie komunikacji opartej na HTTP w aplikacjach .NET. Działa również na platformach, które nie obsługują generowania kodu w czasie rzeczywistym, takich jak .NET Native.

Funkcje RestEase

Potężna i elastyczna biblioteka o nazwie RestEase została stworzona, aby ułatwić interakcję z RESTful API w C#. Oto kilka jej godnych uwagi cech:

Definicje API oparte na interfejsie:

RestEase używa interfejsów do definiowania punktów końcowych API. Aby uczynić kod bardziej czytelnym i zarządzalnym, metody tych interfejsów są opatrzone atrybutami, które identyfikują metody HTTP, URL, nagłówki i inne dane żądania. Metody na tym interfejsie odpowiadają żądaniom składanym do niego.

Atrybuty dla metod HTTP:

Zapewnia atrybuty bezpośrednio na nagłówkach i metodach interfejsu, takie jak [Get], [Post], [Put], [Delete], itd., aby opisać rodzaj wykonywanego żądania HTTP, zapewniając, że odpowiednie żądania są wykonywane.

Łączenie parametrów:

Szczegółową kontrolę nad budowaniem żądania zapewniają atrybuty takie jak [Path], [Query], [Header] i [Body], które są używane do powiązania parametrów metody z odpowiednimi segmentami ścieżki URL, ciągami zapytań, nagłówkami HTTP i ciałami żądań.

Automatyczna serializacja/deserializacja JSON:

RestEase upraszcza przetwarzanie danych, automatycznie obsługując serializację i deserializację ciał żądań i odpowiedzi do JSON.

Wsparcie dla programowania asynchronicznego:

Async i await są w pełni wspierane do programowania asynchronicznego, co pozwala na tworzenie szybkich i responsywnych aplikacji.

Dostosowywalne klienty HTTP:

Rdzeń HttpClient RestEase może być dostosowany poprzez dodanie obsługi, zmianę limitów czasu lub ustawienie innych parametrów, zapewniając elastyczność zaspokajania konkretnych potrzeb.

Obsługa błędów:

Możesz rozwinąć silną obsługę błędów i logikę ponawiania prób dzięki pełnym możliwościom RestEase do zarządzania błędami HTTP i odpowiedziami.

Parametry zapytań i ścieżki:

Umożliwiając rozległe i elastyczne interakcje z API, pozwala na zaawansowane mapowanie parametrów zapytań i ścieżki, w tym mapowanie kolekcji zapytań i niestandardowych obiektów.

Domyślne wartości i opcjonalne parametry:

Parametry mogą być opcjonalne i mieć określone domyślne wartości, co upraszcza sygnatury metod i ich użycie.

Łatwość testowania:

RestEase ułatwia testowanie jednostkowe i symulowanie żądań HTTP, definiując API przez interfejsy, co poprawia testowalność i utrzymywalność kodu.

Zarządzanie nagłówkami i typami treści:

Aby mieć pewność, że żądania spełniają wymagane kryteria, możesz bezproblemowo ustawiać i zarządzać nagłówkami HTTP, takimi jak domyślny typ treści, nagłówki i nagłówki niestandardowe.

Wsparcie dla wstrzykiwania zależności:

Frameworki do wstrzykiwania zależności i RestEase dobrze ze sobą współpracują, umożliwiając płynną integrację we współczesnych aplikacjach .NET.

Create and Configure RestEase C#

W projekcie C# wykonaj następujące czynności, aby stworzyć i skonfigurować RestEase:

Utwórz nową konsolę

Otwórz Visual Studio i stwórz nową aplikację Konsolową (aplikacja .NET Core).

Nadaj nazwę i skonfiguruj projekt według własnych preferencji.

Zainstaluj RestEase

Zainstaluj go za pomocą Konsoli Menedżera Pakietów:

Install-Package RestEase

Zdefiniuj interfejs API

Dodaj nowy interfejs do projektu (np. IApiService.cs). Użyj właściwości RestEase do zdefiniowania metod odpowiadających punktom końcowym API.

using RestEase;
using System.Threading.Tasks;

// Define the API interface with RestEase attributes
public interface IApiService
{
    [Get("users/{id}")]
    Task<User> GetUserAsync([Path] int id);

    [Post("users")]
    Task<User> CreateUserAsync([Body] User user);

    [Put("users/{id}")]
    Task UpdateUserAsync([Path] int id, [Body] User user);

    [Delete("users/{id}")]
    Task DeleteUserAsync([Path] int id);
}

// Define the User class that models the data being worked with
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

using RestEase;
using System.Threading.Tasks;

// Define the API interface with RestEase attributes
public interface IApiService
{
    [Get("users/{id}")]
    Task<User> GetUserAsync([Path] int id);

    [Post("users")]
    Task<User> CreateUserAsync([Body] User user);

    [Put("users/{id}")]
    Task UpdateUserAsync([Path] int id, [Body] User user);

    [Delete("users/{id}")]
    Task DeleteUserAsync([Path] int id);
}

// Define the User class that models the data being worked with
public class User
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
}

Imports RestEase
Imports System.Threading.Tasks

' Define the API interface with RestEase attributes
Public Interface IApiService
	<[Get]("users/{id}")>
	Function GetUserAsync(<Path> ByVal id As Integer) As Task(Of User)

	<Post("users")>
	Function CreateUserAsync(<Body> ByVal user As User) As Task(Of User)

	<Put("users/{id}")>
	Function UpdateUserAsync(<Path> ByVal id As Integer, <Body> ByVal user As User) As Task

	<Delete("users/{id}")>
	Function DeleteUserAsync(<Path> ByVal id As Integer) As Task
End Interface

' Define the User class that models the data being worked with
Public Class User
	Public Property Id() As Integer
	Public Property Name() As String
	Public Property Email() As String
End Class

Imports RestEase
Imports System.Threading.Tasks

' Define the API interface with RestEase attributes
Public Interface IApiService
	<[Get]("users/{id}")>
	Function GetUserAsync(<Path> ByVal id As Integer) As Task(Of User)

	<Post("users")>
	Function CreateUserAsync(<Body> ByVal user As User) As Task(Of User)

	<Put("users/{id}")>
	Function UpdateUserAsync(<Path> ByVal id As Integer, <Body> ByVal user As User) As Task

	<Delete("users/{id}")>
	Function DeleteUserAsync(<Path> ByVal id As Integer) As Task
End Interface

' Define the User class that models the data being worked with
Public Class User
	Public Property Id() As Integer
	Public Property Name() As String
	Public Property Email() As String
End Class

Konfiguracja klienta RestEase

Użyj interfejsu, aby utworzyć instancję klienta RestEase w swoim głównym programie lub klasie usług.

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Create a RestEase client instance
        var apiService = RestClient.For<IApiService>("https://api.example.com");

        // Example usage: Get a user by ID
        var user = await apiService.GetUserAsync(1);
        Console.WriteLine($"User: {user.Name}, Email: {user.Email}");

        // Example usage: Create a new user
        var newUser = new User { Name = "John Doe", Email = "john.doe@example.com" };
        var createdUser = await apiService.CreateUserAsync(newUser);
        Console.WriteLine($"Created User: {createdUser.Name}, Email: {createdUser.Email}");
    }
}

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Create a RestEase client instance
        var apiService = RestClient.For<IApiService>("https://api.example.com");

        // Example usage: Get a user by ID
        var user = await apiService.GetUserAsync(1);
        Console.WriteLine($"User: {user.Name}, Email: {user.Email}");

        // Example usage: Create a new user
        var newUser = new User { Name = "John Doe", Email = "john.doe@example.com" };
        var createdUser = await apiService.CreateUserAsync(newUser);
        Console.WriteLine($"Created User: {createdUser.Name}, Email: {createdUser.Email}");
    }
}

Imports System
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Create a RestEase client instance
		Dim apiService = RestClient.For(Of IApiService)("https://api.example.com")

		' Example usage: Get a user by ID
		Dim user = Await apiService.GetUserAsync(1)
		Console.WriteLine($"User: {user.Name}, Email: {user.Email}")

		' Example usage: Create a new user
		Dim newUser = New User With {
			.Name = "John Doe",
			.Email = "john.doe@example.com"
		}
		Dim createdUser = Await apiService.CreateUserAsync(newUser)
		Console.WriteLine($"Created User: {createdUser.Name}, Email: {createdUser.Email}")
	End Function
End Class

Imports System
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Create a RestEase client instance
		Dim apiService = RestClient.For(Of IApiService)("https://api.example.com")

		' Example usage: Get a user by ID
		Dim user = Await apiService.GetUserAsync(1)
		Console.WriteLine($"User: {user.Name}, Email: {user.Email}")

		' Example usage: Create a new user
		Dim newUser = New User With {
			.Name = "John Doe",
			.Email = "john.doe@example.com"
		}
		Dim createdUser = Await apiService.CreateUserAsync(newUser)
		Console.WriteLine($"Created User: {createdUser.Name}, Email: {createdUser.Email}")
	End Function
End Class

Każda metoda interfejsu odnosi się do punktu końcowego API i jest oznaczona atrybutami RestEase, takimi jak [Path], [Query], [Header] i [Body], aby powiązać parametry metody z segmentami ścieżki URL, ciągami zapytań, nagłówkami i ciałami żądań. Inne atrybuty RestEase obejmują [Get], [Post], [Put] i [Delete] w celu określenia metody HTTP.

Na przykład możesz zainicjować żądanie GET, aby pobrać szczegóły użytkownika według ID, oznaczając metodę interfejsu atrybutami [Get("users/{id}")] i [Path]. Używając RestClient, tworzysz instancję klienta, aby reprezentować (baseUri), gdzie baseUri to bazowy URL API, a T to typ interfejsu. Metody API określone w interfejsie mogą być następnie wywoływane przy użyciu tej instancji klienta, a RestEase zajmuje się komunikacją HTTP, serializacją/deserializacją JSON i obsługą błędów. Dzięki tej abstrakcji programiści mogą skupić się na logice aplikacji, a nie na HTTP, czyniąc kod prostszym, łatwiejszym do zrozumienia i utrzymania.

Pierwsze kroki

Aby użyć RestEase i IronPDF, należy najpierw utworzyć projekt .NET, w którym można użyć IronPDF do tworzenia plików PDF, a RestEase do wywoływania RESTful API. Oto krok po kroku instrukcja, która pomoże ci w tym procesie:

Czym jest IronPDF?

Dokumenty PDF mogą być tworzone, czytane i edytowane przez programy C# dzięki bogatej w funkcje bibliotece .NET IronPDF. Programiści mogą szybko tworzyć gotowe do druku, wysokiej jakości pliki PDF z treści HTML, CSS i JavaScript za pomocą tej aplikacji. Dodawanie nagłówków i stopek, dzielenie i scałanie plików PDF, znakowanie dokumentów, konwersja HTML do PDF to jedne z najważniejszych zadań.

IronPDF obsługuje zarówno .NET Framework, jak i .NET Core, dzięki czemu jest przydatny w szerokim zakresie zastosowań. Programiści mogą z łatwością integrować PDF z ich produktami dzięki bogatej zawartości i łatwości użycia. IronPDF może obsługiwać skomplikowane układy danych i formatowanie, dzięki czemu pliki PDF wychodzące są bliskie oryginalnemu tekstowi HTML klienta.

IronPDF wyróżnia się w konwersji HTML do PDF, zapewniając precyzyjne zachowanie oryginalnych układów i stylów. Idealnie nadaje się do tworzenia plików PDF z treści internetowych, takich jak raporty, faktury i dokumentacja. Dzięki obsłudze plików HTML, adresów URL i surowych ciągów znaków HTML, IronPDF z łatwością tworzy wysokiej jakości dokumenty PDF.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

Funkcje IronPDF

Generowanie plików PDF z HTML

Konwertuj HTML, CSS i JavaScript do formatu PDF. IronPDF obsługuje dwa nowoczesne standardy internetowe: zapytania o media i projekt responsywny. Wsparcie dla nowoczesnych standardów webowych jest przydatne do dynamicznego ozdabiania dokumentów, raportów i rachunków PDF przy użyciu HTML i CSS.

Edycja plików PDF

Możliwe jest dodawanie tekstu, obrazów i innych materiałów do już istniejących plików PDF. IronPDF może wykonywać wiele różnych zadań, takich jak wyodrębnianie tekstu i obrazów z plików PDF, łączenie wielu plików PDF w jeden, dzielenie plików PDF na kilka odrębnych dokumentów i dodawanie nagłówków, stopek, adnotacji i znaków wodnych.

Konwersja plików PDF

Konwertuj różne typy plików, takie jak WORD, Excel i pliki graficzne, do formatu PDF. IronPDF wspiera konwersję PDF na format obrazu (PNG, JPEG, itp.).

Wydajność i niezawodność

W kontekście przemysłowym pożądanymi cechami projektowymi są wysoka wydajność i niezawodność. IronPDF z łatwością obsługuje duże zbiory dokumentów.

Zainstaluj IronPDF

Zainstaluj pakiet IronPDF, aby uzyskać narzędzia potrzebne do pracy z plikami PDF w projektach .NET.

Install-Package IronPdf

Integracja RestEase z IronPDF

Oto przykład pokazujący, jak użyć RestEase do wywołania RESTful API i IronPDF do tworzenia pliku PDF. Za pomocą RestEase stwórz obiekt i interfejs definiujący punkty końcowe API, które chcesz wywołać.

using RestEase;
using System.Threading.Tasks;

// Define the API interface for RestEase
public interface IApiService
{
    [Get("api/data")]
    Task<ApiResponse> GetDataAsync();
}

// Class for holding API response
public class ApiResponse
{
    public string Data { get; set; }
}

using RestEase;
using System.Threading.Tasks;

// Define the API interface for RestEase
public interface IApiService
{
    [Get("api/data")]
    Task<ApiResponse> GetDataAsync();
}

// Class for holding API response
public class ApiResponse
{
    public string Data { get; set; }
}

Imports RestEase
Imports System.Threading.Tasks

' Define the API interface for RestEase
Public Interface IApiService
	<[Get]("api/data")>
	Function GetDataAsync() As Task(Of ApiResponse)
End Interface

' Class for holding API response
Public Class ApiResponse
	Public Property Data() As String
End Class

Imports RestEase
Imports System.Threading.Tasks

' Define the API interface for RestEase
Public Interface IApiService
	<[Get]("api/data")>
	Function GetDataAsync() As Task(Of ApiResponse)
End Interface

' Class for holding API response
Public Class ApiResponse
	Public Property Data() As String
End Class

Aby przekształcić dane otrzymane z API na PDF, użyj IronPDF.

using IronPdf;
using System;
using System.IO;

// Class for generating PDFs
public class PdfGenerator
{
    // Method to generate a PDF from a string content
    public void GeneratePdf(string content)
    {
        var htmlContent = $"<html><body><h1>{content}</h1></body></html>";
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF to the current directory as 'example.pdf'
        var pdfPath = Path.Combine(Directory.GetCurrentDirectory(), "example.pdf");
        pdfDocument.SaveAs(pdfPath);
        Console.WriteLine($"PDF generated and saved to {pdfPath}");
    }
}

using IronPdf;
using System;
using System.IO;

// Class for generating PDFs
public class PdfGenerator
{
    // Method to generate a PDF from a string content
    public void GeneratePdf(string content)
    {
        var htmlContent = $"<html><body><h1>{content}</h1></body></html>";
        var renderer = new ChromePdfRenderer();
        var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF to the current directory as 'example.pdf'
        var pdfPath = Path.Combine(Directory.GetCurrentDirectory(), "example.pdf");
        pdfDocument.SaveAs(pdfPath);
        Console.WriteLine($"PDF generated and saved to {pdfPath}");
    }
}

Imports IronPdf
Imports System
Imports System.IO

' Class for generating PDFs
Public Class PdfGenerator
	' Method to generate a PDF from a string content
	Public Sub GeneratePdf(ByVal content As String)
		Dim htmlContent = $"<html><body><h1>{content}</h1></body></html>"
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

		' Save the PDF to the current directory as 'example.pdf'
		Dim pdfPath = Path.Combine(Directory.GetCurrentDirectory(), "example.pdf")
		pdfDocument.SaveAs(pdfPath)
		Console.WriteLine($"PDF generated and saved to {pdfPath}")
	End Sub
End Class

Imports IronPdf
Imports System
Imports System.IO

' Class for generating PDFs
Public Class PdfGenerator
	' Method to generate a PDF from a string content
	Public Sub GeneratePdf(ByVal content As String)
		Dim htmlContent = $"<html><body><h1>{content}</h1></body></html>"
		Dim renderer = New ChromePdfRenderer()
		Dim pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)

		' Save the PDF to the current directory as 'example.pdf'
		Dim pdfPath = Path.Combine(Directory.GetCurrentDirectory(), "example.pdf")
		pdfDocument.SaveAs(pdfPath)
		Console.WriteLine($"PDF generated and saved to {pdfPath}")
	End Sub
End Class

Użyj IronPDF, aby stworzyć PDF na podstawie odpowiedzi API i RestEase, aby wywołać API z głównego programu.

using System;
using RestEase;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Create RestEase API client
        var apiService = RestClient.For<IApiService>("https://your-api-endpoint.com");
        var pdfGenerator = new PdfGenerator();

        try
        {
            // Get data from API
            var response = await apiService.GetDataAsync();
            // Generate PDF from the data
            pdfGenerator.GeneratePdf(response.Data);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

using System;
using RestEase;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Create RestEase API client
        var apiService = RestClient.For<IApiService>("https://your-api-endpoint.com");
        var pdfGenerator = new PdfGenerator();

        try
        {
            // Get data from API
            var response = await apiService.GetDataAsync();
            // Generate PDF from the data
            pdfGenerator.GeneratePdf(response.Data);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

Imports System
Imports RestEase
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Create RestEase API client
		Dim apiService = RestClient.For(Of IApiService)("https://your-api-endpoint.com")
		Dim pdfGenerator As New PdfGenerator()

		Try
			' Get data from API
			Dim response = Await apiService.GetDataAsync()
			' Generate PDF from the data
			pdfGenerator.GeneratePdf(response.Data)
		Catch ex As Exception
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Function
End Class

Imports System
Imports RestEase
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Create RestEase API client
		Dim apiService = RestClient.For(Of IApiService)("https://your-api-endpoint.com")
		Dim pdfGenerator As New PdfGenerator()

		Try
			' Get data from API
			Dim response = Await apiService.GetDataAsync()
			' Generate PDF from the data
			pdfGenerator.GeneratePdf(response.Data)
		Catch ex As Exception
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Function
End Class

W tym przykładzie pokazaliśmy, jak użyć IronPDF do tworzenia PDF z zawartości HTML z danych, które pozyskujesz, i RestEase do wywołania RESTful API. Najpierw używamy RestEase do zdefiniowania interfejsu o nazwie IApiService, gdzie określamy pożądaną odpowiedź i punkt końcowy API. Odpowiedź API jest modelowana przez klasę ApiResponse. Następnie rozwijamy klasę PdfGenerator, która konwertuje informację HTML do PDF używając IronPDF. Następujące elementy są łączone przez główny program, Program.cs.

Aby skorzystać z API, najpierw tworzy instancję klienta RestEase. Następnie asynchronicznie uzyskuje strumień danych i wykorzystuje PdfGenerator do budowania i zapisywania PDF na podstawie danych. Ten program demonstruje integrację RestEase do interakcji z API i IronPDF do produkcji PDF w aplikacji .NET, poprzez użycie API i danych odpowiedzi do zbudowania dokumentu PDF.

Wnioski

Niezawodnym sposobem łączenia konsumpcji RESTful API z zaawansowanymi możliwościami produkcji PDF jest integracja RestEase z IronPDF w aplikacji .NET Core. Oferując płynny i typowy interfejs żądania HTTP, RestEase ułatwia integrację API i pozwala programistom bez trudu komunikować się z zewnętrznymi serwisami. Ta funkcjonalność jest niezbędna do pozyskiwania dynamicznych danych, które IronPDF potrzebuje, aby tworzyć dokumenty PDF.

Z kolei IronPDF daje programistom możliwość łatwego generowania skomplikowanych raportów, faktur i innych dokumentów, umożliwiając im tworzenie i modyfikację PDF bezpośrednio z tekstu HTML. Programiści mogą ulepszyć swoje procesy automatyzacji dokumentów i usprawnić przepływy pracy, używając RestEase do pobierania danych z API i IronPDF do przekształcania tych danych w profesjonalnej jakości dokumenty PDF.

Możesz korzystać z OCR, skanowania kodów kreskowych, produkcji PDF, łączności z Excel i wielu innych dzięki bibliotekom produktów Iron Software, które pozwalają programistom wypróbować ich szeroki zakres funkcji na własną rękę przed zakupem licencji.

Jeśli opcje licencji dla projektu są dobrze określone, programiści nie będą mieli trudności z wyborem najlepszego modelu. Wspomniane powyżej korzyści ułatwiają terminowe, metodyczne i efektywne wdrażanie rozwiązań przez programistów dla różnych problemów.