¿Cómo puedes retrasar la renderización de PDF en C#?

Puedes retrasar la renderización de PDF en C# usando el método `Thread.Sleep` para una espera sincrónica o `Task.Delay` para una espera asincrónica. Estos métodos te permiten pausar la ejecución del código durante una duración especificada, asegurando que las tareas se realicen en el momento adecuado.

¿Qué es la clase WaitFor en C#?

La clase WaitFor en C# se utiliza para implementar diversas estrategias de espera en tu código. Proporciona métodos como `Thread.Sleep` y `Task.Delay` para gestionar la temporización de la ejecución de tareas, permitiendo a los desarrolladores pausar la ejecución del código según sea necesario.

¿Cómo puedes implementar la espera asincrónica en C# para tareas de PDF?

La espera asincrónica en C# se puede implementar utilizando el método `Task.Delay`, que te permite esperar de manera asincrónica sin bloquear el hilo principal. Esto es particularmente útil en tareas de PDF para asegurar una ejecución fluida y una programación adecuada de las tareas.

¿Qué papel juegan los temporizadores en la gestión de la ejecución de tareas en C#?

Los temporizadores, como los proporcionados por la clase `System.Timers.Timer`, te permiten programar tareas a intervalos específicos. Son útiles para ejecutar tareas como la generación de PDF a intervalos regulares, asegurando una gestión eficiente de tareas sin bloquear el hilo principal.

¿Puedes crear funciones de espera personalizadas en C#?

Sí, puedes crear funciones de espera personalizadas en C# usando delegados asincrónicos. Esto permite pausas de ejecución de código personalizadas para satisfacer requisitos específicos, especialmente cuando los métodos de espera predeterminados no son suficientes.

¿Cómo puedes integrar la generación de PDF con estrategias de espera en C#?

Puedes integrar la generación de PDF con estrategias de espera en C# usando métodos asincrónicos y temporizadores. Esto asegura que las tareas de creación de PDF se gestionen eficientemente, permitiendo una ejecución programada sin bloquear otros procesos.

¿Cómo conviertes HTML a PDF en C#?

Para convertir HTML a PDF en C#, puedes usar bibliotecas como IronPDF. Esta biblioteca proporciona métodos para convertir cadenas HTML, URL y archivos en documentos PDF de manera eficiente.

¿Cuáles son los beneficios de usar métodos asincrónicos en C#?

Los métodos asincrónicos en C# ofrecen el beneficio de la ejecución concurrente de tareas, lo que mejora la eficiencia de la aplicación al permitir que múltiples tareas se ejecuten en paralelo sin bloquear el hilo principal.

¿Cómo instalar una biblioteca de PDF en un proyecto .NET?

Para instalar una biblioteca de PDF en un proyecto .NET, puedes usar el Administrador de paquetes NuGet en Visual Studio para buscar e instalar la biblioteca. Alternativamente, puedes descargar el archivo DLL de la biblioteca y agregarlo manualmente a tu proyecto.

¿Es posible pausar la renderización de PDF por un tiempo específico en C#?

Sí, puedes pausar la renderización de PDF por un tiempo específico en C# usando métodos como `Thread.Sleep` para pausas sincrónicas o `Task.Delay` para pausas asincrónicas, lo que te permite controlar el tiempo de las tareas de generación de PDF.

La Biblioteca PDF de C#

Explore IronPDF Prueba gratis

HTML a PDF

Online Demo Ver Todos los Ejemplos de Código %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ACTUALIZACIONES PARA DESARROLLADORES

Esperar en C# por unos segundos (Cómo funciona para desarrolladores)

Jacob Mellor

Updated: 23 de abril de 2026

En programación, a veces querrás pausar o retrasar la ejecución de tu código durante un cierto tiempo. Esto es para que puedas simular diferentes condiciones de tiempo, priorizar ciertas tareas, ejecutar otras tareas sin bloquear el hilo principal, y más.

En esta guía, explicaremos cómo esperar en C#, incluyendo métodos asincrónicos, comandos de suspensión, funciones de suspensión, aplicaciones de consola, y cómo incluir una función de espera en nuestra herramienta de generación de PDF líder en la industria, IronPDF.

Cómo esperar una tarea en C#

El comando Sleep

'Dormir' es un comando simple pero poderoso que te permite pausar la ejecución de tu tarea actual durante un tiempo específico, básicamente, diciéndole a tu programa que espere antes de pasar a la siguiente tarea. En C#, hacemos esto usando el método Thread.Sleep(int milliseconds), como en el siguiente ejemplo de código:

using System;
using System.Threading;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Starting the program...");
        Thread.Sleep(3000); // Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds");
    }
}

using System;
using System.Threading;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Starting the program...");
        Thread.Sleep(3000); // Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds");
    }
}

Imports System
Imports System.Threading

Class Program
    Public Shared Sub Main()
        Console.WriteLine("Starting the program...")
        Thread.Sleep(3000) ' Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds")
    End Sub
End Class

Imports System
Imports System.Threading

Class Program
    Public Shared Sub Main()
        Console.WriteLine("Starting the program...")
        Thread.Sleep(3000) ' Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds")
    End Sub
End Class

Aquí, el programa comienza imprimiendo "Iniciando el programa..." en la consola antes de usar el método Thread.Sleep para pausar por 3,000 milisegundos (o tres segundos). Después del retraso especificado, el programa se reanuda e imprime el mensaje "...El programa continúa después de 3 segundos" en la consola.

Método Async y tareas

Los métodos asincrónicos en C# te permiten ejecutar múltiples tareas simultáneamente sin interferir con el hilo principal. Esto significa que mientras una tarea está esperando, otras tareas pueden seguir ejecutándose. Para implementar un método async, necesitarás usar la palabra clave async y la clase Task.

using System;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       var task1 = DoSomethingAsync(3000);
       Console.WriteLine("Starting Task 2...");
       var task2 = DoSomethingAsync(2000);

       await Task.WhenAll(task1, task2);
       Console.WriteLine("Both tasks completed.");
   }

   private static async Task DoSomethingAsync(int milliseconds)
   {
       await Task.Delay(milliseconds); // Asynchronously wait without blocking the main thread
       Console.WriteLine($"Task completed after {milliseconds} milliseconds");
   }
}

using System;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       var task1 = DoSomethingAsync(3000);
       Console.WriteLine("Starting Task 2...");
       var task2 = DoSomethingAsync(2000);

       await Task.WhenAll(task1, task2);
       Console.WriteLine("Both tasks completed.");
   }

   private static async Task DoSomethingAsync(int milliseconds)
   {
       await Task.Delay(milliseconds); // Asynchronously wait without blocking the main thread
       Console.WriteLine($"Task completed after {milliseconds} milliseconds");
   }
}

Imports System
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Dim task1 = DoSomethingAsync(3000)
	   Console.WriteLine("Starting Task 2...")
	   Dim task2 = DoSomethingAsync(2000)

	   Await Task.WhenAll(task1, task2)
	   Console.WriteLine("Both tasks completed.")
   End Function

   Private Shared Async Function DoSomethingAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Delay(milliseconds) ' Asynchronously wait without blocking the main thread
	   Console.WriteLine($"Task completed after {milliseconds} milliseconds")
   End Function
End Class

Imports System
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Dim task1 = DoSomethingAsync(3000)
	   Console.WriteLine("Starting Task 2...")
	   Dim task2 = DoSomethingAsync(2000)

	   Await Task.WhenAll(task1, task2)
	   Console.WriteLine("Both tasks completed.")
   End Function

   Private Shared Async Function DoSomethingAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Delay(milliseconds) ' Asynchronously wait without blocking the main thread
	   Console.WriteLine($"Task completed after {milliseconds} milliseconds")
   End Function
End Class

En este ejemplo de código, tenemos dos tareas ejecutándose al mismo tiempo. El método DoSomethingAsync toma un parámetro int que representa el tiempo en milisegundos que la tarea debería retrasarse (como puedes ver en el 3000 y 2000 en el código, ambos son valores de tiempo de espera). El método Task.Delay es similar al método Thread.Sleep(), pero funciona con tareas async y no bloquea el hilo principal.

Uso de temporizadores para programar tareas

Los temporizadores en C# te permiten ejecutar una tarea específica después de un intervalo determinado. Puedes crear un temporizador usando la clase System.Timers.Timer. Aquí hay un ejemplo de cómo usar un temporizador en una aplicación de consola:

using System;
using System.Timers;

class Program
{
   public static void Main()
   {
       var timer = new Timer(1000); // Create a timer with a 1-second interval
       timer.Elapsed += OnTimerElapsed;
       timer.AutoReset = true;
       timer.Enabled = true;

       Console.WriteLine("Press any key to exit...");
       Console.ReadKey();
   }

   private static void OnTimerElapsed(object sender, ElapsedEventArgs e)
   {
       Console.WriteLine("Timer ticked at " + e.SignalTime);
   }
}

using System;
using System.Timers;

class Program
{
   public static void Main()
   {
       var timer = new Timer(1000); // Create a timer with a 1-second interval
       timer.Elapsed += OnTimerElapsed;
       timer.AutoReset = true;
       timer.Enabled = true;

       Console.WriteLine("Press any key to exit...");
       Console.ReadKey();
   }

   private static void OnTimerElapsed(object sender, ElapsedEventArgs e)
   {
       Console.WriteLine("Timer ticked at " + e.SignalTime);
   }
}

Imports System
Imports System.Timers

Class Program
    Public Shared Sub Main()
        Dim timer As New Timer(1000) ' Create a timer with a 1-second interval
        AddHandler timer.Elapsed, AddressOf OnTimerElapsed
        timer.AutoReset = True
        timer.Enabled = True

        Console.WriteLine("Press any key to exit...")
        Console.ReadKey()
    End Sub

    Private Shared Sub OnTimerElapsed(sender As Object, e As ElapsedEventArgs)
        Console.WriteLine("Timer ticked at " & e.SignalTime)
    End Sub
End Class

Imports System
Imports System.Timers

Class Program
    Public Shared Sub Main()
        Dim timer As New Timer(1000) ' Create a timer with a 1-second interval
        AddHandler timer.Elapsed, AddressOf OnTimerElapsed
        timer.AutoReset = True
        timer.Enabled = True

        Console.WriteLine("Press any key to exit...")
        Console.ReadKey()
    End Sub

    Private Shared Sub OnTimerElapsed(sender As Object, e As ElapsedEventArgs)
        Console.WriteLine("Timer ticked at " & e.SignalTime)
    End Sub
End Class

En el ejemplo anterior, creamos un temporizador con un intervalo de 1 segundo. El método OnTimerElapsed se ejecuta cada vez que el temporizador marca. Establecemos la propiedad AutoReset en verdadero para que el temporizador se reinicie automáticamente después de cada marca. La propiedad Enabled se establece en verdadero para iniciar el temporizador.

Cuando ejecutas esta aplicación de consola, verás que el temporizador hace tic cada segundo, imprimiendo el tiempo del tic en la consola. El programa seguirá ejecutándose hasta que presiones cualquier tecla para salir.

Creación de funciones de espera personalizadas

A veces, podrías necesitar una función de espera personalizada para cumplir requisitos específicos en tu código. Por ejemplo, es posible que desees crear una función de espera que solo bloquee la tarea actual, en lugar de todo el hilo. Puedes lograr esto usando delegados asincrónicos.

Aquí hay un ejemplo de una función de espera personalizada:

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       await CustomWaitAsync(3000);
       Console.WriteLine("Task 1 completed.");

       Console.WriteLine("Starting Task 2...");
       await CustomWaitAsync(2000);
       Console.WriteLine("Task 2 completed.");
   }

   private static async Task CustomWaitAsync(int milliseconds)
   {
       await Task.Run(() => Thread.Sleep(milliseconds)); // Run in a separate task to avoid blocking the main thread
   }
}

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       await CustomWaitAsync(3000);
       Console.WriteLine("Task 1 completed.");

       Console.WriteLine("Starting Task 2...");
       await CustomWaitAsync(2000);
       Console.WriteLine("Task 2 completed.");
   }

   private static async Task CustomWaitAsync(int milliseconds)
   {
       await Task.Run(() => Thread.Sleep(milliseconds)); // Run in a separate task to avoid blocking the main thread
   }
}

Imports System
Imports System.Threading
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Await CustomWaitAsync(3000)
	   Console.WriteLine("Task 1 completed.")

	   Console.WriteLine("Starting Task 2...")
	   Await CustomWaitAsync(2000)
	   Console.WriteLine("Task 2 completed.")
   End Function

   Private Shared Async Function CustomWaitAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Run(Sub() Thread.Sleep(milliseconds)) ' Run in a separate task to avoid blocking the main thread
   End Function
End Class

Imports System
Imports System.Threading
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Await CustomWaitAsync(3000)
	   Console.WriteLine("Task 1 completed.")

	   Console.WriteLine("Starting Task 2...")
	   Await CustomWaitAsync(2000)
	   Console.WriteLine("Task 2 completed.")
   End Function

   Private Shared Async Function CustomWaitAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Run(Sub() Thread.Sleep(milliseconds)) ' Run in a separate task to avoid blocking the main thread
   End Function
End Class

Aquí, el método CustomWaitAsync acepta un parámetro int que representa el tiempo de retraso en milisegundos. El método utiliza un delegado async para ejecutar la función Thread.Sleep dentro de una nueva tarea, asegurando que el estado de la tarea actual esté bloqueado mientras espera, pero no el hilo principal.

Elegir la estrategia de espera adecuada

Ahora que hemos cubierto la declaración de espera en C#, el comando de suspensión, los métodos asincrónicos, los temporizadores y las funciones de espera personalizadas, es esencial saber cuándo usar cada técnica. Aquí hay un resumen rápido:

Usa la función Thread.Sleep cuando necesites una forma sencilla de pausar la ejecución de tu código por un tiempo especificado.
Usa métodos asincrónicos y tareas cuando necesites ejecutar múltiples tareas simultáneamente sin bloquear el hilo principal.
Usa temporizadores cuando necesites ejecutar una tarea específica en un intervalo determinado.
Crea funciones de espera personalizadas cuando tengas requisitos específicos que no se cumplan con los métodos integrados.

Generación de PDFs con IronPDF usando la función Wait

IronPDF es una biblioteca PDF .NET ligera diseñada específicamente pensando en los desarrolladores web. Hace que leer, escribir y manipular archivos PDF sea muy sencillo, capaz de convertir todo tipo de tipos de archivo en contenido PDF, y puedes usarlo en tus proyectos .NET tanto para escritorio como para la web. Lo mejor de todo - es gratis para probar en un entorno de desarrollo. Vamos a sumergirnos.

IronPDF funciona con archivos HTML, URLs, cadenas de texto en bruto y archivos ZIP. Aquí tienes una descripción rápida del código:

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

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

IronPDF puede integrarse fácilmente con tus estrategias de espera para generar documentos PDF después de ejecutar tareas, durante intervalos programados o cuando el hilo actual vuelve a la ejecución.

Por ejemplo, puedes usar IronPDF en combinación con un método asincrónico para generar un informe PDF después de obtener datos de una base de datos sin bloquear el hilo principal. Del mismo modo, puedes usar una clase de temporizador para crear una instantánea PDF de los datos de tu aplicación a intervalos regulares.

Instalar la biblioteca IronPDF

IronPDF es fácil de usar, pero es aún más fácil de instalar. Hay un par de maneras de hacerlo:

Método 1: Consola del gestor de paquetes NuGet

En Visual Studio, en el Explorador de Soluciones, haz clic derecho en Referencias y luego haz clic en Administrar paquetes NuGet. Haz clic en buscar y busca 'IronPDF', e instala la versión más reciente. Si ves esto, está funcionando:

También puedes ir a Herramientas -> Administrador de Paquetes NuGet -> Consola del Administrador de Paquetes, e introducir la siguiente línea en la pestaña del Administrador de Paquetes:

PM > Install-Package IronPdf

Install-Package IronPdf

Finalmente, puedes obtener IronPDF directamente del sitio web oficial de NuGet. Selecciona la opción Descargar Paquete del menú a la derecha de la página, haz doble clic en tu descarga para instalarla automáticamente y recarga la Solución para comenzar a usarla en tu proyecto.

¿No funcionó? Puedes encontrar ayuda específica para plataformas en nuestra página de instalación avanzada de NuGet.

Método 2: Utilizar un archivo DLL

También puedes obtener el archivo DLL de IronPDF directamente de nosotros y añadirlo a Visual Studio manualmente. Para obtener instrucciones completas y enlaces a los paquetes DLL de Windows, MacOS y Linux, visita nuestra página de instalación dedica.

Cómo usar C# Wait en IronPDF

Puedes ver cómo incluir una función de espera en IronPDF en el siguiente ejemplo:

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting the PDF generation task...");
       Stopwatch stopwatch = Stopwatch.StartNew();
       await Task.Delay(3000); // Wait for 3 seconds
       GeneratePdf();
       Console.WriteLine("PDF generated successfully.");
   }

   private static void GeneratePdf()
   {
       var htmlToPdf = new ChromePdfRenderer();
       var pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
       pdf.SaveAs("HelloWorld.pdf");
   }
}

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting the PDF generation task...");
       Stopwatch stopwatch = Stopwatch.StartNew();
       await Task.Delay(3000); // Wait for 3 seconds
       GeneratePdf();
       Console.WriteLine("PDF generated successfully.");
   }

   private static void GeneratePdf()
   {
       var htmlToPdf = new ChromePdfRenderer();
       var pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
       pdf.SaveAs("HelloWorld.pdf");
   }
}

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting the PDF generation task...")
	   Dim stopwatch As Stopwatch = System.Diagnostics.Stopwatch.StartNew()
	   Await Task.Delay(3000) ' Wait for 3 seconds
	   GeneratePdf()
	   Console.WriteLine("PDF generated successfully.")
   End Function

   Private Shared Sub GeneratePdf()
	   Dim htmlToPdf = New ChromePdfRenderer()
	   Dim pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
	   pdf.SaveAs("HelloWorld.pdf")
   End Sub
End Class

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting the PDF generation task...")
	   Dim stopwatch As Stopwatch = System.Diagnostics.Stopwatch.StartNew()
	   Await Task.Delay(3000) ' Wait for 3 seconds
	   GeneratePdf()
	   Console.WriteLine("PDF generated successfully.")
   End Function

   Private Shared Sub GeneratePdf()
	   Dim htmlToPdf = New ChromePdfRenderer()
	   Dim pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
	   pdf.SaveAs("HelloWorld.pdf")
   End Sub
End Class

Aquí, usamos el método Task.Delay para esperar 3 segundos antes de generar un PDF. El PDF se guarda como "HelloWorld.pdf" en el directorio de trabajo de la aplicación al completar la espera.

Y aquí está el producto final:

Uso del método de espera con IronPDF

En aplicaciones C#, puedes usar eficientemente la función de suspensión para gestionar el hilo actual y el tiempo de CPU mientras realizas operaciones como cargar datos en un DataTable o generar informes PDF usando IronPDF.

Conclusión

Puede parecer contraintuitivo al principio, pero implementar declaraciones de espera en tu código es una habilidad imprescindible al desarrollar aplicaciones eficientes. Y al incorporar IronPDF, puedes llevar tus aplicaciones al siguiente nivel creando documentos PDF al vuelo, sin bloquear el hilo principal.

¿Listo para poner tus manos en IronPDF? Puedes comenzar con nuestra prueba gratuita de 30 días. También es completamente gratis para usar con fines de desarrollo, para que realmente puedas ver de qué está hecho. Y si te gusta lo que ves, IronPDF comienza por tan solo $999. Para aún más ahorros, revisa el Iron Suite donde puedes obtener todas las nueve herramientas de Iron Software por el precio de dos. ¡Feliz programación!

Jacob Mellor

Chatea con el equipo de ingeniería ahora

Director de Tecnología

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.

...