As classes de temporizador em C# são ferramentas poderosas para agendar a execução de código em intervalos específicos. Quer esteja desenvolvendo um aplicativo Windows Forms ou um aplicativo de console, entender como usar um temporizador pode melhorar muito a funcionalidade do seu aplicativo. Este tutorial irá guiá-lo pelos conceitos básicos de como usar temporizadores em C#, incluindo como configurá-los, lidar com seus eventos e garantir que funcionem corretamente em sua aplicação. Também discutiremos como usar o IronPDF para geração automática de PDFs em aplicações C# para automatizar a geração de PDFs usando um temporizador em C#.
C# oferece diversas classes de temporizador, cada uma adequada para diferentes tarefas e ambientes. As classes de temporizador mais comumente usadas são System.Timers.Timer para temporizadores baseados em servidor e System.Windows.Forms.Timer para aplicativos Windows Forms. Compreender o papel dos manipuladores de eventos é crucial ao trabalhar com classes de temporizador, pois esses manipuladores ditam as ações executadas em cada momento significativo definido pelo temporizador, como os intervalos de tempo de evento (tick ou elapsed).
Configurar o intervalo de tempo do seu temporizador é fundamental para o seu funcionamento, determinando a frequência com que os manipuladores de eventos do temporizador são invocados e, assim, controlando o ritmo das funções do aplicativo que são sensíveis ao tempo. Para usar um temporizador em sua aplicação C#, especialmente ao desenvolver aplicações Windows Forms, você começa adicionando o componente System.Windows.Forms.Timer da caixa de ferramentas ao seu formulário, ou criando programaticamente um objeto de temporizador para maior flexibilidade.
var timer = new System.Timers.Timer(); // Create a new timer
timer.Interval = 2000; // Sets the timer interval to tick every 2 secondsDim timer = New System.Timers.Timer() ' Create a new timer
timer.Interval = 2000 ' Sets the timer interval to tick every 2 secondsEssa configuração simples cria um temporizador que dispara a cada 2 segundos. No entanto, para que o temporizador execute ações, você precisa conectá-lo a um manipulador de eventos.
Ao associar um manipulador de eventos de tempo decorrido ao evento Elapsed de um System.Timers.Timer , você garante que seu aplicativo possa executar tarefas em cada intervalo, respondendo efetivamente a gatilhos baseados em tempo. Este evento é acionado sempre que o intervalo do temporizador expira. Você associa um manipulador a este evento para especificar o que deve acontecer quando o temporizador disparar:
timer.Elapsed += OnTimedEvent;timer.Elapsed += OnTimedEventNo código acima, OnTimedEvent é um método que você define e que será chamado sempre que o evento Elapsed do temporizador for acionado.
Ao definir um manipulador de eventos de temporizador, você cria um método que é executado em resposta aos eventos de pulso do temporizador, permitindo um controle preciso sobre as ações realizadas em intervalos predefinidos. Um manipulador de eventos para o evento "Elapsed" de um temporizador normalmente se parece com isto:
static void OnTimedEvent(Object source, System.Timers.ElapsedEventArgs e)
{
Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}", e.SignalTime);
}Shared Sub OnTimedEvent(ByVal source As Object, ByVal e As System.Timers.ElapsedEventArgs)
Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}", e.SignalTime)
End SubEste método simplesmente imprime a hora atual no console sempre que o temporizador expira, demonstrando como responder ao evento do temporizador.
Após configurar o temporizador e seu manipulador de eventos, você precisa iniciar o temporizador. Você faz isso definindo sua propriedade Enabled como true ou chamando o método Start :
timer.Enabled = true; // or timer.Start();timer.Enabled = True ' or timer.Start();Para parar o temporizador, você pode definir Enabled como falso ou chamar o método Stop . Isso é crucial para evitar que seu aplicativo execute operações desnecessárias quando elas não forem necessárias.
O System.Windows.Forms.Timer é um componente valioso do Windows Forms, projetado para se integrar perfeitamente ao modelo orientado a eventos dos aplicativos Windows Forms, facilitando ações regulares sem comprometer a capacidade de resposta da interface do usuário.
Em um aplicativo Windows Forms, você pode arrastar um controle de temporizador da caixa de ferramentas para o seu formulário ou criá-lo programaticamente da seguinte forma:
System.Windows.Forms.Timer myTimer = new System.Windows.Forms.Timer();
myTimer.Interval = 1000; // 1 second interval
myTimer.Tick += new EventHandler(TimerEventProcessor);
myTimer.Start();Dim myTimer As New System.Windows.Forms.Timer()
myTimer.Interval = 1000 ' 1 second interval
AddHandler myTimer.Tick, AddressOf TimerEventProcessor
myTimer.Start()Aqui, TimerEventProcessor é um manipulador de eventos que será chamado sempre que o evento Tick ocorrer, o que é semelhante ao evento Elapsed em System.Timers.Timer .
Ao trabalhar com temporizadores, é crucial entender o modelo de threading da sua aplicação. As classes System.Timers.Timer e System.Threading.Timer executam seus callbacks em uma thread do pool de threads, permitindo a execução paralela. No entanto, isso pode levar a problemas de segurança de threads se o seu método de retorno de chamada modificar dados compartilhados ou interagir com elementos da interface do usuário. Para atualizar com segurança os elementos da interface do usuário a partir do retorno de chamada de um temporizador, você deve encaminhar a chamada de retorno para a thread da interface do usuário usando técnicas específicas para o tipo do seu aplicativo (por exemplo, usando Invoke ou BeginInvoke no Windows Forms).
Para aplicações que exigem temporização de alta precisão (por exemplo, aplicações multimídia ou jogos), a classe System.Diagnostics.Stopwatch pode ser mais apropriada do que um temporizador para medir o tempo decorrido com alta exatidão. Embora não seja um temporizador em si, a classe Stopwatch pode ser usada em conjunto com um temporizador para obter medições de tempo precisas.
Um cenário comum em que um temporizador é útil é na criação de um cronômetro regressivo. Isso pode ser feito definindo um intervalo de temporizador para um segundo (1000 milissegundos) e decrementando um contador cada vez que o temporizador expirar. Quando o contador chega a zero, o cronômetro para, sinalizando o fim da contagem regressiva.
using System;
namespace CountdownApp
{
class Program
{
static int countdownTime = 10; // Countdown from 10 seconds
public static void Main(string[] args) // Main method
{
StartCountdown();
Console.ReadLine(); // Prevent console from closing immediately
}
static void StartCountdown()
{
var timer = new System.Timers.Timer(1000); // Tick every second
timer.Elapsed += UpdateCountdown;
timer.Enabled = true;
}
static void UpdateCountdown(Object source, System.Timers.ElapsedEventArgs e)
{
if (countdownTime > 0)
{
Console.WriteLine(countdownTime-- + " seconds remaining");
}
else
{
Console.WriteLine("Countdown finished!");
((System.Timers.Timer)source).Stop(); // Stop the timer
}
}
}
}Imports System
Namespace CountdownApp
Friend Class Program
Private Shared countdownTime As Integer = 10 ' Countdown from 10 seconds
Public Shared Sub Main(ByVal args() As String) ' Main method
StartCountdown()
Console.ReadLine() ' Prevent console from closing immediately
End Sub
Private Shared Sub StartCountdown()
Dim timer = New System.Timers.Timer(1000) ' Tick every second
AddHandler timer.Elapsed, AddressOf UpdateCountdown
timer.Enabled = True
End Sub
Private Shared Sub UpdateCountdown(ByVal source As Object, ByVal e As System.Timers.ElapsedEventArgs)
If countdownTime > 0 Then
'INSTANT VB WARNING: An assignment within expression was extracted from the following statement:
'ORIGINAL LINE: Console.WriteLine(countdownTime-- + " seconds remaining");
Console.WriteLine(countdownTime & " seconds remaining")
countdownTime -= 1
Else
Console.WriteLine("Countdown finished!")
DirectCast(source, System.Timers.Timer).Stop() ' Stop the timer
End If
End Sub
End Class
End NamespaceAqui está o resultado do código acima:
Os temporizadores podem ser usados para realizar verificações regulares em um banco de dados, como consultar novos dados ou limpar registros antigos. Este exemplo configura um temporizador para consultar um banco de dados a cada hora:
private static void SetupDatabaseCheckTimer()
{
var timer = new System.Timers.Timer(3600000); // Set to 1 hour
timer.Elapsed += CheckDatabase;
timer.Enabled = true;
}
private static void CheckDatabase(Object source, System.Timers.ElapsedEventArgs e)
{
// Perform database operations here
Console.WriteLine("Database checked at " + e.SignalTime);
}Private Shared Sub SetupDatabaseCheckTimer()
Dim timer = New System.Timers.Timer(3600000) ' Set to 1 hour
AddHandler timer.Elapsed, AddressOf CheckDatabase
timer.Enabled = True
End Sub
Private Shared Sub CheckDatabase(ByVal source As Object, ByVal e As System.Timers.ElapsedEventArgs)
' Perform database operations here
Console.WriteLine("Database checked at " & e.SignalTime)
End SubIronPDF - Gere PDFs facilmente a partir de HTML e ASPX é particularmente elogiado pela sua facilidade de uso na geração de PDFs a partir de HTML ou URLs, permitindo essencialmente que sua aplicação "imprima" qualquer conteúdo HTML como um documento PDF . Isso é incrivelmente útil para gerar relatórios, faturas ou qualquer conteúdo da web que precise ser apresentado em um formato padronizado. O IronPDF também oferece suporte a recursos avançados, como estilos CSS, JavaScript e fontes personalizadas, garantindo que os PDFs gerados mantenham a fidelidade do conteúdo da web.
Uma característica importante do IronPDF é sua capacidade de conversão de HTML para PDF , preservando layouts e estilos. Ele gera PDFs a partir de conteúdo da web, o que é ideal para relatórios, faturas e documentação. Arquivos HTML, URLs e strings HTML podem ser facilmente convertidos em PDFs.
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 ClassVocê pode instalar o IronPDF usando o Gerenciador de Pacotes NuGet executando este comando:
Imagine que você precisa gerar um relatório diário em formato PDF, contendo dados que são atualizados diariamente. Para simplificar, vamos gerar um relatório HTML básico e convertê-lo para PDF usando o IronPDF a cada 24 horas. Em sua aplicação C#, você configurará um System.Timers.Timer para ser acionado a cada 24 horas. É importante notar que o intervalo é definido em milissegundos, portanto, 24 horas são representadas como 24 * 60 * 60 * 1000 milissegundos.
using System;
using System.Timers;
using IronPdf;
using Timer = System.Timers.Timer;
class Program
{
static void Main(string[] args)
{
// Set up the timer for 24 hours
Timer timer = new Timer(24 * 60 * 60 * 1000);
timer.Elapsed += OnTimedEvent;
timer.AutoReset = true;
timer.Enabled = true;
Console.WriteLine("Press Enter to exit the program.");
Console.ReadLine();
}
private static void OnTimedEvent(Object source, ElapsedEventArgs e)
{
GeneratePdfReport();
}
private static void GeneratePdfReport()
{
var renderer = new HtmlToPdf();
var pdf = renderer.RenderHtmlAsPdf("<h1>Daily Report</h1><p>This is the automated daily report.</p>");
string outputPath = $"f:\\DailyReport_{DateTime.Now:yyyyMMdd}.pdf";
pdf.SaveAs(outputPath);
Console.WriteLine($"Generated PDF report at {outputPath}");
}
}Imports System
Imports System.Timers
Imports IronPdf
Imports Timer = System.Timers.Timer
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Set up the timer for 24 hours
Dim timer As New Timer(24 * 60 * 60 * 1000)
AddHandler timer.Elapsed, AddressOf OnTimedEvent
timer.AutoReset = True
timer.Enabled = True
Console.WriteLine("Press Enter to exit the program.")
Console.ReadLine()
End Sub
Private Shared Sub OnTimedEvent(ByVal source As Object, ByVal e As ElapsedEventArgs)
GeneratePdfReport()
End Sub
Private Shared Sub GeneratePdfReport()
Dim renderer = New HtmlToPdf()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Daily Report</h1><p>This is the automated daily report.</p>")
Dim outputPath As String = $"f:\DailyReport_{DateTime.Now:yyyyMMdd}.pdf"
pdf.SaveAs(outputPath)
Console.WriteLine($"Generated PDF report at {outputPath}")
End Sub
End ClassApós executar o código, a seguinte saída será exibida no console. Aqui, modifiquei o código para obter uma saída mais rápida, utilizando um temporizador de 10 segundos.
Aqui está o PDF gerado:
Em conclusão, a integração de temporizadores C# com o IronPDF apresenta uma abordagem poderosa para automatizar a geração e o gerenciamento de documentos PDF em aplicações .NET . Por meio dos exemplos fornecidos, exploramos como configurar um temporizador em C# para acionar tarefas de geração de PDF em intervalos regulares, seja para fins de teste frequente ou para geração de relatórios agendados.
Utilizando temporizadores em C#, podemos controlar com precisão quando nossas tarefas relacionadas a PDFs são executadas, permitindo atualizações regulares, geração de relatórios ou qualquer tarefa que precise ocorrer de acordo com um cronograma. O IronPDF aprimora essa capacidade, fornecendo uma maneira simples e eficiente de criar, manipular e salvar documentos PDF com base em conteúdo dinâmico, HTML ou até mesmo páginas da web.
O IronPDF oferece um período de teste gratuito com informações sobre licenciamento , sendo que licenças para acesso completo e suporte estão disponíveis. Isso proporciona uma maneira econômica de implementar funcionalidades abrangentes de PDF em seus aplicativos .NET .
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.
