RestEase em C# (Como funciona para desenvolvedores)

Funcionalidades do RestEase

Uma biblioteca robusta e adaptável chamada RestEase foi criada para facilitar a interação com APIs RESTful em C#. Aqui estão alguns de seus atributos notáveis:

Definições de API baseadas em interface:

As interfaces são usadas pelo RestEase para definir os endpoints da API. Para tornar o código mais legível e gerenciável, as propriedades de consulta dos métodos dessas interfaces são anotadas com atributos que identificam métodos HTTP, URLs, cabeçalhos e outros dados da requisição. Os métodos na interface correspondem às solicitações feitas nela.

Atributos para métodos HTTP:

Ele fornece atributos diretamente nos cabeçalhos e métodos da interface, como [Get], [Post], [Put], [Delete], e assim por diante, para descrever o tipo de solicitação HTTP que está sendo feita, garantindo que as solicitações apropriadas sejam feitas.

Vinculação de parâmetros:

O controle preciso sobre a construção da requisição é fornecido por meio de atributos como [Path], [Query], [Header] e [Body], que são usados ​​para vincular parâmetros de método a, respectivamente, segmentos de caminho de URL, strings de consulta, cabeçalhos HTTP e corpos de requisição.

Serialização/desserialização JSON automática:

O RestEase agiliza o processamento de dados ao lidar automaticamente com a serialização e desserialização dos corpos de requisição e resposta em JSON.

Suporte assíncrono:

Os protocolos async e await são totalmente compatíveis com a programação assíncrona, permitindo a criação de aplicativos rápidos e responsivos.

Clientes HTTP personalizáveis:

O HttpClient principal do RestEase pode ser personalizado para adicionar manipuladores, alterar tempos limite ou configurar outros parâmetros, oferecendo flexibilidade para atender a necessidades específicas.

Tratamento de erros:

Com todos os recursos do RestEase para gerenciar erros e respostas HTTP, você pode desenvolver uma lógica robusta de tratamento de erros e repetição.

Parâmetros de consulta e caminho:

Possibilitando interações de API extensas e adaptáveis, permite a vinculação complexa de parâmetros de consulta e caminho, incluindo mapas de consulta de coleções e objetos personalizados.

Valores padrão e parâmetros opcionais:

Os parâmetros podem ser opcionais e ter valores padrão especificados, o que simplifica as assinaturas dos métodos e seu uso.

Facilidade de teste:

RestEase facilita os testes unitários e a simulação de requisições HTTP, definindo APIs por meio de interfaces, o que melhora a testabilidade e a manutenção do código.

Cabeçalhos e gerenciamento de tipos de conteúdo:

Para garantir que as solicitações atendam aos critérios necessários, você pode definir e gerenciar facilmente cabeçalhos HTTP, como tipo de conteúdo padrão, cabeçalho e cabeçalhos personalizados.

Suporte à Injeção de Dependência:

Os frameworks de injeção de dependência e o RestEase funcionam bem juntos para permitir uma integração perfeita em aplicações .NET modernas.

Criar e Configurar o RestEase C

Install-Package RestEase

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

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

O que é o IronPDF?

Graças à biblioteca IronPDF do .NET , que oferece diversos recursos, os documentos PDF podem ser criados, lidos e editados por programas em C#. Utilizando este aplicativo, os desenvolvedores podem criar rapidamente PDFs de alta qualidade e prontos para impressão a partir de conteúdo HTML, CSS e JavaScript . Adicionar cabeçalhos e rodapés, dividir e mesclar PDFs, inserir marcas d'água em documentos e converter HTML para PDF são algumas das tarefas mais importantes.

O IronPDF é compatível com o .NET Framework e o .NET Core, o que o torna útil para uma ampla gama de aplicações. Os desenvolvedores podem incluir PDFs em seus produtos com facilidade devido ao seu conteúdo rico e facilidade de uso. O IronPDF consegue lidar com layouts e formatações de dados complexos, de modo que os PDFs que ele produz como saída se assemelham bastante ao texto HTML original do cliente.

O IronPDF se destaca na conversão de HTML para PDF , garantindo a preservação precisa dos layouts e estilos originais. É perfeito para criar PDFs a partir de conteúdo da web, como relatórios, faturas e documentação. Com suporte para arquivos HTML, URLs e strings HTML brutas, o IronPDF produz facilmente documentos PDF de alta qualidade.

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

Funcionalidades do IronPDF

Geração de PDF a partir de HTML

Converter HTML, CSS e JavaScript para PDF. O IronPDF suporta dois padrões modernos da web: media queries e design responsivo. O suporte aos padrões modernos da web é útil para usar HTML e CSS para decorar dinamicamente documentos PDF, relatórios e faturas.

Edição de PDF

É possível adicionar texto, imagens e outros materiais a PDFs já existentes. O IronPDF pode executar diversas tarefas, como extrair texto e imagens de arquivos PDF, mesclar vários PDFs em um único arquivo, dividir arquivos PDF em vários documentos distintos e adicionar cabeçalhos, rodapés, anotações e marcas d'água.

Conversão de PDF

Converta diversos tipos de arquivos, como Word, Excel e imagens, para PDF. O IronPDF permite a conversão de PDF para formatos de imagem (PNG, JPEG, etc.).

Desempenho e confiabilidade

Em contextos industriais, alto desempenho e confiabilidade são atributos de projeto desejáveis. O IronPDF lida facilmente com grandes conjuntos de documentos.

Instale o IronPDF

Instale o pacote IronPDF para obter as ferramentas necessárias para trabalhar com PDFs em projetos .NET .

Install-Package IronPdf

Integre RestEase com IronPDF

Aqui está um exemplo que mostra como usar o RestEase para chamar uma API RESTful e o IronPDF para criar um PDF. Utilizando o RestEase, crie um objeto e uma interface que definam os endpoints da API que você deseja chamar.

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

Para converter os dados recebidos da API em um PDF, use o 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

Utilize o IronPDF para criar o PDF com base na resposta da API e o RestEase para chamar a API a partir do programa principal.

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

Neste exemplo, mostraremos como usar o IronPDF para criar um PDF a partir do conteúdo HTML dos dados que você adquire e o RestEase para chamar uma API RESTful. Primeiro, usamos o RestEase para definir uma interface chamada IApiService, onde especificamos a resposta desejada e o endpoint da API. Uma resposta de API é modelada pela classe ApiResponse. Em seguida, desenvolvemos uma classe PdfGenerator que converte informações HTML em PDF usando o IronPDF. Os seguintes elementos são combinados pelo programa principal, Program.cs.

Para utilizar a API, primeiro é criada uma instância do cliente RestEase. Em seguida, obtém o fluxo de dados de forma assíncrona e utiliza o PdfGenerator para construir e salvar um PDF dependendo dos dados. Este programa demonstra a integração do RestEase para interações com a API e do IronPDF para geração de PDFs em uma aplicação .NET , utilizando a API e os dados de resposta para construir um documento PDF.