C# Timer (So funktioniert es für Entwickler)

Einführung

Timer-Klassen in C# sind leistungsstarke Werkzeuge, um die Ausführung von Code in bestimmten Intervallen zu planen. Unabhängig davon, ob Sie eine Windows-Form-Anwendung oder eine Konsolenanwendung entwickeln, sollten Sie verstehen, wie man eine zeitschaltuhr kann die Funktionalität Ihrer Anwendung erheblich verbessern. In diesem Tutorial lernen Sie die Grundlagen der Verwendung von Zeitgebern in C# kennen. Sie erfahren, wie Sie sie einrichten, ihre Ereignisse behandeln und sicherstellen, dass sie in Ihrer Anwendung reibungslos funktionieren. Wir besprechen auch IronPDF unsere PDF-Generierung mit Timer in C# zu automatisieren.

Einführung in Timer-Klassen in C##

C# bietet mehrere Timer-Klassen, die jeweils für unterschiedliche Aufgaben und Umgebungen geeignet sind. Die am häufigsten verwendeten Zeitgeberklassen sind System.Timers.Timer für serverbasierte Zeitgeber und System.Windows.Forms.Timer für Windows Forms-Anwendungen. Das Verständnis der Rolle von Event-Handlern ist bei der Arbeit mit Timer-Klassen von entscheidender Bedeutung, da diese Handler die Aktionen diktieren, die zu jedem bedeutsamen Zeitpunkt ausgeführt werden, der vom Timer diktiert wird, wie z. B. das Tick- oder das verstrichene Ereigniszeitintervall.

Einrichten eines neuen Timers

Die Konfiguration des Zeitintervalls Ihres Timers ist für dessen Betrieb von grundlegender Bedeutung. Sie bestimmt, wie häufig die Event-Handler des Timers aufgerufen werden und steuert damit den Rhythmus der zeitabhängigen Funktionen der Anwendung. Um einen Timer in Ihrer C#-Anwendung zu verwenden, insbesondere bei der Entwicklung von Windows Forms-Anwendungen, fügen Sie zunächst die Komponente System.Windows.Forms.Timer aus der Toolbox in Ihr Formular ein, oder Sie erstellen programmatisch ein Timer-Objekt für mehr Flexibilität.

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

Mit dieser einfachen Einrichtung wird ein Timer erstellt, der alle 2 Sekunden tickt. Damit der Timer jedoch Aktionen ausführen kann, müssen Sie ihn mit einem Event-Handler verbinden.

Behandlung des Ereignisses "Abgelaufen

Indem Sie einen Handler für das Ereignis Elapsed eines System.Timers.Timer anhängen, stellen Sie sicher, dass Ihre Anwendung in jedem Intervall Aufgaben ausführen kann, um effektiv auf zeitbasierte Auslöser zu reagieren. Dieses Ereignis wird jedes Mal ausgelöst, wenn das Intervall des Timers abgelaufen ist. Sie fügen diesem Ereignis einen Handler zu, um festzulegen, was geschehen soll, wenn der Timer tickt:

timer.Elapsed += OnTimedEvent;

timer.Elapsed += OnTimedEvent;

timer.Elapsed += OnTimedEvent

Im obigen Code ist OnTimedEvent eine von Ihnen definierte Methode, die immer dann aufgerufen wird, wenn das Ereignis Elapsed des Timers ausgelöst wird.

Erstellen eines Ereignis-Handlers

Bei der Definition eines Timer-Ereignishandlers erstellen Sie eine Methode, die als Reaktion auf die Tick-Ereignisse des Timers ausgeführt wird und eine genaue Kontrolle über die in vordefinierten Intervallen durchgeführten Aktionen ermöglicht. Ein Event-Handler für das Ereignis Elapsed eines Timers sieht typischerweise so aus:

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

Diese Methode gibt einfach die aktuelle Zeit auf der Konsole aus, wenn der Timer abläuft, und zeigt, wie man auf das Timer-Ereignis reagiert.

Starten und Stoppen des Timers

Nachdem Sie den Timer und seinen Event-Handler eingerichtet haben, müssen Sie den Timer starten. Dies geschieht, indem Sie die Eigenschaft Enabled auf true setzen oder die Methode Start aufrufen:

timer.Enabled = true; // or timer.Start();

timer.Enabled = true; // or timer.Start();

timer.Enabled = True ' or timer.Start();

Um den Timer anzuhalten, können Sie Enabled auf false setzen oder die Methode Stop aufrufen. Dies ist wichtig, um zu verhindern, dass Ihre Anwendung unnötige Vorgänge ausführt, wenn sie nicht benötigt werden.

Verwendung von Timern in einer Windows Forms-Anwendung

Der System.Windows.Forms.Timer ist eine wertvolle Windows Forms-Komponente, die sich nahtlos in das ereignisgesteuerte Modell von Windows Forms-Anwendungen integrieren lässt und regelmäßige Aktionen ermöglicht, ohne die Reaktionsfähigkeit der Benutzeroberfläche zu beeinträchtigen.

Beispiel: Hinzufügen eines Timers zu einem Formular

In einer Windows Forms-Anwendung können Sie ein Timer-Steuerelement aus der Toolbox auf Ihr Formular ziehen oder es programmatisch wie folgt erstellen:

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

Hier ist TimerEventProcessor ein Ereignis-Handler, der jedes Mal aufgerufen wird, wenn das Tick-Ereignis eintritt, das dem Elapsed-Ereignis in System.Timers.Timer ähnlich ist.

Erweiterte Timer-Verwaltung

Gewindesicherheit mit Timern

Bei der Arbeit mit Timern ist es wichtig, das Threading-Modell Ihrer Anwendung zu verstehen. Der System.Timers.Timer und der System.Threading.Timer führen ihre Rückrufe auf einem Threadpool-Thread aus, was eine parallele Ausführung ermöglicht. Dies kann jedoch zu Problemen mit der Threadsicherheit führen, wenn Ihre Callback-Methode gemeinsam genutzte Daten ändert oder mit Elementen der Benutzeroberfläche interagiert. Um UI-Elemente aus einem Timer-Callback sicher zu aktualisieren, müssen Sie den Aufruf zurück in den UI-Thread marshalen und dabei Techniken verwenden, die für den Typ Ihrer Anwendung spezifisch sind (z. B. mit Invoke oder BeginInvoke in Windows Forms).

Hochpräzises Timing

Für Anwendungen, die eine hochpräzise Zeitmessung erfordern (z. B. Multimedia-Anwendungen oder Spiele)die Klasse System.Diagnostics.Stopwatch kann für die Messung der verstrichenen Zeit mit hoher Genauigkeit besser geeignet sein als ein Timer. Die Klasse Stopwatch ist zwar selbst kein Zeitmesser, kann aber in Verbindung mit einem Zeitmesser verwendet werden, um präzise Zeitmessungen zu erzielen.

Praktische Beispiele

Beispiel: Einrichten eines Countdown-Timers

Ein häufiges Szenario, in dem ein Timer nützlich ist, ist die Erstellung eines Countdown-Timers. Dies kann durch die Einstellung eines Timer-Intervalls von einer Sekunde erreicht werden (1000 Millisekunden) und jedes Mal, wenn der Timer abläuft, wird ein Zähler verringert. Wenn der Zähler Null erreicht, hält der Timer an und signalisiert das Ende des Countdowns.

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

Hier ist die Ausgabe des obigen Codes:

Beispiel: Planen regelmäßiger Datenbanküberprüfungen

Timer können zur regelmäßigen Überprüfung einer Datenbank verwendet werden, z. B. zur Abfrage neuer Daten oder zum Bereinigen alter Datensätze. In diesem Beispiel wird ein Timer eingerichtet, der jede Stunde eine Datenbank abfragt:

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

Einführung in IronPDF

IronPDF wird besonders für seine Benutzerfreundlichkeit bei der Erzeugung von PDFs aus HTML oder URLs gelobt, die es Ihrer Anwendung im Wesentlichen ermöglichen, jede beliebige Datei zu "drucken" HTML-Inhalt als PDF-Dokument. Dies ist äußerst nützlich für die Erstellung von Berichten, Rechnungen oder anderen Webinhalten, die in einem standardisierten Format dargestellt werden müssen. IronPDF unterstützt auch fortschrittliche Funktionen wie CSS-Stile, JavaScript und benutzerdefinierte Schriftarten und stellt so sicher, dass die generierten PDFs den Webinhalten treu bleiben.

Ein herausragendes Merkmal von IronPDF ist seine HTML zu PDF fähigkeit, Layouts und Stile beizubehalten. Es erzeugt PDFs aus Webinhalten, die sich ideal für Berichte, Rechnungen und Dokumentationen eignen. HTML-Dateien, URLs und HTML-Strings können problemlos in PDFs umgewandelt werden.

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

Installation von IronPDF

Sie können IronPDF mit dem NuGet Package Manager installieren, indem Sie diesen Befehl ausführen:

Install-Package IronPdf

Beispiel

Stellen Sie sich vor, Sie müssen täglich einen Bericht im PDF-Format erstellen, der täglich aktualisierte Daten enthält. Der Einfachheit halber erstellen wir einen einfachen HTML-Bericht und konvertieren ihn mit IronPDF alle 24 Stunden in PDF. In Ihrer C#-Anwendung werden Sie einen System.Timers.Timer einrichten, der alle 24 Stunden ausgelöst wird. Es ist wichtig zu beachten, dass das Intervall in Millisekunden angegeben wird, so dass 24 Stunden als "24 _60_60 * 1000" Millisekunden dargestellt werden.

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

Ausgabe

Sobald Sie den Code ausführen, wird die folgende Ausgabe in der Konsole angezeigt. Hier habe ich den Code für eine schnelle Ausgabe geändert, so dass ich einen 10-Sekunden-Timer verwende.

Hier ist das generierte PDF:

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die Integration von C#-Timern mit IronPDF einen leistungsstarken Ansatz zur Automatisierung der Erstellung und Verwaltung von PDF-Dokumenten in .NET-Anwendungen darstellt. Anhand von Beispielen haben wir untersucht, wie man einen C#-Timer einrichtet, um PDF-Generierungsaufgaben in regelmäßigen Abständen auszulösen, sei es für häufige Testzwecke oder für die geplante Berichterstellung.

Mithilfe von C#-Timern können wir genau steuern, wann unsere PDF-bezogenen Aufgaben ausgeführt werden. Dies ermöglicht regelmäßige Aktualisierungen, die Erstellung von Berichten oder andere Aufgaben, die nach einem Zeitplan ablaufen müssen. IronPDF erweitert diese Fähigkeit, indem es eine einfache und effiziente Möglichkeit bietet, PDF-Dokumente zu erstellen, zu bearbeiten und zu speichern, die auf dynamischen Inhalten, HTML oder sogar Webseiten basieren.

IronPDF bietet eine kostenloser Test für Entwickler, um die Funktionen zu erkunden. Lizenzen sind ab $749 für vollen Zugriff und Support erhältlich. Dies bietet eine kostengünstige Möglichkeit, umfassende PDF-Funktionen in Ihre .NET-Anwendungen zu implementieren.