Test dans un environnement réel
Test en production sans filigrane.
Fonctionne partout où vous en avez besoin.
Les classes de temporisation en C# sont des outils puissants permettant de planifier l'exécution du code à des intervalles précis. Que vous développiez une application Windows Form ou une application console, la compréhension de l'utilisation d'un minuterie peut améliorer considérablement la fonctionnalité de votre application. Ce tutoriel vous présente les bases de l'utilisation des temporisateurs en C#, y compris la manière de les configurer, de gérer leurs événements et de garantir leur bon fonctionnement dans votre application. Nous discuterons également IronPDF pour automatiser notre génération de PDF à l'aide d'un Timer en C#.
C# propose plusieurs classes de temporisation, chacune adaptée à des tâches et à des environnements différents. Les classes de temporisation les plus couramment utilisées sont System.Timers.Timer pour les temporisations basées sur le serveur et System.Windows.Forms.Timer pour les applications Windows Forms. Il est essentiel de comprendre le rôle des gestionnaires d'événements lorsque l'on travaille avec des classes de minuterie, car ces gestionnaires dictent les actions à effectuer à chaque moment important dicté par la minuterie, tel que le tic-tac ou les intervalles de temps écoulés de l'événement.
La configuration de l'intervalle de temps de votre minuterie est fondamentale pour son fonctionnement, car elle détermine la fréquence à laquelle les gestionnaires d'événements de la minuterie sont invoqués et contrôle ainsi le rythme des fonctions de l'application qui sont sensibles au temps. Pour utiliser une minuterie dans votre application C#, en particulier lors du développement d'applications Windows Forms, vous commencez par ajouter le composant System.Windows.Forms.Timer de la boîte à outils sur votre formulaire, ou par créer par programme un objet de minuterie pour plus de flexibilité.
var timer = new System.Timers.Timer(); // use a timer
timer.Interval = 2000; // Sets the timer interval to tick every 2 seconds
var timer = new System.Timers.Timer(); // use a timer
timer.Interval = 2000; // Sets the timer interval to tick every 2 seconds
Dim timer = New System.Timers.Timer() ' use a timer
timer.Interval = 2000 ' Sets the timer interval to tick every 2 seconds
Cette configuration simple crée une minuterie qui fait un tic-tac toutes les 2 secondes. Cependant, pour que la minuterie effectue des actions, vous devez la connecter à un gestionnaire d'événements.
En attachant un gestionnaire d'événement écoulé à l'événement Elapsed d'un System.Timers.Timer, vous vous assurez que votre application peut effectuer des tâches à chaque intervalle, en répondant efficacement aux déclencheurs basés sur le temps. Cet événement est déclenché chaque fois que l'intervalle de la minuterie s'est écoulé. Vous attachez un gestionnaire à cet événement pour spécifier ce qui doit se passer lorsque la minuterie fait tic-tac :
timer.Elapsed += OnTimedEvent;
timer.Elapsed += OnTimedEvent;
timer.Elapsed += OnTimedEvent
Dans le code ci-dessus, OnTimedEvent est une méthode que vous définissez et qui sera appelée chaque fois que l'événement Elapsed de la minuterie est déclenché.
En définissant un gestionnaire d'événements de minuterie, vous créez une méthode qui s'exécute en réponse aux événements de la minuterie, ce qui permet un contrôle précis des actions effectuées à des intervalles prédéfinis. Un gestionnaire d'événement pour l'événement Elapsed d'une minuterie ressemble typiquement à ceci :
static void OnTimedEvent(Object source, System.Timers.ElapsedEventArgs e)
{
Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}", e.SignalTime);
}
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 Sub
Cette méthode imprime simplement l'heure actuelle sur la console à chaque fois que la minuterie s'écoule, démontrant ainsi comment répondre à l'événement de la minuterie.
Après avoir configuré la minuterie et son gestionnaire d'événements, vous devez démarrer la minuterie. Pour ce faire, définissez sa propriété Enabled sur true ou appelez la méthode Start :
timer.Enabled = true; // or timer.Start();
timer.Enabled = true; // or timer.Start();
timer.Enabled = True ' or timer.Start();
Pour arrêter la minuterie, vous pouvez définir Enabled sur false ou appeler la méthode Stop. Ceci est crucial pour éviter que votre application n'exécute des opérations inutiles lorsqu'elles ne sont pas nécessaires.
Le System.Windows.Forms.Timer est un précieux composant Windows Forms conçu pour s'intégrer de manière transparente au modèle événementiel des applications Windows Forms, facilitant les actions régulières sans compromettre la réactivité de l'interface utilisateur.
Dans une application Windows Forms, vous pouvez faire glisser un contrôle de minuterie de la boîte à outils sur votre formulaire, ou le créer par programme comme suit :
System.Windows.Forms.Timer myTimer = new System.Windows.Forms.Timer();
myTimer.Interval = 1000; // 1 second
myTimer.Tick += new EventHandler(TimerEventProcessor);
myTimer.Start();
System.Windows.Forms.Timer myTimer = new System.Windows.Forms.Timer();
myTimer.Interval = 1000; // 1 second
myTimer.Tick += new EventHandler(TimerEventProcessor);
myTimer.Start();
Dim myTimer As New System.Windows.Forms.Timer()
myTimer.Interval = 1000 ' 1 second
AddHandler myTimer.Tick, AddressOf TimerEventProcessor
myTimer.Start()
Ici, TimerEventProcessor est un gestionnaire d'événements qui sera appelé à chaque fois que l'événement Tick se produit, ce qui est similaire à l'événement Elapsed dans System.Timers.Timer.
Lorsque vous travaillez avec des timers, il est essentiel de comprendre le modèle de threading de votre application. Les System.Timers.Timer et System.Threading.Timer exécutent leurs rappels sur un thread du pool de threads, ce qui permet une exécution parallèle. Toutefois, cela peut entraîner des problèmes de sécurité des threads si votre méthode de rappel modifie des données partagées ou interagit avec des éléments de l'interface utilisateur. Pour mettre à jour en toute sécurité les éléments de l'interface utilisateur à partir d'un rappel de temporisation, vous devez marshaller l'appel vers le thread de l'interface utilisateur à l'aide de techniques spécifiques au type de votre application (par exemple, en utilisant Invoke ou BeginInvoke dans Windows Forms).
Pour les applications nécessitant une synchronisation de haute précision (par exemple, les applications multimédias ou les jeux)la classe System.Diagnostics.Stopwatch peut être plus appropriée qu'une minuterie pour mesurer le temps écoulé avec une grande précision. Bien qu'elle ne soit pas une minuterie à proprement parler, la classe Stopwatch peut être utilisée en conjonction avec une minuterie pour obtenir des mesures de temps précises.
Un scénario courant dans lequel un minuteur est utile est la création d'un compte à rebours. Pour ce faire, il suffit de régler l'intervalle de la minuterie sur une seconde (1000 millisecondes) et en diminuant un compteur à chaque fois que le temps est écoulé. Lorsque le compteur atteint zéro, la minuterie s'arrête, signalant la fin du compte à rebours.
using System;
namespace CountdownApp
{
class Program
{
static int countdownTime = 10; // Countdown from 10 seconds
// public static void main
public static void Main(string [] args)
{
StartCountdown();
Console.ReadLine(); // Prevent console from closing immediately
}
static void StartCountdown()
{
var timer = new System.Timers.Timer(1000); // Tick every second, var timer
timer.Elapsed += UpdateCountdown;
timer.Enabled = true;
}
// public static void printtimes
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
}
}
}
}
using System;
namespace CountdownApp
{
class Program
{
static int countdownTime = 10; // Countdown from 10 seconds
// public static void main
public static void Main(string [] args)
{
StartCountdown();
Console.ReadLine(); // Prevent console from closing immediately
}
static void StartCountdown()
{
var timer = new System.Timers.Timer(1000); // Tick every second, var timer
timer.Elapsed += UpdateCountdown;
timer.Enabled = true;
}
// public static void printtimes
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 static void main
Public Shared Sub Main(ByVal args() As String)
StartCountdown()
Console.ReadLine() ' Prevent console from closing immediately
End Sub
Private Shared Sub StartCountdown()
Dim timer = New System.Timers.Timer(1000) ' Tick every second, var timer
AddHandler timer.Elapsed, AddressOf UpdateCountdown
timer.Enabled = True
End Sub
' public static void printtimes
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 Namespace
Voici le résultat du code ci-dessus :
Les temporisateurs peuvent être utilisés pour effectuer des contrôles réguliers sur une base de données, par exemple pour rechercher de nouvelles données ou nettoyer d'anciens enregistrements. Cet exemple met en place une minuterie pour interroger une base de données toutes les heures :
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 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 Sub
IronPDF est particulièrement apprécié pour sa facilité à générer des PDF à partir de HTML ou d'URL, ce qui permet à votre application d'"imprimer" n'importe quel fichier PDF Contenu HTML en tant que document PDF. Cette fonction est extrêmement utile pour générer des rapports, des factures ou tout autre contenu web devant être présenté dans un format standardisé. IronPDF prend également en charge des fonctions avancées telles que les styles CSS, JavaScript et les polices personnalisées, ce qui garantit que les PDF générés conservent la fidélité du contenu web.
L'une des principales caractéristiques d'IronPDF est son HTML vers PDF en préservant les mises en page et les styles. Il génère des PDF à partir de contenus web, ce qui est idéal pour les rapports, les factures et la documentation. Les fichiers HTML, les URL et les chaînes HTML peuvent être facilement convertis en PDF.
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");
}
}
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 Class
Vous pouvez installer IronPDF à l'aide du gestionnaire de paquets NuGet en exécutant cette commande :
Install-Package IronPdf
Imaginez que vous ayez besoin de générer un rapport quotidien au format PDF, contenant des données mises à jour chaque jour. Pour simplifier, nous allons générer un rapport HTML de base et le convertir en PDF à l'aide d'IronPDF toutes les 24 heures. Dans votre application C#, vous allez configurer un System.Timers.Timer pour qu'il se déclenche toutes les 24 heures. Il est important de noter que l'intervalle est défini en millisecondes, de sorte que 24 heures sont représentées par 24 * _60*_60 * 1000
millisecondes.
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}");
}
}
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 Class
Une fois le code exécuté, la console affichera la sortie suivante. Ici, j'ai modifié le code pour une sortie rapide, j'utilise donc une minuterie de 10 secondes.
Voici le PDF généré :
En conclusion, l'intégration de temporisateurs C# à IronPDF constitue une approche puissante pour automatiser la génération et la gestion de documents PDF dans les applications .NET. Dans les exemples fournis, nous avons exploré la manière de configurer une minuterie C# pour déclencher des tâches de génération de PDF à intervalles réguliers, que ce soit à des fins de tests fréquents ou de génération de rapports programmés.
Grâce aux minuteries C#, nous pouvons contrôler avec précision le moment où nos tâches liées aux PDF sont exécutées, ce qui permet des mises à jour régulières, la génération de rapports ou toute autre tâche devant se dérouler selon un calendrier. IronPDF renforce cette capacité en offrant un moyen simple et efficace de créer, manipuler et enregistrer des documents PDF basés sur un contenu dynamique, HTML ou même des pages web.
IronPDF offre un service de essai gratuit pour que les développeurs puissent explorer ses fonctionnalités, avec des licences disponibles à partir de $749 pour un accès et un support complets. Il s'agit d'un moyen rentable de mettre en œuvre des fonctionnalités PDF complètes dans vos applications .NET.
9 produits de l'API .NET pour vos documents de bureau