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

Jak przeprowadzić migrację z NReco PDF Generator do IronPDF w języku C#

Curtis Chau
Curtis Chau
Zaktualizowano:

Dlaczego warto przejść z NReco PDF Generator na IronPDF

Krytyczne problemy związane z bezpieczeństwem w programie NReco PDF Generator

NReco PDF Generator wykorzystuje przestarzały plik binarny wkhtmltopdf, dziedzicząc wszystkie jego luki w zabezpieczeniach. Nie jest to kwestia czysto teoretyczna — od czasu zaprzestania wsparcia dla wkhtmltopdf w 2020 r. odnotowano ponad 20 luk CVE, dla których nie są dostępne żadne poprawki:

  • CVE-2020-21365: Fałszowanie żądań po stronie serwera (SSRF)
  • CVE-2022-35583: Odczyt pliku lokalnego poprzez wstrzyknięcie kodu HTML
  • CVE-2022-35580: Możliwość zdalnego wykonania kodu

Luk tych nie da się załatać, ponieważ projekt wkhtmltopdf, na którym są oparte, nie jest już rozwijany.

Dodatkowe ograniczenia generatora PDF NReco

  1. Wersja bezpłatna z znakiem wodnym: Użycie produkcyjne wymaga płatnej licencji o nieprzejrzystej cenie, w związku z czym konieczne jest skontaktowanie się z działem sprzedaży.

  2. Wycofany silnik renderujący: WebKit Qt (ok. 2012 r.) zapewnia ograniczoną obsługę nowoczesnych stron internetowych:

    • Bez CSS Grid ani Flexbox
    • Brak obsługi nowoczesnegoJavaScript(ES6+)
    • Słaba obsługa czcionek internetowych
    • Brak zmiennych CSS ani właściwości niestandardowych

  3. Zewnętrzna zależność binarna: Wymaga zarządzania plikami binarnymi wkhtmltopdf dla każdej platformy (wkhtmltopdf.exe, wkhtmltox.dll).

  4. Brak aktywnego rozwoju: opakowanie jest utrzymywane bez aktualizacji silnika bazowego.

  5. Ograniczona obsługa asynchroniczności: Synchroniczne API blokuje wątki w aplikacjach internetowych.

Porównanie NReco PDF Generator i IronPDF

Aspekt NReco PDF Generator IronPDF
Silnik renderujący WebKit Qt (2012) Chromium (aktualne)
Bezpieczeństwo Ponad 20 luk CVE, brak poprawek Aktywne aktualizacje zabezpieczeń
Obsługa CSS CSS2.1, ograniczone CSS3 Pełna obsługa CSS3, Grid, Flexbox
JavaScript Podstawowy ES5 Pełna obsługa ES6+, async/await
Zależności Zewnętrzny plik binarny wkhtmltopdf Samodzielny
Obsługa asynchroniczna Tylko synchroniczne Pełna obsługa async/await
Czcionki internetowe Ograniczone Pełna obsługa czcionek Google Fonts, @font-face
Licencjonowanie Niejasne ceny, skontaktuj się z działem sprzedaży Przejrzyste ceny
Bezpłatna wersja próbna Z znakiem wodnym Pełna funkcjonalność

Dla zespołów planujących wdrożenie .NET 10 i C# 14 w latach 2025 i 2026,IronPDFzapewnia przyszłościową podstawę dzięki aktywnemu rozwojowi i nowoczesnym możliwościom renderowania.

Zanim zaczniesz

Wymagania wstępne

  1. Środowisko .NET: .NET Framework 4.6.2+ lub .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Dostęp do NuGet: Możliwość instalowania pakietów NuGet
  3. Licencja IronPDF: Uzyskaj klucz licencyjny na stronie ironpdf.com

Zmiany w pakiecie NuGet

# Remove NReco.PdfGenerator
dotnet remove package NReco.PdfGenerator

# Install IronPDF
dotnet add package IronPdf
# Remove NReco.PdfGenerator
dotnet remove package NReco.PdfGenerator

# Install IronPDF
dotnet add package IronPdf
SHELL

Należy również usunąć pliki binarne wkhtmltopdf z wdrożenia:

  • Usuń wkhtmltopdf.exe, wkhtmltox.dll z projektu
  • Usuń wszelkie skrypty instalacyjne wkhtmltopdf
  • Usuń foldery plików binarnych specyficzne dla platformy

Konfiguracja licencji

// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup (Program.cs or Startup.cs)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup (Program.vb or Startup.vb)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Zidentyfikuj zastosowanie generatora PDF NReco

# Find all NReco.PdfGenerator references
grep -r "NReco.PdfGenerator\|HtmlToPdfConverter\|GeneratePdf" --include="*.cs" .
# Find all NReco.PdfGenerator references
grep -r "NReco.PdfGenerator\|HtmlToPdfConverter\|GeneratePdf" --include="*.cs" .
SHELL

Kompletna dokumentacija API

Mapowania klas podstawowych

NReco PDF Generator IronPDF
HtmlToPdfConverter ChromePdfRenderer
PageMargins Właściwości poszczególnych marginesów
PageOrientation PdfPaperOrientation
PageSize PdfPaperSize

Mapowanie metod renderowania

NReco PDF Generator IronPDF
GeneratePdf(html) RenderHtmlAsPdf(html)
GeneratePdfFromFile(url, output) RenderUrlAsPdf(url)
GeneratePdfFromFile(htmlPath, output) RenderHtmlFileAsPdf(path)
(async nie jest obsługiwane) RenderHtmlAsPdfAsync(html)
(async nie jest obsługiwane) RenderUrlAsPdfAsync(url)

Mapowania konfiguracji stron

NReco PDF Generator IronPDF
PageWidth = 210 RenderingOptions.PaperSize = PdfPaperSize.A4
PageHeight = 297 RenderingOptions.SetCustomPaperSizeinMilimeters(w, h)
Orientation = PageOrientation.Landscape RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
Size = PageSize.A4 RenderingOptions.PaperSize = PdfPaperSize.A4

Mapowanie marginesów

NReco PDF Generator IronPDF
Margins.Top = 10 RenderingOptions.MarginTop = 10
Margins.Bottom = 10 RenderingOptions.MarginBottom = 10
Margins.Left = 10 RenderingOptions.MarginLeft = 10
Margins.Right = 10 RenderingOptions.MarginRight = 10
new PageMargins { ... } Poszczególne właściwości

Mapowanie symboli zastępczych nagłówków/stopek

NReco PDF Generator (wkhtmltopdf) IronPDF
[page] {page}
[topage] {total-pages}
[date] {date}
[time] {time}
[title] {html-title}

Mapowania obsługi danych wyjściowych

NReco PDF Generator IronPDF
byte[] pdfBytes = GeneratePdf(html) PdfDocument pdf = RenderHtmlAsPdf(html)
File.WriteAllBytes(path, bytes) pdf.SaveAs(path)
return pdfBytes return pdf.BinaryData
new MemoryStream(pdfBytes) pdf.Stream

Przykłady migracji kodu

Przykład 1: Podstawowy HTML do PDF

Przed (NReco PDF Generator):

// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("output.pdf", pdfBytes);
    }
}
Imports NReco.PdfGenerator
Imports System.IO

Class Program
    Shared Sub Main()
        Dim htmlToPdf = New HtmlToPdfConverter()
        Dim htmlContent = "<html><body><h1>Hello World</h1><p>This is a PDF document.</p></body></html>"
        Dim pdfBytes = htmlToPdf.GeneratePdf(htmlContent)
        File.WriteAllBytes("output.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Po (IronPDF):

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

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

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

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

Podstawowa różnica polega na typie zwracanej wartości i schemacie zapisywania. Funkcja HtmlToPdfConverter.GeneratePdf() programu NReco PDF Generator zwraca byte[], który należy ręcznie zapisać na dysku za pomocą File.WriteAllBytes(). Funkcja ChromePdfRenderer.RenderHtmlAsPdf() bibliotekiIronPDFzwraca obiekt PdfDocument z wbudowaną metodą SaveAs().

To podejście obiektowe zapewnia dodatkowe korzyści: przed zapisaniem można modyfikować plik PDF (dodawać znaki wodne, łączyć dokumenty, dodawać zabezpieczenia). Jeśli potrzebujesz surowych bajtów w celu zapewnienia zgodności z istniejącym kodem, użyj pdf.BinaryData. Dodatkowe opcje renderowania można znaleźć w dokumentacji dotyczącej konwersji HTML do PDF.

Przykład 2: Niestandardowy rozmiar strony z marginesami

Przed (NReco PDF Generator):

// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        htmlToPdf.PageWidth = 210;
        htmlToPdf.PageHeight = 297;
        htmlToPdf.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("custom-size.pdf", pdfBytes);
    }
}
// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        htmlToPdf.PageWidth = 210;
        htmlToPdf.PageHeight = 297;
        htmlToPdf.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdfBytes = htmlToPdf.GeneratePdf(htmlContent);
        File.WriteAllBytes("custom-size.pdf", pdfBytes);
    }
}
Imports NReco.PdfGenerator
Imports System.IO

Class Program
    Shared Sub Main()
        Dim htmlToPdf = New HtmlToPdfConverter()
        htmlToPdf.PageWidth = 210
        htmlToPdf.PageHeight = 297
        htmlToPdf.Margins = New PageMargins With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}
        Dim htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>"
        Dim pdfBytes = htmlToPdf.GeneratePdf(htmlContent)
        File.WriteAllBytes("custom-size.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Po (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("custom-size.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        var htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("custom-size.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        Dim htmlContent = "<html><body><h1>Custom Page Size</h1><p>A4 size document with margins.</p></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("custom-size.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

NReco PDF Generator wykorzystuje wymiary numeryczne (PageWidth = 210, PageHeight = 297) oraz obiekt PageMargins.IronPDFwykorzystuje wyliczenie PdfPaperSize (które obejmuje standardowe rozmiary, takie jak A4, Letter, Legal) oraz indywidualne właściwości marginesów w obiekcie RenderingOptions.

Najważniejsze zmiany związane z migracją:

  • PageHeight → RenderingOptions.PaperSize = PdfPaperSize.A4
  • new PageMargins { Top = 10, ... }→ Individual properties: RenderingOptions.MarginTop = 10

W przypadku niestandardowych rozmiarów papieru, które nie są uwzględnione w wyliczeniu, należy użyć RenderingOptions.SetCustomPaperSizeinMilimeters(width, height). Dowiedz się więcej o opcjach konfiguracji strony.

Przykład 3: Konwersja adresów URL do formatu PDF

Przed (NReco PDF Generator):

// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var pdfBytes = htmlToPdf.GeneratePdfFromFile("https://www.example.com", null);
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
// NuGet: Install-Package NReco.PdfGenerator
using NReco.PdfGenerator;
using System.IO;

class Program
{
    static void Main()
    {
        var htmlToPdf = new HtmlToPdfConverter();
        var pdfBytes = htmlToPdf.GeneratePdfFromFile("https://www.example.com", null);
        File.WriteAllBytes("webpage.pdf", pdfBytes);
    }
}
Imports NReco.PdfGenerator
Imports System.IO

Class Program
    Shared Sub Main()
        Dim htmlToPdf As New HtmlToPdfConverter()
        Dim pdfBytes As Byte() = htmlToPdf.GeneratePdfFromFile("https://www.example.com", Nothing)
        File.WriteAllBytes("webpage.pdf", pdfBytes)
    End Sub
End Class
$vbLabelText   $csharpLabel

Po (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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;

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

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

NReco PDF Generator używa myląco nazwanej metody GeneratePdfFromFile() zarówno dla plików lokalnych, jak i adresów URL, z drugim parametrem, który może przyjmować wartość null.IronPDFudostępnia dedykowane metody: RenderUrlAsPdf() dla adresów URL oraz RenderHtmlFileAsPdf() dla lokalnych plików HTML.

PodejścieIronPDFjest bardziej przejrzyste i intuicyjne. W przypadku asynchronicznych aplikacji internetowych należy używać await renderer.RenderUrlAsPdfAsync(url), aby uniknąć blokowania wątków — czego NReco PDF Generator po prostu nie potrafi zrobić.

Ważne uwagi dotyczące migracji

Konwersja wartości powiększenia

NReco PDF Generator używa wartości zmiennoprzecinkowych (0,0–2,0), podczas gdyIronPDFużywa liczb całkowitych wyrażonych w procentach:

// NReco PDF Generator: Zoom = 0.9f (90%)
// IronPDF: Zoom = 90

// Conversion formula:
int ironPdfZoom = (int)(nrecoZoom * 100);
// NReco PDF Generator: Zoom = 0.9f (90%)
// IronPDF: Zoom = 90

// Conversion formula:
int ironPdfZoom = (int)(nrecoZoom * 100);
' NReco PDF Generator: Zoom = 0.9F (90%)
' IronPDF: Zoom = 90

' Conversion formula:
Dim ironPdfZoom As Integer = CInt(nrecoZoom * 100)
$vbLabelText   $csharpLabel

Aktualizacja składni symboli zastępczych

Należy zaktualizować wszystkie symbole zastępcze w nagłówkach i stopkach:

NReco PDF Generator IronPDF
[page] {page}
[topage] {total-pages}
[date] {date}
[title] {html-title} 
// NReco PDF Generator:
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF:
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
// NReco PDF Generator:
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF:
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
Imports NReco.PdfGenerator
Imports IronPdf

' NReco PDF Generator:
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>"

' IronPDF:
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    .MaxHeight = 20
}
$vbLabelText   $csharpLabel

Zmiana typu zwracanej wartości

NReco PDF Generator zwraca bezpośrednio byte[];IronPDFzwraca PdfDocument:

// NReco PDF Generator pattern:
byte[] pdfBytes = converter.GeneratePdf(html);
File.WriteAllBytes("output.pdf", pdfBytes);

//IronPDFpattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
// NReco PDF Generator pattern:
byte[] pdfBytes = converter.GeneratePdf(html);
File.WriteAllBytes("output.pdf", pdfBytes);

//IronPDFpattern:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Or if you need bytes:
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
Imports System.IO

' NReco PDF Generator pattern:
Dim pdfBytes As Byte() = converter.GeneratePdf(html)
File.WriteAllBytes("output.pdf", pdfBytes)

' IronPDF pattern:
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

' Or if you need bytes:
Dim pdfBytes As Byte() = renderer.RenderHtmlAsPdf(html).BinaryData
$vbLabelText   $csharpLabel

Bezpieczeństwo wątków i możliwość ponownego wykorzystania

NReco PDF Generator zazwyczaj tworzy nowy konwerter przy każdym wywołaniu. Funkcja ChromePdfRenderer bibliotekiIronPDFjest bezpieczna dla wątków i może być ponownie wykorzystana:

// NReco PDF Generator pattern (creates new each time):
public byte[] Generate(string html)
{
    var converter = new HtmlToPdfConverter();
    return converter.GeneratePdf(html);
}

//IronPDFpattern (reuse renderer, thread-safe):
private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] Generate(string html)
{
    return _renderer.RenderHtmlAsPdf(html).BinaryData;
}
// NReco PDF Generator pattern (creates new each time):
public byte[] Generate(string html)
{
    var converter = new HtmlToPdfConverter();
    return converter.GeneratePdf(html);
}

//IronPDFpattern (reuse renderer, thread-safe):
private readonly ChromePdfRenderer _renderer = new ChromePdfRenderer();

public byte[] Generate(string html)
{
    return _renderer.RenderHtmlAsPdf(html).BinaryData;
}
' NReco PDF Generator pattern (creates new each time):
Public Function Generate(html As String) As Byte()
    Dim converter As New HtmlToPdfConverter()
    Return converter.GeneratePdf(html)
End Function

' IronPDF pattern (reuse renderer, thread-safe):
Private ReadOnly _renderer As New ChromePdfRenderer()

Public Function Generate(html As String) As Byte()
    Return _renderer.RenderHtmlAsPdf(html).BinaryData
End Function
$vbLabelText   $csharpLabel

Obsługa asynchroniczna (nowa funkcja)

IronPDF obsługuje wzorce async/await, których nie zapewnia NReco PDF Generator:

// NReco PDF Generator: No async support available

// IronPDF: Full async support
public async Task<byte[]> GenerateAsync(string html)
{
    var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
// NReco PDF Generator: No async support available

// IronPDF: Full async support
public async Task<byte[]> GenerateAsync(string html)
{
    var pdf = await _renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
Imports System.Threading.Tasks

' NReco PDF Generator: No async support available

' IronPDF: Full async support
Public Async Function GenerateAsync(html As String) As Task(Of Byte())
    Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(html)
    Return pdf.BinaryData
End Function
$vbLabelText   $csharpLabel

Rozwiązywanie problemów

Problem 1: Nie znaleziono HtmlToPdfConverter

Problem: Klasa HtmlToPdfConverter nie istnieje w IronPDF.

Rozwiązanie: Użyj ChromePdfRenderer:

// NReco PDF Generator
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
// NReco PDF Generator
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
' NReco PDF Generator
Dim converter As New HtmlToPdfConverter()

' IronPDF
Dim renderer As New ChromePdfRenderer()
$vbLabelText   $csharpLabel

Problem 2: GeneratePdf zwraca niewłaściwy typ

Problem: Kod oczekuje byte[], ale otrzymuje PdfDocument.

Rozwiązanie: Dostęp do właściwości .BinaryData:

// NReco PDF Generator
byte[] pdfBytes = converter.GeneratePdf(html);

// IronPDF
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
// NReco PDF Generator
byte[] pdfBytes = converter.GeneratePdf(html);

// IronPDF
byte[] pdfBytes = renderer.RenderHtmlAsPdf(html).BinaryData;
' NReco PDF Generator
Dim pdfBytes As Byte() = converter.GeneratePdf(html)

' IronPDF
Dim pdfBytes As Byte() = renderer.RenderHtmlAsPdf(html).BinaryData
$vbLabelText   $csharpLabel

Problem 3: Nie znaleziono obiektu PageMargins

Problem: Klasa PageMargins nie istnieje w IronPDF.

Rozwiązanie: Użyj indywidualnych właściwości marginesów:

// NReco PDF Generator
converter.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };

// IronPDF
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
// NReco PDF Generator
converter.Margins = new PageMargins { Top = 10, Bottom = 10, Left = 10, Right = 10 };

// IronPDF
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
' NReco PDF Generator
converter.Margins = New PageMargins With {.Top = 10, .Bottom = 10, .Left = 10, .Right = 10}

' IronPDF
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 10
$vbLabelText   $csharpLabel

Problem 4: Brak numerów stron

Problem: Symbole zastępcze [page] i [topage] nie działają.

Rozwiązanie: Zaktualizuj do składni symboli zastępczych IronPDF:

// NReco PDF Generator
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
// NReco PDF Generator
converter.PageFooterHtml = "<div>Page [page] of [topage]</div>";

// IronPDF
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    MaxHeight = 20
};
Imports NReco.PdfGenerator
Imports IronPdf

converter.PageFooterHtml = "<div>Page [page] of [topage]</div>"

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div>Page {page} of {total-pages}</div>",
    .MaxHeight = 20
}
$vbLabelText   $csharpLabel

Lista kontrolna migracji

Przed migracją

  • Sporządź spis wszystkich wystąpień NReco.PdfGenerator w kodzie źródłowym
  • Udokumentuj wszystkie wartości CustomWkHtmlArgs i CustomWkHtmlPageArgs
  • Wymień wszystkie szablony HTML nagłówków/stopek z symbolami zastępczymi
  • Zidentyfikuj wymagania dotyczące asynchroniczności (kontrolery internetowe, usługi)
  • Sprawdź ustawienia Zoom i marginesów
  • Utwórz kopię zapasową istniejących plików PDF w celu porównania
  • Uzyskaj klucz licencyjny IronPDF

Zmiany w pakiecie

  • Usuń pakiet NuGet NReco.PdfGenerator
  • Zainstaluj pakiet NuGet IronPdf: dotnet add package IronPdf
  • Zaktualizuj importy przestrzeni nazw z using NReco.PdfGenerator; na using IronPdf;

Zmiany w kodzie

  • Dodaj konfigurację klucza licencyjnego podczas uruchamiania
  • Zastąp HtmlToPdfConverter przez ChromePdfRenderer
  • Zastąp GeneratePdf(html) przez RenderHtmlAsPdf(html)
  • Zastąp GeneratePdfFromFile(url, null) przez RenderUrlAsPdf(url)
  • Konwersja obiektu PageMargins na indywidualne właściwości marginesów
  • Zaktualizuj wartości Zoom z typu float na procent
  • Zaktualizuj składnię symboli zastępczych: [page] → {page}, [topage] → {total-pages}
  • Zastąp File.WriteAllBytes() przez pdf.SaveAs()
  • Zamień wywołania synchroniczne na asynchroniczne tam, gdzie jest to korzystne

Po migracji

  • Usuń pliki binarne wkhtmltopdf z projektu/wdrożenia
  • Zaktualizuj pliki Docker, aby usunąć instalację wkhtmltopdf
  • Przeprowadź testy regresji porównujące wynik w formacie PDF
  • Sprawdź, czy symbole zastępcze nagłówków/stopek wyświetlają się poprawnie
  • Przetestuj na wszystkich platformach docelowych (Windows, Linux, macOS)
  • Zaktualizuj potok CI/CD, aby usunąć etapy wkhtmltopdf
  • Zaktualizuj skanowanie bezpieczeństwa, aby potwierdzić usunięcie CVE
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