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 zetpdf do ironpdf
PRZEWODNIKI MIGRACJI

Jak przeprowadzić migrację z ZetPDF do IronPDF w języku C#

Curtis Chau
Curtis Chau
Zaktualizowano:

ZetPDF (zetpdf.com) to komercyjnie licencjonowane SDK PDF dla .NET, którego powierzchnia API przypomina PDFsharp — do tego stopnia, że społeczność PDFsharp pytano, czy jest to zamknięta wersja fork. Dostawca reklamuje to jako zastrzeżony, w całości zarządzany kodem silnik.ZetPDFnie jest dystrybuowany przez NuGet — instalacja to pobranie ZIP z https://zetpdf.com/download/ — a projekt nie wykazuje aktywności publicznego wydania od 2021 roku. Cena jest wieczysta: $299 Single Project / $449 Multi / $599 OEM.

Ten przewodnik oferuje ścieżkę migracji zZetPDFdo IronPDF, z instrukcjami krok po kroku, porównaniami kodu i przykładami dla deweloperów .NET oceniających tę zmianę.

Dlaczego warto przejść z ZetPDF

APIZetPDFw kształcie PDFsharp, oparte na rysowaniu współrzędnych, niesie ograniczenia architektoniczne, które ograniczają współczesne przepływy pracy generowania dokumentów. Powszechne powody, dla których zespoły rozważają migrację:

Coordinate-Based API:ZetPDFpozycjonuje każdy element za pomocą dokładnych XGraphics współrzędnych. Ręczne pozycjonowanie tworzy obciążenie konserwacyjne w miarę zmieniających się wymagań.

Brak wsparcia dla CSS: Brak systemu stylizacji — czcionki i kolory są zarządzane na poziomie elementów w kodzie.

Brak renderowania JavaScript: Nie można renderować dynamicznej zawartości internetowej ani wykonywać kodu JavaScript podczas generowania pliku PDF.

Brak natywnego HTML-to-PDF: W opublikowanej liście funkcjiZetPDFnie uwzględniono konwertera HTML-to-PDF ani URL-to-PDF; renderowanie to tylko niskopoziomowe XGraphics rysowanie.

Brak NuGet, uśpione wydania: Dystrybucja to ZIP dostawcy z https://zetpdf.com/download/, bez publicznej aktywności wydaniowej od 2021 roku.

Ręczne przerwy stron: Przepływ strony musi być obliczany i zarządzany ręcznie, a nie poprzez automatyczne paginowanie.

Wymagana miara tekstu: Ręczne obliczenie zawijania tekstu dodaje obciążenie dla rozwoju.

Podstawowy problem

ZetPDF i PDFsharp zmuszają do pozycjonowania każdego elementu przy użyciu dokładnych współrzędnych:

// ZetPDF: Podręcznik positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form
// ZetPDF: Podręcznik positioning nightmare
graphics.DrawString("Name:", font, brush, new XPoint(50, 100));
graphics.DrawString("John Doe", font, brush, new XPoint(100, 100));
graphics.DrawString("Address:", font, brush, new XPoint(50, 120));
graphics.DrawString("123 Main St", font, brush, new XPoint(100, 120));
// ... hundreds of lines for a simple form
' ZetPDF: Podręcznik positioning nightmare
graphics.DrawString("Name:", font, brush, New XPoint(50, 100))
graphics.DrawString("John Doe", font, brush, New XPoint(100, 100))
graphics.DrawString("Address:", font, brush, New XPoint(50, 120))
graphics.DrawString("123 Main St", font, brush, New XPoint(100, 120))
' ... hundreds of lines for a simple form
$vbLabelText   $csharpLabel

IronPDF wykorzystujeHTML/CSS— silnik układu zajmuje się wszystkim:

// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
// IronPDF: Simple HTML
var html = @"
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>";
var pdf = renderer.RenderHtmlAsPdf(html);
' IronPDF: Simple HTML
Dim html As String = "
<p><strong>Name:</strong> John Doe</p>
<p><strong>Address:</strong> 123 Main St</p>"
Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

IronPDF vs ZetPDF: Porównanie funkcji

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

Funkcja ZetPDF IronPDF
Styl API rysowanie w kształcie PDFsharp XGraphics Renderowanie HTML na wysokim poziomie
Konwersja HTML do PDF Nie na dokumentowanej liście funkcji Tak (pełna wersja Chromium)
Licencja komercyjna Tak, wieczysta ($299 / $449 / $599) Tak
Dystrybucja Pobieranie ZIP (brak pakietu NuGet) NuGet (IronPdf)
Ostatnia publiczna aktywność Brak wydanych wersji od 2021 Aktywne, częste wydania
Obsługa CSS Nie Pełny CSS3
JavaScript Nie Pełna wersja ES2024
Automatyczny układ Nie Tak
Automatyczne podziały stron Nie Tak
Tabele Rysowanie ręczne HTML
Nagłówki/stopki Podręcznik HTML/CSS
Znaki wodne Kod podręcznika Wbudowane
Łączenie plików PDF Brak pomocnika z najwyższej półki Tak
Podział plików PDF Brak pomocnika z najwyższej półki Tak
Podpisy cyfrowe Nie Tak
PDF/A Nie Tak

Szybki start: Migracja zZetPDFdo IronPDF

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

Krok 1: Zastąp odwołanieZetPDFpakietem NuGet IronPDF

ZetPDF nie jest dostępny na NuGet — jest dostarczany jako ZIP z https://zetpdf.com/download/i używany poprzez dodanie ZetPDF.dll do projektu. Po migracji usuń tę referencję do DLL i zainstaluj IronPDF z NuGet:

# Remove the ZetPDF.dll reference from your csproj manually, then:
dotnet add package IronPdf
# Remove the ZetPDF.dll reference from your csproj manually, then:
dotnet add package IronPdf
SHELL

Krok 2: Aktualizacja przestrzeni nazw

Zastąp przestrzenie nazwZetPDFprzestrzenią nazw IronPDF:

// Before (ZetPDF)
using ZetPDF;
using ZetPDF.Drawing;
using ZetPDF.Fonts;

// After (IronPDF)
using IronPdf;
// Before (ZetPDF)
using ZetPDF;
using ZetPDF.Drawing;
using ZetPDF.Fonts;

// After (IronPDF)
using IronPdf;
Imports IronPdf
$vbLabelText   $csharpLabel

Krok 3: 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

Na opublikowanej liście funkcjiZetPDFnie uwzględniono natywnego konwertera HTML-to-PDF ani URL-to-PDF — opublikowana powierzchnia obejmuje wyświetlanie/drukowanie PDF, adnotacje, szyfrowanie AES256, pola formularzy i ekstrakcję tekstu. Pseudo-wrapper poniżej ilustruje, w jaki sposób zespoły zazwyczaj tworzą punkt wejścia HTML-to-PDF na bazie ZetPDF; w praktyce praca wraca do zewnętrznego renderer HTML lub do niskopoziomowego XGraphics rysowania.

MetodaZetPDF(ilustracja — brak natywnego HTML-to-PDF):

//ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Nie native HtmlToPdfConverter exists inZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
//ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Nie native HtmlToPdfConverter exists inZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        ' Nie native HtmlToPdfConverter exists in ZetPDF— illustrative call only.
        Dim converter As New HtmlToPdfConverter()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

Podejście IronPDF:

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(htmlContent);
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
Imports IronPdf
Imports System

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        Dim htmlContent As String = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF zapewnia ChromePdfRenderer z RenderHtmlAsPdf(), który zwraca obiekt PdfDocument — można zapisać do pliku, pobrać dane binarne lub wykonać dodatkowe operacje przed zapisem.

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

Konwersja adresów URL do formatu PDF

ZetPDF również nie posiada natywnego konwertera URL-to-PDF; renderowanie HTML/URL nie jest częścią dokumentowanej listy funkcji. Praktyczne ścieżki migracji zazwyczaj parująZetPDFz zewnętrznym rendererem HTML lub przenoszą się do biblioteki opartej na Chromium, takiej jak IronPDF.

MetodaZetPDF(ilustracja — brak natywnego URL-to-PDF):

//ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Nie native ConvertUrlToPdf exists inZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
//ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        // Nie native ConvertUrlToPdf exists inZetPDF— illustrative call only.
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
Imports ZetPDF
Imports System

Class Program
    Shared Sub Main()
        ' Nie native ConvertUrlToPdf exists inZetPDF— illustrative call only.
        Dim converter As New HtmlToPdfConverter()
        Dim url As String = "https://www.example.com"
        converter.ConvertUrlToPdf(url, "webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

Podejście IronPDF:

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var url = "https://www.example.com";
        var pdf = renderer.RenderUrlAsPdf(url);
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
Imports IronPdf
Imports System

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        Dim url As String = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

Funkcja RenderUrlAsPdf()IronPDF na ChromePdfRenderer wykorzystuje pełny silnik renderowania Chromium do przechwytywania stron internetowych, w tym wykonywania JavaScript i nowoczesnego CSS.

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.

Łączenie wielu plików PDF

ZetPDF nie dostarcza pomocnika PdfMerger.MergeFiles() jednowierszowego. Scalanie śledzi ten sam wzór co PDFsharp (któremuZetPDFprzypomina): otwórz każdy wejściowy za pomocą PdfReader, a następnie przenieś strony do wyjściowego PdfDocument i Save(). Ilustracyjny wrapper poniżej odzwierciedla powierzchnięIronPDF dla porównania; w prawdziwym kodzieZetPDFpiszesz ręczną pętlę.

MetodaZetPDF(ilustracja — brak wbudowanego łączenia PDF):

//ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        //ZetPDFhas no built-in PdfMerger — illustrative call only.
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
//ZetPDFis NOT on NuGet — install via SDK ZIP from https://zetpdf.com/download/
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        //ZetPDFhas no built-in PdfMerger — illustrative call only.
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
Imports ZetPDF
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        ' ZetPDFhas no built-in PdfMerger — illustrative call only.
        Dim merger As New PdfMerger()
        Dim files As New List(Of String) From {"document1.pdf", "document2.pdf"}
        merger.MergeFiles(files, "merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

Podejście IronPDF:

// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var pdfs = new List<PdfDocument>
        {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        };
        var merged = PdfDocument.Merge(pdfs);
        merged.SaveAs("merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic

Module Program
    Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim pdfs As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        }
        Dim merged As PdfDocument = PdfDocument.Merge(pdfs)
        merged.SaveAs("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

IronPDF ładuje dokumenty jako obiekty PdfDocument przy użyciu PdfDocument.FromFile(), a następnie scala je za pomocą statycznej metody PdfDocument.Merge(). Podejście zorientowane na obiekt pozwala na dodatkowe operacje na scalonym dokumencie przed jego zapisaniem.

Zapoznaj się z dokumentacją dotyczącą łączenia plików PDF, aby poznać dodatkowe opcje łączenia.

Rysowanie oparte na współrzędnych a HTML

W przypadku programistów korzystających z istniejącego koduZetPDFwykorzystującego grafikę opartą na współrzędnych ścieżka migracji obejmuje konwersję poleceń rysowania do formatu HTML/CSS.

Podejście oparte na współrzędnych ZetPDF:

using ZetPDF;
using ZetPDF.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");
using ZetPDF;
using ZetPDF.Drawing;

var document = new PdfDocument();
var page = document.AddPage();
page.Width = XUnit.FromMillimeter(210);
page.Height = XUnit.FromMillimeter(297);

var graphics = XGraphics.FromPdfPage(page);
var titleFont = new XFont("Arial", 24, XFontStyle.Bold);
var bodyFont = new XFont("Arial", 12);

graphics.DrawString("Company Report", titleFont, XBrushes.Navy,
    new XPoint(50, 50));
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black,
    new XPoint(50, 80));
graphics.DrawString("Generated: " + DateTime.Now.ToString(), bodyFont, XBrushes.Gray,
    new XPoint(50, 100));

document.Save("report.pdf");
Imports ZetPDF
Imports ZetPDF.Drawing

Dim document As New PdfDocument()
Dim page = document.AddPage()
page.Width = XUnit.FromMillimeter(210)
page.Height = XUnit.FromMillimeter(297)

Dim graphics = XGraphics.FromPdfPage(page)
Dim titleFont As New XFont("Arial", 24, XFontStyle.Bold)
Dim bodyFont As New XFont("Arial", 12)

graphics.DrawString("Company Report", titleFont, XBrushes.Navy, New XPoint(50, 50))
graphics.DrawString("This is the introduction paragraph.", bodyFont, XBrushes.Black, New XPoint(50, 80))
graphics.DrawString("Generated: " & DateTime.Now.ToString(), bodyFont, XBrushes.Gray, New XPoint(50, 100))

document.Save("report.pdf")
$vbLabelText   $csharpLabel

Podejście IronPDF HTML:

using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
using IronPdf;

var html = $@"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("report.pdf");
Imports IronPdf

Dim html As String = $"
<html>
<head>
    <style>
        body {{font-family: Arial, sans-serif; padding: 50px;}}
        h1 {{color: navy;}}
        .date {{color: gray;}}
    </style>
</head>
<body>
    <h1>Company Report</h1>
    <p>This is the introduction paragraph.</p>
    <p class='date'>Generated: {DateTime.Now}</p>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

PodejścieZetPDFwymaga tworzenia obiektów czcionek, obliczania dokładnych pozycji pikseli oraz ręcznego zarządzania kontekstem graficznym. Podejście IronPDF wykorzystuje standardowy HTML i CSS, które są już znane programistom stron internetowych — czcionki, kolory i układ są obsługiwane za pomocą znanych właściwości CSS.

Dokumentacja APIZetPDFdo IronPDF

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

ZetPDF IronPDF
new PdfDocument() new ChromePdfRenderer()
document.AddPage() Automatyczne
XGraphics.FromPdfPage(page) N/A (HTML/CSS zamiast)
graphics.DrawString() Elementy tekstowe HTML
graphics.DrawImage() tag
graphics.DrawLine() CSS borders /
graphics.DrawRectangle() CSS border + div
new XFont() CSS font-family
XBrushes.Black CSS color
document.Save() pdf.SaveAs()
PdfReader.Open() PdfDocument.FromFile()
(no native HTML-to-PDF) ChromePdfRenderer.RenderHtmlAsPdf()
(no native URL-to-PDF) ChromePdfRenderer.RenderUrlAsPdf()
(manual page-copy loop) PdfDocument.Merge()

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

Problem 1: Układ oparty na współrzędnych

ZetPDF: Wszystko wymaga dokładnych współrzędnych X,Y z ręcznym pozycjonowaniem.

Rozwiązanie: Zastosuj układ płynny HTML/CSS. W razie potrzeby do pozycjonowania absolutnego użyj CSS:

.positioned-element {
    position: absolute;
    top: 100px;
    left: 50px;
}

Problem 2: Zarządzanie obiektami czcionek

ZetPDF: Utwórz obiekty XFont dla każdej wariacji czcionki.

Rozwiązanie: Użyj właściwości CSS font-family — czcionki są obsługiwane automatycznie:

<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>
<style>
    body { font-family: Arial, sans-serif; }
    h1 { font-family: 'Times New Roman', serif; font-size: 24px; font-weight: bold; }
</style>
HTML

Problem 3: Obsługa kolorów

ZetPDF: Użyj obiektów XBrushes i kolorów.

Rozwiązanie: Użyj standardowych kolorów CSS:

.header { color: navy; background-color: #f5f5f5; }
.warning { color: rgb(255, 0, 0); }

Problem 4: Ręczne podziały stron

ZetPDF: Śledź pozycję Y i ręcznie twórz nowe strony, gdy zawartość się przepełnia.

Rozwiązanie:IronPDF obsługuje automatyczne podziały stron. Aby uzyskać precyzyjną kontrolę, użyj CSS:

.section { page-break-after: always; }
.keep-together { page-break-inside: avoid; }

Problem 5: Tworzenie tabel

ZetPDF: Wymaga ręcznego rysowania prostokątów, linii i pozycjonowania tekstu.

Rozwiązanie: Użyj standardowych tabel HTML ze stylizacją CSS:

<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>
<table style="border-collapse: collapse; width: 100%;">
    <tr>
        <th style="border: 1px solid black; padding: 8px;">Header</th>
    </tr>
    <tr>
        <td style="border: 1px solid black; padding: 8px;">Data</td>
    </tr>
</table>
HTML

Lista kontrolna migracji ZetPDF

Zadania przed migracją

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

grep -r "using ZetPDF" --include="*.cs" .
grep -r "XGraphics\|XFont\|XBrushes\|PdfReader" --include="*.cs" .
grep -r "using ZetPDF" --include="*.cs" .
grep -r "XGraphics\|XFont\|XBrushes\|PdfReader" --include="*.cs" .
SHELL

Dokument zawierający kod rysowania oparty na współrzędnych, który wymaga konwersji do formatu HTML. Zwróć uwagę na wzorce użycia czcionek i kolorów. Należy odwzorować struktury układu na odpowiedniki w HTML.

Zadania związane z aktualizacją kodu

  1. Usuń ręczne odniesienie do ZetPDF.dll z .csproj
  2. Zainstaluj pakiet IronPDF NuGet (dotnet add package IronPdf)
  3. Zaktualizuj importy przestrzeni nazw z ZetPDF do IronPdf
  4. Zastąp wszelkie wewnętrzne osłonki HTML-do-PDF wokółZetPDFz ChromePdfRenderer.RenderHtmlAsPdf()
  5. Zastąp wszelkie osłonki URL-do-PDF z ChromePdfRenderer.RenderUrlAsPdf()
  6. Zastąp ręczne pętle scalania kopiowania stron z PdfDocument.Merge()
  7. Konwertuj wywołania DrawString() na HTML elementy tekstowe
  8. Konwertuj XFont na CSS font-family
  9. Zastąp XBrushes kolorami CSS
  10. Dodaj inicjalizację licencji IronPDF przy uruchomieniu (IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";)

Testy po migracji

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

  • Porównaj wygląd końcowy, aby upewnić się, że jest on zgodny z oryginałem lub lepszy
  • Sprawdź, czy czcionki wyświetlają się zgodnie z oczekiwaniami przy zastosowaniu stylów CSS
  • Sprawdź, czy podziały stron działają poprawnie przy automatycznej paginacji
  • Sprawdź, czy obrazy są prawidłowo rozmieszczone i wyświetlane
  • Testowe operacje łączenia plików PDF dają poprawny wynik
  • Sprawdź, czy wszystkie istniejące funkcje działają z nową implementacją

Kluczowe korzyści z migracji do IronPDF

Przejście zZetPDFna IronPDF zapewnia kilka kluczowych korzyści:

Nowoczesny silnik renderujący Chromium:IronPDF wykorzystuje Chromium do konwersji HTML na PDF, zapewniając pełną obsługę CSS3 i JavaScript ES2024. Nowoczesne frameworki i responsywne projekty wyświetlają się poprawnie.

Tworzenie treści opartych na HTML: Programiści stron internetowych mogą wykorzystać swoje dotychczasowe umiejętności w zakresie HTML i CSS. Nie ma potrzeby uczenia się interfejsów API rysowania opartych na współrzędnych ani zarządzania obiektami czcionek.

Automatyczny układ i paginacja: zawijanie tekstu, podziały stron i układ przepływu odbywają się automatycznie. Nie należy ręcznie obliczać pozycji elementów.

Uproszczone API: Wywołania pojedynczych metod dla typowych operacji. PdfDocument.Merge() zastępuje złożone wzorce obsługi ścieżki pliku.

Aktywny Rozwoj: Regularna publikacja IronPDF utrzymuje biblioteke aktualna z nowoczesnymi wersjami .NET, w przeciwienstwie do braku publicznych aktywnosci wydawniczychZetPDFod 2021 roku.

Kompleksowy zestaw funkcji: Wbudowane znakowanie wodne, podpisy cyfrowe, zgodnosc z PDF/A i zaawansowane funkcje manipulacji PDF, ktorych brak w dokumentowanej powierzchni ZetPDF.

Zwróć uwagęPDFSharp iZetPDFsą zarejestrowanymi znakami towarowymi ich właścicieli. Ta strona nie jest powiązana, popierana ani sponsorowana przezZetPDFani empira Software GmbH. 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