Metoda Thread Sleep w języku C# (jak działa dla programistów)

Zrozumienie Thread.Sleep()

Metoda Thread.Sleep() jest częścią przestrzeni nazw System.Threading w języku C# i służy do blokowania wykonywania bieżącego wątku na określony czas. Wątek oczekujący lub zablokowany wstrzymuje wykonywanie do momentu upływu czasu określonego dla funkcji sleep. Metoda Sleep przyjmuje jeden argument, reprezentujący przedział czasu, przez który wątek powinien pozostawać nieaktywny. Argument można podać w milisekundach lub jako obiekt TimeSpan, co zapewnia elastyczność w wyrażaniu pożądanego czasu trwania pauzy.

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 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 System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 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
    }
}

Imports System
Imports System.Threading

Friend Class Program
	Shared Sub Main()
		' 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
	End Sub
End Class

Cel Thread.Sleep

Głównym celem użycia Thread.Sleep jest wprowadzenie opóźnienia lub przerwy w wykonywaniu wątku. Może to być przydatne w różnych sytuacjach, takich jak:

1. Symulacja zachowania w czasie rzeczywistym: W scenariuszach, w których aplikacja musi symulować zachowanie w czasie rzeczywistym, wprowadzenie opóźnień może pomóc w odzwierciedleniu ograniczeń czasowych modelowanego systemu.
2. Zapobieganie nadmiernemu zużyciu zasobów: Krótkie wstrzymanie działania jednego wątku może być przydatne w sytuacjach, w których ciągłe wykonywanie nie jest konieczne, co pozwala uniknąć niepotrzebnego zużycia zasobów.
3. Koordynacja wątków: W przypadku pracy z wieloma wątkami wprowadzenie przerw może pomóc w synchronizacji ich wykonywania, zapobiegając sytuacjom wyścigu i zapewniając uporządkowane przetwarzanie.

Przykład z życia wzięty

Rozważmy rzeczywisty przykład, w którym metoda Thread.Sleep() może zostać wykorzystana do symulacji systemu sterowania sygnalizacją świetlną. W tym scenariuszu stworzymy prostą aplikację konsolową, która modeluje zachowanie sygnalizacji świetlnej z czerwonym, żółtym i zielonym światłem.

using System;
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:u}");
            Thread.Sleep(5000); // Pause for 5 seconds

            // Display the yellow light
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine($"Get ready! Yellow light - {DateTime.Now:u}");
            Thread.Sleep(2000); // Pause for 2 seconds

            // Display the green light
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine($"Go! Green light - {DateTime.Now:u}");
            Thread.Sleep(5000); // Pause for 5 seconds

            // Reset console color and clear screen
            Console.ResetColor();
            Console.Clear();
        }
    }
}

using System;
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:u}");
            Thread.Sleep(5000); // Pause for 5 seconds

            // Display the yellow light
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine($"Get ready! Yellow light - {DateTime.Now:u}");
            Thread.Sleep(2000); // Pause for 2 seconds

            // Display the green light
            Console.ForegroundColor = ConsoleColor.Green;
            Console.WriteLine($"Go! Green light - {DateTime.Now:u}");
            Thread.Sleep(5000); // Pause for 5 seconds

            // Reset console color and clear screen
            Console.ResetColor();
            Console.Clear();
        }
    }
}

Imports System
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:u}")
			Thread.Sleep(5000) ' Pause for 5 seconds

			' Display the yellow light
			Console.ForegroundColor = ConsoleColor.Yellow
			Console.WriteLine($"Get ready! Yellow light - {DateTime.Now:u}")
			Thread.Sleep(2000) ' Pause for 2 seconds

			' Display the green light
			Console.ForegroundColor = ConsoleColor.Green
			Console.WriteLine($"Go! Green light - {DateTime.Now:u}")
			Thread.Sleep(5000) ' Pause for 5 seconds

			' Reset console color and clear screen
			Console.ResetColor()
			Console.Clear()
		Loop
	End Sub
End Class

W powyższym przykładzie programu mamy prostą symulację sygnalizacji świetlnej w pętli while. Metoda Thread.Sleep() służy do wprowadzania opóźnień między zmianami sygnałów świetlnych. Oto jak działa ten przykład:

1. Program wchodzi w pętlę nieskończoną, aby symulować ciągłą pracę.
2. Czerwone światło świeci się przez 5 sekund, co oznacza sygnał stopu.
3. Po 5 sekundach przez 2 sekundy świeci się żółte światło, sygnalizujące fazę przygotowawczą.
4. Na koniec zielone światło świeci się przez 5 sekund, umożliwiając pojazdom przejazd.
5. Kolor konsoli zostaje zresetowany, a pętla się powtarza.

Korzystanie z TimeSpan Timeout w metodzie Sleep

Możesz użyć TimeSpan z metodą Thread.Sleep(), aby określić czas trwania uśpienia. Oto przykład rozszerzający symulację sygnalizacji świetlnej z poprzedniego przykładu, wykorzystujący TimeSpan:

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: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: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:u}");
            Thread.Sleep(TimeSpan.FromSeconds(5)); // Pause for 5 seconds

            // Reset console color and clear screen
            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: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: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:u}");
            Thread.Sleep(TimeSpan.FromSeconds(5)); // Pause for 5 seconds

            // Reset console color and clear screen
            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: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: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:u}")
			Thread.Sleep(TimeSpan.FromSeconds(5)) ' Pause for 5 seconds

			' Reset console color and clear screen
			Console.ResetColor()
			Console.Clear()
		Loop
	End Sub
End Class

W tym zmodyfikowanym przykładzie TimeSpan.FromSeconds() służy do utworzenia obiektu TimeSpan reprezentującego żądany czas uśpienia. Dzięki temu kod jest bardziej czytelny i wyrazisty.

Korzystając z właściwości TimeSpan w metodzie Thread.Sleep(), można bezpośrednio określić czas trwania w sekundach (lub dowolnej innej jednostce obsługiwanej przez TimeSpan), co zapewnia bardziej intuicyjny sposób pracy z przedziałami czasowymi. Może to być szczególnie przydatne w przypadku dłuższych lub bardziej złożonych okresów uśpienia w aplikacji.

Przykłady zastosowań

1. Symulowanie zachowania w czasie rzeczywistym: Rozważmy aplikację symulacyjną, w której trzeba modelować zachowanie systemu działającego w czasie rzeczywistym. Strategiczne umieszczenie Thread.Sleep() w kodzie pozwala naśladować opóźnienia występujące w rzeczywistym systemie, zwiększając dokładność symulacji.

void SimulateRealTimeEvent()
{
    // Simulate some event
}

void SimulateNextEvent()
{
    // Simulate another event
}

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

void SimulateRealTimeEvent()
{
    // Simulate some event
}

void SimulateNextEvent()
{
    // Simulate another event
}

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

Private Sub SimulateRealTimeEvent()
	' Simulate some event
End Sub

Private Sub SimulateNextEvent()
	' Simulate another event
End Sub

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

2. Animacje i aktualizacje interfejsu użytkownika: W graficznych aplikacjach do tworzenia stron internetowych lub w tworzeniu gier płynne animacje i aktualizacje interfejsu użytkownika mają kluczowe znaczenie. Thread.Sleep() może służyć do kontrolowania częstotliwości odświeżania i zapewnienia, że aktualizacje następują w tempie przyjemnym dla oka.

void UpdateUIElement()
{
    // Code to update a UI element
}

void UpdateNextUIElement()
{
    // Code to update the next UI element
}

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

void UpdateUIElement()
{
    // Code to update a UI element
}

void UpdateNextUIElement()
{
    // Code to update the next UI element
}

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

Private Sub UpdateUIElement()
	' Code to update a UI element
End Sub

Private Sub UpdateNextUIElement()
	' Code to update the next UI element
End Sub

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

3. Ograniczanie wywołań usług zewnętrznych: Podczas interakcji z usługami zewnętrznymi lub interfejsami API często stosuje się limity częstotliwości lub ograniczanie przepustowości, aby zapobiec nadmiernej liczbie żądań. Thread.Sleep() może być wykorzystane do wprowadzania opóźnień między kolejnymi wywołaniami usług, pozostając w granicach limitów częstotliwości.

void CallExternalService()
{
    // Call to external service
}

void CallNextService()
{
    // Call to another external service
}

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

void CallExternalService()
{
    // Call to external service
}

void CallNextService()
{
    // Call to another external service
}

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

Private Sub CallExternalService()
	' Call to external service
End Sub

Private Sub CallNextService()
	' Call to another external service
End Sub

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

Zalety Thread.Sleep()

1. Synchronizacja i koordynacja: Thread.Sleep() pomaga w synchronizacji wykonywania wątków, zapobiegając sytuacjom wyścigu i zapewniając uporządkowane przetwarzanie podczas pracy z wieloma wątkami.
2. Oszczędzanie zasobów: Tymczasowe wstrzymanie wątku może być korzystne w sytuacjach, w których ciągłe wykonywanie nie jest konieczne, co pozwala oszczędzać zasoby systemowe.
3. Prostota i czytelność: Metoda ta zapewnia prosty i czytelny sposób wprowadzania opóźnień, dzięki czemu kod staje się bardziej zrozumiały, zwłaszcza dla programistów, którzy dopiero zaczynają przygodę z koncepcjami wielowątkowości.

Potencjalne pułapki i kwestie do rozważenia

Chociaż Thread.Sleep() jest prostym rozwiązaniem do wprowadzania opóźnień, istnieją potencjalne pułapki i kwestie, o których programiści powinni wiedzieć:

1. Blokowanie wątku: Gdy wątek jest wstrzymywany za pomocą Thread.Sleep(), jest on faktycznie zablokowany i w tym czasie nie można wykonywać żadnych innych zadań. W sytuacjach, w których szybkość reakcji ma kluczowe znaczenie, blokowanie głównego wątku przez dłuższy czas może prowadzić do pogorszenia komfortu użytkowania.
2. Niedokładność w zakresie czasu: Dokładność czasu trwania pauzy zależy od harmonogramu podstawowego systemu operacyjnego i może nie być precyzyjna. Programiści powinni zachować ostrożność, polegając na Thread.Sleep() w przypadku wymagań dotyczących precyzyjnego czasu.
3. Alternatywne podejścia: We współczesnym programowaniu w języku C# alternatywne rozwiązania, takie jak metoda Task.Delay() lub programowanie asynchroniczne z wykorzystaniem async/await, są często preferowane w stosunku do Thread.Sleep(). Podejścia te zapewniają lepszą responsywność bez blokowania wątków.

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // Using Task.Delay() instead of Thread.Sleep()
        await Task.Delay(1000); // Pause for 1 second asynchronously
    }
}

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        // Using Task.Delay() instead of Thread.Sleep()
        await Task.Delay(1000); // Pause for 1 second asynchronously
    }
}

Imports System
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main() As Task
		' Using Task.Delay() instead of Thread.Sleep()
		Await Task.Delay(1000) ' Pause for 1 second asynchronously
	End Function
End Class

Przedstawiamy IronPDF

IronPDF firmy Iron Software to biblioteka C# do obsługi plików PDF, służąca zarówno jako generator, jak i czytnik plików PDF. W tej sekcji przedstawiono podstawowe funkcje. Więcej szczegółów można znaleźć w dokumentacji IronPDF.

Najważniejszą cechą IronPDF są możliwości konwersji HTML do PDF, zapewniające zachowanie wszystkich układów i stylów. Przekształca treści internetowe w pliki PDF, przydatne do tworzenia raportów, faktur i dokumentacji. Pliki HTML, adresy URL i ciągi znaków HTML można łatwo konwertować na pliki 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

Instalacja

Aby zainstalować IronPDF za pomocą menedżera pakietów NuGet, należy skorzystać z konsoli menedżera pakietów NuGet lub menedżera pakietów Visual Studio.

Zainstaluj bibliotekę IronPDF za pomocą konsoli menedżera pakietów NuGet, używając jednego z poniższych poleceń:

dotnet add package IronPdf
# or
Install-Package IronPdf

Zainstaluj bibliotekę IronPDF za pomocą Menedżera pakietów programu Visual Studio:

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

        // Content to print to PDF
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>Last 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"; // Set First Name
        person.LastName = "Doe"; // Set Last Name

        // Display the full name again
        person.DisplayFullName();

        Console.WriteLine("Pause for 2 seconds and Print PDF");
        Thread.Sleep(2000); // Pause for 2 seconds

        // 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.");

        // Content to print to PDF
        string content = $@"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>Last 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"; // Set First Name
        person.LastName = "Doe"; // Set Last Name

        // Display the full name again
        person.DisplayFullName();

        Console.WriteLine("Pause for 2 seconds and Print PDF");
        Thread.Sleep(2000); // Pause for 2 seconds

        // Print the full name to PDF
        person.PrintPdf();
    }
}

Imports System
Imports IronPdf

Friend Class Person
	Public Property FirstName() As String
	Public Property LastName() As String

	Public Sub DisplayFullName()
		If String.IsNullOrEmpty(FirstName) OrElse String.IsNullOrEmpty(LastName) Then
			LogError($"Invalid name: {NameOf(FirstName)} or {NameOf(LastName)} is missing.")
		Else
			Console.WriteLine($"Full Name: {FirstName} {LastName}")
		End If
	End Sub

	Public Sub PrintPdf()
		Console.WriteLine("Generating PDF using IronPDF.")

		' Content to print to PDF
		Dim content As String = $"<!DOCTYPE html>
<html>
<body>
<h1>Hello, {FirstName}!</h1>
<p>First Name: {FirstName}</p>
<p>Last Name: {LastName}</p>
</body>
</html>"

		' Create a new PDF document
		Dim pdfDocument = New ChromePdfRenderer()
		pdfDocument.RenderHtmlAsPdf(content).SaveAs("person.pdf")
	End Sub

	Private Sub LogError(ByVal errorMessage As String)
		Console.ForegroundColor = ConsoleColor.Red
		Console.WriteLine($"Error: {errorMessage}")
		Console.ResetColor()
	End Sub
End Class

Friend Class Program
	Public Shared Sub Main()
		' Create an instance of the Person class
		Dim person As New Person()

		' Attempt to display the full name
		person.DisplayFullName()

		' Set the properties
		person.FirstName = "John" ' Set First Name
		person.LastName = "Doe" ' Set Last Name

		' Display the full name again
		person.DisplayFullName()

		Console.WriteLine("Pause for 2 seconds and Print PDF")
		Thread.Sleep(2000) ' Pause for 2 seconds

		' Print the full name to PDF
		person.PrintPdf()
	End Sub
End Class

W tym programie pokazujemy, jak korzystać z Thread.Sleep i IronPDF. Kod początkowo sprawdza właściwości FirstName i LastName danej osoby. Następnie PRINTuje pełne imię i nazwisko osoby na konsoli. Następnie czeka 2 sekundy, używając Thread.Sleep, a później drukuje FullName do pliku PDF przy użyciu metody PrintPdf() i biblioteki IronPDF.

"IronPdf.LicenseKey": "your license key"

Wnioski

Metoda Thread.Sleep() w języku C# służy jako podstawowe narzędzie do zarządzania synchronizacją i taktowaniem wątków. Chociaż jest to proste i skuteczne rozwiązanie służące do wprowadzania opóźnień, programiści powinni mieć na uwadze jego ograniczenia i potencjalny wpływ na wydajność aplikacji. Wraz z ewolucją nowoczesnego programowania w języku C#, odkrywanie alternatywnych podejść, takich jak Task.Delay() i programowanie asynchroniczne, staje się niezbędne do pisania responsywnych i wydajnych aplikacji wielowątkowych. Dzięki zrozumieniu niuansów synchronizacji wątków i doborowi odpowiednich narzędzi programiści mogą tworzyć solidne i wydajne oprogramowanie, które spełnia wymagania przetwarzania współbieżnego w dynamicznym środowisku.

Ponadto zwróciliśmy uwagę na wszechstronność możliwości IronPDF w zakresie generowania dokumentów PDF oraz na to, jak można go używać z metodą Thread.Sleep. Aby uzyskać więcej przykładów korzystania z IronPDF, odwiedź stronę z przykładami kodu na stronie przykładów IronPDF.