Comment pouvez-vous retarder le rendu PDF en C# ?

Vous pouvez retarder le rendu PDF en C# en utilisant la méthode `Thread.Sleep` pour une attente synchrone ou `Task.Delay` pour une attente asynchrone. Ces méthodes vous permettent de suspendre l'exécution du code pour une durée spécifiée, garantissant que les tâches sont effectuées au bon moment.

Qu'est-ce que la classe WaitFor en C# ?

La classe WaitFor en C# est utilisée pour mettre en œuvre différentes stratégies d'attente dans votre code. Elle fournit des méthodes comme `Thread.Sleep` et `Task.Delay` pour aider à gérer le timing d'exécution des tâches, permettant aux développeurs de suspendre l'exécution du code si nécessaire.

Comment pouvez-vous implémenter une attente asynchrone en C# pour les tâches PDF ?

L'attente asynchrone en C# peut être implémentée en utilisant la méthode `Task.Delay`, qui vous permet d'attendre de manière asynchrone sans bloquer le thread principal. Cela est particulièrement utile pour les tâches PDF afin d'assurer une exécution fluide et une planification correcte des tâches.

Quel rôle jouent les minuteries dans la gestion de l'exécution des tâches en C# ?

Les minuteries, telles que celles fournies par la classe `System.Timers.Timer`, vous permettent de planifier des tâches à des intervalles spécifiques. Elles sont utiles pour exécuter des tâches comme la génération de PDF à intervalles réguliers, garantissant une gestion efficace des tâches sans bloquer le thread principal.

Pouvez-vous créer des fonctions d'attente personnalisées en C# ?

Oui, vous pouvez créer des fonctions d'attente personnalisées en C# en utilisant des délégués asynchrones. Cela permet des pauses d'exécution du code sur mesure pour répondre à des exigences spécifiques, en particulier lorsque les méthodes d'attente par défaut ne suffisent pas.

Comment pouvez-vous intégrer la génération de PDF avec des stratégies d'attente en C# ?

Vous pouvez intégrer la génération de PDF avec des stratégies d'attente en C# en utilisant des méthodes async et des minuteries. Cela garantit que les tâches de création de PDF sont gérées efficacement, permettant une exécution planifiée sans bloquer d'autres processus.

Comment convertir HTML en PDF en C# ?

Pour convertir du HTML en PDF en C#, vous pouvez utiliser des bibliothèques comme IronPDF. Cette bibliothèque fournit des méthodes pour convertir des chaînes HTML, des URL et des fichiers en documents PDF de manière efficace.

Quels sont les avantages d'utiliser des méthodes asynchrones en C# ?

Les méthodes asynchrones en C# offrent l'avantage de l'exécution concurrente des tâches, ce qui améliore l'efficacité de l'application en permettant à plusieurs tâches de s'exécuter en parallèle sans bloquer le thread principal.

Comment installer une bibliothèque PDF dans un projet .NET ?

Pour installer une bibliothèque PDF dans un projet .NET, vous pouvez utiliser le Package Manager NuGet dans Visual Studio pour rechercher et installer la bibliothèque. Alternativement, vous pouvez télécharger le fichier DLL de la bibliothèque et l'ajouter manuellement à votre projet.

Est-il possible de suspendre le rendu PDF pendant un temps spécifique en C# ?

Oui, vous pouvez suspendre le rendu PDF pendant un temps spécifique en C# en utilisant des méthodes comme `Thread.Sleep` pour des pauses synchrones ou `Task.Delay` pour des pauses asynchrones, vous permettant de contrôler le timing des tâches de génération de PDF.

La Bibliothèque PDF C#

Explore IronPDF Essai gratuit

HTML en PDF

Online Demo Voir tous les exemples de code %s

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

MISES À JOUR POUR LES DÉVELOPPEURS

C# Attendre quelques secondes (Comment cela fonctionne pour les développeurs)

Jacob Mellor

Updated: 23 avril 2026

En programmation, vous voudrez parfois suspendre ou retarder l'exécution de votre code pendant un certain temps. Cela vous permet de simuler différentes conditions temporelles, de prioriser certaines tâches, d'exécuter d'autres tâches sans bloquer le thread principal, et plus encore.

Dans ce guide, nous expliquerons comment attendre en C#, y compris les méthodes asynchrones, les commandes sleep, les fonctions sleep, les applications console, et comment inclure une fonction d'attente dans notre outil de génération de PDF leader du secteur, IronPDF.

Comment attendre une tâche en C#

La Commande Sleep

'Sleep' est une commande simple mais puissante qui vous permet de suspendre l'exécution de votre tâche actuelle pendant un temps spécifique, essentiellement en demandant à votre programme d'attendre avant de passer à la tâche suivante. En C#, nous faisons cela en utilisant la méthode Thread.Sleep(int milliseconds), comme dans l'exemple de code suivant :

using System;
using System.Threading;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Starting the program...");
        Thread.Sleep(3000); // Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds");
    }
}

using System;
using System.Threading;

class Program
{
    public static void Main()
    {
        Console.WriteLine("Starting the program...");
        Thread.Sleep(3000); // Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds");
    }
}

Imports System
Imports System.Threading

Class Program
    Public Shared Sub Main()
        Console.WriteLine("Starting the program...")
        Thread.Sleep(3000) ' Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds")
    End Sub
End Class

Imports System
Imports System.Threading

Class Program
    Public Shared Sub Main()
        Console.WriteLine("Starting the program...")
        Thread.Sleep(3000) ' Sleep for 3 seconds
        Console.WriteLine("...Program continues after 3 seconds")
    End Sub
End Class

Ici, le programme commence par imprimer " Démarrage du programme... " dans la console avant d'utiliser la méthode Thread.Sleep pour faire une pause de 3 000 millisecondes (ou trois secondes). Après le délai spécifié, le programme reprend et imprime le résultat "...Le programme continue après 3 secondes" dans la console.

Méthode Asynchrone et Tâches

Les méthodes asynchrones en C# vous permettent d'exécuter plusieurs tâches simultanément sans interférer avec le thread principal. Cela signifie que pendant qu'une tâche attend, d'autres tâches peuvent continuer à s'exécuter. Pour implémenter une méthode async, vous devrez utiliser le mot-clé async et la classe Task.

using System;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       var task1 = DoSomethingAsync(3000);
       Console.WriteLine("Starting Task 2...");
       var task2 = DoSomethingAsync(2000);

       await Task.WhenAll(task1, task2);
       Console.WriteLine("Both tasks completed.");
   }

   private static async Task DoSomethingAsync(int milliseconds)
   {
       await Task.Delay(milliseconds); // Asynchronously wait without blocking the main thread
       Console.WriteLine($"Task completed after {milliseconds} milliseconds");
   }
}

using System;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       var task1 = DoSomethingAsync(3000);
       Console.WriteLine("Starting Task 2...");
       var task2 = DoSomethingAsync(2000);

       await Task.WhenAll(task1, task2);
       Console.WriteLine("Both tasks completed.");
   }

   private static async Task DoSomethingAsync(int milliseconds)
   {
       await Task.Delay(milliseconds); // Asynchronously wait without blocking the main thread
       Console.WriteLine($"Task completed after {milliseconds} milliseconds");
   }
}

Imports System
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Dim task1 = DoSomethingAsync(3000)
	   Console.WriteLine("Starting Task 2...")
	   Dim task2 = DoSomethingAsync(2000)

	   Await Task.WhenAll(task1, task2)
	   Console.WriteLine("Both tasks completed.")
   End Function

   Private Shared Async Function DoSomethingAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Delay(milliseconds) ' Asynchronously wait without blocking the main thread
	   Console.WriteLine($"Task completed after {milliseconds} milliseconds")
   End Function
End Class

Imports System
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Dim task1 = DoSomethingAsync(3000)
	   Console.WriteLine("Starting Task 2...")
	   Dim task2 = DoSomethingAsync(2000)

	   Await Task.WhenAll(task1, task2)
	   Console.WriteLine("Both tasks completed.")
   End Function

   Private Shared Async Function DoSomethingAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Delay(milliseconds) ' Asynchronously wait without blocking the main thread
	   Console.WriteLine($"Task completed after {milliseconds} milliseconds")
   End Function
End Class

Dans cet exemple de code, nous avons deux tâches s'exécutant en même temps. La méthode DoSomethingAsync prend un paramètre int qui représente le temps en millisecondes pendant lequel la tâche doit être retardée (comme vous pouvez le voir dans le 3000 et le 2000 dans le code, les deux étant une valeur de délai d'attente). La méthode Task.Delay est similaire à la méthode Thread.Sleep(), mais elle fonctionne avec des tâches async et ne bloque pas le thread principal.

Utiliser des Timers pour Planifier Vos Tâches

Les timers en C# vous permettent d'exécuter une tâche spécifique après un intervalle spécifié. Vous pouvez créer un minuteur en utilisant la classe System.Timers.Timer. Voici un exemple sur la façon d'utiliser un timer dans une application console :

using System;
using System.Timers;

class Program
{
   public static void Main()
   {
       var timer = new Timer(1000); // Create a timer with a 1-second interval
       timer.Elapsed += OnTimerElapsed;
       timer.AutoReset = true;
       timer.Enabled = true;

       Console.WriteLine("Press any key to exit...");
       Console.ReadKey();
   }

   private static void OnTimerElapsed(object sender, ElapsedEventArgs e)
   {
       Console.WriteLine("Timer ticked at " + e.SignalTime);
   }
}

using System;
using System.Timers;

class Program
{
   public static void Main()
   {
       var timer = new Timer(1000); // Create a timer with a 1-second interval
       timer.Elapsed += OnTimerElapsed;
       timer.AutoReset = true;
       timer.Enabled = true;

       Console.WriteLine("Press any key to exit...");
       Console.ReadKey();
   }

   private static void OnTimerElapsed(object sender, ElapsedEventArgs e)
   {
       Console.WriteLine("Timer ticked at " + e.SignalTime);
   }
}

Imports System
Imports System.Timers

Class Program
    Public Shared Sub Main()
        Dim timer As New Timer(1000) ' Create a timer with a 1-second interval
        AddHandler timer.Elapsed, AddressOf OnTimerElapsed
        timer.AutoReset = True
        timer.Enabled = True

        Console.WriteLine("Press any key to exit...")
        Console.ReadKey()
    End Sub

    Private Shared Sub OnTimerElapsed(sender As Object, e As ElapsedEventArgs)
        Console.WriteLine("Timer ticked at " & e.SignalTime)
    End Sub
End Class

Imports System
Imports System.Timers

Class Program
    Public Shared Sub Main()
        Dim timer As New Timer(1000) ' Create a timer with a 1-second interval
        AddHandler timer.Elapsed, AddressOf OnTimerElapsed
        timer.AutoReset = True
        timer.Enabled = True

        Console.WriteLine("Press any key to exit...")
        Console.ReadKey()
    End Sub

    Private Shared Sub OnTimerElapsed(sender As Object, e As ElapsedEventArgs)
        Console.WriteLine("Timer ticked at " & e.SignalTime)
    End Sub
End Class

Dans l'exemple ci-dessus, nous créons un timer avec un intervalle d'une seconde. La méthode OnTimerElapsed est exécutée chaque fois que le minuteur s'enclenche. Nous définissons la propriété AutoReset à true pour que le minuteur redémarre automatiquement après chaque déclenchement. La propriété Enabled est définie à true pour démarrer le minuteur.

Lorsque vous exécutez cette application console, vous verrez le timer qui déclenche chaque seconde, imprimant l'heure de déclenchement dans la console. Le programme continuera à s'exécuter jusqu'à ce que vous appuyiez sur n'importe quelle touche pour quitter.

Créer des Fonctions d'Attente Personnalisées

Parfois, vous pourriez avoir besoin d'une fonction d'attente personnalisée pour répondre à des exigences spécifiques dans votre code. Par exemple, vous pourriez vouloir créer une fonction d'attente qui ne bloque que la tâche actuelle, plutôt que tout le thread. Vous pouvez y parvenir en utilisant des délégués asynchrones.

Voici un exemple de fonction d'attente personnalisée :

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       await CustomWaitAsync(3000);
       Console.WriteLine("Task 1 completed.");

       Console.WriteLine("Starting Task 2...");
       await CustomWaitAsync(2000);
       Console.WriteLine("Task 2 completed.");
   }

   private static async Task CustomWaitAsync(int milliseconds)
   {
       await Task.Run(() => Thread.Sleep(milliseconds)); // Run in a separate task to avoid blocking the main thread
   }
}

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting Task 1...");
       await CustomWaitAsync(3000);
       Console.WriteLine("Task 1 completed.");

       Console.WriteLine("Starting Task 2...");
       await CustomWaitAsync(2000);
       Console.WriteLine("Task 2 completed.");
   }

   private static async Task CustomWaitAsync(int milliseconds)
   {
       await Task.Run(() => Thread.Sleep(milliseconds)); // Run in a separate task to avoid blocking the main thread
   }
}

Imports System
Imports System.Threading
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Await CustomWaitAsync(3000)
	   Console.WriteLine("Task 1 completed.")

	   Console.WriteLine("Starting Task 2...")
	   Await CustomWaitAsync(2000)
	   Console.WriteLine("Task 2 completed.")
   End Function

   Private Shared Async Function CustomWaitAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Run(Sub() Thread.Sleep(milliseconds)) ' Run in a separate task to avoid blocking the main thread
   End Function
End Class

Imports System
Imports System.Threading
Imports System.Threading.Tasks

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting Task 1...")
	   Await CustomWaitAsync(3000)
	   Console.WriteLine("Task 1 completed.")

	   Console.WriteLine("Starting Task 2...")
	   Await CustomWaitAsync(2000)
	   Console.WriteLine("Task 2 completed.")
   End Function

   Private Shared Async Function CustomWaitAsync(ByVal milliseconds As Integer) As Task
	   Await Task.Run(Sub() Thread.Sleep(milliseconds)) ' Run in a separate task to avoid blocking the main thread
   End Function
End Class

Ici, la méthode CustomWaitAsync accepte un paramètre int représentant le temps de retard en millisecondes. La méthode utilise un délégué async pour exécuter la fonction Thread.Sleep dans une nouvelle tâche, garantissant ainsi que le statut de la tâche actuelle est bloqué pendant l'attente, mais pas le thread principal.

Choisir la Bonne Stratégie d'Attente

Maintenant que nous avons couvert l'instruction d'attente en C#, la commande sleep, les méthodes asynchrones, les timers et les fonctions d'attente personnalisées, il est essentiel de savoir quand utiliser chaque technique. Voici un rapide résumé :

Utilisez la fonction Thread.Sleep lorsque vous avez besoin d'un moyen simple de suspendre l'exécution de votre code pour une durée spécifiée.
Utilisez les méthodes et tâches asynchrones lorsque vous avez besoin d'exécuter plusieurs tâches simultanément sans bloquer le thread principal.
Utilisez des timers lorsque vous avez besoin d'exécuter une tâche spécifique à un intervalle spécifié.
Créez des fonctions d'attente personnalisées lorsque vous avez des exigences spécifiques qui ne sont pas satisfaites par les méthodes intégrées.

Générer des PDF avec IronPDF en utilisant la Fonction d'Attente

IronPDF est une bibliothèque PDF .NET légère conçue spécifiquement pour les développeurs web. Elle simplifie la lecture, l'écriture et la manipulation des fichiers PDF, capable de convertir toutes sortes de types de fichiers en contenu PDF, et vous pouvez l'utiliser dans vos projets .NET aussi bien pour le bureau que pour le web. La meilleure partie - elle est gratuite à essayer dans un environnement de développement. Plongeons-nous dedans.

IronPDF fonctionne avec des fichiers HTML, des URL, des chaînes de caractères brutes et des fichiers ZIP. Voici un aperçu rapide du code :

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

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

IronPDF peut s'intégrer parfaitement avec vos stratégies d'attente pour générer des documents PDF après avoir exécuté des tâches, pendant des intervalles programmés, ou lorsque le thread actuel reprend l'exécution.

Par exemple, vous pouvez utiliser IronPDF en combinaison avec une méthode asynchrone pour générer un rapport PDF après avoir récupéré des données d'une base de données sans bloquer le thread principal. De même, vous pouvez utiliser une classe timer pour créer une photo instantanée PDF des données de votre application à intervalles réguliers.

Installer la Bibliothèque IronPDF

IronPDF est facile à utiliser mais encore plus facile à installer. Il y a plusieurs façons de le faire :

Méthode 1 : Console du Gestionnaire de Packages NuGet

Dans Visual Studio, dans l'Explorateur de solutions, cliquez avec le bouton droit sur Références, puis cliquez sur Gérer les packages NuGet. Cliquez sur rechercher et tapez 'IronPDF', puis installez la dernière version. Si vous voyez cela, cela fonctionne :

Vous pouvez également aller à Outils -> Package Manager NuGet -> Console du Package Manager, et entrer la ligne suivante dans l'onglet du Package Manager :

PM > Install-Package IronPdf

Install-Package IronPdf

Enfin, vous pouvez obtenir IronPDF directement depuis le site officiel de NuGet. Sélectionnez l'option Télécharger le Package dans le menu à droite de la page, double-cliquez sur votre téléchargement pour l'installer automatiquement et rechargez la Solution pour commencer à l'utiliser dans votre projet.

Ça n'a pas marché ? Vous pouvez trouver de l'aide spécifique à la plateforme sur notre page d'installation avancée de NuGet.

Méthode 2 : Utilisation d'un fichier DLL

Vous pouvez également obtenir le fichier DLL de IronPDF directement de notre part et l'ajouter manuellement à Visual Studio. Pour des instructions complètes et des liens vers les packages DLL pour Windows, macOS et Linux, consultez notre page d'installation dédiée.

Comment utiliser C# Wait dans IronPDF

Vous pouvez voir comment inclure une fonction d'attente dans IronPDF dans l'exemple suivant :

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting the PDF generation task...");
       Stopwatch stopwatch = Stopwatch.StartNew();
       await Task.Delay(3000); // Wait for 3 seconds
       GeneratePdf();
       Console.WriteLine("PDF generated successfully.");
   }

   private static void GeneratePdf()
   {
       var htmlToPdf = new ChromePdfRenderer();
       var pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
       pdf.SaveAs("HelloWorld.pdf");
   }
}

using System;
using System.Threading.Tasks;
using System.Diagnostics;
using IronPdf;

class Program
{
   public static async Task Main()
   {
       Console.WriteLine("Starting the PDF generation task...");
       Stopwatch stopwatch = Stopwatch.StartNew();
       await Task.Delay(3000); // Wait for 3 seconds
       GeneratePdf();
       Console.WriteLine("PDF generated successfully.");
   }

   private static void GeneratePdf()
   {
       var htmlToPdf = new ChromePdfRenderer();
       var pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>");
       pdf.SaveAs("HelloWorld.pdf");
   }
}

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting the PDF generation task...")
	   Dim stopwatch As Stopwatch = System.Diagnostics.Stopwatch.StartNew()
	   Await Task.Delay(3000) ' Wait for 3 seconds
	   GeneratePdf()
	   Console.WriteLine("PDF generated successfully.")
   End Function

   Private Shared Sub GeneratePdf()
	   Dim htmlToPdf = New ChromePdfRenderer()
	   Dim pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
	   pdf.SaveAs("HelloWorld.pdf")
   End Sub
End Class

Imports System
Imports System.Threading.Tasks
Imports System.Diagnostics
Imports IronPdf

Friend Class Program
   Public Shared Async Function Main() As Task
	   Console.WriteLine("Starting the PDF generation task...")
	   Dim stopwatch As Stopwatch = System.Diagnostics.Stopwatch.StartNew()
	   Await Task.Delay(3000) ' Wait for 3 seconds
	   GeneratePdf()
	   Console.WriteLine("PDF generated successfully.")
   End Function

   Private Shared Sub GeneratePdf()
	   Dim htmlToPdf = New ChromePdfRenderer()
	   Dim pdf = htmlToPdf.RenderHtmlAsPdf("<h1>Hello, World!</h1>")
	   pdf.SaveAs("HelloWorld.pdf")
   End Sub
End Class

Ici, nous utilisons la méthode Task.Delay pour attendre 3 secondes avant de générer un PDF. Le PDF est ensuite enregistré sous le nom "HelloWorld.pdf" dans le répertoire de travail de l'application après la fin de l'attente.

Et voici le produit final :

Utiliser la Méthode d'Attente avec IronPDF

Dans les applications C#, vous pouvez utiliser efficacement la fonction sleep pour gérer le thread actuel et le temps CPU tout en effectuant des opérations telles que le chargement de données dans un DataTable ou la génération de rapports PDF avec IronPDF.

Conclusion

Cela peut sembler contre-intuitif au départ, mais implémenter des instructions d'attente dans votre code est une compétence indispensable lors de la création d'applications efficaces. Et en incorporant IronPDF, vous pouvez amener vos applications au niveau supérieur en créant des documents PDF à la volée, sans bloquer le thread principal.

Prêt à mettre la main sur IronPDF ? Vous pouvez commencer avec notre essai gratuit de 30 jours. C'est aussi totalement gratuit à utiliser à des fins de développement afin que vous puissiez vraiment voir ce dont il est fait. Et si vous aimez ce que vous voyez, IronPDF commence à partir de $999. Pour encore plus d'économies, consultez l'Iron Suite où vous pouvez obtenir les neuf outils Iron Software pour le prix de deux. Bonne programmation !

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, la transformant aux côtés du PDG Cameron Rimington en une entreprise de plus de 50 personnes au service de la NASA, de Tesla et d'agences gouvernementales mondiales.

...