RestSharp é uma biblioteca .NET de código aberto popular para fazer requisições HTTP em C#. Simplifica o processo de trabalho com APIs RESTful, proporcionando uma forma direta e flexível de comunicação com serviços web. Neste artigo, exploraremos os recursos essenciais do RestSharp e do IronPDF e demonstraremos como você pode extrair dados e gerar um PDF.
Em aplicações modernas de múltiplas camadas, diferentes serviços precisam se comunicar entre si com muita frequência, e o RestSharp oferece uma maneira simples e eficiente de fazer isso, encapsulando todas as complexidades. Isso simplifica muito o processo de desenvolvimento de software.
O RestSharp está disponível como um pacote NuGet e pode ser instalado em seu projeto C#. Você pode fazer isso usando o Console do Gerenciador de Pacotes NuGet ou a interface do usuário do Gerenciador de Pacotes NuGet do Visual Studio .
Vamos começar com um exemplo simples de como fazer uma requisição GET para uma API RESTful usando o RestSharp. Suponha que queremos recuperar informações de uma API pública do ASP.NET Core que retorna dados do usuário:
using RestSharp;
namespace rest_sharp_demo
{
class Program
{
static void Main()
{
// Base URL for the REST API
var baseUrl = "https://jsonplaceholder.typicode.com/users";
// Create a RestClientOptions with default credentials
var options = new RestClientOptions(baseUrl) { UseDefaultCredentials = true };
var client = new RestClient(options);
// Create a RestRequest for the GET method
var request = new RestRequest();
// Execute the request and get the response
var response = client.Get(request);
// Check if the request was successful
if (response.IsSuccessful)
{
// Output the response body content
Console.WriteLine(response.Content);
}
else
{
// Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}");
}
}
// Additional method to log data
public void LogData(string msg)
{
Console.WriteLine(msg);
}
}
}Imports RestSharp
Namespace rest_sharp_demo
Class Program
Shared Sub Main()
' Base URL for the REST API
Dim baseUrl = "https://jsonplaceholder.typicode.com/users"
' Create a RestClientOptions with default credentials
Dim options = New RestClientOptions(baseUrl) With {
.UseDefaultCredentials = True
}
Dim client = New RestClient(options)
' Create a RestRequest for the GET method
Dim request = New RestRequest()
' Execute the request and get the response
Dim response = client.Get(request)
' Check if the request was successful
If response.IsSuccessful Then
' Output the response body content
Console.WriteLine(response.Content)
Else
' Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}")
End If
End Sub
' Additional method to log data
Public Sub LogData(msg As String)
Console.WriteLine(msg)
End Sub
End Class
End NamespaceO RestSharp também oferece suporte a solicitações e respostas assíncronas usando os métodos de API assíncronos.
O RestSharp oferece métodos convenientes para desserializar o conteúdo da resposta em objetos C#. Vamos expandir nosso exemplo para desserializar os dados de resposta JSON em uma lista de objetos de usuário:
// Deserialize JSON response into a list of User objects
var users = JsonSerializer.Deserialize<List<User>>(response.Content);
// Output user information
foreach (var user in users)
{
Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}, Email: {user.Email}");
}' Deserialize JSON response into a list of User objects
Dim users = JsonSerializer.Deserialize(Of List(Of User))(response.Content)
' Output user information
For Each user In users
Console.WriteLine($"User ID: {user.Id}, Name: {user.Name}, Email: {user.Email}")
Next userNeste exemplo, definimos uma classe User com propriedades correspondentes aos campos JSON. Usamos JsonSerializer.Deserialize do namespace System.Text.Json.
public class User
{
[JsonPropertyName("company")]
public Company Company { get; set; }
[JsonPropertyName("id")]
public int Id { get; set; }
[JsonPropertyName("phone")]
public string Phone { get; set; }
[JsonPropertyName("website")]
public string Website { get; set; }
[JsonPropertyName("name")]
public string Name { get; set; }
[JsonPropertyName("username")]
public string Username { get; set; }
[JsonPropertyName("email")]
public string Email { get; set; }
[JsonPropertyName("address")]
public Address Address { get; set; }
}Public Class User
<JsonPropertyName("company")>
Public Property Company As Company
<JsonPropertyName("id")>
Public Property Id As Integer
<JsonPropertyName("phone")>
Public Property Phone As String
<JsonPropertyName("website")>
Public Property Website As String
<JsonPropertyName("name")>
Public Property Name As String
<JsonPropertyName("username")>
Public Property Username As String
<JsonPropertyName("email")>
Public Property Email As String
<JsonPropertyName("address")>
Public Property Address As Address
End ClassTodos os IDs e nomes de usuário são exibidos na saída.
Todo o código está disponível no Git neste link .
O RestSharp suporta o envio de solicitações com corpo em XML ou JSON. Os métodos AddJsonBody ou AddXmlBody da instância RestRequest podem ser usados para adicionar corpo JSON ou XML. O RestSharp definirá o tipo de conteúdo automaticamente. Ele processa respostas JSON ou XML automaticamente.
// Serialize the user object to JSON
var jsonBodyString = JsonSerializer.Serialize(newUser);
// Create a RestRequest for the POST method with the JSON request data
var requestData = new RestRequest().AddJsonBody(jsonBodyString);
var response = client.ExecutePost(requestData);' Serialize the user object to JSON
Dim jsonBodyString = JsonSerializer.Serialize(newUser)
' Create a RestRequest for the POST method with the JSON request data
Dim requestData = (New RestRequest()).AddJsonBody(jsonBodyString)
Dim response = client.ExecutePost(requestData)O RestSharp também oferece suporte ao envio de dados no corpo da solicitação, o que é comum ao criar ou atualizar recursos. Vamos modificar nosso exemplo para demonstrar uma API de requisição POST:
using RestSharp;
using System.Text.Json;
namespace rest_sharp_demo
{
class Program
{
static void Main()
{
var client = new RestClient("https://jsonplaceholder.typicode.com/users");
// New user object
var newUser = new User
{
Name = "John Doe",
Email = "john.doe@example.com"
};
// Serialize the user object to JSON
var jsonBody = JsonSerializer.Serialize(newUser);
// Create a RestRequest for the POST method with the JSON request body
var request = new RestRequest().AddJsonBody(jsonBody);
// Execute the POST request
var response = client.ExecutePost(request);
// Check if the request was successful
if (response.IsSuccessful)
{
// Output the response content
Console.WriteLine(response.Content);
}
else
{
Console.WriteLine($"Error: {response.ErrorMessage}");
}
}
}
}Imports RestSharp
Imports System.Text.Json
Namespace rest_sharp_demo
Class Program
Shared Sub Main()
Dim client = New RestClient("https://jsonplaceholder.typicode.com/users")
' New user object
Dim newUser = New User With {
.Name = "John Doe",
.Email = "john.doe@example.com"
}
' Serialize the user object to JSON
Dim jsonBody = JsonSerializer.Serialize(newUser)
' Create a RestRequest for the POST method with the JSON request body
Dim request = New RestRequest().AddJsonBody(jsonBody)
' Execute the POST request
Dim response = client.ExecutePost(request)
' Check if the request was successful
If response.IsSuccessful Then
' Output the response content
Console.WriteLine(response.Content)
Else
Console.WriteLine($"Error: {response.ErrorMessage}")
End If
End Sub
End Class
End NamespaceNeste exemplo, criamos um novo objeto User, serializamos para JSON e o incluímos no corpo da solicitação usando o método AddJsonBody. O servidor recebe os dados JSON e processa a solicitação de acordo.
O RestSharp também oferece suporte ao envio de solicitações com autenticação. O RestClientOptions pode incluir parâmetros de autenticação.
var options = new RestClientOptions("https://auth.net")
{
Authenticator = new HttpBasicAuthenticator(_clientId, _clientSecret)
};Dim options = New RestClientOptions("https://auth.net") With {.Authenticator = New HttpBasicAuthenticator(_clientId, _clientSecret)}Aqui estamos usando a autenticação básica com o segredo do ID do cliente, que é enviado em cada solicitação.
O RestSharp consegue lidar com erros que ocorrem durante as requisições de URL, como erros de tempo limite, autenticação ou autorização. O RestSharp não lança uma exceção se a solicitação falhar automaticamente. É necessário configurá-lo manualmente.
As seguintes configurações de tratamento de erros podem ser feitas:
ResponseStatus para Error de acordo.var restClientOptions = new RestClientOptions(url)
{
ThrowOnAnyError = true
};
var client = new RestClient(restClientOptions);Dim restClientOptions As New RestClientOptions(url) With {.ThrowOnAnyError = True}
Dim client = New RestClient(restClientOptions)IronPDF é uma biblioteca C# para PDF da Iron Software que auxilia na leitura e geração de documentos PDF. Ele consegue converter facilmente documentos formatados com informações de estilo para PDF. O IronPDF pode gerar PDFs facilmente a partir de conteúdo HTML; Ele pode baixar o HTML de um URL e, em seguida, gerar PDFs.
Uma das principais funcionalidades do IronPDF é a conversão de HTML para PDF , preservando todos os seus layouts e estilos. Ele converte conteúdo da web em PDFs, sendo ideal para relatórios, faturas e documentação. Arquivos HTML, URLs e strings HTML podem ser facilmente convertidos em PDFs.
using IronPdf;
class Program
{
static void Main(string[] args)
{
// Create a PDF renderer using Chrome
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)
' Create a PDF renderer using Chrome
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 ClassPara integrar o IronPDF ao seu projeto Selenium RestSharp usando o gerenciador de pacotes NuGet , siga estas etapas:
Se você deseja incluir o IronPDF em seu projeto por meio do Console do Gerenciador de Pacotes, execute o seguinte comando no Console do Gerenciador de Pacotes:
Ele irá buscar e instalar o IronPDF no seu projeto.
Para obter uma visão geral detalhada do IronPDF, incluindo seus recursos, compatibilidade e opções adicionais de download, visite a página do IronPDF no site do NuGet emhttps://www.nuget.org/packages/IronPdf .
Alternativamente, você pode incorporar o IronPDF diretamente em seu projeto usando o arquivo DLL. Baixe o arquivo ZIP contendo a DLL na página de downloads do IronPDF . Descompacte o arquivo e inclua a DLL no seu projeto.
Agora vamos obter todos os usuários e gerar um relatório em PDF usando uma string HTML e o gerador IronPDF .
using System.Text.Json;
using System.Text.Json.Serialization;
using RestSharp;
using IronPdf;
namespace rest_sharp_demo
{
class Program
{
static void Main()
{
// Create a RestClient
var baseUrl = "https://jsonplaceholder.typicode.com/users";
RestClientOptions options = new RestClientOptions(baseUrl) { UseDefaultCredentials = true };
var client = new RestClient(options);
// Create a RestRequest for the GET method
var request = new RestRequest();
// Execute the request and get the response
var response = client.Get(request);
// Check if the request was successful
if (response.IsSuccessful)
{
// Deserialize JSON response into a list of User objects
var users = JsonSerializer.Deserialize<List<User>>(response.Content);
// Generate PDF
var html = GetHtml(users);
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("UsersReport.pdf");
}
else
{
// Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}");
}
}
// Method to generate HTML from user data
private static string GetHtml(List<User>? users)
{
string header = @"
<html>
<head><title>Users List</title></head>
<body>
";
var footer = @"
</body>
</html>";
var htmlContent = header;
foreach (var user in users)
{
htmlContent += $@"
<h1>{user.Name}</h1>
<p>Username: {user.Username}</p>
<p>Email: {user.Email}</p>
<p>Company: {user.Company}</p>
<p>Phone: {user.Phone}</p>
<p>Website: {user.Website}</p>
<p>Suite: {user.Address.Suite}</p>
<p>Street: {user.Address.Street}</p>
<p>City: {user.Address.City}</p>
<p>Zipcode: {user.Address.Zipcode}</p>
";
}
htmlContent += footer;
return htmlContent;
}
}
}Imports System.Text.Json
Imports System.Text.Json.Serialization
Imports RestSharp
Imports IronPdf
Namespace rest_sharp_demo
Class Program
Shared Sub Main()
' Create a RestClient
Dim baseUrl = "https://jsonplaceholder.typicode.com/users"
Dim options As New RestClientOptions(baseUrl) With {.UseDefaultCredentials = True}
Dim client As New RestClient(options)
' Create a RestRequest for the GET method
Dim request As New RestRequest()
' Execute the request and get the response
Dim response = client.Get(request)
' Check if the request was successful
If response.IsSuccessful Then
' Deserialize JSON response into a list of User objects
Dim users = JsonSerializer.Deserialize(Of List(Of User))(response.Content)
' Generate PDF
Dim html = GetHtml(users)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("UsersReport.pdf")
Else
' Handle the error
Console.WriteLine($"Error: {response.ErrorMessage}")
End If
End Sub
' Method to generate HTML from user data
Private Shared Function GetHtml(users As List(Of User)) As String
Dim header As String = "
<html>
<head><title>Users List</title></head>
<body>
"
Dim footer As String = "
</body>
</html>"
Dim htmlContent As String = header
For Each user In users
htmlContent += $"
<h1>{user.Name}</h1>
<p>Username: {user.Username}</p>
<p>Email: {user.Email}</p>
<p>Company: {user.Company}</p>
<p>Phone: {user.Phone}</p>
<p>Website: {user.Website}</p>
<p>Suite: {user.Address.Suite}</p>
<p>Street: {user.Address.Street}</p>
<p>City: {user.Address.City}</p>
<p>Zipcode: {user.Address.Zipcode}</p>
"
Next
htmlContent += footer
Return htmlContent
End Function
End Class
End NamespaceO código completo pode ser encontrado no Git neste link .
Aqui, primeiro geramos uma string HTML a partir da lista de usuários com toda a formatação necessária para os relatórios. Em seguida, usamos o IronPDF para gerar um documento PDF. Usamos o método RenderHtmlAsPdf para converter a string HTML em um documento PDF. O documento gerado é o seguinte:
O documento contém uma pequena marca d'água referente a licenças de avaliação, a qual pode ser removida com uma licença válida.
Para que o código acima funcione, é necessária uma chave de licença. Esta chave precisa ser colocada em appsettings.json da seguinte forma:
{
"IronPdf.LicenseKey": "your license key"
}Uma licença de avaliação está disponível para desenvolvedores após o cadastro, e nenhum cartão de crédito é necessário para obtê-la. É possível fornecer o endereço de e-mail e se inscrever para um teste gratuito.
A biblioteca RestSharp simplifica o processo de trabalho com APIs RESTful em C#, fornecendo uma maneira limpa e eficiente de fazer solicitações HTTP e lidar com respostas. Quer você esteja recuperando dados com solicitações GET ou enviando dados com solicitações POST, a API intuitiva e os recursos convenientes do RestSharp o tornam uma ferramenta valiosa para desenvolvedores que criam aplicativos que interagem com serviços da web.
O IronPDF oferece uma solução flexível e fácil de usar para gerar PDFs. Para obter informações adicionais sobre os diversos recursos do IronPDF , visite a página de documentação do IronPDF .
As licenças perpétuas do IronPDF ajudarão você a aprimorar suas habilidades de programação e a atender aos requisitos de aplicativos modernos.
Conhecer tanto o RestSharp quanto o IronPDF agrega grandes habilidades, permitindo que os desenvolvedores criem aplicativos modernos.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
