C# Warten auf Sekunden (Wie es für Entwickler funktioniert)

Der Befehl Sleep

'Sleep' ist ein einfacher, aber leistungsstarker Befehl, mit dem Sie die Ausführung Ihrer aktuellen Aufgabe für einen bestimmten Zeitraum pausieren können, wobei Sie Ihr Programm im Grunde anweisen, vor dem Fortfahren mit der nächsten Aufgabe zu warten. In C# tun wir dies, indem wir die Thread.Sleep(int milliseconds)-Methode verwenden, wie im folgenden Codebeispiel:

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");
    }
}

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");
    }
}

Hier startet das Programm, indem es "Programm startet..." auf die Konsole ausgibt, bevor es die Thread.Sleep-Methode verwendet, um für 3.000 Millisekunden (oder drei Sekunden) zu pausieren. Nach der angegebenen Verzögerung wird das Programm fortgesetzt und gibt die Ausgabe "...Programm geht nach 3 Sekunden weiter" in die Konsole aus.

Async-Methode und Aufgaben

Asynchrone Methoden in C# ermöglichen es Ihnen, mehrere Aufgaben gleichzeitig auszuführen, ohne den Hauptthread zu beeinflussen. Das bedeutet, dass während eine Aufgabe wartet, andere Aufgaben weiterlaufen können. Um eine asynchrone Methode zu implementieren, müssen Sie das async-Schlüsselwort und die Task-Klasse verwenden.

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");
   }
}

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");
   }
}

In diesem Codebeispiel haben wir zwei Aufgaben, die gleichzeitig laufen. Die DoSomethingAsync-Methode nimmt einen int-Parameter, der die Zeit in Millisekunden darstellt, die die Aufgabe verzögert werden soll (wie Sie im 3000 und 2000 im Code sehen, beide ein Timeout-Wert). Die Task.Delay-Methode ist ähnlich der Thread.Sleep()-Methode, arbeitet jedoch mit asynchronen Aufgaben und blockiert den Haupt-Thread nicht.

Verwendung von Timern zur Planung von Aufgaben

Timer in C# ermöglichen es Ihnen, eine bestimmte Aufgabe nach einem bestimmten Intervall auszuführen. Sie können einen Timer mit der System.Timers.Timer-Klasse erstellen. Hier ist ein Beispiel, wie Sie einen Timer in einer Konsolenanwendung verwenden:

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);
   }
}

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);
   }
}

In dem obigen Beispiel erstellen wir einen Timer mit einem 1-Sekunden-Intervall. Die OnTimerElapsed-Methode wird jedes Mal ausgeführt, wenn der Timer tickt. Wir setzen die AutoReset-Eigenschaft auf true, damit der Timer nach jedem Tick automatisch neu startet. Die Enabled-Eigenschaft wird auf true gesetzt, um den Timer zu starten.

Wenn Sie diese Konsolenanwendung ausführen, sehen Sie, wie der Timer jede Sekunde tickt und die Tick-Zeit in die Konsole ausgibt. Das Programm läuft weiter, bis Sie eine Taste drücken, um es zu beenden.

Benutzerdefinierte Wartefunktionen erstellen

Manchmal benötigen Sie möglicherweise eine benutzerdefinierte Wartefunktion, um spezifische Anforderungen in Ihrem Code zu erfüllen. Zum Beispiel möchten Sie möglicherweise eine Wartefunktion erstellen, die nur die aktuelle Aufgabe blockiert, nicht jedoch den gesamten Thread. Dies können Sie mit asynchronen Delegaten erreichen.

Hier ist ein Beispiel für eine benutzerdefinierte Wartefunktion:

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
   }
}

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
   }
}

Hier akzeptiert die CustomWaitAsync-Methode einen int-Parameter, der die Verzögerungszeit in Millisekunden darstellt. Die Methode verwendet einen asynchronen Delegaten, um die Thread.Sleep-Funktion innerhalb einer neuen Aufgabe auszuführen, wodurch sichergestellt wird, dass der Status der aktuellen Aufgabe blockiert ist, während gewartet wird, jedoch nicht der Haupt-Thread.

Auswahl der richtigen Wartestrategie

Da wir nun die C#-Wartedeclaration, den Sleep-Befehl, asynchrone Methoden, Timer und benutzerdefinierte Wartefunktionen behandelt haben, ist es wichtig zu wissen, wann welche Technik eingesetzt werden sollte. Hier ist eine kurze Zusammenfassung:

• Verwenden Sie die Thread.Sleep-Funktion, wenn Sie eine einfache Möglichkeit benötigen, die Ausführung Ihres Codes für einen bestimmten Zeitraum zu unterbrechen.
• Verwenden Sie asynchrone Methoden und Aufgaben, wenn Sie mehrere Aufgaben gleichzeitig ausführen möchten, ohne den Hauptthread zu blockieren.
• Verwenden Sie Timer, wenn Sie eine bestimmte Aufgabe in einem bestimmten Intervall ausführen müssen.
• Erstellen Sie benutzerdefinierte Wartefunktionen, wenn Sie spezifische Anforderungen haben, die von den eingebauten Methoden nicht erfüllt werden.

Die IronPDF-Bibliothek installieren

Install-Package IronPdf

Wie man C# Wait in IronPDF verwendet

Sie können sehen, wie eine Wartefunktion in IronPDF integriert wird, im folgenden Beispiel:

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");
   }
}

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");
   }
}

Hier verwenden wir die Task.Delay-Methode, um 3 Sekunden zu warten, bevor ein PDF generiert wird. Das PDF wird dann als "HelloWorld.pdf" im Arbeitsverzeichnis der Anwendung gespeichert, wenn das Warten abgeschlossen ist.

Und hier ist das Endprodukt:

Verwendung der Wait-Methode mit IronPDF

In C#-Anwendungen können Sie die Schlaf-Funktion effizient verwenden, um den aktuellen Thread und die CPU-Zeit zu verwalten, während Sie Vorgänge wie das Laden von Daten in eine DataTable oder das Generieren von PDF-Berichten mit IronPDF ausführen.