C# Wait For Seconds (Cómo funciona para desarrolladores)

La sentencia wait de C# es una función muy utilizada en programación cuando se necesita pausar la ejecución del programa durante un tiempo determinado. En este tutorial, cubriremos todo lo que necesitas saber sobre las sentencias wait, incluyendo los métodos async, el comando sleep, la función sleep y las aplicaciones de consola. Utilizaremos un enfoque narrativo y ejemplos de la vida real para mantener las cosas atractivas y fáciles de entender. Así que, empecemos!

La orden de dormir

El comando sleep es una herramienta sencilla pero potente que te permite pausar la ejecución de tu código durante un tiempo determinado. Es como decirle a tu programa que se eche una siestecita antes de pasar a la siguiente tarea. En C#, puede utilizar el método Thread.Sleep(int milisegundos) para conseguirlo.

He aquí un ejemplo de cómo utilizar el comando sleep en una aplicación de consola:

    using System;
    using System.Threading;

    class Program
    {
        public static void Main()
        {
            Console.WriteLine("Starting the program...");
            Thread.Sleep(3000); //  Dormir durante 3 segundos
            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); //  Dormir durante 3 segundos
            Console.WriteLine("...Program continues after 3 seconds");
        }
    }

Imports System
	Imports System.Threading

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

En el ejemplo anterior, el programa se inicia imprimiendo "Iniciando el programa..." en la consola. A continuación, utiliza el método Thread.Sleep para hacer una pausa de 3.000 milisegundos, o tres segundos. Tras el retardo especificado, el programa se reanuda e imprime la salida "...El programa continúa después de 3 segundos" en la consola.

Método asíncrono y tareas

Los métodos asíncronos de C# permiten ejecutar varias tareas simultáneamente sin bloquear el subproceso principal. Esto significa que mientras una tarea espera, otras pueden seguir ejecutándose. Para implementar un método async, necesitarás utilizar la palabra clave async y la clase Task.

Considere el siguiente ejemplo:

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);
        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);
        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)
		Console.WriteLine($"Task completed after {milliseconds} milliseconds")
	End Function
End Class

En este ejemplo de código, tenemos dos tareas que se ejecutan simultáneamente. El método DoSomethingAsync toma un parámetro int, que representa el tiempo en milisegundos que la tarea debe retrasarse. El método Task.Delay es similar al método Thread.Sleep()pero funciona con tareasasync` y no bloquea el hilo principal.

Uso de temporizadores Programación de tareas

Los temporizadores en C# le permiten ejecutar una tarea específica en un intervalo especificado. Puedes crear un temporizador utilizando la clase System.Timers.Timer. He aquí un ejemplo de cómo utilizar un temporizador en una aplicación de consola

using System;
using System.Timers;

class Program
{
    public static void Main()
    {
        var timer = new Timer(1000); //  Crear un temporizador con un intervalo de 1 segundo
        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); //  Crear un temporizador con un intervalo de 1 segundo
        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

Friend Class Program
	Public Shared Sub Main()
		Dim timer As New Timer(1000) '  Crear un temporizador con un intervalo de 1 segundo
		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(ByVal sender As Object, ByVal 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 hace tictac. Establecemos la propiedad AutoReset a true para que el temporizador se reinicie automáticamente después de cada tick. La propiedad Enabled se establece en true para iniciar el temporizador.

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

Creación de funciones de espera personalizadas

A veces, es posible que necesite una función de espera personalizada para satisfacer requisitos específicos de su código. Por ejemplo, es posible que desee crear una función de espera que sólo bloquea la tarea actual, en lugar de todo el hilo. Puedes conseguirlo utilizando delegados async.

He aquí un ejemplo de 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));
    }
}

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

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))
	End Function
End Class

En este ejemplo de código, el método CustomWaitAsync acepta un parámetro int que representa el tiempo de retardo en milisegundos. El método utiliza un delegado async para ejecutar la función Thread.Sleep dentro de una nueva tarea, asegurando que la tarea actual se bloquea mientras espera, pero no el hilo principal.

Elegir la estrategia de espera adecuada

Ahora que hemos cubierto la sentencia wait de C#, el comando sleep, los métodos async, los temporizadores y las funciones de espera personalizadas, es esencial saber cuándo utilizar cada técnica. He aquí un breve resumen

• Utilice la función Thread.Sleep cuando necesite una forma sencilla de pausar la ejecución de su código durante un tiempo determinado.
• Utiliza métodos y tareas async cuando necesites ejecutar múltiples tareas concurrentemente sin bloquear el hilo principal.
• Utilice temporizadores cuando necesite ejecutar una tarea específica en un intervalo determinado.
• Cree funciones de espera personalizadas cuando tenga requisitos específicos que no se cumplan con los métodos incorporados.

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

IronPDF convierte HTML en PDF preservando la estructura y presentación de los contenidos tal y como aparecen en los navegadores web. Los usuarios pueden utilizar IronPDF para generar PDF a partir de contenido web para informes, facturas y mucho más. Además, IronPDF proporciona a los usuarios flexibilidad para editar y personalizar el contenido del PDF después de la conversión.

IronPDF funciona con archivos HTML, URL, cadenas sin procesar y archivos ZIP.

using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();

        //  1. Convertir cadena HTML a 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. Convertir archivo HTML a PDF
        var htmlFilePath = "path_to_your_html_file.html"; //  Especifique la ruta a su archivo HTML
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        //  3. Convertir URL a PDF
        var url = "http://ironpdf.com"; // Especificar la URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}

using IronPdf;

class Program
{
    static void Main(string [] args)
    {
        var renderer = new ChromePdfRenderer();

        //  1. Convertir cadena HTML a 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. Convertir archivo HTML a PDF
        var htmlFilePath = "path_to_your_html_file.html"; //  Especifique la ruta a su archivo HTML
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        //  3. Convertir URL a PDF
        var url = "http://ironpdf.com"; // Especificar la 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. Convertir cadena HTML a 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. Convertir archivo HTML a PDF
		Dim htmlFilePath = "path_to_your_html_file.html" '  Especifique la ruta a su archivo HTML
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		'  3. Convertir URL a PDF
		Dim url = "http://ironpdf.com" ' Especificar la URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class

IronPDF puede integrarse perfectamente con sus estrategias de espera para generar documentos PDF después de ejecutar tareas o durante intervalos programados.

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

Para empezar a utilizar IronPDF, debe instalar el paquete NuGet:

Install-Package IronPdf

He aquí un ejemplo de cómo utilizar IronPDF con una función de espera:

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); //  Espere 3 segundos
        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); //  Espere 3 segundos
        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) '  Espere 3 segundos
		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

En este ejemplo de código, utilizamos el método Task.Delay para esperar 3 segundos antes de generar un PDF. A continuación, el PDF se guarda como "HelloWorld.pdf" en el directorio de trabajo de la aplicación.

SALIDA

En las aplicaciones C#, puede utilizar eficazmente la función sleep para gestionar el hilo actual y el tiempo de CPU mientras se realizan operaciones como cargar datos en un archivo Tabla de datos o generar informes en PDF con IronPDF.

Conclusión

En conclusión, comprender e implementar las sentencias wait de C#, los comandos sleep, los métodos async, los temporizadores y las funciones wait personalizadas es crucial para gestionar tus aplicaciones de forma eficiente.

Mediante la incorporación de IronPDF puede llevar sus aplicaciones al siguiente nivel creando documentos PDF sobre la marcha, sin bloquear el subproceso principal.

IronPDF ofrece un prueba gratuita que le permite explorar sus amplias posibilidades sin ningún compromiso. Si decide seguir utilizando IronPDF después del período de prueba, la licencia comienza en $749.