.NET AIDE

C# Thread Sleep Method (Comment ça fonctionne pour les développeurs)

Mis à jour:5 novembre 2025

Le multithreading est un aspect crucial du développement logiciel moderne, permettant aux développeurs d'exécuter plusieurs tâches simultanément, améliorant ainsi les performances et la réactivité. Cependant, gérer efficacement les threads nécessite une considération attentive de la synchronisation et de la coordination. Un outil essentiel dans l'arsenal d'un développeur C# pour gérer le timing et la coordination des threads est la méthode Thread.Sleep().

Dans cet article, nous allons examiner en détail la méthode Thread.Sleep(), en explorant son but, son utilisation, ses pièges potentiels et ses alternatives. De plus, dans cet article, nous présentons la bibliothèque PDF IronPDF pour C#, qui facilite la génération programmatique de documents PDF.

Compréhension `Thread.Sleep()`

La méthode Thread.Sleep() fait partie de l'espace de noms System.Threading en C# et permet de bloquer l'exécution du thread courant pendant une durée spécifiée. Le thread en attente ou le thread bloqué interrompt son exécution jusqu'à la fin de la durée de pause. La méthode sleep prend un seul argument, représentant l'intervalle de temps pendant lequel le thread doit rester inactif. Cet argument peut être spécifié en millisecondes ou sous forme d'objet TimeSpan, offrant ainsi une grande flexibilité pour exprimer la durée de pause souhaitée.

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

$vbLabelText $csharpLabel

Objectif de `Thread.Sleep`

L'objectif principal de l'utilisation de Thread.Sleep est d'introduire un délai ou une pause dans l'exécution d'un thread. Cela peut être bénéfique dans divers scénarios, tels que :

Simulation d'un comportement en temps réel : Dans les scénarios où l'application doit simuler un comportement en temps réel, l'introduction de délais peut aider à imiter les contraintes temporelles du système modélisé.
Prévention de la consommation excessive de ressources : Mettre en pause un thread pendant une courte durée peut être utile dans les scénarios où l'exécution constante est inutile, évitant ainsi une consommation de ressources inutile.
Coordination des threads : Lorsqu'on gère plusieurs threads, l'introduction de pauses peut aider à synchroniser leur exécution, évitant les conditions de concurrence et assurant un traitement ordonné.

Exemple du monde réel

Prenons un exemple concret où la méthode Thread.Sleep() peut être utilisée pour simuler un système de contrôle de feux de circulation. Dans ce scénario, nous allons créer une simple application console qui modélise le comportement d'un feu de signalisation avec des feux rouges, jaunes et verts.

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

$vbLabelText $csharpLabel

Dans l'exemple de programme ci-dessus, nous avons une simulation simple de feux de circulation à l'intérieur d'une boucle while. La méthode Thread.Sleep() est utilisée pour introduire des délais entre les transitions des signaux de circulation. Voici comment fonctionne l'exemple :

Le programme entre dans une boucle infinie pour simuler une opération continue.
Le feu rouge est affiché pendant 5 secondes, représentant un signal d'arrêt.
Après 5 secondes, le feu jaune est affiché pendant 2 secondes, indiquant une phase de préparation.
Enfin, le feu vert est affiché pendant 5 secondes, permettant aux véhicules de passer.
La couleur de la console est réinitialisée, et la boucle se répète.

Sortie

Méthode C# Thread.Sleep (Fonctionnement pour les développeurs) : Figure 1 - Sortie du programme : Affichage du simulateur de feux de circulation à l'aide de la méthode Thread.Sleep().

Cet exemple démontre comment Thread.Sleep() peut être utilisé pour contrôler le timing d'une simulation de feu de circulation, offrant un moyen simple de modéliser le comportement d'un système du monde réel. Gardez à l'esprit qu'il s'agit d'un exemple de base à des fins d'illustration, et dans une application plus complexe, vous pourriez envisager d'explorer des techniques de threading et de synchronisation plus avancées pour gérer l'entrée utilisateur, gérer plusieurs feux de signalisation et garantir un timing précis.

Utilisation du délai `TimeSpan` dans la méthode de veille

Vous pouvez utiliser TimeSpan avec la méthode Thread.Sleep() pour spécifier la durée du sommeil. Voici un exemple étendant la simulation de feux de circulation de l'exemple précédent, utilisant 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

$vbLabelText $csharpLabel

Dans cet exemple modifié, TimeSpan.FromSeconds() est utilisé pour créer un objet TimeSpan représentant la durée de sommeil souhaitée. Cela rend le code plus lisible et expressif.

En utilisant la propriété TimeSpan dans la méthode Thread.Sleep(), vous pouvez spécifier directement la durée en secondes (ou toute autre unité prise en charge par TimeSpan), offrant ainsi une manière plus intuitive de travailler avec les intervalles de temps. Cela peut être particulièrement utile lors de la gestion de durées de pause plus longues ou plus complexes dans votre application.

Cas d'utilisation

Simulation de comportement en temps réel : Envisagez une application de simulation où vous devez modéliser le comportement d'un système en temps réel. En plaçant stratégiquement Thread.Sleep() dans votre code, vous pouvez imiter les délais qui se produisent dans le système réel, améliorant ainsi la précision de votre simulation.

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

$vbLabelText $csharpLabel

Animations et mises à jour de l'UI : Dans les applications de développement graphique Web ou de développement de jeux, des animations fluides et des mises à jour de l'interface utilisateur sont cruciales. Thread.Sleep() peut être utilisé pour contrôler la fréquence d'images et garantir que les mises à jour se produisent à un rythme visuellement agréable.

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

$vbLabelText $csharpLabel

Limitation des appels vers des services externes : Lorsque vous interagissez avec des services externes ou des API, il est courant d'imposer des limites de taux ou des restrictions pour éviter des requêtes excessives. Thread.Sleep() peut être utilisé pour introduire des délais entre les appels de service consécutifs, en restant dans les limites de débit.

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

$vbLabelText $csharpLabel

Avantages de `Thread.Sleep()`

Synchronisation et coordination : Thread.Sleep() aide à synchroniser l'exécution des threads, à prévenir les conditions de concurrence et à assurer un traitement ordonné lors de la gestion de plusieurs threads.
Conservation des ressources : Mettre temporairement en pause un thread peut être avantageux dans les scénarios où l'exécution constante n'est pas nécessaire, conservant les ressources du système.
Simplicité et lisibilité : La méthode fournit un moyen simple et lisible d'introduire des délais, rendant le code plus compréhensible, surtout pour les développeurs novices en concepts de multithreading.

Pièges potentiels et considérations

Bien que Thread.Sleep() soit une solution simple pour introduire des délais, il existe des pièges potentiels et des considérations dont les développeurs doivent être conscients :

Blocage du thread : Lorsqu'un thread est mis en pause à l'aide de Thread.Sleep(), il est effectivement bloqué et aucune autre tâche ne peut être effectuée pendant ce temps. Dans les scénarios où la réactivité est essentielle, le blocage prolongé du thread principal peut dégrader l'expérience utilisateur.
Imprécision du timing : La précision de la durée de pause dépend de la planification du système d'exploitation sous-jacent et peut être imprécise. Les développeurs doivent faire preuve de prudence lorsqu'ils se fient à Thread.Sleep() pour des exigences de timing précises.
Approches alternatives : Dans le développement C# moderne, des alternatives comme la méthode Task.Delay() ou la programmation asynchrone utilisant async/await sont souvent préférées à Thread.Sleep(). Ces approches offrent une meilleure réactivité sans bloquer les threads.

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

$vbLabelText $csharpLabel

Présentation d'IronPDF

IronPDF par Iron Software est une bibliothèque PDF pour C# servant à la fois de générateur et de lecteur de PDF. Cette section présente des fonctionnalités fondamentales. Pour plus de détails, consultez la documentation IronPDF.

Le point fort d'IronPDF est sa capacité de conversion de HTML en PDF, assurant la préservation de tous les layouts et styles. Il transforme le contenu web en PDF, utile 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

$vbLabelText $csharpLabel

Installation

Pour installer IronPDF en utilisant le Gestionnaire de Packages NuGet, utilisez soit la console du gestionnaire de packages NuGet, soit le gestionnaire de packages de Visual Studio.

Installez la bibliothèque IronPDF en utilisant la console du gestionnaire de packages NuGet avec l'une des commandes suivantes :

dotnet add package IronPdf
# or
Install-Package IronPdf

Installez la bibliothèque IronPDF en utilisant le Gestionnaire de Packages de Visual Studio :

C# Thread Sleep Method (How It Works For Developers): Figure 2 - Install IronPDF using NuGet Package Manager by searching ironpdf in the search bar of NuGet Package Manager.

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

$vbLabelText $csharpLabel

Dans ce programme, nous démontrons comment utiliser Thread.Sleep et IronPDF. Le code est initialement validé pour les propriétés FirstName et LastName d'une personne. Puis imprime le nom complet de la personne sur la console. Ensuite, il attend 2 secondes en utilisant Thread.Sleep et imprime ensuite le FullName au format PDF en utilisant la méthode PrintPdf() et la bibliothèque IronPDF .

Sortie

Méthode Thread.Sleep en C# (Fonctionnement pour les développeurs) : Figure 3 - Sortie console : Affichage de l'utilisation de Thread.Sleep lors de la génération d'un PDF avec IronPDF.

PDF généré

Méthode de mise en veille d'un thread C# (Fonctionnement pour les développeurs) : Figure 4 - Fichier PDF généré.

Licence (essai gratuit disponible)

Pour utiliser IronPDF, insérez cette clé dans le fichier appsettings.json.

"IronPdf.LicenseKey": "your license key"

Pour recevoir une licence d'essai, veuillez fournir votre email. Pour plus d'informations sur la licence d'IronPDF, veuillez consulter cette page de licence IronPDF.

Conclusion

La méthode Thread.Sleep() en C# sert d'outil fondamental pour la gestion du temps et de la synchronisation des threads. Bien qu'elle soit une solution simple et efficace pour introduire des délais, les développeurs doivent être conscients de ses limitations et de son impact potentiel sur les performances de l'application. À mesure que le développement moderne en C# évolue, l'exploration d'approches alternatives comme Task.Delay() et la programmation asynchrone devient essentielle pour écrire des applications multithread réactives et efficaces. En comprenant les nuances de la synchronisation des threads et en choisissant les outils appropriés, les développeurs peuvent créer des logiciels robustes et efficaces qui répondent aux exigences du traitement simultané dans un environnement dynamique.

De plus, nous avons observé la polyvalence des capacités d'IronPDF dans la génération de documents PDF et comment il peut être utilisé avec la méthode Thread.Sleep. Pour plus d'exemples sur la façon d'utiliser IronPDF, veuillez consulter leurs exemples de code sur la page d'exemples IronPDF.

Questions Fréquemment Posées

À quoi sert la méthode Thread.Sleep() en C# ?

La méthode `Thread.Sleep()` en C# est utilisée pour suspendre l'exécution du thread actuel pendant un temps spécifié. Cela peut aider à simuler des scénarios en temps réel, à gérer la consommation des ressources et à coordonner plusieurs threads de manière efficace. IronPDF peut être utilisé conjointement avec cette méthode pour gérer des tâches nécessitant un timing précis, comme la génération de documents PDF à des intervalles spécifiques.

Comment la méthode Thread.Sleep() influence-t-elle les applications multi-threads ?

Dans les applications multi-threads, la méthode `Thread.Sleep()` peut être utilisée pour contrôler le timing et la synchronisation des threads en arrêtant temporairement leur exécution. Cela peut prévenir la surutilisation des ressources et aider à coordonner les tâches. Lors du travail avec IronPDF, les développeurs peuvent intégrer `Thread.Sleep()` pour gérer le timing des tâches de génération de PDF efficacement.

Quels sont des exemples de l'utilisation de Thread.Sleep() dans des applications réelles ?

Les applications réelles de `Thread.Sleep()` incluent la simulation de systèmes comme les feux de circulation, où la méthode est utilisée pour créer des délais entre les changements d'état. De même, dans les applications using IronPDF, `Thread.Sleep()` peut être employée pour contrôler le timing des tâches de génération de PDF, garantissant que les documents sont créés à des intervalles appropriés.

Pourquoi les développeurs pourraient-ils choisir des alternatives à Thread.Sleep() en C# ?

Les développeurs pourraient opter pour des alternatives à `Thread.Sleep()`, telles que `Task.Delay()` ou les motifs async/await, car ces méthodes ne bloquent pas le thread actuel, permettant une meilleure réactivité et une gestion plus efficace des ressources. Lors de l'utilisation d'IronPDF, l'adoption de telles alternatives peut aider à maintenir la performance de l'application tout en gérant des tâches comme la génération de PDF.

Comment la classe TimeSpan peut-elle améliorer l'utilisation de Thread.Sleep() ?

La classe `TimeSpan` peut améliorer la méthode `Thread.Sleep()` en fournissant un moyen plus lisible et flexible de spécifier les durées de sommeil. Par exemple, utiliser `TimeSpan.FromSeconds(5)` rend le code plus intuitif. Cette approche est bénéfique dans les applications using IronPDF, où un timing précis est crucial pour des tâches comme générer des documents PDF à des intervalles spécifiés.

Quels sont les avantages et les inconvénients de l'utilisation de Thread.Sleep() ?

Les avantages de l'utilisation de `Thread.Sleep()` incluent la simplicité et la facilité d'usage pour contrôler le timing et la synchronisation des threads. Cependant, les inconvénients incluent le potentiel de blocage des threads, entraînant une réactivité réduite de l'application, et des inexactitudes de timing dues à la planification du système d'exploitation. Les utilisateurs d'IronPDF doivent prendre en compte ces facteurs lors de l'intégration de délais de threads dans les tâches de génération de PDF.

Comment Thread.Sleep() peut-il être appliqué pour simuler un système de feux de circulation ?

Dans la simulation d'un système de feux de circulation, `Thread.Sleep()` peut être utilisé pour introduire des délais entre les changements de lumières, comme une pause de 5 secondes sur rouge, 2 secondes sur jaune, et 5 secondes sur vert. Cette approche peut être adaptée dans des applications using IronPDF, permettant aux développeurs de gérer le timing des tâches de génération de documents PDF de manière efficace.

Quel rôle joue IronPDF dans la gestion du timing des threads dans les applications C# ?

IronPDF est une bibliothèque PDF C# qui peut être utilisée dans des applications nécessitant un timing et une synchronisation précis pour des tâches comme la génération de PDF. En intégrant IronPDF avec des méthodes comme `Thread.Sleep()`, les développeurs peuvent contrôler le timing et le séquençage des opérations liées aux PDF, garantissant une performance efficace d'applications multi-threads.

Jacob Mellor

Discutez maintenant avec l'équipe d'ingénierie

Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, ...

Articles connexes

Mis à jour20 février 2026

Bridging CLI Simplicity & .NET : Using Curl DotNet with IronPDF for .NET (en anglais)

Jacob Mellor a comblé cette lacune avec CurlDotNet, une bibliothèque créée pour apporter la familiarité de cURL à l'écosystème .NET.

Mis à jour20 décembre 2025

RandomNumberGenerator C#

L'utilisation de la classe RandomNumberGenerator C# peut aider à porter vos projets de génération et d'édition de PDF à un niveau supérieur

Mis à jour20 décembre 2025

C# String Equals (Comment ça fonctionne pour les développeurs)

Lorsqu'il est combiné avec une bibliothèque PDF puissante comme IronPDF, la correspondance de modèle de switch permet de construire une logique plus intelligente et plus propre pour le traitement de documents

C# Null Conditional Operator (Comment ça fonctionne pour les développeurs)

C# Const (Comment ça fonctionne po...

Mise en avant du client :

Projecteur sur les Développeurs:

Webinaires:

Essai gratuit de 30 jours

C# Thread Sleep Method (Comment ça fonctionne pour les développeurs)

Compréhension `Thread.Sleep()`

Objectif de `Thread.Sleep`

Exemple du monde réel

Sortie

Utilisation du délai `TimeSpan` dans la méthode de veille

Cas d'utilisation

Avantages de `Thread.Sleep()`

Pièges potentiels et considérations

Présentation d'IronPDF

Installation

Sortie

PDF généré

Licence (essai gratuit disponible)

Conclusion

Questions Fréquemment Posées

À quoi sert la méthode Thread.Sleep() en C# ?

Comment la méthode Thread.Sleep() influence-t-elle les applications multi-threads ?

Quels sont des exemples de l'utilisation de Thread.Sleep() dans des applications réelles ?

Pourquoi les développeurs pourraient-ils choisir des alternatives à Thread.Sleep() en C# ?

Comment la classe TimeSpan peut-elle améliorer l'utilisation de Thread.Sleep() ?

Quels sont les avantages et les inconvénients de l'utilisation de Thread.Sleep() ?

Comment Thread.Sleep() peut-il être appliqué pour simuler un système de feux de circulation ?

Quel rôle joue IronPDF dans la gestion du timing des threads dans les applications C# ?

Équipe de soutien Iron

Essai gratuit de 30 jours

C# Thread Sleep Method (Comment ça fonctionne pour les développeurs)

Compréhension Thread.Sleep()

Objectif de Thread.Sleep

Exemple du monde réel

Sortie

Utilisation du délai TimeSpan dans la méthode de veille

Cas d'utilisation

Avantages de Thread.Sleep()

Pièges potentiels et considérations

Présentation d'IronPDF

Installation

Sortie

PDF généré

Licence (essai gratuit disponible)

Conclusion

Questions Fréquemment Posées

À quoi sert la méthode Thread.Sleep() en C# ?

Comment la méthode Thread.Sleep() influence-t-elle les applications multi-threads ?

Quels sont des exemples de l'utilisation de Thread.Sleep() dans des applications réelles ?

Pourquoi les développeurs pourraient-ils choisir des alternatives à Thread.Sleep() en C# ?

Comment la classe TimeSpan peut-elle améliorer l'utilisation de Thread.Sleep() ?

Quels sont les avantages et les inconvénients de l'utilisation de Thread.Sleep() ?

Comment Thread.Sleep() peut-il être appliqué pour simuler un système de feux de circulation ?

Quel rôle joue IronPDF dans la gestion du timing des threads dans les applications C# ?

Articles connexes

Bridging CLI Simplicity & .NET : Using Curl DotNet with IronPDF for .NET (en anglais)

RandomNumberGenerator C#

C# String Equals (Comment ça fonctionne pour les développeurs)

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

De confiance par des millions d'ingénieurs dans le monde entier

Équipe de soutien Iron

Compréhension `Thread.Sleep()`

Objectif de `Thread.Sleep`

Utilisation du délai `TimeSpan` dans la méthode de veille

Avantages de `Thread.Sleep()`