Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. migration from wkhtmltopdf to ironpdf
PRZEWODNIKI MIGRACJI

Jak przejść z wkhtmltopdf na IronPDF w języku C#

Curtis Chau
Curtis Chau
Zaktualizowano:

wkhtmltopdf jest szeroko stosowanym narzędziem do konwersji dokumentów HTML do formatu PDF przy użyciu Qt WebKit. Pomimo popularności wśród programistów ze względu na możliwości wiersza poleceń i bezpłatną licencję, projekt stwarza obecnie poważne zagrożenia dla bezpieczeństwa, których nie można już dłużej ignorować. Biblioteka została oficjalnie wycofana w latach 2016–2017, a luka o poziomie krytycznym (CVE-2022-35583) pozostaje na stałe niezałatana.

Niniejszy przewodnik zawiera kompletną ścieżkę migracji zwkhtmltopdfdo IronPDF, wraz z instrukcjami krok po kroku, porównaniami kodu i praktycznymi przykładami dla profesjonalnych programistów .NET, którzy muszą wyeliminować to zagrożenie bezpieczeństwa ze swoich aplikacji.

Krytyczne ostrzeżenie dotyczące bezpieczeństwa: CVE-2022-35583

wkhtmltopdf zawiera krytyczną lukę w zabezpieczeniach, która nigdy nie zostanie naprawiona:

Problem Waga Status
CVE-2022-35583 KLUCZOWE (9,8/10) UNPATCHED
Luka SSRF Ryzyko przejęcia infrastruktury UNPATCHED
Ostatnia aktualizacja 2016-2017 PORZUCONE
Wersja WebKit 2015 (Qt WebKit) NIEAKTUALNE
Obsługa CSS Grid None Uszkodzone
Obsługa Flexbox Częściowe Uszkodzone
JavaScript ES6+ None Uszkodzone

Jak działa atak SSRF

Luka typu Server-Side Request Forgery pozwala atakującym uzyskać dostęp do usług wewnętrznych, wykraść dane uwierzytelniające, skanować sieć wewnętrzną i wykradać poufne dane za pomocą spreparowanego kodu HTML:


<iframe src="http://169.254.169.254/latest/meta-data/iam/security-credentials/"></iframe>
<img src="http://internal-database:5432/admin"/>

<iframe src="http://169.254.169.254/latest/meta-data/iam/security-credentials/"></iframe>
<img src="http://internal-database:5432/admin"/>
HTML

Kiedywkhtmltopdfrenderuje ten kod HTML, pobiera te adresy URL z kontekstu sieciowego serwera, omijając zapory sieciowe i zabezpieczenia.

Biblioteki opakowujące, których to dotyczy

Wszystkie nakładki .NET dlawkhtmltopdfdziedziczą te luki w zabezpieczeniach:

Biblioteka opakowująca Status Zagrożenie bezpieczeństwa
DinkToPdf Porzucony ⚠️ BARDZO WAŻNE
Rotativa Porzucony ⚠️ BARDZO WAŻNE
TuesPechkin Porzucony ⚠️ BARDZO WAŻNE
WkHtmlToPdf-DotNet Porzucony ⚠️ BARDZO WAŻNE
NReco.PdfGenerator Wykorzystujewkhtmltopdf ⚠️ BARDZO WAŻNE

Jeśli korzystasz z którejkolwiek z tych bibliotek, jesteś narażony na lukę CVE-2022-35583.

IronPDFa wkhtmltopdf: porównanie funkcji

Zrozumienie różnic architektonicznych pomaga decydentom technicznym w ocenie inwestycji w migrację:

Funkcja wkhtmltopdf IronPDF
Licencjonowanie LGPLv3 (bezpłatna) Komercjalne
Silnik renderujący Qt WebKit (2015) Aktualny silnik Chromium
Luki w zabezpieczeniach CVE-2022-35583, poważne niezałatane luki Brak znanych luk CVE
Aktywna konserwacja Projekt porzucony, brak znaczących aktualizacji od 2017 roku Aktywnie utrzymywany z regularnymi wydaniami
Obsługa nowoczesnych standardów internetowych Ograniczone (uszkodzony flexbox, brak CSS Grid) Obsługiwane
Integracja i wsparcie Ograniczone do forów społecznościowych Obszerna dokumentacja i dedykowane wsparcie
CSS Grid ❌ Nieobsługiwane ✅ Obsługiwane
Flexbox ⚠️ Uszkodzone ✅ Obsługiwane
JavaScript ES6+ ❌ Nieobsługiwane ✅ Obsługiwane
Async/Await ❌ Nieobsługiwane ✅ Obsługiwane
Manipulacja plikami PDF ❌ Nieobsługiwane ✅ Obsługiwane
Podpisy cyfrowe ❌ Nieobsługiwane ✅ Obsługiwane
Zgodność z PDF/A ❌ Nieobsługiwane ✅ Obsługiwane

Szybki start: Migracja zwkhtmltopdfdo IronPDF

Migrację można rozpocząć natychmiast, wykonując te podstawowe kroki.

Krok 1: Usuń pakiety i pliki binarne wkhtmltopdf

Usuń wszystkie pakiety opakowujące wkhtmltopdf:

# Removewkhtmltopdfwrapper (whichever you're using)
dotnet remove package WkHtmlToPdf-DotNet
dotnet remove package DinkToPdf
dotnet remove package TuesPechkin
dotnet remove package Rotativa
dotnet remove package Rotativa.AspNetCore
dotnet remove package NReco.PdfGenerator

# Removewkhtmltopdfbinary from your deployment
# Delete wkhtmltopdf.exe, wkhtmltox.dll, etc.
# Removewkhtmltopdfwrapper (whichever you're using)
dotnet remove package WkHtmlToPdf-DotNet
dotnet remove package DinkToPdf
dotnet remove package TuesPechkin
dotnet remove package Rotativa
dotnet remove package Rotativa.AspNetCore
dotnet remove package NReco.PdfGenerator

# Removewkhtmltopdfbinary from your deployment
# Delete wkhtmltopdf.exe, wkhtmltox.dll, etc.
SHELL

Krok 2: Zainstaluj IronPDF

# AddIronPDF(secure, modern alternative)
dotnet add package IronPdf
# AddIronPDF(secure, modern alternative)
dotnet add package IronPdf
SHELL

Krok 3: Aktualizacja przestrzeni nazw

Zastąp przestrzenie nazwwkhtmltopdfprzestrzenią nazw IronPdf:

// Before (wkhtmltopdf)
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;

// After (IronPDF)
using IronPdf;
// Before (wkhtmltopdf)
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;

// After (IronPDF)
using IronPdf;
' Before (wkhtmltopdf)
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts

' After (IronPDF)
Imports IronPdf
$vbLabelText   $csharpLabel

Krok 4: Inicjalizacja licencji

Dodaj inicjalizację licencji podczas uruchamiania aplikacji:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Przykłady migracji kodu

Konwersja HTML do PDF

Najbardziej podstawowa operacja ujawnia różnicę w złożoności między tymi podejściami do obsługi plików PDF w środowisku .NET.

Podejście wkhtmltopdf:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
' NuGet: Install-Package WkHtmlToPdf-DotNet
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New SynchronizedConverter(New PdfTools())
        Dim doc = New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = {
                New ObjectSettings() With {
                    .HtmlContent = "<h1>Hello World</h1><p>This is a PDF from HTML.</p>"
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Class
$vbLabelText   $csharpLabel

Podejście IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF from HTML.</p>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

wkhtmltopdf wymaga utworzenia SynchronizedConverter z PdfTools, skonstruowania HtmlToPdfDocument z GlobalSettings i Objects, ustawienie właściwości takich jak ColorMode, Orientation i PaperSize, wywołanie converter.Convert() w celu uzyskania surowych bajtów oraz ręczne zapisanie do pliku za pomocą File.WriteAllBytes().

IronPDF całkowicie eliminuje tę procedurę — wystarczy utworzyć ChromePdfRenderer, wywołać RenderHtmlAsPdf() i użyć wbudowanej metody SaveAs().

W przypadku zaawansowanych scenariuszy konwersji HTML do PDF zapoznaj się z przewodnikiem po konwersji HTML do PDF.

Konwersja adresów URL do formatu PDF

Konwersja adresów URL do formatu PDF wykazuje podobne wzorce złożoności.

Podejście wkhtmltopdf:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "https://www.example.com"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Portrait,
                PaperSize = PaperKind.A4
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "https://www.example.com"
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
' NuGet: Install-Package WkHtmlToPdf-DotNet
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts
Imports System.IO

Module Program
    Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())
        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Portrait,
                .PaperSize = PaperKind.A4
            },
            .Objects = {
                New ObjectSettings() With {
                    .Page = "https://www.example.com"
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Module
$vbLabelText   $csharpLabel

Podejście IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

wkhtmltopdf używa właściwości Page w ObjectSettings do określenia adresu URL, co wymaga takiego samego wzorca budowy dokumentu.IronPDFudostępnia dedykowaną metodę RenderUrlAsPdf(), która jasno wyraża intencję.

Zapoznaj się z dokumentacją dotyczącą konwersji adresów URL do formatu PDF, aby uzyskać informacje na temat uwierzytelniania i opcji niestandardowych nagłówków.

Ustawienia niestandardowe: pliki HTML z konfiguracją strony

Konfiguracja orientacji, marginesów i rozmiaru papieru wymaga różnych podejść.

Podejście wkhtmltopdf:

// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "input.html",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom-output.pdf", pdf);
    }
}
// NuGet: Install-Package WkHtmlToPdf-DotNet
using WkHtmlToPdfDotNet;
using WkHtmlToPdfDotNet.Contracts;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new SynchronizedConverter(new PdfTools());
        var doc = new HtmlToPdfDocument()
        {
            GlobalSettings = {
                ColorMode = ColorMode.Color,
                Orientation = Orientation.Landscape,
                PaperSize = PaperKind.A4,
                Margins = new MarginSettings() { Top = 10, Bottom = 10, Left = 10, Right = 10 }
            },
            Objects = {
                new ObjectSettings()
                {
                    Page = "input.html",
                    WebSettings = { DefaultEncoding = "utf-8" }
                }
            }
        };
        byte[] pdf = converter.Convert(doc);
        File.WriteAllBytes("custom-output.pdf", pdf);
    }
}
' NuGet: Install-Package WkHtmlToPdf-DotNet
Imports WkHtmlToPdfDotNet
Imports WkHtmlToPdfDotNet.Contracts
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter As New SynchronizedConverter(New PdfTools())
        Dim doc As New HtmlToPdfDocument() With {
            .GlobalSettings = New GlobalSettings() With {
                .ColorMode = ColorMode.Color,
                .Orientation = Orientation.Landscape,
                .PaperSize = PaperKind.A4,
                .Margins = New MarginSettings() With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
            },
            .Objects = {
                New ObjectSettings() With {
                    .Page = "input.html",
                    .WebSettings = New WebSettings() With {.DefaultEncoding = "utf-8"}
                }
            }
        }
        Dim pdf As Byte() = converter.Convert(doc)
        File.WriteAllBytes("custom-output.pdf", pdf)
    End Sub
End Class
$vbLabelText   $csharpLabel

Podejście IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("custom-output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("custom-output.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("custom-output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

wkhtmltopdf umieszcza ustawienia wewnątrz GlobalSettings i Objects, a MarginSettings jest oddzielnym obiektem.IronPDFudostępnia bezpośrednie właściwości RenderingOptions o jasnych nazwach, takich jak PaperOrientation, MarginTop i PaperSize.

Dokumentacja APIwkhtmltopdfdo IronPDF

To mapowanie przyspiesza migrację, pokazując bezpośrednie odpowiedniki API:

Mapowanie CLI do IronPDF

Opcja CLIwkhtmltopdf OdpowiednikIronPDF
wkhtmltopdf input.html output.pdf renderer.RenderHtmlFileAsPdf()
wkhtmltopdf URL output.pdf renderer.RenderUrlAsPdf()
--page-size A4 RenderingOptions.PaperSize = PdfPaperSize.A4
--page-size Letter RenderingOptions.PaperSize = PdfPaperSize.Letter
--orientation Landscape RenderingOptions.PaperOrientation = Landscape
--margin-top 10mm RenderingOptions.MarginTop = 10
--margin-bottom 10mm RenderingOptions.MarginBottom = 10
--margin-left 10mm RenderingOptions.MarginLeft = 10
--margin-right 10mm RenderingOptions.MarginRight = 10
--header-html header.html RenderingOptions.HtmlHeader
--footer-center "[page]" {page} miejsce na tekst
--footer-center "[toPage]" {total-pages} miejsce na tekst
--enable-javascript Włączone domyślnie
--javascript-delay 500 RenderingOptions.WaitFor.RenderDelay = 500
--dpi 300 RenderingOptions.Dpi = 300
--grayscale RenderingOptions.GrayScale = true

Mapowanie API opakowania C

wkhtmltopdf Wrapper IronPDF
SynchronizedConverter ChromePdfRenderer
HtmlToPdfDocument RenderingOptions
GlobalSettings.Out pdf.SaveAs()
GlobalSettings.PaperSize RenderingOptions.PaperSize
GlobalSettings.Orientation RenderingOptions.PaperOrientation
GlobalSettings.Margins RenderingOptions.Margin*
ObjectSettings.Page RenderHtmlFileAsPdf()
ObjectSettings.HtmlContent RenderHtmlAsPdf()
converter.Convert(doc) renderer.RenderHtmlAsPdf()

Migracja składni symboli zastępczych

wkhtmltopdfMiejsce na tekst IronPDF Placeholder
[page] {page}
[toPage] {total-pages}
[date] {date}
[time] {time}
[title] {html-title}
[url] {url}

Typowe problemy związane z migracją i ich rozwiązania

Problem 1: Składnia symboli zastępczych nagłówków/stopek

wkhtmltopdf: Używa składni z nawiasami kwadratowymi, np. [page] i [toPage].

Rozwiązanie: Zaktualizuj do symbolów zastępczych nawiasów klamrowych IronPDF:

// Before (wkhtmltopdf)
FooterSettings = { Left = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:left;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};
// Before (wkhtmltopdf)
FooterSettings = { Left = "Page [page] of [toPage]" }

// After (IronPDF)
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:left;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};
' Before (wkhtmltopdf)
FooterSettings = New With {.Left = "Page [page] of [toPage]"}

' After (IronPDF)
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:left;'>Page {page} of {total-pages}</div>",
    .MaxHeight = 25
}
$vbLabelText   $csharpLabel

Problem 2: Konfiguracja opóźnienia w JavaScript

wkhtmltopdf: Wykorzystuje właściwość JavaScriptDelay o ograniczonej niezawodności.

Rozwiązanie:IronPDFoferuje wiele opcji:

renderer.RenderingOptions.EnableJavaScript = true;

// Option 1: Fixed delay
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Option 2: Wait for specific element (more reliable)
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

// Option 3: Wait for JavaScript condition
renderer.RenderingOptions.WaitFor.JavaScript("window.renderComplete === true");
renderer.RenderingOptions.EnableJavaScript = true;

// Option 1: Fixed delay
renderer.RenderingOptions.WaitFor.RenderDelay(500);

// Option 2: Wait for specific element (more reliable)
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded");

// Option 3: Wait for JavaScript condition
renderer.RenderingOptions.WaitFor.JavaScript("window.renderComplete === true");
renderer.RenderingOptions.EnableJavaScript = True

' Option 1: Fixed delay
renderer.RenderingOptions.WaitFor.RenderDelay(500)

' Option 2: Wait for specific element (more reliable)
renderer.RenderingOptions.WaitFor.HtmlElementById("content-loaded")

' Option 3: Wait for JavaScript condition
renderer.RenderingOptions.WaitFor.JavaScript("window.renderComplete === true")
$vbLabelText   $csharpLabel

Problem 3: Nowoczesny CSS nie wyświetla się

Objaw: Układy CSS Grid i Flexbox są wyświetlane nieprawidłowo w wkhtmltopdf.

Rozwiązanie: Silnik Chromium firmyIronPDFpoprawnie obsługuje nowoczesny CSS:

// This CSS now works with IronPDF
var html = @"
<style>
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
    .flex { display: flex; justify-content: space-between; align-items: center; }
</style>
<div class='grid'>
    <div>Column 1</div>
    <div>Column 2</div>
    <div>Column 3</div>
</div>";

var pdf = renderer.RenderHtmlAsPdf(html);
// This CSS now works with IronPDF
var html = @"
<style>
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
    .flex { display: flex; justify-content: space-between; align-items: center; }
</style>
<div class='grid'>
    <div>Column 1</div>
    <div>Column 2</div>
    <div>Column 3</div>
</div>";

var pdf = renderer.RenderHtmlAsPdf(html);
Dim html As String = "
<style>
    .grid { display: grid; grid-template-columns: repeat(3, 1fr); gap: 10px; }
    .flex { display: flex; justify-content: space-between; align-items: center; }
</style>
<div class='grid'>
    <div>Column 1</div>
    <div>Column 2</div>
    <div>Column 3</div>
</div>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Problem 4: Renderowanie synchroniczne a asynchroniczne

wkhtmltopdf: Funkcje opakowujące są synchroniczne i blokują wątki.

Rozwiązanie:IronPDFobsługuje renderowanie asynchroniczne:

public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
Imports System.Threading.Tasks

Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
    Dim renderer As New ChromePdfRenderer()
    Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
    Return pdf.BinaryData
End Function
$vbLabelText   $csharpLabel

Lista kontrolna migracji wkhtmltopdf

Zadania przed migracją

Przeprowadź audyt kodu źródłowego, aby zidentyfikować wszystkie przypadki użycia wkhtmltopdf:

# Find allwkhtmltopdfreferences
grep -r "WkHtmlToPdfDotNet\|DinkToPdf\|TuesPechkin\|Rotativa" --include="*.cs" .
grep -r "wkhtmltopdf" --include="*.yml" --include="*.yaml" --include="Dockerfile" .
# Find allwkhtmltopdfreferences
grep -r "WkHtmlToPdfDotNet\|DinkToPdf\|TuesPechkin\|Rotativa" --include="*.cs" .
grep -r "wkhtmltopdf" --include="*.yml" --include="*.yaml" --include="Dockerfile" .
SHELL

Zlokalizuj i udokumentuj pliki binarnewkhtmltopdfw celu ich usunięcia. Uwzględnij aktualne ustawienia (rozmiar papieru, marginesy, nagłówki/stopki).

Zadania związane z aktualizacją kodu

  1. Usuń wszystkie pakiety NuGet otaczające wkhtmltopdf
  2. Usuń pliki binarnewkhtmltopdf(wkhtmltopdf.exe, wkhtmltox.dll)
  3. Zainstaluj pakiet IronPdf NuGet
  4. Zaktualizuj importy przestrzeni nazw z WkHtmlToPdfDotNet na IronPdf
  5. Zastąp SynchronizedConverter przez ChromePdfRenderer
  6. Przekształć wzorce HtmlToPdfDocument na metody bezpośredniego renderowania
  7. Zaktualizuj konfiguracje GlobalSettings na RenderingOptions
  8. Przekształć konfiguracje marginesów z MarginSettings na poszczególne właściwości
  9. Zaktualizuj składnię symboli zastępczych ([page] → {page}, [toPage] → {total-pages})
  10. Dodaj inicjalizację licencjiIronPDFpodczas uruchamiania

Testy po migracji

Po migracji należy zweryfikować następujące aspekty:

  • Wizualne porównanie pliku PDF (powinno wyglądać lepiej dzięki obsłudze nowoczesnego CSS)
  • Sprawdź renderowanie nowoczesnego CSS (CSS Grid i Flexbox teraz działają)
  • Testowanie stron z dużą ilością kodu JavaScript
  • Skanowanie bezpieczeństwa w celu potwierdzenia, że nie pozostały żadne pliki binarne wkhtmltopdf
  • Test obciążeniowy w celu porównania wydajności

Weryfikacja bezpieczeństwa

# Scan for any remainingwkhtmltopdfartifacts
find /var/www/ -name "*wkhtmlto*" 2>/dev/null
find /usr/local/bin/ -name "*wkhtmlto*" 2>/dev/null
docker images | grep wkhtmltopdf

# Check if any process is still using it
ps aux | grep wkhtmltopdf
# Scan for any remainingwkhtmltopdfartifacts
find /var/www/ -name "*wkhtmlto*" 2>/dev/null
find /usr/local/bin/ -name "*wkhtmlto*" 2>/dev/null
docker images | grep wkhtmltopdf

# Check if any process is still using it
ps aux | grep wkhtmltopdf
SHELL

Kluczowe korzyści z migracji do IronPDF

Przejście zwkhtmltopdfnaIronPDFzapewnia kilka kluczowych korzyści:

Bezpieczeństwo: Usunięto lukę CVE-2022-35583 oraz wszystkie luki w zabezpieczeniach biblioteki wkhtmltopdf.IronPDFnie ma żadnych znanych luk CVE i regularnie otrzymuje aktualizacje zabezpieczeń.

Nowoczesny silnik renderujący:IronPDFwykorzystuje aktualny silnik Chromium, zapewniając pełną obsługę CSS3, CSS Grid, Flexbox oraz JavaScript ES6+. Nowoczesne frameworki wyświetlają się poprawnie.

Uproszczone API: Metody bezpośredniego renderowania zastępują wzorce tworzenia dokumentów. Wbudowane metody SaveAs() eliminują ręczną obsługę bajtów.

Rozszerzone możliwości: Manipulacja plikami PDF, podpisy cyfrowe, zgodność z PDF/A, znaki wodne oraz operacje łączenia i dzielenia to wbudowane funkcje, którychwkhtmltopdfnie był w stanie zapewnić.

Aktywny rozwój: W miarę jak do 2026 r. wzrośnie popularność .NET 10 i C# 14, regularne aktualizacjeIronPDFzapewnią zgodność z obecnymi i przyszłymi wersjami .NET.

Obsługa asynchroniczna: Zapobieganie blokowaniu wątków w aplikacjach internetowych o dużym obciążeniu dzięki natywnej obsłudze async/await.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

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ę...

Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie