1. IronPDF
  2. Guides pratiques
  3. Utiliser WaitFor pour retarder le rendu PDF
Comment utiliser WaitFor pour retarder le rendu PDF C#

Using the C# WaitFor Class to Delay PDF Rendering

Curtis Chau
Curtis Chau
Mis à jour:
This article was translated from English: Does it need improvement?
Translated
View the article in English

La classe C# WaitFor d'IronPDF aide les développeurs à retarder le rendu PDF jusqu'à ce que toutes les ressources, polices et scripts JavaScript soient chargés, ce qui évite les rendus incomplets grâce à des méthodes telles que RenderDelay, NetworkIdle et des déclencheurs JavaScript.

Guide de démarrage rapide : Utilisation de WaitFor pour améliorer le rendu des PDF

La fonctionnalité WaitFor d'IronPDF permet aux développeurs d'améliorer le rendu des PDF en gérant la synchronisation asynchrone. En définissant des options telles que RenderDelay, vous pouvez vous assurer que tous les fichiers et scripts sont chargés avant la conversion, ce qui évite d'obtenir des documents PDF incomplets. Ce guide explique comment implémenter WaitFor dans vos projets pour un rendu précis et efficace.

new IronPdf.ChromePdfRenderer { RenderingOptions = { WaitFor = IronPdf.WaitFor.RenderDelay(3000) } }
    .RenderUrlAsPdf("https://example.com")
    .SaveAs("output.pdf");
new IronPdf.ChromePdfRenderer { RenderingOptions = { WaitFor = IronPdf.WaitFor.RenderDelay(3000) } }
    .RenderUrlAsPdf("https://example.com")
    .SaveAs("output.pdf");
$vbLabelText   $csharpLabel

Workflow minimal (5 étapes)

  1. Téléchargez la bibliothèque C# IronPDF pour différer le rendu des PDF
  2. Générer un document PDF à partir d'une chaîne HTML, d'un fichier ou d'une URL Web
  3. Utilisez la méthode JavaScript WaitFor pour déclencher le rendu à partir d'une fonction JavaScript
  4. Retarder le rendu en fonction du nombre d'activités réseau
  5. Attendez que les éléments HTML spécifiques ainsi que toutes les polices soient chargés

Qu'est-ce que la classe WaitFor et ses options ?

Pour un rendu PDF aux performances optimales, la classe WaitFor améliore le processus de rendu PDF. L'objet WaitFor de RenderOptions offre plusieurs options :

  • PageLoad : Rendu par défaut sans délai.
  • RenderDelay : Définit un temps d'attente arbitraire.
  • Fonts : attend que toutes les polices soient chargées.
  • JavaScript : Déclenche le rendu à l'aide d'une fonction JavaScript.
  • HTML elements : attend des éléments HTML spécifiques, tels que les identifiants d'éléments, les noms, les noms de balises et les sélecteurs de requête pour cibler des éléments.
  • NetworkIdle : Attend que le réseau soit inactif (0, 2 ou une durée personnalisée).

Ces fonctionnalités sont disponibles lors de la conversion de chaînes HTML en PDF avec IronPDF, de fichiers HTML en PDF avec IronPDF et d'URL Web en PDF avec IronPDF.

Comment puis-je générer des PDF immédiatement sans attendre ?

Par défaut, le rendu s'effectue immédiatement après le chargement complet de la page. La méthode `` n'a pas besoin d'être appelée pour un rendu normal. Cette approche fonctionne bien pour du contenu HTML simple, sans JavaScript complexe ni ressources externes.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-pageload.cs
using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();

// Render as soon as the page is loaded
renderer.RenderingOptions.WaitFor.PageLoad();

PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Render as soon as the page is loaded
renderer.RenderingOptions.WaitFor.PageLoad()

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>testing</h1>")
$vbLabelText   $csharpLabel

Comment puis-je ajouter un délai personnalisé avant le rendu PDF ?

Lorsqu'un délai spécifique est requis avant le rendu du PDF, vous pouvez définir un nombre arbitraire de millisecondes comme délai. Cela offre une certaine flexibilité pour répondre à des exigences de timing spécifiques, en particulier lorsqu'il s'agit de contenu riche en JavaScript.

Cette option fonctionne de la même manière que l'ancienne implémentation utilisant la propriété . Cependant, l&#x27;ancienne propriété a été dépréciée. Utilisez la nouvelle API :.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-delay-time.cs
using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();

// Render after 3000ms
renderer.RenderingOptions.WaitFor.RenderDelay(3000);

PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
Imports IronPdf

Private renderer As New ChromePdfRenderer()

' Render after 3000ms
renderer.RenderingOptions.WaitFor.RenderDelay(3000)

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>testing</h1>")
$vbLabelText   $csharpLabel

Le mécanisme de délai est utile lorsque votre code HTML contient des animations, du contenu chargé de manière différée ou nécessite du temps pour la génération de contenu dynamique. Pour les scénarios de rendu complexes, explorez les options de rendu personnalisées.

Comment attendre que toutes les polices soient chargées avant le rendu ?

La méthode de la classe suspend le rendu du PDF jusqu'à ce que toutes les polices soient chargées à partir de sources externes telles que Google Fonts. Cela garantit que le PDF final inclut toutes les polices requises, préservant ainsi la typographie et l'apparence visuelle prévues du document. Cette fonctionnalité garantit une qualité de sortie PDF professionnelle.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-all-fonts.cs
using IronPdf;

string htmlContent = @"
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Test Registration of Extension</title>
  <!-- for google web fonts -->
  <link rel=""preconnect"" href=""https://fonts.googleapis.com"">
  <link rel=""preconnect"" href=""https://fonts.gstatic.com"" crossorigin>
  <link rel=""stylesheet"" href=""https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap"" >

  <style>
  /* for remote fonts */
  @font-face {
    font-family: 'CustomFont';
    src: url('https://stage.gradfinale.co.uk/tcpdf/fonts/avgr65wttf.ttf');
  }
  p#p1 { font-family: CustomFont, sans-serif; }

  /* for local fonts */
  @font-face {
    font-family: 'LocalCustomFont';
    src: local('Arial');
  }
  p#p3 { font-family: LocalCustomFont, sans-serif; }
  </style>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
	<p style=""font-family: Roboto, monospace;"">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla scelerisque ligula venenatis erat <strong>scelerisque</strong> auctor.</p>
	<p id=""p1"">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla scelerisque ligula venenatis erat <strong>scelerisque</strong> auctor.</p>
	<p id=""p3"">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla scelerisque ligula venenatis erat <strong>scelerisque</strong> auctor.</p>
</body>
</html>)";

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.AllFontsLoaded(10000);

PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
Imports IronPdf

Dim htmlContent As String = "
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Test Registration of Extension</title>
  <!-- for google web fonts -->
  <link rel=""preconnect"" href=""https://fonts.googleapis.com"">
  <link rel=""preconnect"" href=""https://fonts.gstatic.com"" crossorigin>
  <link rel=""stylesheet"" href=""https://fonts.googleapis.com/css2?family=Roboto:wght@400;700&display=swap"" >

  <style>
  /* for remote fonts */
  @font-face {
    font-family: 'CustomFont';
    src: url('https://stage.gradfinale.co.uk/tcpdf/fonts/avgr65wttf.ttf');
  }
  p#p1 { font-family: CustomFont, sans-serif; }

  /* for local fonts */
  @font-face {
    font-family: 'LocalCustomFont';
    src: local('Arial');
  }
  p#p3 { font-family: LocalCustomFont, sans-serif; }
  </style>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
	<p style=""font-family: Roboto, monospace;"">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla scelerisque ligula venenatis erat <strong>scelerisque</strong> auctor.</p>
	<p id=""p1"">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla scelerisque ligula venenatis erat <strong>scelerisque</strong> auctor.</p>
	<p id=""p3"">Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nulla scelerisque ligula venenatis erat <strong>scelerisque</strong> auctor.</p>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.AllFontsLoaded(10000)

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
$vbLabelText   $csharpLabel

Pour plus d'informations sur la gestion des polices dans les PDF, y compris les options d'intégration et de sous-ensemble, consultez le guide sur la gestion des polices dans les PDF.

Comment déclencher le rendu PDF à l'aide d'un script JavaScript personnalisé ?

Pour un meilleur contrôle du processus de rendu, vous pouvez spécifier une fonction JavaScript personnalisée qui s'exécute avant le rendu du document PDF. Cela vous permet d'effectuer les tâches ou vérifications nécessaires avant de lancer le processus de rendu, vous donnant ainsi le contrôle sur le moment où déclencher le rendu.

En JavaScript, la fonction déclenche la tâche de rendu. Une fois que est appelé, le processus de rendu démarre. C'est vous qui décidez quand appeler la fonction.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-javascript.cs
using IronPdf;

string html = @"<!DOCTYPE html>
<html>
<body>
<h1>Testing</h1>
<script type='text/javascript'>

// Set delay
setTimeout(function() {
    window.ironpdf.notifyRender();
}, 1000);

</script>
</body>
</html>";

ChromePdfRenderOptions renderingOptions = new ChromePdfRenderOptions();

// Set rendering to wait for the notifyRender function
renderingOptions.WaitFor.JavaScript(5000);

PdfDocument pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(html, renderingOptions);
JAVASCRIPT

Cette approche est efficace lorsqu'elle est combinée à des requêtes AJAX ou lorsqu'il s'agit de s'assurer que le contenu généré dynamiquement se charge entièrement avant le rendu. Pour les scénarios JavaScript avancés, consultez le guide sur l'exécution de JavaScript personnalisé dans les PDF.

Comment puis-je attendre des éléments HTML spécifiques avant le rendu ?

Avec cette option, le processus de rendu attend des éléments HTML spécifiques, tels que les identifiants d'éléments, les noms, les noms de balises et les sélecteurs de requête, pour cibler les éléments. Cette fonctionnalité est utile lorsque l'on travaille avec des applications monopages (SPA) ou du contenu qui se charge de manière asynchrone.

Comment attendre un élément par son ID ?

Le rendu attend un identifiant d'élément spécifique dans l'exemple de code ci-dessous.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-html-element-id.cs
using IronPdf;

string htmlContent = @"
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Delayed render tests</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var h1Tag = document.createElement(""h1"");
		h1Tag.innerHTML = ""bla bla bla"";
		h1Tag.setAttribute(""id"", ""myid"");

        var block = document.querySelector(""div#x"");
		block.appendChild(h1Tag);
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>";

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.HtmlElementById("myid", 5000);

PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
Imports IronPdf

Dim htmlContent As String = "
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Delayed render tests</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var h1Tag = document.createElement(""h1"");
		h1Tag.innerHTML = ""bla bla bla"";
		h1Tag.setAttribute(""id"", ""myid"");

        var block = document.querySelector(""div#x"");
		block.appendChild(h1Tag);
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.HtmlElementById("myid", 5000)

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
$vbLabelText   $csharpLabel

Comment attendre un élément par son attribut " name " ?

Le processus de rendu attend un nom d'élément spécifique dans l'exemple de code ci-dessous.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-html-element-id.cs
using IronPdf;

string htmlContent = @"
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Delayed render tests</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var h1Tag = document.createElement(""h1"");
		h1Tag.innerHTML = ""bla bla bla"";
		h1Tag.setAttribute(""id"", ""myid"");

        var block = document.querySelector(""div#x"");
		block.appendChild(h1Tag);
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>";

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.HtmlElementById("myid", 5000);

PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
Imports IronPdf

Dim htmlContent As String = "
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Delayed render tests</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var h1Tag = document.createElement(""h1"");
		h1Tag.innerHTML = ""bla bla bla"";
		h1Tag.setAttribute(""id"", ""myid"");

        var block = document.querySelector(""div#x"");
		block.appendChild(h1Tag);
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.HtmlElementById("myid", 5000)

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
$vbLabelText   $csharpLabel

Comment attendre des éléments par nom de balise ?

Le processus de rendu attend un nom de balise d'élément spécifique dans l'exemple de code ci-dessous.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-html-element-tag-name.cs
using IronPdf;

string htmlContent = @"
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Delayed render tests</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var newElem = document.createElement(""h2"");
		newElem.innerHTML = ""bla bla bla"";

        var block = document.querySelector(""div#x"");
		block.appendChild(newElem);
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>";

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.HtmlElementByTagName("h2", 5000);

PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
Imports IronPdf

Dim htmlContent As String = "
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Delayed render tests</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var newElem = document.createElement(""h2"");
		newElem.innerHTML = ""bla bla bla"";

        var block = document.querySelector(""div#x"");
		block.appendChild(newElem);
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.HtmlElementByTagName("h2", 5000)

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
$vbLabelText   $csharpLabel

Comment utiliser les sélecteurs de requête pour attendre des éléments ?

Le processus de rendu attend l'élément sélectionné par le sélecteur de requête dans l'exemple de code ci-dessous. La méthode attend une balise avec un id de " myid " et une class de " blablastyle ".

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-html-element-query-selector.cs
using IronPdf;

string htmlContent = @"
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Test Registration of Extension</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var img = document.createElement(""img"");
		img.onload = function() {
			img.setAttribute(""id"", ""myid"");
			img.setAttribute(""class"", ""blablastyle"");
			var block = document.getElementById(""x"");
			block.appendChild(img);
		};
		img.src = ""https://www.w3schools.com/images/picture.jpg"";	// .src after .onload to ignore cached, if any
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>";

ChromePdfRenderer renderer = new ChromePdfRenderer();
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("img#myid.blablastyle", 5000);

PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent);
Imports IronPdf

Dim htmlContent As String = "
<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""UTF-8"">
  <title>Test Registration of Extension</title>
  <script type=""text/javascript"">
	setTimeout(function() {
		var img = document.createElement(""img"");
		img.onload = function() {
			img.setAttribute(""id"", ""myid"");
			img.setAttribute(""class"", ""blablastyle"");
			var block = document.getElementById(""x"");
			block.appendChild(img);
		};
		img.src = ""https://www.w3schools.com/images/picture.jpg"";	// .src after .onload to ignore cached, if any
	}, 1000);
  </script>
</head>
<body>
	<h1>This is Delayed Render Test!</h1>
    <div id=""x""></div>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("img#myid.blablastyle", 5000)

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
$vbLabelText   $csharpLabel

Comment attendre que l'activité réseau soit terminée ?

Lors du rendu de pages web qui effectuent des requêtes réseau pour des ressources, des données ou des appels API, assurez-vous que toute l'activité réseau soit terminée avant de générer le PDF. IronPDF propose plusieurs méthodes pour gérer différents scénarios réseau.

Quand dois-je attendre que l'activité réseau soit nulle ?

Ce type d'inactivité réseau attend qu'il n'y ait plus d'activité réseau, ce qui indique généralement que le contenu a été entièrement chargé. Cela convient aux applications monopages (SPA) ou aux pages web simples sans requêtes réseau de type " long-polling " ni activité réseau continue.

Le processus de rendu commence dès qu'il n'y a plus d'activité réseau depuis au moins 500 ms.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-network-idle-0.cs
using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();

// Render unless there has been no network activity for at least 500ms
renderer.RenderingOptions.WaitFor.NetworkIdle0();

PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Render unless there has been no network activity for at least 500ms
renderer.RenderingOptions.WaitFor.NetworkIdle0()

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>testing</h1>")
$vbLabelText   $csharpLabel

Quand dois-je autoriser deux activités réseau ?

La méthode `` convient aux applications web ou aux pages web utilisant des requêtes réseau de type " long polling " ou des pings de type " heartbeat ". En général, 1 à 2 demandes sont concernées. Même si ces requêtes sont en cours, elles n'invalideront pas le déclenchement de l'événement d'inactivité du réseau, car un maximum de deux est acceptable.

Avant de lancer le processus de rendu, il ne doit rester au maximum que deux activités réseau pendant au moins 500 ms. Cette option permet une configuration rapide pour gérer un nombre fixe d'activités réseau.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-network-idle-2.cs
using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();

// Render unless there are at most 2 network activities for at least 500ms
renderer.RenderingOptions.WaitFor.NetworkIdle2();

PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Render unless there are at most 2 network activities for at least 500ms
renderer.RenderingOptions.WaitFor.NetworkIdle2()

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>testing</h1>")
$vbLabelText   $csharpLabel

Comment personnaliser les seuils d'activité réseau ?

Lorsque plusieurs requêtes réseau sont impliquées, vous pouvez personnaliser à la fois la durée d'inactivité du réseau et le nombre de requêtes réseau autorisées qui n'invalident pas l'événement d'inactivité du réseau. Cette option convient aux applications web ou aux pages web présentant des exigences spécifiques qui ne correspondent pas aux deux méthodes précédentes. Cette personnalisation couvre un large éventail de cas d'utilisation dans différentes circonstances.

:path=/static-assets/pdf/content-code-examples/how-to/waitfor-customize-network.cs
using IronPdf;

ChromePdfRenderer renderer = new ChromePdfRenderer();

// Render unless there are at most 5 network activities for at least 1000ms
renderer.RenderingOptions.WaitFor.NetworkIdle(1000, 5);

PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
Imports IronPdf

Private renderer As New ChromePdfRenderer()

' Render unless there are at most 5 network activities for at least 1000ms
renderer.RenderingOptions.WaitFor.NetworkIdle(1000, 5)

Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>testing</h1>")
$vbLabelText   $csharpLabel

Ce niveau de personnalisation est précieux lorsque l'on travaille avec des applications web complexes qui maintiennent des connexions persistantes ou présentent des schémas d'activité réseau en arrière-plan prévisibles.

Comment définir un délai d'attente maximal ?

,, et vous permettent de définir un temps d'attente maximal afin de garantir que l'attente ne sera pas indéfinie. Le paramètre `` de ces méthodes sert à cette fin. Cela empêche votre application de se bloquer indéfiniment si les conditions attendues ne se produisent jamais.

Toutes les valeurs de temps indiquées sont exprimées en millisecondes.

Lors de la mise en œuvre de ces stratégies d'attente, il convient de trouver un équilibre entre le chargement complet du contenu et le maintien d'une performance raisonnable. Pour les applications nécessitant un contrôle précis du timing, explorez les techniques de génération asynchrone de PDF.

Prêt à découvrir ce que vous pouvez faire d'autre ? Consultez la page du tutoriel ici : Fonctionnalités supplémentaires ou découvrez comment créer des PDF avec IronPDF pour des techniques plus avancées.

Questions Fréquemment Posées

Qu'est-ce que la classe WaitFor et pourquoi devrais-je l'utiliser ?

La classe WaitFor d'IronPDF permet aux développeurs de retarder le rendu du PDF jusqu'à ce que tous les actifs, polices et JavaScript aient fini de se charger. Cela permet d'éviter les rendus incomplets et de s'assurer que les pages web complexes sont entièrement chargées avant d'être converties en PDF, ce qui permet d'obtenir des documents PDF plus précis et plus complets.

Quelles sont les différentes options de WaitFor disponibles ?

La classe WaitFor d'IronPDF offre plusieurs options : PageLoad (rendu immédiat par défaut), RenderDelay (délai personnalisé en millisecondes), Fonts (attend le chargement de toutes les polices), JavaScript (déclenche le rendu via une fonction JavaScript), HTML elements (attend des éléments spécifiques par ID, nom, balise ou sélecteur de requête), et NetworkIdle (attend la fin de l'activité du réseau).

Comment ajouter un délai personnalisé avant le rendu du PDF ?

Vous pouvez ajouter un délai personnalisé à l'aide de la méthode RenderDelay d'IronPDF. Il suffit de spécifier le délai en millisecondes : `new ChromePdfRenderer { RenderingOptions = { WaitFor = WaitFor.RenderDelay(3000) } }`. Ceci est particulièrement utile pour les contenus à forte teneur en JavaScript qui ont besoin de plus de temps pour s'exécuter.

Puis-je attendre le chargement d'éléments HTML spécifiques avant d'effectuer le rendu ?

Oui, IronPDF vous permet d'attendre des éléments HTML spécifiques en utilisant des ID d'éléments, des noms, des noms de balises ou des sélecteurs de requêtes. Cela permet de s'assurer que le contenu essentiel est présent sur la page avant que la conversion PDF ne commence, évitant ainsi les éléments manquants dans votre document PDF final.

Qu'est-ce que NetworkIdle et quand dois-je l'utiliser ?

NetworkIdle dans IronPDF attend que l'activité du réseau cesse avant de rendre le PDF. Vous pouvez le configurer pour qu'il attende 0, 2 ou un nombre personnalisé de connexions réseau. Cette fonction est idéale pour les pages qui chargent le contenu de manière dynamique par le biais d'appels AJAX ou d'autres requêtes réseau asynchrones.

Comment puis-je déclencher le rendu d'un PDF à partir de JavaScript ?

L'option JavaScript WaitFor d'IronPDF vous permet de déclencher le processus de rendu à partir d'une fonction JavaScript. Vous avez ainsi un contrôle total sur le moment où le PDF est généré, ce qui est parfait pour les applications à page unique ou les sites web complexes pilotés par JavaScript, pour lesquels vous avez besoin d'un contrôle précis de la synchronisation.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite
Prêt à commencer?
Nuget Téléchargements 19,014,616 | Version : 2026.5 just released
Still Scrolling Icon

Vous faites encore défiler ?

Vous voulez une preuve rapidement ? PM > Install-Package IronPdf
exécuter un échantillon Regardez votre code HTML se transformer en PDF.