# Using the C# `WaitFor` Class to Delay PDF Rendering
Klasa `WaitFor` C# w IronPDF pomaga programistom opóźnić renderowanie PDF do czasu załadowania wszystkich zasobów, czcionek i JavaScript, zapobiegając niekompletnym renderom poprzez użycie metod takich jak `RenderDelay`, `NetworkIdle`, i wyzwalacze JavaScript.
*as-heading:2(Szybki start: Użycie `WaitFor` do poprawy renderowania PDF)*
Funkcja `WaitFor` IronPDF pozwala programistom poprawić renderowanie PDF poprzez zarządzanie asynchronicznymi harmonogramami. Ustawiając opcje takie jak `RenderDelay`, możesz upewnić się, że wszystkie zasoby i skrypty zostaną załadowane przed konwersją, zapobiegając niekompletnym dokumentom PDF. Ten przewodnik pokazuje, jak zaimplementować `WaitFor` w twoich projektach dla precyzyjnego i wydajnego renderowania.
```cs
new IronPdf.ChromePdfRenderer { RenderingOptions = { WaitFor = IronPdf.WaitFor.RenderDelay(3000) } }
.RenderUrlAsPdf("https://example.com")
.SaveAs("output.pdf");
```
<div class="hsg-featured-snippet">
<h3>Minimalny proces (5 kroków)</h3>
<ol>
<li><a class="js-modal-open" data-modal-id="trial-license-after-download" href="https://www.nuget.org/packages/IronPdf/">Pobierz bibliotekę C# IronPDF w celu opóźnienia renderowania PDF</a></li>
<li>Generuj dokument PDF z ciągu HTML, pliku lub adresu URL sieci web</li>
<li>Użyj metody JavaScript <code>WaitFor</code>, aby wyzwolić renderowanie z funkcji JavaScript</li>
<li>Opóźnij renderowanie na podstawie liczby aktywności sieciowych</li>
<li>Czekaj na załadowanie określonych elementów HTML i wszystkich czcionek</li>
</ol>
</div>
## Co to jest klasa `WaitFor` i jej opcje?
Dla [renderowania PDFów z optymalną wydajnością](/troubleshooting/ironpdf-performance-assistance/), klasa `WaitFor` poprawia proces renderowania PDF. Obiekt `WaitFor` z `RenderOptions` oferuje kilka opcji:
- `PageLoad`: Domyślne renderowanie bez oczekiwania.
- `RenderDelay`: Ustawienie arbitralnego czasu oczekiwania.
- `Fonts`: Czeka na załadowanie wszystkich czcionek.
- `JavaScript`: Wyzwala renderowanie za pomocą funkcji JavaScript.
- `HTML elements`: Czeka na określone elementy HTML, takie jak identyfikatory elementów, nazw, nazewnictwo tagów i selektory zapytań, aby skierować elementy.
- `NetworkIdle`: Czeka, aż sieć będzie bezczynna (0, 2, lub określona ilość).
Te funkcje działają podczas konwertowania [ciągów HTML na PDF za pomocą IronPDF](/how-to/html-string-to-pdf/), [plików HTML na PDF za pomocą IronPDF](/how-to/html-file-to-pdf/) i [adresów URL sieci web na PDF za pomocą IronPDF](/how-to/url-to-pdf/).
## Jak renderuję PDFy natychmiast bez czekania?
Domyślnie renderowanie odbywa się natychmiast po załadowaniu strony. Metoda `PageLoad` nie musi być wywoływana do normalnego renderowania. To podejście działa dobrze dla prostych treści HTML bez złożonego JavaScript lub zewnętrznych zasobów.
```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>");
```
## Jak mogę dodać niestandardowe opóźnienie przed renderowaniem PDF?
Kiedy wymagane jest określone opóźnienie przed renderowaniem PDF, można ustawić arbitralną liczbę milisekund jako opóźnienie. To zapewnia elastyczność w zakresie specyficznych wymagań czasowych, szczególnie podczas pracy z [treściami bogatymi w JavaScript](https://ironpdf.com/how-to/javascript-to-pdf/).
Ta opcja działa tak samo jak stara implementacja, używając właściwości `RenderingOptions.RenderDelay`. Jednakże, stara właściwość została przestarzała. Użyj nowego API: `RenderingOptions.WaitFor.RenderDelay`.
```cs
using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();
// Render after 3000ms
renderer.RenderingOptions.WaitFor.RenderDelay(3000);
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>testing</h1>");
```
Mechanizm opóźnienia jest użyteczny, kiedy HTML zawiera animacje, zawartość wczytywaną sekwencyjnie lub wymaga czasu do generowania dynamicznej zawartości. Dla złożonych scenariuszy renderowania, zapoznaj się z [opcje renderowania niestandardowe](https://ironpdf.com/how-to/rendering-options/).
## Jak czekam na załadowanie wszystkich czcionek przed renderowaniem?
Metoda `AllFontsLoaded` w klasie `WaitFor` wstrzymuje renderowanie PDF do czasu, aż wszystkie czcionki zostaną załadowane ze zewnętrznych źródeł, takich jak Google Fonts. To zapewnia, że finalny PDF zawiera wszystkie wymagane czcionki, zachowując zamierzony wygląd typografii i wizualny. Ta funkcja utrzymuje [profesjonalną jakość wyjścia PDF](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);
```
Aby uzyskać więcej informacji na temat zarządzania czcionkami w PDFach, w tym opcji osadzania i podzbiorów, sprawdź przewodnik na temat [zarządzania czcionkami w PDFach](https://ironpdf.com/how-to/manage-fonts/).
## Jak wyzwalam renderowanie PDF za pomocą niestandardowego JavaScript?
Dla większej kontroli nad procesem renderowania, można wskazać niestandardową funkcję JavaScript, która jest wykonywana przed renderowaniem dokumentu PDF. To pozwala na wykonanie niezbędnych zadań lub kontroli przed rozpoczęciem procesu renderowania, dając kontrolę nad momentem wyzwolenia renderowania.
W JavaScript, funkcja `window.ironpdf.notifyRender()` wyzwala zadanie renderowania. Gdy tylko zostanie wywołane `notifyRender()`, proces renderowania rozpocznie się. Kontrolujesz moment wywołania funkcji.
```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);
```
To podejście jest skuteczne, gdy jest stosowane z żądaniami AJAX lub kiedy należy zapewnić pełne załadowanie dynamicznie generowanej zawartości przed renderowaniem. Dla zaawansowanych scenariuszy JavaScript, zobacz przewodnik na temat [wykonywania niestandardowego JavaScript w PDFach](https://ironpdf.com/examples/execute-custom-javascript/).
## Jak mogę czekać na określone elementy HTML przed renderowaniem?
Dzięki tej opcji proces renderowania czeka na określone elementy HTML, takie jak identyfikatory elementów, nazwy, nazwy tagów i selektory zapytań w celu wskazania elementów. Ta funkcja jest pomocna przy pracy z Aplikacjami Jednostronicowymi (SPA) lub zawartością ładowaną asynchronicznie.
### Jak czekam na element na podstawie identyfikatora?
Renderowanie czeka na określony identyfikator elementu w poniższym przykładzie kodu.
```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);
```
### Jak czekam na element na podstawie atrybutu nazwy?
Proces renderowania czeka na określoną nazwę elementu w poniższym przykładzie kodu.
```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);
```
### Jak czekam na elementy na podstawie nazwy tagu?
Proces renderowania czeka na określoną nazwę tagu elementu w poniższym przykładzie kodu.
```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);
```
### Jak używamy selektorów zapytań do czekania na elementy?
Proces renderowania czeka na element wybrany za pomocą selektóra zapytania w poniższym przykładzie kodu. Metoda `HtmlQuerySelector` czeka na `img tag` z `id of 'myid'` i `class of '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);
```
## Jak czekam na zakończenie aktywności sieciowej?
Podczas renderowania stron internetowych, które wykonują żądania sieciowe w celu zasobów, danych lub wywołań API, upewnij się, że wszystkie aktywności sieciowe zostały zakończone przed wygenerowaniem PDF. IronPDF zapewnia kilka metod obsługi różnych scenariuszy sieciowych.
### Gdy należy czekać na zerową aktywność sieciową?
Ten typ bezczynności sieciowej czeka, aż nie będzie żadnej aktywności sieciowej, co zazwyczaj wskazuje na pełne załadowanie treści. To pasuje do Aplikacji Jednostronicowych (SPA) lub prostych stron internetowych bez długoprotujących żądań sieciowych lub bieżącej aktywności sieciowej.
Proces renderowania rozpoczyna się, gdy nie było **żadnej trwającej** aktywności sieciowej przez **co najmniej 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>");
```
### Kiedy należy dopuścić dwie aktywności sieciowe?
Metoda `NetworkIdle2` nadaje się do aplikacji webowych lub stron internetowych z długim zapytaniem o sieć lub pingami stanu. Zazwyczaj 1-2 żądania są zaangażowane. Nawet jeśli te żądania są w toku, nie unieważniają one wyzwalania zdarzenia bezczynności sieci, ponieważ dopuszczalne jest posiadanie maksymalnie dwóch.
Przed rozpoczęciem procesu renderowania powinno być **maksymalnie dwie** aktywności sieciowe pozostające przez **co najmniej 500 ms**. Ta opcja zapewnia szybkie skonfigurowanie do obsługi ustalonej liczby aktywności sieciowych.
```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>");
```
### Jak dostosować progi aktywności sieciowej?
Kiedy zaangażowanych jest wiele żądań sieciowych, można dostosować zarówno **czas bezczynności sieciowej**, jak i **liczbę dozwolonych żądań sieciowych**, które nie unieważniają zdarzenia bezczynności sieciowej. Ta opcja pasuje do aplikacji internetowych lub stron internetowych z określonymi wymaganiami, które nie pasują do poprzednich dwóch metod. To dostosowanie obejmuje szeroką gamę przypadków użycia w różnych okolicznościach.
```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>");
```
Ten poziom dostosowania jest cenny podczas pracy z złożonymi aplikacjami internetowymi, które utrzymują trwałe połączenia lub mają przewidywalne wzorce aktywności sieciowej w tle.
## Jak ustawić maksymalny czas oczekiwania?
Metody `JavaScript`, `NetworkIdle`, `NetworkIdle0`, i `NetworkIdle2` pozwalają ustawić maksymalny czas oczekiwania, aby upewnić się, że czekanie nie będzie nieskończone. Parametr `maxWaitTime` tych metod służy temu celowi. To zapobiega przerwaniu pracy aplikacji na nieokreślony czas, jeśli oczekiwane warunki nigdy nie wystąpią.
Wszystkie określone wartości czasu mają jednostkę milisekund.
Podczas wdrażania tych strategii oczekiwania zachowaj równowagę między zapewnieniem pełnego załadowania zawartości a utrzymaniem rozsądnej wydajności. Dla aplikacji wymagających precyzyjnej kontroli czasu, zapoznaj się z [asynchronicznymi technikami generowania PDF](https://ironpdf.com/how-to/async/).
Gotowy, aby sprawdzić, co jeszcze możesz zrobić? Sprawdź stronę z samouczkiem tutaj: [Dodatkowe funkcje](https://ironpdf.com/tutorials/pdf-assets-and-performance-csharp/) lub zapoznaj się z [tworzeniem PDF z IronPDF](https://ironpdf.com/how-to/create-new-pdfs/) dla bardziej zaawansowanych technik.
Klasa WaitFor C# w IronPDF pomaga programistom opóźnić renderowanie PDF do czasu załadowania wszystkich zasobów, czcionek i JavaScript, zapobiegając niekompletnym renderom poprzez użycie metod takich jak RenderDelay, NetworkIdle, i wyzwalacze JavaScript.
Szybki start: Użycie WaitFor do poprawy renderowania PDF
Funkcja WaitFor IronPDF pozwala programistom poprawić renderowanie PDF poprzez zarządzanie asynchronicznymi harmonogramami. Ustawiając opcje takie jak RenderDelay, możesz upewnić się, że wszystkie zasoby i skrypty zostaną załadowane przed konwersją, zapobiegając niekompletnym dokumentom PDF. Ten przewodnik pokazuje, jak zaimplementować WaitFor w twoich projektach dla precyzyjnego i wydajnego renderowania.
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")
RenderDelay: Ustawienie arbitralnego czasu oczekiwania.
Fonts: Czeka na załadowanie wszystkich czcionek.
JavaScript: Wyzwala renderowanie za pomocą funkcji JavaScript.
HTML elements: Czeka na określone elementy HTML, takie jak identyfikatory elementów, nazw, nazewnictwo tagów i selektory zapytań, aby skierować elementy.
NetworkIdle: Czeka, aż sieć będzie bezczynna (0, 2, lub określona ilość).
Domyślnie renderowanie odbywa się natychmiast po załadowaniu strony. Metoda PageLoad nie musi być wywoływana do normalnego renderowania. To podejście działa dobrze dla prostych treści HTML bez złożonego JavaScript lub zewnętrznych zasobów.
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>")
Jak mogę dodać niestandardowe opóźnienie przed renderowaniem PDF?
Kiedy wymagane jest określone opóźnienie przed renderowaniem PDF, można ustawić arbitralną liczbę milisekund jako opóźnienie. To zapewnia elastyczność w zakresie specyficznych wymagań czasowych, szczególnie podczas pracy z treściami bogatymi w JavaScript.
Ta opcja działa tak samo jak stara implementacja, używając właściwości RenderingOptions.RenderDelay. Jednakże, stara właściwość została przestarzała. Użyj nowego API: RenderingOptions.WaitFor.RenderDelay.
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>")
Mechanizm opóźnienia jest użyteczny, kiedy HTML zawiera animacje, zawartość wczytywaną sekwencyjnie lub wymaga czasu do generowania dynamicznej zawartości. Dla złożonych scenariuszy renderowania, zapoznaj się z opcje renderowania niestandardowe.
Jak czekam na załadowanie wszystkich czcionek przed renderowaniem?
Metoda AllFontsLoaded w klasie WaitFor wstrzymuje renderowanie PDF do czasu, aż wszystkie czcionki zostaną załadowane ze zewnętrznych źródeł, takich jak Google Fonts. To zapewnia, że finalny PDF zawiera wszystkie wymagane czcionki, zachowując zamierzony wygląd typografii i wizualny. Ta funkcja utrzymuje profesjonalną jakość wyjścia PDF.
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)
Aby uzyskać więcej informacji na temat zarządzania czcionkami w PDFach, w tym opcji osadzania i podzbiorów, sprawdź przewodnik na temat zarządzania czcionkami w PDFach.
Jak wyzwalam renderowanie PDF za pomocą niestandardowego JavaScript?
Dla większej kontroli nad procesem renderowania, można wskazać niestandardową funkcję JavaScript, która jest wykonywana przed renderowaniem dokumentu PDF. To pozwala na wykonanie niezbędnych zadań lub kontroli przed rozpoczęciem procesu renderowania, dając kontrolę nad momentem wyzwolenia renderowania.
W JavaScript, funkcja window.ironpdf.notifyRender() wyzwala zadanie renderowania. Gdy tylko zostanie wywołane notifyRender(), proces renderowania rozpocznie się. Kontrolujesz moment wywołania funkcji.
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
To podejście jest skuteczne, gdy jest stosowane z żądaniami AJAX lub kiedy należy zapewnić pełne załadowanie dynamicznie generowanej zawartości przed renderowaniem. Dla zaawansowanych scenariuszy JavaScript, zobacz przewodnik na temat wykonywania niestandardowego JavaScript w PDFach.
Jak mogę czekać na określone elementy HTML przed renderowaniem?
Dzięki tej opcji proces renderowania czeka na określone elementy HTML, takie jak identyfikatory elementów, nazwy, nazwy tagów i selektory zapytań w celu wskazania elementów. Ta funkcja jest pomocna przy pracy z Aplikacjami Jednostronicowymi (SPA) lub zawartością ładowaną asynchronicznie.
Jak czekam na element na podstawie identyfikatora?
Renderowanie czeka na określony identyfikator elementu w poniższym przykładzie kodu.
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)
Jak czekam na element na podstawie atrybutu nazwy?
Proces renderowania czeka na określoną nazwę elementu w poniższym przykładzie kodu.
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)
Jak czekam na elementy na podstawie nazwy tagu?
Proces renderowania czeka na określoną nazwę tagu elementu w poniższym przykładzie kodu.
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)
Jak używamy selektorów zapytań do czekania na elementy?
Proces renderowania czeka na element wybrany za pomocą selektóra zapytania w poniższym przykładzie kodu. Metoda HtmlQuerySelector czeka na img tag z id of 'myid' i class of '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)
Moją ulubioną biblioteką tego typu jest IronPDF. Umożliwia ona szybkie i efektywne manipulowanie plikami PDF. Posiada także wiele cennych funkcji, takich jak eksport do formatu PDF/A i cyfrowe podpisywanie dokumentów PDF.
IronOCR pozwala nam oszczędzić 40 000 USD rocznie na ręcznym przetwarzaniu, jednocześnie zwiększając produktywność i uwalniając zasoby do zadań o wysokim wpływie. Gorąco polecam.
Podczas renderowania stron internetowych, które wykonują żądania sieciowe w celu zasobów, danych lub wywołań API, upewnij się, że wszystkie aktywności sieciowe zostały zakończone przed wygenerowaniem PDF. IronPDF zapewnia kilka metod obsługi różnych scenariuszy sieciowych.
Gdy należy czekać na zerową aktywność sieciową?
Ten typ bezczynności sieciowej czeka, aż nie będzie żadnej aktywności sieciowej, co zazwyczaj wskazuje na pełne załadowanie treści. To pasuje do Aplikacji Jednostronicowych (SPA) lub prostych stron internetowych bez długoprotujących żądań sieciowych lub bieżącej aktywności sieciowej.
Proces renderowania rozpoczyna się, gdy nie było żadnej trwającej aktywności sieciowej przez co najmniej 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>")
Kiedy należy dopuścić dwie aktywności sieciowe?
Metoda NetworkIdle2 nadaje się do aplikacji webowych lub stron internetowych z długim zapytaniem o sieć lub pingami stanu. Zazwyczaj 1-2 żądania są zaangażowane. Nawet jeśli te żądania są w toku, nie unieważniają one wyzwalania zdarzenia bezczynności sieci, ponieważ dopuszczalne jest posiadanie maksymalnie dwóch.
Przed rozpoczęciem procesu renderowania powinno być maksymalnie dwie aktywności sieciowe pozostające przez co najmniej 500 ms. Ta opcja zapewnia szybkie skonfigurowanie do obsługi ustalonej liczby aktywności sieciowych.
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>")
Jak dostosować progi aktywności sieciowej?
Kiedy zaangażowanych jest wiele żądań sieciowych, można dostosować zarówno czas bezczynności sieciowej, jak i liczbę dozwolonych żądań sieciowych, które nie unieważniają zdarzenia bezczynności sieciowej. Ta opcja pasuje do aplikacji internetowych lub stron internetowych z określonymi wymaganiami, które nie pasują do poprzednich dwóch metod. To dostosowanie obejmuje szeroką gamę przypadków użycia w różnych okolicznościach.
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>")
Ten poziom dostosowania jest cenny podczas pracy z złożonymi aplikacjami internetowymi, które utrzymują trwałe połączenia lub mają przewidywalne wzorce aktywności sieciowej w tle.
Jak ustawić maksymalny czas oczekiwania?
Metody JavaScript, NetworkIdle, NetworkIdle0, i NetworkIdle2 pozwalają ustawić maksymalny czas oczekiwania, aby upewnić się, że czekanie nie będzie nieskończone. Parametr maxWaitTime tych metod służy temu celowi. To zapobiega przerwaniu pracy aplikacji na nieokreślony czas, jeśli oczekiwane warunki nigdy nie wystąpią.
Wszystkie określone wartości czasu mają jednostkę milisekund.
Podczas wdrażania tych strategii oczekiwania zachowaj równowagę między zapewnieniem pełnego załadowania zawartości a utrzymaniem rozsądnej wydajności. Dla aplikacji wymagających precyzyjnej kontroli czasu, zapoznaj się z asynchronicznymi technikami generowania PDF.
Gotowy, aby sprawdzić, co jeszcze możesz zrobić? Sprawdź stronę z samouczkiem tutaj: Dodatkowe funkcje lub zapoznaj się z tworzeniem PDF z IronPDF dla bardziej zaawansowanych technik.
Często Zadawane Pytania
Czym jest klasa WaitFor i dlaczego warto ją użyć?
Klasa WaitFor w IronPDF pozwala programistom opóźniać renderowanie PDF do momentu zakończenia ładowania wszystkich zasobów, czcionek i JavaScript. Zapobiega to niekompletnym renderom i zapewnia, że złożone strony webowe są w pełni załadowane przed konwersją na PDF, co skutkuje bardziej dokładnymi i kompletnymi dokumentami PDF.
Jakie są dostępne opcje WaitFor?
Klasa WaitFor IronPDF oferuje kilka opcji: PageLoad (domyślne natychmiastowe renderowanie), RenderDelay (niestandardowe opóźnienie w milisekundach), Fonts (czeka na załadowanie wszystkich czcionek), JavaScript (wyzwala renderowanie za pomocą funkcji JavaScript), elementy HTML (czeka na specyficzne elementy według ID, nazwy, tagu lub selektóra zapytania) i NetworkIdle (czeka aż aktywność sieciowa ustanie).
Jak dodać niestandardowe opóźnienie przed renderowaniem PDF?
Możesz dodać niestandardowe opóźnienie, używając metody RenderDelay w IronPDF. Wystarczy określić opóźnienie w milisekundach: `new ChromePdfRenderer { RenderingOptions = { WaitFor = WaitFor.RenderDelay(3000) } }`. Jest to szczególnie przydatne dla treści z dużą ilością JavaScript, które wymagają dodatkowego czasu na wykonanie.
Czy mogę poczekać na załadowanie specyficznych elementów HTML przed renderowaniem?
Tak, IronPDF pozwala na czekanie na specyficzne elementy HTML przy użyciu ID elementów, nazw, nazw tagów lub selektorów zapytania. Zapewnia to, że istotna treść jest obecna na stronie przed rozpoczęciem konwersji do PDF, zapobiegając brakującym elementom w końcowym dokumencie PDF.
Czym jest NetworkIdle i kiedy go użyć?
NetworkIdle w IronPDF czeka na ustanie aktywności sieciowej przed renderowaniem PDF. Można go ustawić, aby czekał na 0, 2 lub dowolną liczbę połączeń sieciowych. Jest idealny dla stron, które ładują zawartość dynamicznie za pośrednictwem wywołań AJAX lub innych asynchronicznych żądań sieciowych.
Jak mogę wyzwolić renderowanie PDF z JavaScript?
Opcja WaitFor JavaScript w IronPDF pozwala na wyzwolenie procesu renderowania z funkcji JavaScript. Daje to pełną kontrolę nad momentem generacji PDF, co jest idealne dla aplikacji jednostronicowych lub złożonych stron z napędem JavaScript, gdzie potrzebna jest precyzyjna kontrola czasowa.
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 posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podręczników.
