AYUDA .NET

C# Async Await (Cómo funciona para los desarrolladores)

Publicado en 14 de enero, 2025

Aproveche el poder de la programación asincrónica para un mejor procesamiento de PDF en aplicaciones .NET.

En las aplicaciones web y de servidor modernas, el rendimiento y la escalabilidad son primordiales. Programación asincrónica en C# utilizando el async y awaitpalabras clave permiten a los desarrolladores crear aplicaciones no bloqueantes y altamente receptivas. Cuando se combinan con bibliotecas poderosas como IronPDF, los desarrolladores pueden aprovechar al máximo un método asincrónico, especialmente al trabajar con tareas vinculadas a la E/S, como la generación y manipulación de PDF.

En este artículo, exploraremos cómo escribir código asíncrono con IronPDF, compare la programación sincrónica y la programación asincrónica, y proporcione ejemplos del mundo real para tareas como la generación de PDF, la extracción de texto y la manipulación. Además, cubriremos las mejores prácticas para manejar múltiples tareas y demostraremos cómo escribir código que integre de manera fluida tanto el código sincrónico como el asíncrono.

Introducción a la programación asincrónica

La programación asincrónica en C# es una técnica esencial que permite a sus aplicaciones realizar tareas sin bloquear el hilo principal. Es particularmente beneficioso para manejar operaciones de larga duración como consultas de bases de datos, entrada/salida de archivos, o en este caso, generar o manipular archivos PDF.

IronPDF es una biblioteca robusta que simplifica la manipulación de PDF en aplicaciones .NET. Permite realizar diversas operaciones con PDF, desde convertir HTML a PDF, hasta extraer texto e imágenes. Al integrar IronPDF con patrones de programación asincrónica, los desarrolladores pueden mejorar significativamente el rendimiento de las aplicaciones que manejan PDFs.

Comprender Async/Await en C

Antes de sumergirnos en cómo usar async/await con IronPDF, primero echemos un vistazo rápido a lo que hacen estas palabras clave y por qué son importantes en el desarrollo moderno de .NET.

¿Qué es Async/Await?

Las palabras clave async y await se utilizan para definir métodos asincrónicos en C#. Un método asincrónico realiza una operación sin bloquear la ejecución del hilo principal de la aplicación, lo que permite que la aplicación permanezca receptiva incluso al realizar tareas prolongadas.

async: Esta palabra clave se aplica a los métodos que se espera que realicen operaciones asíncronas. Indica que el método contiene al menos una expresión await.
await: Esta palabra clave se usa para pausar la ejecución del método hasta que la tarea en espera se complete. Garantiza que el hilo esté libre para ejecutar otras tareas mientras espera que la operación termine.

public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}

public async Task WaitExampleAsync()
{
    await Task.Delay(1000); // Waits for 1 second without blocking the thread
    Console.WriteLine("Finished waiting asynchronously!");
}

Public Async Function WaitExampleAsync() As Task
	Await Task.Delay(1000) ' Waits for 1 second without blocking the thread
	Console.WriteLine("Finished waiting asynchronously!")
End Function

VB C#

C# Async Await(Cómo funciona para los desarrolladores): Figura 1

Los métodos asincrónicos mejoran la capacidad de respuesta al liberar el hilo principal para que maneje otras operaciones mientras espera que las tareas se completen.

Beneficios clave de la programación asincrónica

Operaciones no bloqueantes: Con la programación asíncrona, las operaciones que consumen mucho tiempo(como operaciones de entrada/salida de archivos o solicitudes de red)no bloquees el hilo principal. Esto es crucial para las aplicaciones web, donde las operaciones no bloqueantes aseguran que el servidor pueda manejar múltiples solicitudes simultáneamente.
Mejor escalabilidad: La palabra clave async permite que la aplicación maneje más operaciones concurrentes con menos hilos, mejorando la escalabilidad.
Mejor experiencia del usuario: Para aplicaciones de escritorio o web, las operaciones asíncronas aseguran que la interfaz de usuario permanezca receptiva a las interacciones del usuario mientras las tareas se ejecutan en segundo plano.

Código sincrónico y asincrónico

Comprender cuándo usar programación sincrónica versus programación asincrónica es fundamental para un diseño de aplicaciones eficiente.

La programación sincrónica ejecuta una operación a la vez, bloqueando el hilo principal hasta que la operación se complete. Por ejemplo, un método que genera un PDF con código síncrono podría verse así:

public void GeneratePdfSync()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>");
    pdf.SaveAs("output.pdf");
}

public void GeneratePdfSync()
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>");
    pdf.SaveAs("output.pdf");
}

Public Sub GeneratePdfSync()
	Dim renderer As New ChromePdfRenderer()
	Dim pdf = renderer.RenderHtmlAsPdf("<h1>Sync PDF</h1>")
	pdf.SaveAs("output.pdf")
End Sub

VB C#

Aunque es sencillo, este enfoque puede causar cuellos de botella en el rendimiento, especialmente en aplicaciones web que manejan múltiples tareas o en escenarios que requieren un alto consumo de E/S.

La programación asíncrona permite ejecutar operaciones sin bloquear el hilo principal. Esto es especialmente beneficioso para tareas de E/S como la generación de PDF, donde puedes usar código asincrónico para mantener la aplicación receptiva.
En la siguiente sección, exploraremos cómo integrar la programación asíncrona con IronPDF para mejorar su procesamiento de PDF.

Integrando Async/Await con IronPDF

IronPDFes una potente biblioteca de manipulación de PDF para .NET, diseñada para facilitar el trabajo con archivos PDF. Ofrece funciones que te permiten generar, editar y extraer contenido de archivos PDF con una configuración y un esfuerzo de codificación mínimos. Cuando se combina con el patrón async/await de C#, IronPDF puede realizar operaciones relacionadas con PDF de manera no bloqueante, mejorando tanto el rendimiento como la escalabilidad en aplicaciones que requieren un procesamiento intensivo de PDF.

Descripción general de IronPDF

C# Async Await(Cómo Funciona para Desarrolladores): Figura 2

IronPDFpermite a los desarrolladores .NET integrar funcionalidades de PDF directamente en sus aplicaciones, ya sea para entornos web o de escritorio. Aquí hay algunas de las características clave que ofrece IronPDF:

Conversión de HTML a PDF: IronPDF puede convertircontenido HTML (incluyendo CSS, imágenes y JavaScript)en PDFs completamente formateados. Esto es especialmente útil para renderizar páginas web dinámicas o informes como PDFs.
Edición de PDF: Con IronPDF, puedes manipular documentos PDF existentes agregando texto, imágenes y gráficos, así comoediciónel contenido de las páginas existentes.
Extracción de Texto e Imágenes: La biblioteca te permiteextraer texto e imágenesde PDFs, facilitando el análisis y la interpretación del contenido PDF.
Relleno de formularios: IronPDF admite el llenado decampos de formularioen PDFs, lo cual es útil para generar documentos personalizados.
Marcado de agua: También es posible añadirmarcas de aguaa documentos PDF para branding o protección de derechos de autor.

¿Por qué usar IronPDF con Async/Await?

Aunque IronPDF no es nativamente asincrónico, se adapta bien a los patrones async/await debido a la naturaleza de operaciones de entrada/salida de la mayoría de las tareas de procesamiento de PDF. Por ejemplo, convertir HTML a PDF o cargar un documento PDF grande puede tomar una cantidad significativa de tiempo, pero esto se puede hacer de manera asíncrona para evitar bloquear el hilo principal.

Aquí hay algunos ejemplos de cómo IronPDF se integra bien con la programación asincrónica:

Generación de PDF: Si su aplicación necesita generar múltiples PDFs basados en contenido dinámico, ejecutar estos procesos de manera asíncrona permite que el sistema permanezca receptivo mientras se crean los PDFs.
Manipulación de PDF: Si necesitas modificar archivos PDF grandes, como añadir marcas de agua o combinar documentos, realizar estas tareas de manera asincrónica asegura que tu aplicación no se quede colgada mientras estas operaciones que consumen mucho tiempo se procesan en segundo plano.
Entrada/Salida de archivos: Leer y escribir en archivos PDF es una operación limitada por E/S. La programación asíncrona es perfecta para estas tareas, ya que libera recursos del sistema y evita bloqueos innecesarios.

Ejemplo básico: Generación asíncrona de PDF con IronPDF

Aquí tienes un ejemplo de cómo escribir código asincrónico con IronPDF para generar un archivo PDF:

using IronPdf;
public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));
        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}

using IronPdf;
public class Program
{
    public static async Task Main(string[] args)
    {
        // Initialize renderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"));
        // Save the generated PDF to a file
        await Task.Run(() => pdf.SaveAs("output.pdf"));
    }
}

Imports IronPdf
Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		' Initialize renderer
		Dim renderer As New ChromePdfRenderer()
		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF Example</h1>"))
		' Save the generated PDF to a file
		Await Task.Run(Function() pdf.SaveAs("output.pdf"))
	End Function
End Class

VB C#

C# Async Await(Cómo funciona para los desarrolladores): Figura 3

Cómo funciona esto

Creación del Convertidor de HTML a PDF:
La clase ChromePdfRenderer se utiliza para convertir contenido HTML en un PDF. En este ejemplo, pasamos contenido HTML simple como una cadena.(```html
Ejemplo de PDF Asíncrono
```), pero en una aplicación real, esto podría ser HTML dinámico, como una plantilla de informe.
Usando Task.Run para la generación asincrónica de PDF:
El método RenderHtmlAsPdf no es asíncrono por defecto, por lo que usamos Task.Run.()para descargar la generación de PDF a un hilo en segundo plano. Esto es importante porque la generación de PDF puede requerir muchos recursos y ser lenta, especialmente al tratar con documentos grandes o complejos.
Guardando el PDF:
Después de que se genere el PDF, se guarda en el sistema de archivos utilizando pdf.SaveAs.(). Esta operación de E/S también está envuelta en un Task.Run.()para asegurarse de que no bloquee el hilo principal mientras guarda el archivo.
Operaciones en espera:
La palabra clave await garantiza que cada operación asíncrona se complete antes de que comience la siguiente. Mientras se espera a que se complete la generación del PDF, el hilo principal permanece libre para manejar otras tareas.(por ejemplo, atendiendo otras solicitudes HTTP en una aplicación web).

Manejo de múltiples tareas con IronPDF

Para aplicaciones que manejan grandes PDFs, es posible que necesite realizar múltiples operaciones, como dividir, fusionar o agregar contenido a archivos grandes. Usar async asegura que, mientras una operación se está procesando, la aplicación permanezca receptiva a la entrada o solicitudes del usuario.

Por ejemplo, podrías combinar múltiples operaciones asincrónicas en una canalización:

using IronPdf;
public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");
        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));
        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));
        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}

using IronPdf;
public class Program
{
    public static async Task Main(string[] args)
    {
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        PdfDocument page = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>");
        // Use Task.Run to run the PDF generation asynchronously
        PdfDocument pdf = await Task.Run(() => PdfDocument.FromFile("output.pdf"));
        // Perform some operations asynchronously
        await Task.Run(() => pdf.ApplyWatermark("Confidential"));
        PdfDocument merged = await Task.Run(() => PdfDocument.Merge(pdf, page));
        await Task.Run(() => merged.SaveAs("processed_output.pdf"));
    }
}

Imports IronPdf
Public Class Program
	Public Shared Async Function Main(ByVal args() As String) As Task
		Dim renderer As New ChromePdfRenderer()
		Dim page As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Added Page</h1>")
		' Use Task.Run to run the PDF generation asynchronously
		Dim pdf As PdfDocument = Await Task.Run(Function() PdfDocument.FromFile("output.pdf"))
		' Perform some operations asynchronously
		Await Task.Run(Function() pdf.ApplyWatermark("Confidential"))
		Dim merged As PdfDocument = Await Task.Run(Function() PdfDocument.Merge(pdf, page))
		Await Task.Run(Function() merged.SaveAs("processed_output.pdf"))
	End Function
End Class

VB C#

C# Async Await(Cómo funciona para desarrolladores): Figura 4

En este ejemplo, cargamos un archivo PDF y creamos uno nuevo, agregamos una marca de agua, fusionamos los dos PDF y lo guardamos, todo sin bloquear el hilo principal.

Mejores prácticas para operaciones asincrónicas con IronPDF

Consideraciones sobre el grupo de subprocesos: Dado que IronPDF depende de subprocesos en segundo plano para el procesamiento, tenga en cuenta el grupo de subprocesos al utilizar Task.Run.(). Para tareas de alta frecuencia, considere usar un servicio en segundo plano dedicado o encolar tareas para evitar sobrecargar el grupo de subprocesos.
Evita los métodos async void: Siempre usa async Task para los métodos que realizan operaciones asincrónicas. Reserve métodos async void para manejadores de eventos.
Tokens de cancelación: Para operaciones de larga duración como la generación de PDF o la extracción de texto, es una buena idea admitir tokens de cancelación para permitir que los usuarios cancelen la operación si es necesario. Esto asegura que los recursos se liberen si la operación ya no es necesaria.

public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);
    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}

public async Task GeneratePdfWithCancellationAsync(CancellationToken cancellationToken)
{
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken);
    if (cancellationToken.IsCancellationRequested)
    {
        Console.WriteLine("Operation was canceled.");
        return;
    }
    pdf.SaveAs("output.pdf");
}

Public Async Function GeneratePdfWithCancellationAsync(ByVal cancellationToken As CancellationToken) As Task
	Dim renderer As New ChromePdfRenderer()
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF with Cancellation</h1>"), cancellationToken)
	If cancellationToken.IsCancellationRequested Then
		Console.WriteLine("Operation was canceled.")
		Return
	End If
	pdf.SaveAs("output.pdf")
End Function

VB C#

Manejo de Errores: Al igual que con cualquier operación asíncrona, asegúrese de manejar adecuadamente los errores en caso de excepciones que puedan ocurrir durante el procesamiento de PDF, como problemas de acceso a archivos o datos de entrada no válidos.

try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

try
{
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"));
    pdf.SaveAs("output.pdf");
}
catch (Exception ex)
{
    Console.WriteLine($"Error: {ex.Message}");
}

Try
	Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf("<h1>Async PDF</h1>"))
	pdf.SaveAs("output.pdf")
Catch ex As Exception
	Console.WriteLine($"Error: {ex.Message}")
End Try

VB C#

Conclusión

IronPDFes una biblioteca versátil y poderosa de manipulación de PDF que funciona excepcionalmente bien con el patrón async/await de C#. Al aprovechar la programación asíncrona con IronPDF, puede mejorar significativamente el rendimiento y la escalabilidad de sus aplicaciones .NET que manejan la generación y manipulación de PDF. Ya sea que estés generando informes dinámicos, extrayendo datos de documentos o editando PDFs, la integración fluida de IronPDF con la programación asíncrona lo convierte en una excelente opción para los desarrolladores modernos de .NET.

No olvides explorarPrueba gratuita de IronPDF, que proporciona acceso a todas las características y te permite probar estas capacidades en tus propios proyectos. Al incorporar operaciones asíncronas con IronPDF, podrás crear aplicaciones más rápidas y eficientes que se escalan mejor con cargas de trabajo crecientes.

< ANTERIOR
Eventos en C# (Cómo funciona para desarrolladores)

SIGUIENTE >
Formato Timespan de C# (Cómo funciona para desarrolladores)