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

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");
    }
}

Aquí, el programa comienza imprimiendo "Iniciando el programa..." en la consola antes de usar el método Thread.Sleep para hacer una pausa de 3000 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 asíncrono, necesitará utilizar 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");
   }
}

En este ejemplo de código, tenemos dos tareas ejecutándose simultáneamente. El método DoSomethingAsync toma un parámetro int que representa el tiempo en milisegundos que debe retrasarse la tarea (como se puede ver en 3000 y 2000 en el código, ambos valores de tiempo de espera). El método Task.Delay es similar al método Thread.Sleep(), pero funciona con tareas asincrónicas 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. Puede crear un temporizador utilizando 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);
   }
}

En el ejemplo anterior, creamos un temporizador con un intervalo de 1 segundo. El método OnTimerElapsed se ejecuta cada vez que el temporizador hace tictac. Establecemos la propiedad AutoReset en verdadera para que el temporizador se reinicie automáticamente después de cada tic. La propiedad Enabled se establece en verdadera 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
   }
}

Aquí, el método CustomWaitAsync acepta un parámetro int que representa el tiempo de retraso en milisegundos. El método utiliza un delegado asíncrono para ejecutar la función Thread.Sleep dentro de una nueva tarea, lo que garantiza 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:

• Utilice la función Thread.Sleep cuando necesite una forma sencilla de pausar la ejecución de su código durante un período de tiempo específico.
• 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.

Instalar la biblioteca IronPDF

Install-Package IronPdf

Cómo utilizar 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");
   }
}

Aquí, utilizamos 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.