# Using the C# `WaitFor` Class to Delay PDF Rendering
La clase C# `WaitFor` en IronPDF ayuda a los desarrolladores a retrasar el renderizado de PDF hasta que todos los recursos, fuentes y JavaScript se hayan cargado, impidiendo rendizados incompletos mediante el uso de métodos como `RenderDelay`, `NetworkIdle` y disparadores de JavaScript.
## Inicio rápido: Uso de `WaitFor` para mejorar el renderizado de PDF
La característica `WaitFor` de IronPDF permite a los desarrolladores mejorar el renderizado de PDF gestionando el tiempo asincrónico. Al establecer opciones como `RenderDelay`, puedes asegurar que todos los recursos y scripts se carguen antes de la conversión, evitando documentos PDF incompletos. Esta guía muestra cómo implementar `WaitFor` en tus proyectos para un renderizado preciso y eficiente.
```cs
new IronPdf.ChromePdfRenderer { RenderingOptions = { WaitFor = IronPdf.WaitFor.RenderDelay(3000) } }
.RenderUrlAsPdf("https://example.com")
.SaveAs("output.pdf");
```
<div class="hsg-featured-snippet">
<h3>Flujo de trabajo mínimo (5 pasos)</h3>
<ol>
<li><a class="js-modal-open" data-modal-id="trial-license-after-download" href="https://www.nuget.org/packages/IronPdf/">Descargue la biblioteca IronPDF de C# para retrasar el procesamiento de PDF</a></li>
<li>Genera un documento PDF a partir de una cadena HTML, archivo, o URL web</li>
<li>Utilice el método JavaScript de <code>WaitFor</code> para activar la renderización desde una función JavaScript</li>
<li>Retrasa la renderización basada en el número de actividades de red</li>
<li>Esperar por elementos HTML específicos así como por la carga de todas las fuentes</li>
</ol>
</div>
## ¿Qué es la clase `WaitFor` y sus opciones?
Para [renderizar PDFs con un rendimiento óptimo](/troubleshooting/ironpdf-performance-assistance/), la clase `WaitFor` mejora el proceso de renderizado de PDF. El objeto `WaitFor` de `RenderOptions` ofrece varias opciones:
- `PageLoad`: Renderizado por defecto sin esperar.
- `RenderDelay`: Establece un tiempo de espera arbitrario.
- `Fonts`: Espera hasta que todas las fuentes se hayan cargado.
- `JavaScript`: Desencadena el renderizado con una función de JavaScript.
- `HTML elements`: Espera elementos HTML específicos, como IDs de elementos, nombres, nombres de etiquetas y selectores de consulta para dirigir a los elementos.
- `NetworkIdle`: Espera la inactividad de la red (0, 2 o una cantidad personalizada).
Estas funciones funcionan al convertir [cadenas HTML a PDF con IronPDF](/how-to/html-string-to-pdf/), [archivos HTML a PDF con IronPDF](/how-to/html-file-to-pdf/) y [URL web a PDF con IronPDF](/how-to/url-to-pdf/).
## ¿Cómo renderizar archivos PDF inmediatamente sin esperar?
Por defecto, la renderización se produce inmediatamente después de que la página termina de cargarse. El método `` no necesita ser llamado para un renderizado normal. Este enfoque funciona bien para contenidos HTML sencillos sin JavaScript complejo ni recursos externos.
```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>");
```
## ¿Cómo puedo añadir un retardo personalizado antes de renderizar un PDF?
Cuando se requiere un retardo específico antes de renderizar el PDF, se puede establecer un número arbitrario de milisegundos como retardo. Esto proporciona flexibilidad para los requisitos de tiempo específicos, especialmente cuando se trata de [contenido con mucho JavaScript](https://ironpdf.com/how-to/javascript-to-pdf/).
Esta opción funciona igual que la vieja implementación usando la propiedad ``. Sin embargo, la antigua propiedad ha quedado obsoleta. Use la nueva API: ``.
```cs
using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();
// Render after 3000ms
renderer.RenderingOptions.WaitFor.RenderDelay(3000);
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
```
El mecanismo de retardo es útil cuando su HTML contiene animaciones, contenido de carga perezosa o requiere tiempo para la generación de contenido dinámico. Para escenarios de renderizado complejos, explore [opciones de renderizado personalizado](https://ironpdf.com/how-to/rendering-options/).
## ¿Cómo puedo esperar a que se carguen todas las fuentes antes de renderizar?
El método `` en la clase `` pausa el renderizado de PDF hasta que todas las fuentes externas se hayan cargado, como las fuentes de Google. Esto garantiza que el PDF final incluya todas las fuentes necesarias, preservando la tipografía y el aspecto visual previstos para el documento. Esta función mantiene [una calidad de salida PDF profesional](https://ironpdf.com/how-to/pixel-perfect-html-to-pdf/).
```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);
```
Para obtener más información sobre la gestión de fuentes en PDF, incluidas las opciones de incrustación y subconjunto, consulte la guía sobre [gestión de fuentes en PDF](https://ironpdf.com/how-to/manage-fonts/).
## ¿Cómo activar la renderización de PDF mediante JavaScript personalizado?
Para un mayor control sobre el proceso de renderizado, puede especificar una función JavaScript personalizada que se ejecute antes de renderizar el documento PDF. Esto le permite realizar las tareas o comprobaciones necesarias antes de iniciar el proceso de renderizado, dándole el control sobre cuándo activar el renderizado.
En JavaScript, la función `` dispara la tarea de renderizado. Una vez que se invoca ``, comienza el proceso de renderizado. Usted controla cuándo invocar la función.
```js
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);
```
Este enfoque es eficaz cuando se combina con solicitudes AJAX o cuando se garantiza que el contenido generado dinámicamente se carga por completo antes de la renderización. Para situaciones avanzadas de JavaScript, consulte la guía sobre [ejecución de JavaScript personalizado en PDF](https://ironpdf.com/examples/execute-custom-javascript/).
## ¿Cómo puedo esperar elementos HTML específicos antes de renderizar?
Con esta opción, el proceso de renderizado espera elementos HTML específicos, como ID de elementos, nombres, nombres de etiquetas y selectores de consulta a elementos de destino. Esta función resulta útil cuando se trabaja con aplicaciones de página única (SPA) o contenidos que se cargan de forma asíncrona.
### ¿Cómo buscar un elemento por ID?
La renderización espera un ID de elemento específico en el ejemplo de código siguiente.
```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);
```
### ¿Cómo espero un atributo de elemento por nombre?
El proceso de renderización espera un nombre de elemento específico en el siguiente ejemplo de código.
```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);
```
### ¿Cómo buscar elementos por nombre de etiqueta?
El proceso de renderización espera un nombre de etiqueta de elemento específico en el ejemplo de código siguiente.
```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);
```
### ¿Cómo utilizar selectores de consulta para esperar elementos?
El proceso de renderización espera el elemento seleccionado por el selector de consulta en el siguiente ejemplo de código. El método `` espera un ``tag img`` con un ``id de 'myid'`` y una ``class de 'blablastyle'``.
```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);
```
## ¿Cómo puedo esperar a que se complete la actividad de red?
Al renderizar páginas web que realicen solicitudes de red para recursos, datos o llamadas a API, asegúrese de que toda la actividad de red finaliza antes de generar el PDF. IronPDF ofrece varios métodos para manejar diferentes escenarios de red.
### ¿Cuándo debo esperar a que no haya actividad en la red?
Este tipo de inactividad de red espera hasta que no hay actividad en la red, lo que suele indicar que el contenido se ha cargado por completo. Esto es adecuado para aplicaciones de una sola página (SPA) o páginas web sencillas sin solicitudes de red de larga duración o actividad de red continua.
El proceso de renderización comienza una vez que no ha habido actividad en la red durante al menos 500 ms.
```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>");
```
### ¿Cuándo debo permitir dos actividades en red?
El método `` se adapta a aplicaciones web o páginas web con peticiones de red de sondeo prolongado o pulsos de latido. Normalmente se trata de 1-2 solicitudes. Aunque estas solicitudes sean continuas, no invalidarán la activación del evento de inactividad de la red, ya que tener como máximo dos es aceptable.
Antes de iniciar el proceso de renderización, debería haber **un máximo de dos** actividades de red restantes durante **al menos 500ms**. Esta opción proporciona una configuración rápida para gestionar un número fijo de actividades de red.
```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>");
```
### ¿Cómo personalizo los umbrales de actividad de red?
Cuando hay varias solicitudes de red implicadas, puede personalizar tanto la **duración de inactividad de red** como el **número de solicitudes de red permitidas** que no invalidan el evento de inactividad de red. Esta opción es adecuada para aplicaciones o páginas web con requisitos específicos que no se ajustan a los dos métodos anteriores. Esta personalización aborda una amplia gama de casos de uso en diferentes circunstancias.
```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>");
```
Este nivel de personalización es valioso cuando se trabaja con aplicaciones web complejas que mantienen conexiones persistentes o tienen patrones predecibles de actividad de red en segundo plano.
## ¿Cómo puedo establecer un tiempo máximo de espera?
Los métodos ``, ``, `` y `` permiten establecer un tiempo máximo de espera para asegurar que la espera no sea indefinida. El parámetro `` de estos métodos sirve para este propósito. Esto evita que su aplicación se cuelgue indefinidamente si nunca se dan las condiciones esperadas.
Todos los valores de tiempo especificados están en milisegundos.
Al aplicar estas estrategias de espera, hay que equilibrar la carga completa del contenido con el mantenimiento de un rendimiento razonable. Para las aplicaciones que requieren un control preciso de los tiempos, explore [técnicas de generación de PDF asíncronos](https://ironpdf.com/how-to/async/).
¿Listo para ver qué más puedes hacer? Consulta la página del tutorial aquí: [Características adicionales](https://ironpdf.com/tutorials/pdf-assets-and-performance-csharp/) o explore [crear PDF con IronPDF](https://ironpdf.com/how-to/create-new-pdfs/) para conocer técnicas más avanzadas.
La clase C# WaitFor en IronPDF ayuda a los desarrolladores a retrasar el renderizado de PDF hasta que todos los recursos, fuentes y JavaScript se hayan cargado, impidiendo rendizados incompletos mediante el uso de métodos como RenderDelay, NetworkIdle y disparadores de JavaScript.
Inicio rápido: Uso de WaitFor para mejorar el renderizado de PDF
La característica WaitFor de IronPDF permite a los desarrolladores mejorar el renderizado de PDF gestionando el tiempo asincrónico. Al establecer opciones como RenderDelay, puedes asegurar que todos los recursos y scripts se carguen antes de la conversión, evitando documentos PDF incompletos. Esta guía muestra cómo implementar WaitFor en tus proyectos para un renderizado preciso y eficiente.
ImportsIronPdfDim renderer As New ChromePdfRendererWith { .RenderingOptions = New ChromePdfRenderOptionsWith { .WaitFor = WaitFor.RenderDelay(3000) }}renderer.RenderUrlAsPdf("https://example.com").SaveAs("output.pdf")
Imports IronPdf
Dim renderer As New ChromePdfRenderer With {
.RenderingOptions = New ChromePdfRenderOptions With {
.WaitFor = WaitFor.RenderDelay(3000)
}
}
renderer.RenderUrlAsPdf("https://example.com").SaveAs("output.pdf")
Genera un documento PDF a partir de una cadena HTML, archivo, o URL web
Utilice el método JavaScript de WaitFor para activar la renderización desde una función JavaScript
Retrasa la renderización basada en el número de actividades de red
Esperar por elementos HTML específicos así como por la carga de todas las fuentes
¿Qué es la clase WaitFor y sus opciones?
Para renderizar PDFs con un rendimiento óptimo, la clase WaitFor mejora el proceso de renderizado de PDF. El objeto WaitFor de RenderOptions ofrece varias opciones:
PageLoad: Renderizado por defecto sin esperar.
RenderDelay: Establece un tiempo de espera arbitrario.
Fonts: Espera hasta que todas las fuentes se hayan cargado.
JavaScript: Desencadena el renderizado con una función de JavaScript.
HTML elements: Espera elementos HTML específicos, como IDs de elementos, nombres, nombres de etiquetas y selectores de consulta para dirigir a los elementos.
NetworkIdle: Espera la inactividad de la red (0, 2 o una cantidad personalizada).
¿Cómo renderizar archivos PDF inmediatamente sin esperar?
Por defecto, la renderización se produce inmediatamente después de que la página termina de cargarse. El método `` no necesita ser llamado para un renderizado normal. Este enfoque funciona bien para contenidos HTML sencillos sin JavaScript complejo ni recursos externos.
using IronPdf;ChromePdfRenderer renderer = new ChromePdfRenderer();// Render as soon as the page is loadedrenderer.RenderingOptions.WaitFor.PageLoad();PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
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>");
ImportsIronPdfDim renderer As New ChromePdfRenderer()' Render as soon as the page is loadedrenderer.RenderingOptions.WaitFor.PageLoad()Dim pdf AsPdfDocument = 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>")
¿Cómo puedo añadir un retardo personalizado antes de renderizar un PDF?
Cuando se requiere un retardo específico antes de renderizar el PDF, se puede establecer un número arbitrario de milisegundos como retardo. Esto proporciona flexibilidad para los requisitos de tiempo específicos, especialmente cuando se trata de contenido con mucho JavaScript.
Esta opción funciona igual que la vieja implementación usando la propiedad . Sin embargo, la antigua propiedad ha quedado obsoleta. Use la nueva API: .
using IronPdf;ChromePdfRenderer renderer = new ChromePdfRenderer();// Render after 3000msrenderer.RenderingOptions.WaitFor.RenderDelay(3000);PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();
// Render after 3000ms
renderer.RenderingOptions.WaitFor.RenderDelay(3000);
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
ImportsIronPdfPrivate renderer As New ChromePdfRenderer()' Render after 3000msrenderer.RenderingOptions.WaitFor.RenderDelay(3000)Dim pdf AsPdfDocument = 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>")
El mecanismo de retardo es útil cuando su HTML contiene animaciones, contenido de carga perezosa o requiere tiempo para la generación de contenido dinámico. Para escenarios de renderizado complejos, explore opciones de renderizado personalizado.
¿Cómo puedo esperar a que se carguen todas las fuentes antes de renderizar?
El método en la clase pausa el renderizado de PDF hasta que todas las fuentes externas se hayan cargado, como las fuentes de Google. Esto garantiza que el PDF final incluya todas las fuentes necesarias, preservando la tipografía y el aspecto visual previstos para el documento. Esta función mantiene una calidad de salida PDF profesional.
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);
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);
ImportsIronPdfDim htmlContent AsString = "<!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 AsPdfDocument = 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)
Para obtener más información sobre la gestión de fuentes en PDF, incluidas las opciones de incrustación y subconjunto, consulte la guía sobre gestión de fuentes en PDF.
¿Cómo activar la renderización de PDF mediante JavaScript personalizado?
Para un mayor control sobre el proceso de renderizado, puede especificar una función JavaScript personalizada que se ejecute antes de renderizar el documento PDF. Esto le permite realizar las tareas o comprobaciones necesarias antes de iniciar el proceso de renderizado, dándole el control sobre cuándo activar el renderizado.
En JavaScript, la función dispara la tarea de renderizado. Una vez que se invoca, comienza el proceso de renderizado. Usted controla cuándo invocar la función.
usingIronPdf;string html = @"<!DOCTYPE html><html><body><h1>Testing</h1><script type='text/javascript'>// Set delaysetTimeout(function() { window.ironpdf.notifyRender();}, 1000);</script></body></html>";ChromePdfRenderOptions renderingOptions = new ChromePdfRenderOptions();// Set rendering to wait for the notifyRender functionrenderingOptions.WaitFor.JavaScript(5000);PdfDocument pdf = ChromePdfRenderer.StaticRenderHtmlAsPdf(html, renderingOptions);
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
Este enfoque es eficaz cuando se combina con solicitudes AJAX o cuando se garantiza que el contenido generado dinámicamente se carga por completo antes de la renderización. Para situaciones avanzadas de JavaScript, consulte la guía sobre ejecución de JavaScript personalizado en PDF.
¿Cómo puedo esperar elementos HTML específicos antes de renderizar?
Con esta opción, el proceso de renderizado espera elementos HTML específicos, como ID de elementos, nombres, nombres de etiquetas y selectores de consulta a elementos de destino. Esta función resulta útil cuando se trabaja con aplicaciones de página única (SPA) o contenidos que se cargan de forma asíncrona.
¿Cómo buscar un elemento por ID?
La renderización espera un ID de elemento específico en el ejemplo de código siguiente.
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);
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);
ImportsIronPdfDim htmlContent AsString = "<!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 AsPdfDocument = 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)
¿Cómo espero un atributo de elemento por nombre?
El proceso de renderización espera un nombre de elemento específico en el siguiente ejemplo de código.
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);
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);
ImportsIronPdfDim htmlContent AsString = "<!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 AsPdfDocument = 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)
¿Cómo buscar elementos por nombre de etiqueta?
El proceso de renderización espera un nombre de etiqueta de elemento específico en el ejemplo de código siguiente.
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);
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);
ImportsIronPdfDim htmlContent AsString = "<!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 AsPdfDocument = 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)
¿Cómo utilizar selectores de consulta para esperar elementos?
El proceso de renderización espera el elemento seleccionado por el selector de consulta en el siguiente ejemplo de código. El método espera untag imgcon unid de 'myid'y unaclass de 'blablastyle'``.
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);
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);
ImportsIronPdfDim htmlContent AsString = "<!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 AsPdfDocument = 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)
Mi biblioteca favorita de este tipo es IronPDF. Permite una manipulación rápida y eficiente de archivos PDF. También tiene muchas funciones valiosas, como exportar al formato PDF/A y firmar documentos PDF digitalmente.
IronOCR significa que podemos ahorrar $40,000 anualmente en el procesamiento manual, mientras mejoramos la productividad y liberamos recursos para tareas de alto impacto. Lo recomendaría encarecidamente.
El Iron Suite juega un papel crucial en nuestras operaciones. Estas son herramientas que aumentan la eficiencia en toda la empresa, incluyendo la creación de planos y la mejora en la gestión de inventario.
¿Cómo puedo esperar a que se complete la actividad de red?
Al renderizar páginas web que realicen solicitudes de red para recursos, datos o llamadas a API, asegúrese de que toda la actividad de red finaliza antes de generar el PDF. IronPDF ofrece varios métodos para manejar diferentes escenarios de red.
¿Cuándo debo esperar a que no haya actividad en la red?
Este tipo de inactividad de red espera hasta que no hay actividad en la red, lo que suele indicar que el contenido se ha cargado por completo. Esto es adecuado para aplicaciones de una sola página (SPA) o páginas web sencillas sin solicitudes de red de larga duración o actividad de red continua.
El proceso de renderización comienza una vez que no ha habido actividad en la red durante al menos 500 ms.
using IronPdf;ChromePdfRenderer renderer = new ChromePdfRenderer();// Render unless there has been no network activity for at least 500msrenderer.RenderingOptions.WaitFor.NetworkIdle0();PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
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>");
ImportsIronPdfDim renderer As New ChromePdfRenderer()' Render unless there has been no network activity for at least 500msrenderer.RenderingOptions.WaitFor.NetworkIdle0()Dim pdf AsPdfDocument = 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>")
¿Cuándo debo permitir dos actividades en red?
El método `` se adapta a aplicaciones web o páginas web con peticiones de red de sondeo prolongado o pulsos de latido. Normalmente se trata de 1-2 solicitudes. Aunque estas solicitudes sean continuas, no invalidarán la activación del evento de inactividad de la red, ya que tener como máximo dos es aceptable.
Antes de iniciar el proceso de renderización, debería haber un máximo de dos actividades de red restantes durante al menos 500ms. Esta opción proporciona una configuración rápida para gestionar un número fijo de actividades de red.
using IronPdf;ChromePdfRenderer renderer = new ChromePdfRenderer();// Render unless there are at most 2 network activities for at least 500msrenderer.RenderingOptions.WaitFor.NetworkIdle2();PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
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>");
ImportsIronPdfDim renderer As New ChromePdfRenderer()' Render unless there are at most 2 network activities for at least 500msrenderer.RenderingOptions.WaitFor.NetworkIdle2()Dim pdf AsPdfDocument = 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>")
¿Cómo personalizo los umbrales de actividad de red?
Cuando hay varias solicitudes de red implicadas, puede personalizar tanto la duración de inactividad de red como el número de solicitudes de red permitidas que no invalidan el evento de inactividad de red. Esta opción es adecuada para aplicaciones o páginas web con requisitos específicos que no se ajustan a los dos métodos anteriores. Esta personalización aborda una amplia gama de casos de uso en diferentes circunstancias.
using IronPdf;ChromePdfRenderer renderer = new ChromePdfRenderer();// Render unless there are at most 5 network activities for at least 1000msrenderer.RenderingOptions.WaitFor.NetworkIdle(1000, 5);PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
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>");
ImportsIronPdfPrivate renderer As New ChromePdfRenderer()' Render unless there are at most 5 network activities for at least 1000msrenderer.RenderingOptions.WaitFor.NetworkIdle(1000, 5)Dim pdf AsPdfDocument = 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>")
Este nivel de personalización es valioso cuando se trabaja con aplicaciones web complejas que mantienen conexiones persistentes o tienen patrones predecibles de actividad de red en segundo plano.
¿Cómo puedo establecer un tiempo máximo de espera?
Los métodos , , y permiten establecer un tiempo máximo de espera para asegurar que la espera no sea indefinida. El parámetro `` de estos métodos sirve para este propósito. Esto evita que su aplicación se cuelgue indefinidamente si nunca se dan las condiciones esperadas.
Todos los valores de tiempo especificados están en milisegundos.
Al aplicar estas estrategias de espera, hay que equilibrar la carga completa del contenido con el mantenimiento de un rendimiento razonable. Para las aplicaciones que requieren un control preciso de los tiempos, explore técnicas de generación de PDF asíncronos.
¿Qué es la clase WaitFor y por qué debería utilizarla?
La clase WaitFor de IronPDF permite a los desarrolladores retrasar la renderización del PDF hasta que todos los recursos, fuentes y JavaScript hayan terminado de cargarse. De este modo, se evitan las renderizaciones incompletas y se garantiza que las páginas web complejas se carguen por completo antes de convertirlas a PDF, lo que se traduce en documentos PDF más precisos y completos.
¿Cuáles son las diferentes opciones de WaitFor disponibles?
La clase WaitFor de IronPDF ofrece varias opciones: PageLoad (renderización inmediata por defecto), RenderDelay (retardo personalizado en milisegundos), Fonts (espera a que se carguen todas las fuentes), JavaScript (activa la renderización mediante una función JavaScript), HTML elements (espera a elementos específicos por ID, nombre, etiqueta o selector de consulta) y NetworkIdle (espera a que cese la actividad de la red).
¿Cómo añado un retardo personalizado antes de la renderización del PDF?
Puede añadir un retraso personalizado utilizando el método RenderDelay en IronPDF. Simplemente especifique el retardo en milisegundos: new ChromePdfRenderer { RenderingOptions = { WaitFor = WaitFor.RenderDelay(3000) } }`. Esto es particularmente útil para el contenido de JavaScript-pesado que necesita tiempo extra para ejecutarse.
¿Puedo esperar a que se carguen determinados elementos HTML antes de renderizarlos?
Sí, IronPDF le permite esperar elementos HTML específicos utilizando ID de elementos, nombres, nombres de etiquetas o selectores de consulta. Esto garantiza que el contenido crítico esté presente en la página antes de que comience la conversión a PDF, evitando que falten elementos en su documento PDF final.
¿Qué es NetworkIdle y cuándo debería usarlo?
NetworkIdle en IronPDF espera a que cese la actividad de la red antes de renderizar el PDF. Puede configurarlo para que espere 0, 2 o un número personalizado de conexiones de red. Esto es ideal para páginas que cargan contenido dinámicamente a través de llamadas AJAX u otras solicitudes de red asíncronas.
¿Cómo puedo activar la renderización de PDF desde JavaScript?
La opción WaitFor JavaScript de IronPDF le permite activar el proceso de renderizado desde una función JavaScript. Esto le da un control completo sobre cuándo se produce la generación de PDF, por lo que es perfecto para aplicaciones de una sola página o sitios web complejos basados en JavaScript en los que necesita un control preciso del tiempo.
How can I set a maximum waiting time for rendering a PDF in IronPDF?
You can set a maximum waiting time when using methods like `JavaScript`, `NetworkIdle`, `NetworkIdle0`, and `NetworkIdle2` in IronPDF. This prevents indefinite waiting by specifying a maximum duration to wait for conditions to be met.
Is it possible to customize network activity thresholds in IronPDF?
Yes, IronPDF allows you to customize the number of allowable network activities and the duration before considering the network idle. This flexibility is particularly useful for handling complex web applications with persistent network connections.
What happens when using the default `PageLoad` method in IronPDF?
The `PageLoad` method in IronPDF initiates rendering immediately after the HTML page finishes loading, without any delays. This approach is best for simple HTML content without additional asynchronous resources.
How does IronPDF handle PDF rendering for JavaScript-heavy content?
For JavaScript-heavy content, IronPDF allows setting explicit delays and waiting for specific JavaScript events to ensure all scripts and dynamic elements are fully processed and available before rendering the PDF.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
