Nie znalazłeś tego, czego szukałeś?
Ikona wiadomości
Przejdź do treści stopki
  1. IronPDF
  2. Blog IronPDF
  3. Przewodniki migracji
  4. migracja z NReco PDF Generator do IronPDF
PRZEWODNIKI MIGRACJI

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

Curtis Chau
Curtis Chau
Zaktualizowano:

Dlaczego warto przejść zNReco PDF Generatorna IronPDF

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

NReco PDF Generator opakowuje binary wkhtmltopdf, dziedzicząc jego znane luki bezpieczeństwa. Ostatnia stabilna wersja projektu wkhtmltopdf to 0.12.6 (czerwiec 2020), a repozytorium upstream zostało zarchiwizowane 2 stycznia 2023, więc nie pojawią się żadne patche:

  • CVE-2020-21365: Traversal katalogu / odczyt lokalnego pliku przez spreparowany HTML (słabość polityki tego samego pochodzenia)
  • CVE-2022-35583: Podstawiona serwerowa prośba (SSRF) za pomocą wstrzykniętego <iframe> w wersji 0.12.6 (CVSS 9.8)

Dodatkowe ograniczenia generatora PDF NReco

  1. Frykcyjne licencjonowanie na dużą skalę: Darmowe dla wdrożeń produkcyjnych jednoserwerowych poza SaaS; SaaS, multi-serwer lub scenariusze redystrybucyjne wymagają pakietu Enterprise z kodem źródłowym za 199 USD od nrecosite.com.

  2. Zdeprecjonowany silnik renderujący: WebKit Qt (około 2012) z ograniczoną obsługą CSS3/JS:

    • 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. Wstrzymane utrzymanie: NReco.PdfGenerator 1.2.1 został opublikowany 8 stycznia 2023 i nie było dalszych wydań na nuget.org; podstawowy silnik wkhtmltopdf nie jest już aktualizowany.

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

PorównanieNReco PDF Generatori IronPDF

Aspekt NReco PDF Generator IronPDF
Silnik renderujący WebKit Qt (2012) Chromium (aktualne)
Bezpieczeństwo Wiele niezałatanych CVE (np. CVE-2020-21365, CVE-2022-35583); silnik zarchiwizowany 2 stycznia 2023 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 Darmowy dla jednoserwerowego non-SaaS; 199 USD za pakiet Enterprise dla SaaS / multi-serwer Przejrzyste komercyjne wyceny
Poziom bezpłatny Darmowy pod licencją non-SaaS jednoserwerowa Próbne bez znaku wodnego

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
nowe 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) new MemoryStream(pdf.BinaryData)

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. HtmlToPdfConverter.GeneratePdf()NReco PDF Generatorzwraca byte[], który należy ręcznie zapisać na dysku za pomocą File.WriteAllBytes(). ChromePdfRenderer.RenderHtmlAsPdf()IronPDF zwraca 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 do 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 używa numerycznych wymiarów (PageWidth = 210, PageHeight = 297) oraz obiektu PageMargins.IronPDF używa wyliczenia PdfPaperSize (które obejmuje standardowe rozmiary, takie jak A4, Letter, Legal) oraz indywidualnych właściwości marginesu na obiekcie RenderingOptions.

Najważniejsze zmiany związane z migracją:

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

Dla niestandardowych rozmiarów papieru, które nie są obsługiwane przez wyliczenie, użyj 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 nazwanego GeneratePdfFromFile() do obsługi zarówno lokalnych plików, jak i URL-i, z opcjonalnym drugim parametrem.IronPDF oferuje dedykowane metody: RenderUrlAsPdf() dla URL-i i RenderHtmlFileAsPdf() dla lokalnych plików HTML.

Podejście IronPDF jest czystsze i bardziej intuicyjne. Dla asynchronicznych aplikacji webowych użyj await renderer.RenderUrlAsPdfAsync(url), aby uniknąć blokowania wątków - coś, czegoNReco PDF Generatornie potrafi.

Ważne uwagi dotyczące migracji

Konwersja wartości powiększenia

NReco PDF Generator używa wartości zmiennoprzecinkowych (0,0–2,0), podczas gdy IronPDF uż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[];IronPDF zwraca PdfDocument:

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

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

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

//IronPDF pattern:
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. ChromePdfRendererIronPDF jest bezpieczny dla wątków i można go ponownie użyć:

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

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

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

//IronPDF pattern (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: Uzyskaj 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: Nie działają zastępcze miejsca [page] i [topage].

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ą

  • Inwentaryzuj wszystkie użycia NReco.PdfGenerator w kodzie
  • Dokumentuj 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
  • Zamień HtmlToPdfConverter na ChromePdfRenderer
  • Zamień GeneratePdf(html) na RenderHtmlAsPdf(html)
  • Zamień GeneratePdfFromFile(url, null) na RenderUrlAsPdf(url)
  • Przekształć obiekt PageMargins na indywidualne właściwości marginesu
  • Zaktualizuj wartości Zoom z typu float na procent
  • Zaktualizuj składnię zastępczych miejsc: [page] → {page}, [topage] → {total-pages}
  • Zamień File.WriteAllBytes() na 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

Zwróć uwagęNReco i wkhtmltopdf sa zarejestrowanymi znakami towarowymi swoich odpowiednich wlascicieli. Ta strona nie jest powiazana, zatwierdzona ani sponsorowana przez NReco ani wkhtmltopdf. Wszystkie nazwy produktów, logo i marki są własnością ich odpowiednich właścicieli. Porównania mają charakter wyłącznie informacyjny i odzwierciedlają informacje dostępne publicznie w momencie pisania.

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

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie