Em programação, às vezes você precisará pausar ou atrasar a execução do seu código por um determinado período de tempo. Isso permite simular diferentes condições de tempo, priorizar certas tarefas, executar outras tarefas sem bloquear a thread principal e muito mais.
Neste guia, explicaremos como aguardar em C#, incluindo métodos assíncronos, comandos sleep, funções sleep, aplicativos de console e como incluir uma função wait em nossa ferramenta líder de mercado para geração de PDFs, o IronPDF.
'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");
}
}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 ClassAqui, 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.
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");
}
}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 ClassNeste exemplo de código, temos duas tarefas executando 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 no 3000 e 2000 no código, ambos um valor de tempo limite). O método Task.Delay é semelhante ao método Thread.Sleep(), mas funciona com tarefas assíncronas e não bloqueia o thread principal.
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);
}
}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 ClassNo exemplo acima, criamos um temporizador com um intervalo de 1 segundo. O método OnTimerElapsed é executado toda vez que o temporizador marca. Definimos a propriedade AutoReset como verdadeira para que o temporizador reinicie automaticamente após cada marcação. 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.
À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
}
}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 ClassAqui, o método CustomWaitAsync aceita um parâmetro int que representa o tempo de atraso em milissegundos. O método usa um delegado assíncrono para executar a função Thread.Sleep dentro de uma nova tarefa, garantindo que o status da tarefa atual seja bloqueado enquanto espera, mas não o thread principal.
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:
Thread.Sleep quando precisar de uma maneira simples de pausar a execução do seu código por um período de tempo especificado.IronPDF é uma biblioteca PDF .NET leve, projetada especificamente para desenvolvedores web. Facilita a leitura, a escrita e a manipulação de arquivos PDF, sendo capaz de converter todos os tipos de arquivos em conteúdo PDF, e você pode usá-lo em seus projetos .NET , tanto para desktop quanto para a web. A melhor parte: é grátis para experimentar em um ambiente de desenvolvimento. Vamos começar.
O IronPDF funciona com arquivos HTML, URLs, strings brutas e arquivos ZIP. Segue um breve resumo do 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");
}
}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 ClassO IronPDF pode ser integrado perfeitamente às suas estratégias de espera para gerar documentos PDF após a execução de tarefas, durante intervalos agendados ou quando o thread atual retomar a execução.
Por exemplo, você pode usar o IronPDF em combinação com um método assíncrono para gerar um relatório em PDF após buscar dados de um banco de dados, sem bloquear a thread principal. Da mesma forma, você pode usar uma classe de temporizador para criar um instantâneo em PDF dos dados do seu aplicativo em intervalos regulares.
O IronPDF é fácil de usar, mas é ainda mais fácil de instalar. Existem algumas maneiras de fazer isso:
No Visual Studio, no Solution Explorer, clique com o botão direito do mouse em Referências e, em seguida, clique em Gerenciar Pacotes NuGet . Clique em "Procurar" e pesquise por "IronPDF" e instale a versão mais recente. Se você vir isso, significa que está funcionando:
Você também pode acessar Ferramentas -> Gerenciador de Pacotes NuGet -> Console do Gerenciador de Pacotes e inserir a seguinte linha na guia Gerenciador de Pacotes:
Por fim, você pode obter o IronPDF diretamente do site oficial do NuGet . Selecione a opção "Baixar Pacote" no menu à direita da página, clique duas vezes no arquivo baixado para instalá-lo automaticamente e recarregue a solução para começar a usá-la em seu projeto.
Não funcionou? Você pode encontrar ajuda específica para sua plataforma em nossa página de instalação avançada do NuGet .
Você também pode obter o arquivo DLL do IronPDF diretamente conosco e adicioná-lo manualmente ao Visual Studio. Para obter instruções completas e links para os pacotes DLL do Windows, MacOS e Linux, consulte nossa página de instalação dedicada.
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");
}
}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 ClassAqui, 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:
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.
Pode parecer contraintuitivo à primeira vista, mas implementar instruções de espera no seu código é uma habilidade essencial para criar aplicações eficientes. Ao incorporar o IronPDF, você pode levar seus aplicativos para o próximo nível, criando documentos PDF instantaneamente, sem bloquear a thread principal.
Pronto para colocar as mãos no IronPDF? Você pode começar com nosso teste gratuito de 30 dias . Além disso, é totalmente gratuito para uso em desenvolvimento, permitindo que você realmente veja do que ele é capaz. E se você gostar do que vê, IronPDF começa a partir de $999. Para economizar ainda mais, confira o Iron Suite , onde você pode obter todas as nove ferramentas do Iron Software pelo preço de duas. Boa programação!
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
