Méthode de mise en veille des threads en C# (comment cela fonctionne pour les développeurs)

Introduction

Le multithreading est un aspect crucial du développement des logiciels modernes. Il permet aux développeurs d'exécuter plusieurs tâches simultanément, ce qui améliore les performances et la réactivité. Cependant, la gestion efficace des threads nécessite une attention particulière à la synchronisation et à la coordination. L'un des outils essentiels de l'arsenal d'un développeur C# pour gérer la synchronisation et la coordination des threads est la méthode Thread.Sleep().

Dans cet article, nous allons nous plonger dans les subtilités de la méthode Thread.Sleep(), en explorant son objectif, son utilisation, les écueils potentiels et les alternatives. De plus, dans cet article, nous présentons la bibliothèque PDF IronPDF C#, qui facilite la génération programmatique de documents PDF.

Comprendre Thread.Sleep()

La méthode Thread.Sleep() fait partie de l'espace de noms System.Threading en C# et est utilisée pour bloquer l'exécution du thread actuel pendant une durée spécifiée. Le thread en attente ou bloqué arrête son exécution jusqu'au temps spécifié pour la pause. La méthode Sleep prend un seul argument, représentant l'intervalle de temps pendant lequel le thread doit rester inactif. L'argument peut être spécifié en millisecondes ou comme un objet TimeSpan, offrant ainsi une flexibilité pour exprimer la durée de pause souhaitée.

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

Objectif de Thread.Sleep

Le but 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 s'avérer utile dans différents cas de figure, par exemple :

1. Simulation du 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 de temps du système modélisé.

2. Prévenir la consommation excessive de ressources : Mettre en pause un fil d'exécution pour une courte durée peut être utile dans des scénarios où une exécution constante n'est pas nécessaire, évitant ainsi une consommation de ressources inutile.

3. Coordination des threads : Lorsqu'il s'agit de plusieurs threads, introduire des pauses peut aider à synchroniser leur exécution, empêchant les conditions de concurrence et assurant un traitement ordonné.

Exemple concret

Considérons 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 application console simple qui modélise le comportement d'un feu de circulation avec des signaux rouge, jaune et vert.

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

Dans l'exemple de programme ci-dessus, nous avons une simulation simple de feu de signalisation à 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 du feu de signalisation. Voici comment fonctionne l'exemple :

1. Le programme entre dans une boucle infinie pour simuler un fonctionnement continu.

2. Le feu rouge s'affiche pendant 5 secondes, ce qui représente un signal d'arrêt.

3. Après 5 secondes, le voyant jaune s'affiche pendant 2 secondes, indiquant une phase de préparation.

4. Enfin, le feu vert s'allume pendant 5 secondes, permettant aux véhicules de poursuivre leur route.

5. La couleur de la console est réinitialisée et la boucle se répète.

Sortie

Cet exemple démontre comment Thread.Sleep() peut être utilisé pour contrôler le timing d'une simulation de feux de signalisation, offrant une manière simple de modéliser le comportement d'un système réel. Gardez à l'esprit qu'il s'agit d'un exemple de base à des fins d'illustration et que, dans une application plus complexe, vous souhaiterez peut-être explorer des techniques de threading et de synchronisation plus avancées pour traiter les entrées des utilisateurs, gérer plusieurs feux de signalisation et garantir une synchronisation précise.

Utilisation du délai d'attente dans la méthode Sleep

Vous pouvez utiliser TimeSpan avec la méthode Thread.Sleep() pour spécifier la durée de sommeil. Voici un exemple d'extension de 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.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

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 plus 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 une manière plus intuitive de travailler avec les intervalles de temps. Cela peut s'avérer particulièrement utile lorsque vous avez affaire à des durées de sommeil plus longues ou plus complexes dans votre application.

Cas d'utilisation

1. Simulation du comportement en temps réel : Considérez 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 de temps qui se produisent dans le système réel, améliorant ainsi la précision de votre simulation.

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

2. Mises à jour d'animation et d'interface utilisateur : Dans les applications de développement web graphique ou le développement de jeux, des animations fluides et des mises à jour d'interface utilisateur sont cruciales. La méthode Thread.Sleep() peut être utilisée pour contrôler le taux de rafraîchissement et garantir que les mises à jour se produisent à un rythme visuellement agréable.

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

3. Limitation des appels de services externes : Lors de l'interaction avec des services ou API externes, il est courant d'imposer des limites de taux ou une limitation pour éviter les requêtes excessives. Thread.Sleep() peut être utilisé pour introduire des délais entre des appels de service consécutifs, tout en restant dans les limites de débit.

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

Avantages de Thread.Sleep()

1. Synchronisation et coordination : Thread.Sleep() aide à synchroniser l'exécution des threads, en empêchant les conditions de compétition et en assurant un traitement ordonné lors de la gestion de plusieurs threads.

2. Conservation des ressources : Suspendre temporairement un thread peut être avantageux dans des scénarios où une exécution constante n'est pas nécessaire, permettant de préserver les ressources système.

3. Simplicité et Lisibilité : La méthode offre un moyen simple et lisible d'introduire des pauses, rendant le code plus compréhensible, surtout pour les développeurs novices en concepts de multithreading.

Pièges et considérations possibles

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 :

1. Blocage du Thread : Lorsqu'un thread est mis en pause en utilisant Thread.Sleep(), il est effectivement bloqué et aucun autre travail ne peut être accompli pendant ce temps. Dans des scénarios où la réactivité est cruciale, bloquer le thread principal pendant de longues périodes peut conduire à une mauvaise expérience utilisateur.

2. Inexactitude dans le minutage : La précision de la durée de pause dépend de la planification du système d'exploitation sous-jacent et peut ne pas être précise. Les développeurs doivent être prudents lorsqu'ils se fient à Thread.Sleep() pour des exigences de synchronisation précises.

3. Approches Alternatives : Dans le développement moderne en C#, 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 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

Présentation d'IronPDF

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

Le point fort d'IronPDF est ses capacités de conversion HTML en PDF, garantissant que toutes les mises en page et styles sont préservés. 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

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 à l'aide de la console du gestionnaire de paquets NuGet en utilisant l'une des commandes suivantes :

dotnet add package IronPdf
# or
Install-Package IronPdf

dotnet add package IronPdf
# or
Install-Package IronPdf

Installez la bibliothèque IronPDF à l'aide du gestionnaire de paquets de 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.");
        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

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

Sortie

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 indiquer votre adresse électronique. Pour plus d'informations sur les licences d'IronPDF, veuillez visiter cette page de licences IronPDF.

Conclusion

La méthode Thread.Sleep() en C# sert d'outil fondamental pour gérer le minutage et la synchronisation des threads. Bien qu'il s'agisse d'une solution simple et efficace pour introduire des délais, les développeurs doivent être conscients de ses limites et de son impact potentiel sur les performances de l'application. À mesure que le développement moderne en C# évolue, explorer des approches alternatives comme Task.Delay() et la programmation asynchrone devient essentiel 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.

En outre, 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 l'utilisation de IronPDF, veuillez consulter leurs exemples de code sur la page d'exemple IronPDF.