Saltar al pie de página
.NET AYUDA

RestSharp C# (Cómo funciona para desarrolladores)

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.

¿Por qué RestSharp?

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.

Instalar RestSharp

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.

Install-Package RestSharp

Hacer solicitudes GET sencillas

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);
        }
    }
}
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
	Friend 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(ByVal msg As String)
			Console.WriteLine(msg)
		End Sub
	End Class
End Namespace
$vbLabelText   $csharpLabel

RestSharp también soporta solicitudes y respuestas asincrónicas usando los métodos API async.

Manejo de datos de respuesta

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
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 user
$vbLabelText   $csharpLabel

En este ejemplo, hemos definido una clase User con propiedades que corresponden 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 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 Class
$vbLabelText   $csharpLabel

Resultado

Todos los ID de usuario y nombres se muestran en la salida.

RestSharp C# (Cómo Funciona para Desarrolladores): Figura 1 - Salida del Consola mostrando todos los ID de Usuario y Nombres.

El código completo está disponible en Git en este enlace.

Tipo de contenido

RestSharp admite el envío de solicitudes de cuerpo XML o JSON. Los métodos AddJsonBody o AddXmlBody de la instancia de RestRequest se pueden usar para agregar cuerpo XML o JSON. 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
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)
$vbLabelText   $csharpLabel

Envío de datos con solicitudes POST

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}");
            }
        }
    }
}
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
	Friend 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 Namespace
$vbLabelText   $csharpLabel

En 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.

Resultado

RestSharp C# (Cómo Funciona para Desarrolladores): Figura 2 - Salida del Consola

Autenticación

RestSharp también admite el envío de solicitudes con autenticación. Las RestClientOptions pueden incluir parámetros de autenticación.

var options = new RestClientOptions("https://auth.net")
{
    Authenticator = new HttpBasicAuthenticator(_clientId, _clientSecret)
};
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)}
$vbLabelText   $csharpLabel

Aquí estamos utilizando autenticación básica de ID de cliente secreto, que se envía en cada solicitud.

Manejo de errores

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:

  • FailOnDeserializationError: Establecer esta propiedad en verdadero hará que RestSharp considere una falla en la deserialización como un error y establezca el ResponseStatus en Error en consecuencia.
  • ThrowOnDeserializationError: Establecer esta propiedad en verdadero hará que RestSharp lance una excepción cuando falle la deserialización.
  • ThrowOnAnyError: Lanza una excepción si ocurre algún error al realizar una solicitud o durante la deserialización.
var restClientOptions = new RestClientOptions(url)
{
    ThrowOnAnyError = true
};
var client = new RestClient(restClientOptions);
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)
$vbLabelText   $csharpLabel

Presentación de IronPDF

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");
    }
}
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 Class
$vbLabelText   $csharpLabel

Instalar la biblioteca IronPDF

Para integrar IronPDF en su proyecto Selenium RestSharp usando el gestor de paquetes NuGet, siga estos pasos:

  1. Abra Visual Studio, y en el Explorador de Soluciones, haga clic derecho en su proyecto.
  2. Elija "Gestionar paquetes NuGet..." en el menú contextual.
  3. Ve a la pestaña Buscar y busca IronPDF.
  4. Selecciona la biblioteca IronPDF de los resultados de búsqueda y haz clic en el botón de instalar.
  5. Acepta cualquier mensaje de acuerdo de licencia.

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:

Install-Package IronPdf

Se descargará e instalará IronPDF en tu proyecto.

Instalación mediante el sitio web de NuGet

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.

Instalación mediante DLL

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;
        }
    }
}
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
	Friend 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 = 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
				' 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
'INSTANT VB WARNING: Nullable reference types have no equivalent in VB:
'ORIGINAL LINE: private static string GetHtml(List<User>? users)
		Private Shared Function GetHtml(ByVal users As List(Of User)) As String
			Dim header As String = "
<html>
<head><title>Users List</title></head>
<body>
"
			Dim footer = "
</body>
</html>"
			Dim htmlContent = 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 user
			htmlContent &= footer
			Return htmlContent
		End Function
	End Class
End Namespace
$vbLabelText   $csharpLabel

El 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. Usamos el método RenderHtmlAsPdf para convertir la cadena HTML a un documento PDF. El documento generado es el siguiente:

RestSharp C# (Cómo Funciona para Desarrolladores): Figura 4 - PDF de Salida

El documento tiene una pequeña marca de agua para las licencias de prueba, que se puede eliminar usando una licencia válida.

Licencia (Prueba gratuita disponible)

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.

Conclusión

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.

Preguntas Frecuentes

¿Cómo puedo convertir HTML a PDF en C#?

Puedes usar el método RenderHtmlAsPdf de IronPDF para convertir cadenas de HTML en PDFs. También puedes convertir archivos HTML a PDFs usando RenderHtmlFileAsPdf.

¿Qué es RestSharp en C#?

RestSharp es una popular biblioteca de código abierto de .NET para realizar solicitudes HTTP en C#. Simplifica el trabajo con APIs RESTful al proporcionar una forma fácil y flexible de comunicarse con servicios web.

¿Cómo instalo RestSharp en un proyecto C#?

RestSharp puede instalarse como un paquete NuGet en tu proyecto C#. Puedes hacerlo usando la Consola del Administrador de Paquetes NuGet con el comando Install-Package RestSharp o a través de la interfaz de usuario del Administrador de Paquetes NuGet en Visual Studio.

¿Cómo puedo generar PDFs a partir de datos de API usando C#?

Puedes usar RestSharp para obtener datos de una API e IronPDF para convertir esos datos en un PDF. Primero, recupera los datos usando RestSharp y luego formatea los datos en HTML, que puede ser convertido en un PDF usando IronPDF.

¿Cuáles son las mejores prácticas para el manejo de errores en RestSharp?

RestSharp proporciona mecanismos para el manejo de errores permitiéndote verificar el estado de la respuesta y manejar excepciones. Puedes inspeccionar las propiedades ResponseStatus y StatusCode para determinar si la solicitud fue exitosa o si ocurrió un error.

¿Cómo puedo manejar los datos JSON en las respuestas de RestSharp?

RestSharp puede manejar fácilmente los datos JSON en las respuestas. Proporciona métodos para deserializar contenido JSON en objetos C# usando bibliotecas como System.Text.Json o Newtonsoft.Json.

¿Puedes convertir URLs a PDFs en C#?

Sí, IronPDF permite convertir URLs web en PDFs usando el método RenderUrlAsPdf, el cual obtiene el contenido de la URL y lo convierte en un documento PDF.

¿Cómo envío datos con una solicitud POST usando RestSharp?

Para enviar datos con una solicitud POST usando RestSharp, crea un nuevo objeto, sérialo a JSON e inclúyelo en el cuerpo de la solicitud usando el método AddJsonBody de RestRequest. Luego ejecutas la solicitud POST con el cliente.

¿RestSharp es compatible con la autenticación?

Sí, RestSharp es compatible con el envío de solicitudes con autenticación. Puedes incluir parámetros de autenticación en RestClientOptions, como usar HttpBasicAuthenticator para la autenticación básica.

¿Cómo puedo integrar la generación de PDF en mi aplicación C#?

Puedes integrar la generación de PDF en tu aplicación C# usando IronPDF. Permite convertir contenido HTML, URLs o archivos HTML en PDFs, lo cual es útil para generar informes, documentación o facturas directamente dentro de una aplicación.

Jacob Mellor, Director de Tecnología @ Team Iron
Director de Tecnología

Jacob Mellor es Director de Tecnología en Iron Software y un ingeniero visionario que lidera la tecnología PDF en C#. Como el desarrollador original detrás de la base de código central de Iron Software, ha moldeado la arquitectura de productos de la compañía desde ...

Leer más