1. IronPDF
  2. Tutoriais
  3. Use WaitFor para atrasar a renderização do PDF.
Como usar o WaitFor para atrasar a renderização de PDF em C#

Using the C# WaitFor Class to Delay PDF Rendering

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

A classe C# WaitFor no IronPDF ajuda os desenvolvedores a atrasar a renderização do PDF até que todos os recursos, fontes e JavaScript tenham sido carregados, evitando renderizações incompletas usando métodos como RenderDelay, NetworkIdle e gatilhos JavaScript .

Guia rápido: Usando WaitFor para melhorar a renderização de PDFs

O recurso WaitFor do IronPDF permite que os desenvolvedores melhorem a renderização de PDFs gerenciando o tempo assíncrono. Ao definir opções como RenderDelay, você pode garantir que todos os recursos e scripts sejam carregados antes da conversão, evitando documentos PDF incompletos. Este guia mostra como implementar WaitFor em seus projetos para uma renderização precisa e eficiente.

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

Fluxo de trabalho mínimo (5 etapas)

  1. Baixe a biblioteca IronPDF em C# para atrasar a renderização de PDFs.
  2. Gere um documento PDF a partir de uma string HTML, arquivo ou URL da web.
  3. Utilize o método `WaitFor` do JavaScript para acionar a renderização a partir de uma função JavaScript.
  4. Atrasar a renderização com base no número de atividades de rede
  5. Aguarde o carregamento de elementos HTML específicos e de todas as fontes.

O que é a classe WaitFor e quais são suas opções?

Para renderizar PDFs com desempenho ideal , a classe WaitFor melhora o processo de renderização de PDF. O objeto WaitFor de RenderOptions oferece diversas opções:

  • PageLoad: Renderização padrão sem espera.
  • RenderDelay: Define um tempo de espera arbitrário.
  • Fonts: Aguarda até que todas as fontes sejam carregadas.
  • JavaScript: Aciona a renderização com uma função JavaScript .
  • HTML elements: Aguarda elementos HTML específicos, como IDs de elementos, nomes, nomes de tags e seletores de consulta para direcionar elementos.
  • NetworkIdle: Aguarda ociosidade da rede (0, 2 ou um valor personalizado).

Essas funcionalidades são aplicadas ao converter strings HTML em PDF com o IronPDF , arquivos HTML em PDF com o IronPDF e URLs da web em PDF com o IronPDF .

Como faço para renderizar PDFs instantaneamente, sem esperar?

Por padrão, a renderização ocorre imediatamente após a página terminar de carregar. O método PageLoad não precisa ser chamado para a renderização normal. Essa abordagem funciona bem para conteúdo HTML simples, sem JavaScript complexo ou recursos externos.

: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

Como posso adicionar um atraso personalizado antes da renderização do PDF?

Quando for necessário um atraso específico antes de renderizar o PDF, você pode definir um número arbitrário de milissegundos como atraso. Isso proporciona flexibilidade para requisitos de temporização específicos, especialmente ao lidar com conteúdo que utiliza muito JavaScript .

Esta opção funciona da mesma forma que a implementação antiga usando a propriedade RenderingOptions.RenderDelay. No entanto, o imóvel antigo foi descontinuado. Use a nova API: RenderingOptions.WaitFor.RenderDelay.

: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

O mecanismo de atraso é útil quando seu HTML contém animações, conteúdo carregado sob demanda ou requer tempo para a geração de conteúdo dinâmico. Para cenários de renderização complexos, explore as opções de renderização personalizadas .

Como faço para esperar que todas as fontes sejam carregadas antes de renderizar?

O método AllFontsLoaded na classe WaitFor pausa a renderização do PDF até que todas as fontes sejam carregadas de fontes externas, como o Google Fonts. Isso garante que o PDF final inclua todas as fontes necessárias, preservando a tipografia e a aparência visual pretendidas do documento. Este recurso mantém a qualidade profissional da saída em PDF . 

: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

Para obter mais informações sobre como gerenciar fontes em PDFs, incluindo opções de incorporação e seleção de subconjuntos, consulte o guia sobre gerenciamento de fontes em PDFs .

Como posso acionar a renderização de PDF usando JavaScript personalizado?

Para maior controle sobre o processo de renderização, você pode especificar uma função JavaScript personalizada que será executada antes da renderização do documento PDF. Isso permite que você execute tarefas ou verificações necessárias antes de iniciar o processo de renderização, dando a você controle sobre quando acionar a renderização.

Em JavaScript, a função window.ironpdf.notifyRender() aciona a tarefa de renderização. Assim que notifyRender() for invocado, o processo de renderização será iniciado. Você controla quando a função será invocada.

: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

Essa abordagem é eficaz quando combinada com solicitações AJAX ou quando se garante que o conteúdo gerado dinamicamente seja totalmente carregado antes da renderização. Para cenários avançados de JavaScript , consulte o guia sobre como executar JavaScript personalizado em PDFs .

Como posso aguardar a renderização de elementos HTML específicos?

Com essa opção, o processo de renderização aguarda elementos HTML específicos, como IDs de elementos, nomes, nomes de tags e seletores de consulta para direcionar os elementos. Essa funcionalidade é útil ao trabalhar com aplicativos de página única (SPAs) ou conteúdo que carrega de forma assíncrona.

Como faço para aguardar um elemento pelo ID?

No exemplo de código abaixo, a renderização aguarda um ID de elemento específico.

: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

Como faço para aguardar um elemento pelo atributo nome?

No exemplo de código abaixo, o processo de renderização aguarda um nome de elemento específico.

: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

Como faço para aguardar elementos pelo nome da tag?

No exemplo de código abaixo, o processo de renderização aguarda um nome de tag de elemento específico.

: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

Como faço para usar seletores de consulta para aguardar elementos?

O processo de renderização aguarda o elemento selecionado pelo seletor de consulta no exemplo de código abaixo. O método HtmlQuerySelector aguarda um img tag com um id of 'myid' e um class of '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

Como faço para aguardar a conclusão da atividade de rede?

Ao renderizar páginas da web que fazem solicitações de rede para recursos, dados ou chamadas de API, certifique-se de que toda a atividade de rede seja concluída antes de gerar o PDF. O IronPDF oferece diversos métodos para lidar com diferentes cenários de rede.

Quando devo esperar que não haja mais atividade de rede?

Esse tipo de espera ociosa na rede ocorre até que não haja mais atividade na rede, o que geralmente indica que o conteúdo foi totalmente carregado. Isso é adequado para aplicativos de página única (SPAs) ou páginas da web simples, sem solicitações de rede de longa duração ou atividade de rede contínua.

O processo de renderização começa assim que não houver atividade de rede em andamento por pelo menos 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

Quando devo permitir duas atividades de rede?

O método NetworkIdle2 é adequado para aplicações web ou páginas web com requisições de rede de longa duração ou pings de pulsação. Normalmente, são envolvidos de 1 a 2 pedidos. Mesmo que essas solicitações sejam contínuas, elas não invalidarão o acionamento do evento de ociosidade da rede, já que ter no máximo duas é aceitável.

Antes de iniciar o processo de renderização, devem existir no máximo duas atividades de rede restantes por pelo menos 500 ms . Esta opção oferece configuração rápida para lidar com um número fixo de atividades de rede.

: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

Como faço para personalizar os limites de atividade da rede?

Quando várias solicitações de rede estão envolvidas, você pode personalizar tanto a duração da inatividade da rede quanto o número de solicitações de rede permitidas que não invalidam o evento de inatividade da rede. Essa opção é adequada para aplicações web ou páginas web com requisitos específicos que não se encaixam nos dois métodos anteriores. Essa personalização atende a uma ampla gama de casos de uso em diferentes circunstâncias.

: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

Esse nível de personalização é valioso ao trabalhar com aplicações web complexas que mantêm conexões persistentes ou possuem padrões previsíveis de atividade de rede em segundo plano.

Como faço para definir um tempo máximo de espera?

Os métodos JavaScript, NetworkIdle, NetworkIdle0 e NetworkIdle2 permitem definir um tempo máximo de espera para garantir que a espera não seja indefinida. O parâmetro maxWaitTime desses métodos serve a esse propósito. Isso impede que seu aplicativo fique travado indefinidamente caso as condições esperadas nunca ocorram.

Todos os valores de tempo especificados estão em milissegundos.

Ao implementar essas estratégias de espera, busque um equilíbrio entre garantir o carregamento completo do conteúdo e manter um desempenho razoável. Para aplicações que exigem controle preciso de tempo, explore técnicas de geração assíncrona de PDFs .

Pronto para ver o que mais você pode fazer? Confira a página de tutoriais aqui: Recursos adicionais ou explore a criação de PDFs com o IronPDF para técnicas mais avançadas.

Perguntas frequentes

O que é a classe WaitFor e por que eu deveria usá-la?

A classe WaitFor do IronPDF permite que os desenvolvedores atrasem a renderização do PDF até que todos os recursos, fontes e JavaScript tenham terminado de carregar. Isso evita renderizações incompletas e garante que páginas da web complexas sejam totalmente carregadas antes da conversão para PDF, resultando em documentos PDF mais precisos e completos.

Quais são as diferentes opções de WaitFor disponíveis?

A classe WaitFor do IronPDF oferece diversas opções: PageLoad (renderização imediata por padrão), RenderDelay (atraso personalizado em milissegundos), Fonts (aguarda o carregamento de todas as fontes), JavaScript (aciona a renderização por meio de uma função JavaScript), HTML elements (aguarda elementos específicos por ID, nome, tag ou seletor de consulta) e NetworkIdle (aguarda a cessação da atividade de rede).

Como adiciono um atraso personalizado antes da renderização do PDF?

Você pode adicionar um atraso personalizado usando o método RenderDelay no IronPDF. Basta especificar o atraso em milissegundos: `new ChromePdfRenderer { RenderingOptions = { WaitFor = WaitFor.RenderDelay(3000) } }`. Isso é particularmente útil para conteúdo com uso intensivo de JavaScript que precisa de mais tempo para ser executado.

Posso esperar que elementos HTML específicos sejam carregados antes de renderizar?

Sim, o IronPDF permite que você aguarde elementos HTML específicos usando IDs de elementos, nomes, nomes de tags ou seletores de consulta. Isso garante que o conteúdo essencial esteja presente na página antes do início da conversão para PDF, evitando a ausência de elementos no seu documento PDF final.

O que é NetworkIdle e quando devo usá-lo?

A propriedade `NetworkIdle` do IronPDF aguarda a cessação da atividade de rede antes de renderizar o PDF. Você pode configurá-la para aguardar 0, 2 ou um número personalizado de conexões de rede. Isso é ideal para páginas que carregam conteúdo dinamicamente por meio de chamadas AJAX ou outras solicitações de rede assíncronas.

Como posso acionar a renderização de PDF a partir do JavaScript?

A opção WaitFor JavaScript do IronPDF permite que você acione o processo de renderização a partir de uma função JavaScript. Isso lhe dá controle total sobre quando a geração do PDF ocorre, tornando-o perfeito para aplicativos de página única ou sites complexos baseados em JavaScript, onde você precisa de um controle preciso do tempo.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais ...

Leia mais
Pronto para começar?
Nuget Downloads 18,318,263 | Versão: 2026.4 acaba de ser lançado
Still Scrolling Icon

Ainda está rolando a tela?

Quer provas rápidas? PM > Install-Package IronPdf
executar um exemplo Veja seu HTML se transformar em um PDF.