Aguardar alguns segundos em C# (Como funciona para desenvolvedores)

O comando do sono

'Sleep' é um comando simples, porém poderoso, que permite pausar a execução da tarefa atual por um período específico, essencialmente dizendo ao programa para esperar antes de passar para a próxima tarefa. Em C#, fazemos isso usando o método Thread.Sleep(int milliseconds), como no exemplo de código a seguir:

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

Aqui, o programa começa imprimindo "Iniciando o programa..." no console antes de usar o método Thread.Sleep para pausar por 3.000 milissegundos (ou três segundos). Após o atraso especificado, o programa é retomado e imprime a mensagem "...O programa continua após 3 segundos" no console.

Métodos e tarefas assíncronas

Os métodos assíncronos em C# permitem executar várias tarefas simultaneamente sem interferir na thread principal. Isso significa que, enquanto uma tarefa está em espera, outras tarefas podem continuar em execução. Para implementar um método assíncrono, você precisará usar a palavra-chave async e a classe 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

Neste exemplo de código, temos duas tarefas sendo executadas ao mesmo tempo. O método DoSomethingAsync recebe um parâmetro int que representa o tempo em milissegundos que a tarefa deve ser atrasada (como você pode ver em 3000 e 2000 no código, ambos são valores de tempo limite). O método Task.Delay é semelhante ao método Thread.Sleep(), mas funciona com tarefas assíncronas e não bloqueia a thread principal.

Usando temporizadores para agendar suas tarefas

Os temporizadores em C# permitem executar uma tarefa específica após um intervalo determinado. Você pode criar um temporizador usando a classe System.Timers.Timer. Aqui está um exemplo de como usar um temporizador em um aplicativo de console:

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

No exemplo acima, criamos um temporizador com um intervalo de 1 segundo. O método OnTimerElapsed é executado a cada pulso do temporizador. Definimos a propriedade AutoReset como verdadeira para que o temporizador reinicie automaticamente após cada pulso. A propriedade Enabled é definida como verdadeira para iniciar o temporizador.

Ao executar este aplicativo de console, você verá o cronômetro marcando um segundo a cada segundo, imprimindo o tempo da marcação no console. O programa continuará em execução até que você pressione qualquer tecla para sair.

Criando funções de espera personalizadas

Às vezes, você pode precisar de uma função de espera personalizada para atender a requisitos específicos em seu código. Por exemplo, você pode querer criar uma função de espera que bloqueie apenas a tarefa atual, em vez de toda a thread. Você pode conseguir isso usando delegados assíncronos.

Aqui está um exemplo de uma função 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

Aqui, o método CustomWaitAsync aceita um parâmetro int que representa o tempo de atraso em milissegundos. O método utiliza um delegado assíncrono para executar a função Thread.Sleep dentro de uma nova tarefa, garantindo que o estado da tarefa atual seja bloqueado enquanto aguarda, mas não a thread principal.

Como escolher a estratégia de espera correta

Agora que já abordamos a instrução wait em C#, o comando sleep, métodos assíncronos, temporizadores e funções de espera personalizadas, é essencial saber quando usar cada técnica. Segue um breve resumo:

• Use a função Thread.Sleep quando precisar de uma maneira simples de pausar a execução do seu código por um período de tempo específico.
• Utilize métodos e tarefas assíncronas quando precisar executar várias tarefas simultaneamente sem bloquear a thread principal.
• Utilize temporizadores quando precisar executar uma tarefa específica em um intervalo determinado.
• Crie funções de espera personalizadas quando tiver requisitos específicos que não sejam atendidos pelos métodos integrados.

Instale a biblioteca IronPDF.

Install-Package IronPdf

Como usar o comando Wait em C# no IronPDF

Você pode ver como incluir uma função de espera no IronPDF no exemplo a seguir:

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

Aqui, usamos o método Task.Delay para esperar 3 segundos antes de gerar um PDF. O PDF é então salvo como "HelloWorld.pdf" no diretório de trabalho do aplicativo após a conclusão da espera.

E aqui está o produto final:

Utilizando o método de espera com o IronPDF

Em aplicações C#, você pode usar a função sleep de forma eficiente para gerenciar o thread atual e o tempo de CPU enquanto realiza operações como carregar dados em um DataTable ou gerar relatórios em PDF usando o IronPDF.