AIDE .NET

Timer en C# (Comment ça marche pour les développeurs)

Publié mars 6, 2024

Introduction

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'unminuterie 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 de la manière d'utiliserIronPDF pour la génération automatisée de PDF dans les applications C# pour automatiser notre génération de PDF à l'aide d'un Timer en C#.

Introduction aux classes de temporisation en C# ;

Timer C# (Comment ça marche pour les développeurs) : Figure 1 - Classe Timer

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.

Configuration d'une nouvelle minuterie

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

VB C#

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.

Gestion de l'événement Elapsed

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

VB C#

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é.

Création d'un gestionnaire d'événements

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

VB C#

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.

Démarrage et arrêt 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();

VB C#

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.

Utilisation de temporisateurs dans une application Windows Forms

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.

Exemple : Ajout d'une minuterie à un formulaire

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()

VB C#

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.

Gestion avancée des minuteries

Sécurité des fils avec des minuteries

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).

Timing de haute précision

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.

Exemples pratiques

Exemple : Mise en œuvre d'un compte à rebours

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

VB C#

Voici le résultat du code ci-dessus :

Minuterie C# (Comment ça marche pour les développeurs) : Figure 2 - Sortie du compte à rebours

Exemple : Programmation de vérifications régulières de la base de données

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

VB C#

Introduction à IronPDF

IronPDF - Générer facilement des PDF à partir de HTML et ASPX 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 PDFContenu HTML sous forme de 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 sonConversion de HTML en 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

VB C#

Installation d'IronPDF

Vous pouvez installer IronPDF à l'aide du gestionnaire de paquets NuGet en exécutant cette commande :

Install-Package IronPdf

Exemple

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

VB C#

Sortie

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.

Minuterie C# (Comment ça marche pour les développeurs) : Figure 3 - Sortie de la console

Voici le PDF généré :

Timer C# (Comment ça marche pour les développeurs) : Figure 4 - Rapport PDF

Conclusion

Timer C# (Comment ça marche pour les développeurs) : Figure 5 - Licence

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 deessai gratuit avec informations sur les licencesla traduction doit être réalisée en anglais, avec des licences disponibles pour un accès et une assistance complets. Il s'agit d'un moyen rentable de mettre en œuvre des fonctionnalités PDF complètes dans vos applications .NET.

< PRÉCÉDENT
Graphql C# (Comment ça marche pour les développeurs)

SUIVANT >
Math.Round C# (Comment ça marche pour les développeurs)