.NET-HILFE

C# Thread Sleep-Methode (Wie es funktioniert für Entwickler)

Veröffentlicht 6. März 2024

Teilen Sie:

Einführung

Multithreading ist ein wichtiger Aspekt der modernen Softwareentwicklung, der es Entwicklern ermöglicht, mehrere Aufgaben gleichzeitig auszuführen und so die Leistung und Reaktionsfähigkeit zu verbessern. Die effektive Verwaltung von Threads erfordert jedoch eine sorgfältige Berücksichtigung von Synchronisierung und Koordination. Ein wesentliches Werkzeug im Arsenal eines C#-Entwicklers für die Verwaltung von Thread-Timing und Koordination ist die Thread.Sleep() methode.

In diesem Artikel werden wir uns mit den Feinheiten der Thread.Sleep() methode, wobei ihr Zweck, ihre Verwendung, mögliche Fallstricke und Alternativen untersucht werden. Außerdem stellen wir in diesem Artikel die IronPDFc# PDF-Bibliothek von Iron Softwaredas die programmatische Erstellung von PDF-Dokumenten erleichtert.

Verstehen Thread.Sleep()

Die Thread.Sleep() methode ist Teil des System.Threading-Namespace in C# und wird verwendet, um die Ausführung des aktuellen Threads für eine bestimmte Zeit zu blockieren. Der wartende Thread oder der blockierte Thread hält die Ausführung bis zu der für Sleep angegebenen Zeit an. Die Sleep-Methode benötigt ein einzelnes Argument, das das Zeitintervall angibt, für das der Thread inaktiv bleiben soll. Das Argument kann in Millisekunden oder als TimeSpan-Objekt angegeben werden, wodurch die gewünschte Pausendauer flexibel ausgedrückt werden kann.

// Using Thread.Sleep() with a specified number of milliseconds
Thread.Sleep(1000); // block for 1 second
// Using Thread.Sleep() with TimeSpan
TimeSpan sleepDuration = TimeSpan.FromSeconds(2);
Thread.Sleep(sleepDuration); // block for 2 seconds

// Using Thread.Sleep() with a specified number of milliseconds
Thread.Sleep(1000); // block for 1 second
// Using Thread.Sleep() with TimeSpan
TimeSpan sleepDuration = TimeSpan.FromSeconds(2);
Thread.Sleep(sleepDuration); // block for 2 seconds

' Using Thread.Sleep() with a specified number of milliseconds
Thread.Sleep(1000) ' block for 1 second
' Using Thread.Sleep() with TimeSpan
Dim sleepDuration As TimeSpan = TimeSpan.FromSeconds(2)
Thread.Sleep(sleepDuration) ' block for 2 seconds

VB C#

Zweck von `Thread.Sleep`

Der Hauptzweck der Verwendung von Thread.Sleep ist es, eine Verzögerung oder Pause in der Ausführung eines Threads einzuführen. Dies kann in verschiedenen Szenarien von Vorteil sein, z. B.:

Simulation von Echtzeitverhalten: In Szenarien, in denen die Anwendung Echtzeitverhalten simulieren muss, kann die Einführung von Verzögerungen dazu beitragen, die zeitlichen Beschränkungen des zu modellierenden Systems zu imitieren.
Vermeidung von übermäßigem Ressourcenverbrauch: Das Pausieren eines Threads für eine kurze Dauer kann in Szenarien nützlich sein, in denen eine konstante Ausführung unnötig ist, um unnötigen Ressourcenverbrauch zu vermeiden.
Thread-Koordination: Bei der Arbeit mit mehreren Threads kann die Einführung von Pausen dazu beitragen, deren Ausführung zu synchronisieren, um Wettlaufbedingungen zu verhindern und eine ordnungsgemäße Verarbeitung zu gewährleisten.

Beispiel aus der Praxis

Betrachten wir ein reales Beispiel, bei dem die Funktion `Thread.Sleep()die Methode kann zur Simulation einer Ampelsteuerung eingesetzt werden. In diesem Szenario werden wir eine einfache Konsolenanwendung erstellen, die das Verhalten einer Ampel mit roten, gelben und grünen Signalen modelliert.

using System .Threading;
public class TrafficLightSimulator
{
    static void Main()
    {
        Console.WriteLine("Traffic Light Simulator");
        while (true)
        {
            // Display the red light
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"Stop! Red light - {DateTime.Now.ToString("u")}");
            Thread.Sleep(5000); // Pause for 5 seconds and start execution
            // Display the yellow light
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine($"Get ready! Yellow light - {DateTime.Now.ToString("u")}");
            Thread.Sleep(2000); // Pause for 2 seconds
            // Display the green light
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine($"Go! Green light - {DateTime.Now.ToString("u")}");
            Thread.Sleep(5000); // Pause for 5 seconds
            // Reset console color
            Console.ResetColor();
            Console.Clear();
        }
    }
}

using System .Threading;
public class TrafficLightSimulator
{
    static void Main()
    {
        Console.WriteLine("Traffic Light Simulator");
        while (true)
        {
            // Display the red light
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine($"Stop! Red light - {DateTime.Now.ToString("u")}");
            Thread.Sleep(5000); // Pause for 5 seconds and start execution
            // Display the yellow light
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine($"Get ready! Yellow light - {DateTime.Now.ToString("u")}");
            Thread.Sleep(2000); // Pause for 2 seconds
            // Display the green light
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine($"Go! Green light - {DateTime.Now.ToString("u")}");
            Thread.Sleep(5000); // Pause for 5 seconds
            // Reset console color
            Console.ResetColor();
            Console.Clear();
        }
    }
}

Imports System.Threading
Public Class TrafficLightSimulator
	Shared Sub Main()
		Console.WriteLine("Traffic Light Simulator")
		Do
			' Display the red light
			Console.ForegroundColor = ConsoleColor.Red
			Console.WriteLine($"Stop! Red light - {DateTime.Now.ToString("u")}")
			Thread.Sleep(5000) ' Pause for 5 seconds and start execution
			' Display the yellow light
			Console.ForegroundColor = ConsoleColor.Yellow
			Console.WriteLine($"Get ready! Yellow light - {DateTime.Now.ToString("u")}")
			Thread.Sleep(2000) ' Pause for 2 seconds
			' Display the green light
			Console.ForegroundColor = ConsoleColor.Green
			Console.WriteLine($"Go! Green light - {DateTime.Now.ToString("u")}")
			Thread.Sleep(5000) ' Pause for 5 seconds
			' Reset console color
			Console.ResetColor()
			Console.Clear()
		Loop
	End Sub
End Class

VB C#

In dem obigen Programmbeispiel haben wir eine einfache Ampelsimulation innerhalb einer while-Schleife. Der Thread.Sleep() methode wird verwendet, um Verzögerungen zwischen den Übergängen der Lichtsignale einzuführen. Das Beispiel funktioniert folgendermaßen:

Das Programm geht in eine Endlosschleife, um einen Dauerbetrieb zu simulieren.
Das rote Licht wird 5 Sekunden lang angezeigt, was ein Haltesignal darstellt.
Nach 5 Sekunden leuchtet das gelbe Licht für 2 Sekunden auf und zeigt damit eine Vorbereitungsphase an.
Schließlich leuchtet das grüne Licht für 5 Sekunden auf und die Fahrzeuge können weiterfahren.
Die Farbe der Konsole wird zurückgesetzt, und die Schleife wird wiederholt.

Ausgabe

C#-Thread-Sleep-Methode (So funktioniert es für Entwickler): Abbildung 1 - Programmausgabe: Anzeige des Ampelsimulators mit der Methode Thread.Sleep().

Dieses Beispiel zeigt, wie Thread.Sleep() kann verwendet werden, um das Timing einer Ampelsimulation zu steuern, was eine einfache Möglichkeit darstellt, das Verhalten eines realen Systems zu modellieren. Denken Sie daran, dass dies ein einfaches Beispiel zur Veranschaulichung ist. In einer komplexeren Anwendung möchten Sie vielleicht fortschrittlichere Threading- und Synchronisierungstechniken für die Verarbeitung von Benutzereingaben, die Verwaltung mehrerer Ampeln und die Sicherstellung eines genauen Zeitplans erkunden.

Zeitspannen-Timeout in der Sleep-Methode verwenden

Sie können TimeSpan mit dem Thread.Sleep verwenden() methode, um die Schlafdauer festzulegen. Hier ist ein Beispiel, das die Ampelsimulation aus dem vorherigen Beispiel erweitert und TimeSpan verwendet:

using System;
using System.Threading;
class TrafficLightSimulator
{
    public static void Main()
    {
        Console.WriteLine("Traffic Light Simulator");
        while (true)
        {
            // Display the red light
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Stop! Red light- {DateTime.Now.ToString("u")}");
            Thread.Sleep(TimeSpan.FromSeconds(5)); // Pause for 5 seconds
            // Display the yellow light
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Get ready! Yellow light-     {DateTime.Now.ToString("u")}");
            Thread.Sleep(TimeSpan.FromSeconds(2)); // Pause for 2 seconds
            // Display the green light
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Go! Green light- {DateTime.Now.ToString("u")}");
            Thread.Sleep(TimeSpan.FromSeconds(5)); // Pause for 5 seconds
            // Reset console color
            Console.ResetColor();
            Console.Clear();
        }
    }
}

using System;
using System.Threading;
class TrafficLightSimulator
{
    public static void Main()
    {
        Console.WriteLine("Traffic Light Simulator");
        while (true)
        {
            // Display the red light
            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("Stop! Red light- {DateTime.Now.ToString("u")}");
            Thread.Sleep(TimeSpan.FromSeconds(5)); // Pause for 5 seconds
            // Display the yellow light
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine("Get ready! Yellow light-     {DateTime.Now.ToString("u")}");
            Thread.Sleep(TimeSpan.FromSeconds(2)); // Pause for 2 seconds
            // Display the green light
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine("Go! Green light- {DateTime.Now.ToString("u")}");
            Thread.Sleep(TimeSpan.FromSeconds(5)); // Pause for 5 seconds
            // Reset console color
            Console.ResetColor();
            Console.Clear();
        }
    }
}

Imports System
Imports System.Threading
Friend Class TrafficLightSimulator
	Public Shared Sub Main()
		Console.WriteLine("Traffic Light Simulator")
		Do
			' Display the red light
			Console.ForegroundColor = ConsoleColor.Red
			Console.WriteLine("Stop! Red light- {DateTime.Now.ToString("u")}")
			Thread.Sleep(TimeSpan.FromSeconds(5)) ' Pause for 5 seconds
			' Display the yellow light
			Console.ForegroundColor = ConsoleColor.Yellow
			Console.WriteLine("Get ready! Yellow light-     {DateTime.Now.ToString("u")}")
			Thread.Sleep(TimeSpan.FromSeconds(2)) ' Pause for 2 seconds
			' Display the green light
			Console.ForegroundColor = ConsoleColor.Green
			Console.WriteLine("Go! Green light- {DateTime.Now.ToString("u")}")
			Thread.Sleep(TimeSpan.FromSeconds(5)) ' Pause for 5 seconds
			' Reset console color
			Console.ResetColor()
			Console.Clear()
		Loop
	End Sub
End Class

VB C#

In diesem geänderten Beispiel wird TimeSpan.FromSeconds() wird verwendet, um ein TimeSpan-Objekt zu erstellen, das die gewünschte Schlafdauer darstellt. Dadurch wird der Code besser lesbar und aussagekräftiger.

Durch die Verwendung der Eigenschaft TimeSpan in der Datei `Thread.Sleep()methode können Sie die Dauer direkt in Sekunden angeben (oder jede andere von TimeSpan unterstützte Einheit)und bietet eine intuitivere Möglichkeit, mit Zeitintervallen zu arbeiten. Dies kann besonders nützlich sein, wenn Sie in Ihrer Anwendung mit längeren oder komplexeren Schlafdauern arbeiten.

Anwendungsfälle

Simulation von Echtzeitverhalten: Betrachten Sie eine Simulationsanwendung, bei der Sie das Verhalten eines Echtzeitsystems modellieren müssen. Durch strategisches Platzieren von `Thread.Sleep()in Ihrem Code können Sie die Zeitverzögerungen, die im tatsächlichen System auftreten, nachahmen und so die Genauigkeit Ihrer Simulation erhöhen.

// Simulating real-time behavior with Thread.Sleep()
SimulateRealTimeEvent();
Thread.Sleep(1000); // Pause for 1 second
SimulateNextEvent();

// Simulating real-time behavior with Thread.Sleep()
SimulateRealTimeEvent();
Thread.Sleep(1000); // Pause for 1 second
SimulateNextEvent();

' Simulating real-time behavior with Thread.Sleep()
SimulateRealTimeEvent()
Thread.Sleep(1000) ' Pause for 1 second
SimulateNextEvent()

VB C#

Animation und UI-Updates: Bei der Entwicklung von grafischen Webanwendungen oder Spielen sind reibungslose Animationen und UI-Updates entscheidend. `Thread.Sleep()kann die Bildrate gesteuert werden, um sicherzustellen, dass die Aktualisierungen in einem visuell angenehmen Tempo erfolgen.

// Updating UI with controlled delays
UpdateUIElement();
Thread.Sleep(50); // Pause for 50 milliseconds
UpdateNextUIElement();

// Updating UI with controlled delays
UpdateUIElement();
Thread.Sleep(50); // Pause for 50 milliseconds
UpdateNextUIElement();

' Updating UI with controlled delays
UpdateUIElement()
Thread.Sleep(50) ' Pause for 50 milliseconds
UpdateNextUIElement()

VB C#

Drosselung externer Dienstaufrufe: Bei der Interaktion mit externen Diensten oder APIs ist es üblich, Ratenbegrenzungen oder Drosselungen einzuführen, um übermäßige Anfragen zu verhindern. Thread.Sleep() kann eingesetzt werden, um Verzögerungen zwischen aufeinanderfolgenden Serviceabrufen einzuführen, ohne dass die Tarifgrenzen überschritten werden.

// Throttling service calls with Thread.Sleep()
CallExternalService();
Thread.Sleep(2000); // Pause for 2 seconds before the next call
CallNextService();

// Throttling service calls with Thread.Sleep()
CallExternalService();
Thread.Sleep(2000); // Pause for 2 seconds before the next call
CallNextService();

' Throttling service calls with Thread.Sleep()
CallExternalService()
Thread.Sleep(2000) ' Pause for 2 seconds before the next call
CallNextService()

VB C#

Vorteile von Thread.Sleep()

Synchronisierung und Koordinierung: `Thread.Sleep()hilft bei der Synchronisierung der Thread-Ausführung, verhindert Wettlaufsituationen und gewährleistet eine ordnungsgemäße Verarbeitung bei der Arbeit mit mehreren Threads.
Ressourcenschonung: Das vorübergehende Anhalten eines Threads kann in Szenarien, in denen eine konstante Ausführung unnötig ist, vorteilhaft sein und schont die Systemressourcen.
Einfachheit und Lesbarkeit: Die Methode bietet eine einfache und lesbare Möglichkeit zur Einführung von Verzögerungen, wodurch der Code verständlicher wird, insbesondere für Entwickler, die mit Multithreading-Konzepten noch nicht vertraut sind.

Potenzielle Fallstricke und Überlegungen

While `Thread.Sleep()auch wenn die Einführung von Verzögerungen eine unkomplizierte Lösung ist, gibt es potenzielle Fallstricke und Überlegungen, die Entwickler beachten sollten:

Blockieren des Threads: Wenn ein Thread mit Thread.Sleep' pausiert wird(), ist er effektiv blockiert, und während dieser Zeit kann keine andere Arbeit ausgeführt werden. In Szenarien, in denen die Reaktionsfähigkeit von entscheidender Bedeutung ist, kann das Blockieren des Hauptthreads über längere Zeiträume zu einer schlechten Benutzererfahrung führen.
Ungenauigkeit der Zeitmessung: Die Genauigkeit der Pausendauer hängt von der Zeitplanung des zugrunde liegenden Betriebssystems ab und ist möglicherweise nicht präzise. Entwickler sollten vorsichtig sein, wenn sie sich auf Thread.Sleep' verlassen() für genaue Zeitvorgaben.
Alternative Ansätze: In der modernen C#-Entwicklung gibt es Alternativen wie die Task.Delay()methode oder die asynchrone Programmierung mitasync/awaitwerden oft gegenüberThread.Sleepbevorzugt(). Diese Ansätze bieten eine bessere Reaktionsfähigkeit ohne blockierende Threads.

// Using Task.Delay() instead of Thread.Sleep()
await Task.Delay(1000); // Pause for 1 second asynchronously

// Using Task.Delay() instead of Thread.Sleep()
await Task.Delay(1000); // Pause for 1 second asynchronously

' Using Task.Delay() instead of Thread.Sleep()
Await Task.Delay(1000) ' Pause for 1 second asynchronously

VB C#

Einführung in IronPDF

IronPDFvon Iron Software entwickelt, ist eine C#-PDF-Bibliothek, die sowohl als PDF-Generator als auch als PDF-Leser dient. In diesem Abschnitt werden die grundlegenden Funktionen vorgestellt. Weitere Einzelheiten finden Sie in der dokumentation seite.

Der Clou von IronPDF ist seine HTML zu PDF funktion, damit alle Layouts und Stile erhalten bleiben. Es wandelt Webinhalte in PDF-Dateien um, die für Berichte, Rechnungen und Dokumentationen nützlich sind. 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

VB C#

Einrichtung

Zum Installieren IronPDFverwenden Sie entweder die NuGet-Paketmanager-Konsole oder den Visual Studio-Paketmanager.

Installieren Sie die IronPDF-Bibliothek über die NuGet-Paketmanager-Konsole mit einem der folgenden Befehle:

dotnet add package IronPdf
# or
Install-Package IronPdf

Installieren Sie die IronPDF-Bibliothek mit dem Paketmanager von Visual Studio:

C#-Thread-Sleep-Methode (So funktioniert es für Entwickler): Abbildung 2 - Installieren Sie IronPDF mit dem NuGet Package Manager, indem Sie "ironpdf" in der Suchleiste des NuGet Package Managers suchen.

using System;
using IronPdf;
class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) 
 string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing.");
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }
    public void PrintPdf()
    {
        Console.WriteLine("Generating PDF using IronPDF.");
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>First Name: {LastName}</p>
</body>
</html>";
        // Create a new PDF document
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("person.pdf");
    }
    private void LogError(string errorMessage)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"Error: {errorMessage}");
        Console.ResetColor();
    }
}
class Program
{
    public static void Main()
    {
        // Create an  instance of the Person class
        Person person = new Person();
        // Attempt to display the full name
        person.DisplayFullName();
        // Set the properties
        person.FirstName = "John"; // string literal
        person.LastName = "Doe"; // string literal
        // Display the full name again
        person.DisplayFullName();
        Console.WriteLine("Pause for 2 seconds and Print PDF");
        Thread.Sleep(2000); // Pause for 2 seconds and Print PDF
        // Print the full name to PDF
        person.PrintPdf();
    }
}

using System;
using IronPdf;
class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public void DisplayFullName()
    {
        if (string.IsNullOrEmpty(FirstName) 
 string.IsNullOrEmpty(LastName))
        {
            LogError($"Invalid name: {nameof(FirstName)} or {nameof(LastName)} is missing.");
        }
        else
        {
            Console.WriteLine($"Full Name: {FirstName} {LastName}");
        }
    }
    public void PrintPdf()
    {
        Console.WriteLine("Generating PDF using IronPDF.");
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>First Name: {LastName}</p>
</body>
</html>";
        // Create a new PDF document
        var pdfDocument = new ChromePdfRenderer();
        pdfDocument.RenderHtmlAsPdf(content).SaveAs("person.pdf");
    }
    private void LogError(string errorMessage)
    {
        Console.ForegroundColor = ConsoleColor.Red;
        Console.WriteLine($"Error: {errorMessage}");
        Console.ResetColor();
    }
}
class Program
{
    public static void Main()
    {
        // Create an  instance of the Person class
        Person person = new Person();
        // Attempt to display the full name
        person.DisplayFullName();
        // Set the properties
        person.FirstName = "John"; // string literal
        person.LastName = "Doe"; // string literal
        // Display the full name again
        person.DisplayFullName();
        Console.WriteLine("Pause for 2 seconds and Print PDF");
        Thread.Sleep(2000); // Pause for 2 seconds and Print PDF
        // Print the full name to PDF
        person.PrintPdf();
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

VB C#

In diesem Programm wird demonstriert, wie man Thread.Sleep und IronPDF verwendet. Der Code überprüft zunächst die Eigenschaften Vorname und Nachname einer Person. Anschließend wird der vollständige Name der Person auf der Konsole ausgegeben. Wartet dann 2 Sekunden lang mit Thread.Sleep und druckt später den Vollnamen mit der Funktion PrintPdf als PDF aus()`-Methode und IronPDF-Bibliothek.

Ausgabe

C# Thread Sleep-Methode (Wie es funktioniert für Entwickler): Abbildung 3 - Konsolenausgabe: Anzeige der Verwendung von Thread.Sleep bei der PDF-Erzeugung mit IronPDF.

Erstelltes PDF

C#-Thread-Sleep-Methode (So funktioniert es für Entwickler): Abbildung 4 - PDF-Ausgabe erstellt.

Lizenzierung (kostenlose Testversion verfügbar)

Zu verwenden IronPDF. Fügen Sie diesen Schlüssel in die Datei appsettings.json ein.

"IronPdf.LicenseKey": "your license key"

"IronPdf.LicenseKey": "your license key"

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'"IronPdf.LicenseKey": "your license key"

VB C#

Um eine Testlizenz zu erhalten, geben Sie bitte Ihre E-Mail-Adresse an. Weitere Informationen über die Lizenzierung von IronPDF finden Sie hier lizenzseite.

Schlussfolgerung

Die Funktion Thread.Sleep()methode in C# dient als grundlegendes Werkzeug für die Verwaltung von Thread-Timing und Synchronisierung. Obwohl es sich um eine einfache und effektive Lösung für die Einführung von Verzögerungen handelt, sollten Entwickler ihre Grenzen und die möglichen Auswirkungen auf die Anwendungsleistung beachten. Da sich die moderne C#-Entwicklung weiterentwickelt, ist die Erforschung alternativer Ansätze wieTask.Delay()und asynchrone Programmierung wird für das Schreiben von reaktionsschnellen und effizienten Multithreading-Anwendungen unerlässlich. Wenn Entwickler die Feinheiten der Thread-Synchronisierung verstehen und die geeigneten Tools auswählen, können sie robuste und effiziente Software erstellen, die den Anforderungen der gleichzeitigen Verarbeitung in einer dynamischen Umgebung gerecht wird.

Außerdem haben wir die Vielseitigkeit der IronPDF bibliothek bei der Erzeugung von PDF-Dokumenten und wie sie mit der Methode Thread.Sleep verwendet werden kann. Weitere Beispiele für die Verwendung von IronPDF finden Sie in den Code-Beispielen seite.

< PREVIOUS
C# Null Conditional Operator (Wie es funktioniert für Entwickler)

NÄCHSTES >
C# Const (Wie es für Entwickler funktioniert)