RestSharp es una popular biblioteca de código abierto de .NET para realizar solicitudes HTTP en C#. Simplifica el proceso de trabajar con API RESTful, proporcionando una manera sencilla y flexible de comunicarse con servicios web. En este artículo, exploraremos las características cruciales de RestSharp y IronPDF y demostraremos cómo puede extraer datos y generar un PDF.
En aplicaciones modernas, de múltiples capas, diferentes servicios necesitan comunicarse con frecuencia, y RestSharp ofrece una manera sencilla y eficiente al encapsular todas las complejidades. Esto simplifica enormemente el proceso de desarrollo de software.
RestSharp está disponible como un paquete NuGet y se puede instalar en su proyecto de C#. Puede hacerlo usando la Consola del Administrador de Paquetes NuGet o la interfaz de usuario del Administrador de Paquetes NuGet de Visual Studio.
Comencemos con un ejemplo simple de cómo realizar una solicitud GET a una API RESTful usando RestSharp. Supongamos que queremos obtener información de una API pública de ASP.NET Core que devuelve datos de usuarios:
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 NamespaceRestSharp también soporta solicitudes y respuestas asincrónicas usando los métodos API async.
RestSharp proporciona métodos convenientes para deserializar el contenido de la respuesta en objetos C#. Extendamos nuestro ejemplo para deserializar los datos de la respuesta JSON en una lista de objetos de usuario:
// 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 userEn este ejemplo, hemos definido una clase User con propiedades correspondientes a los campos JSON. Hemos utilizado JsonSerializer.Deserialize del espacio de nombres 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 los ID de usuario y nombres se muestran en la salida.
El código completo está disponible en Git en este enlace.
RestSharp admite el envío de solicitudes de cuerpo XML o JSON. Los métodos AddJsonBody o AddXmlBody de la instancia RestRequest se pueden usar para añadir cuerpo JSON o XML. RestSharp configurará automáticamente el tipo de contenido. Maneja automáticamente las respuestas JSON o XML.
// 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)RestSharp también soporta el envío de datos en el cuerpo de la solicitud, lo cual es común al crear o actualizar recursos. Modifiquemos nuestro ejemplo para demostrar una API de solicitud 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 NamespaceEn este ejemplo, creamos un nuevo objeto User, lo serializamos a JSON y lo incluimos en el cuerpo de la solicitud usando el método AddJsonBody. El servidor recibe los datos JSON y procesa la solicitud en consecuencia.
RestSharp también admite el envío de solicitudes con autenticación. El RestClientOptions puede incluir parámetros de autenticación.
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)}Aquí estamos utilizando autenticación básica de ID de cliente secreto, que se envía en cada solicitud.
RestSharp puede manejar errores que ocurren durante las solicitudes de URL, como errores de tiempo de espera, autenticación o autorización. RestSharp no lanza una excepción si la solicitud falla automáticamente. Debe configurarse manualmente.
Se pueden realizar las siguientes configuraciones de manejo de errores:
ResponseStatus a Error de acuerdo.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 es una biblioteca PDF de C# de Iron Software que ayuda a leer y generar documentos PDF. Puede convertir fácilmente documentos formateados con información de estilo a PDF. IronPDF puede generar fácilmente PDFs a partir de contenido HTML; puede descargar el HTML de una URL y luego generar PDFs.
Una característica clave de IronPDF es la conversión de HTML a PDF, preservando todos sus diseños y estilos. Convierte contenido web en PDFs, lo que lo hace ideal para informes, facturas y documentación. Los archivos HTML, URLs y cadenas HTML pueden ser fácilmente convertidos a 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 IronPDF en su proyecto Selenium RestSharp usando el gestor de paquetes NuGet, siga estos pasos:
Si desea incluir IronPDF en su proyecto a través de la Consola del Administrador de Paquetes, ejecute el siguiente comando en la Consola del Administrador de Paquetes:
Se descargará e instalará IronPDF en tu proyecto.
Para una descripción detallada de IronPDF, incluyendo sus características, compatibilidad y opciones de descarga adicionales, visita la página de IronPDF en el sitio web de NuGet en https://www.nuget.org/packages/IronPdf.
Alternativamente, puede incorporar IronPDF directamente en su proyecto usando su archivo DLL. Descargue el archivo ZIP que contiene el DLL desde Descargas de IronPDF. Descomprímalo e incluya el DLL en su proyecto.
Ahora obtendremos todos los usuarios y generaremos un informe en PDF usando una cadena HTML y el generador de 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 NamespaceEl código completo se puede encontrar en Git en este enlace.
Aquí primero estamos generando una cadena HTML de la lista de usuarios con todo el formato requerido para los informes. Luego usamos IronPDF para generar un documento PDF. Utilizamos el método RenderHtmlAsPdf para convertir la cadena HTML en un documento PDF. El documento generado es el siguiente:
El documento tiene una pequeña marca de agua para las licencias de prueba, que se puede eliminar usando una licencia válida.
Para que funcione el código anterior, se requiere una clave de licencia. Esta clave debe colocarse en appsettings.json de la siguiente manera:
{
"IronPdf.LicenseKey": "your license key"
}Un licencia de prueba está disponible para los desarrolladores al registrarse, y no se requiere tarjeta de crédito para una licencia de prueba. Uno puede proporcionar su ID de correo electrónico y registrarse para una prueba gratuita.
La biblioteca RestSharp simplifica el proceso de trabajar con APIs RESTful en C#, proporcionando una manera limpia y eficiente de realizar solicitudes HTTP y manejar respuestas. Ya sea que esté obteniendo datos con solicitudes GET o enviando datos con solicitudes POST, la API intuitiva de RestSharp y sus características convenientes lo convierten en una herramienta valiosa para los desarrolladores que construyen aplicaciones que interactúan con servicios web.
IronPDF proporciona una solución flexible y fácil de usar para generar PDFs. Para obtener información adicional sobre varias características de IronPDF, por favor visite la página de documentación de IronPDF.
Las licencias perpetuas de IronPDF lo ayudarán a mejorar sus habilidades de codificación y cumplir con los requisitos modernos de las aplicaciones.
Conocer tanto RestSharp como IronPDF añade grandes habilidades, permitiendo a los desarrolladores crear aplicaciones modernas.
Jacob Mellor es Director de Tecnología de Iron Software y un ingeniero visionario pionero en la tecnología C# PDF. Como desarrollador original de la base de código principal de Iron Software, ha dado forma a la arquitectura de productos de la empresa desde su creación, transformándola, junto con el director ejecutivo Cameron Rimington, en una empresa de más de 50 personas que presta servicios a la NASA, Tesla y organismos gubernamentales de todo el mundo.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
