Didn’t find what you were looking for?
Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von zetpdf zu IronPDF
VIDEOS

Konvertieren von HTML in PDF mit C# in .NET 10 | IronPDF

Curtis Chau
Curtis Chau
Aktualisiert:

ZetPDF (zetpdf.com) ist ein kommerziell lizenziertes .NET PDF SDK, dessen API-Oberfläche PDFsharp sehr ähnlich ist — bis zu dem Punkt, an dem die PDFsharp-Gemeinschaft gefragt hat, ob es sich um einen geschlossenen Fork handelt. Der Anbieter vermarktet es als proprietärer, 100% managed-code Motor. ZetPDFwird nicht über NuGet distribuiert — die Installation erfolgt über einen ZIP-Download von https://zetpdf.com/download/ — und das Projekt zeigt seit 2021 keine öffentliche Veröffentlichungsaktivität. Die Preisgestaltung ist unbefristet: $299 Einzelprojekt / $449 Multi / $599 OEM.

Diese Anleitung bietet einen Migrationspfad von ZetPDFzu IronPDF, mit Schritt-für-Schritt-Anleitungen, Codevergleichen und Beispielen for .NET-Entwickler, die diese Umstellung bewerten.

Warum von ZetPDFmigrieren

ZetPDFs PDFsharp-ähnliche, koordinatenzeichnende API hat architektonische Einschränkungen, die moderne Dokumentenerstellungsworkflows einschränken. Häufige Gründe, warum Teams eine Migration in Betracht ziehen:

Koordinatenbasierte API: ZetPDFpositioniert jedes Element über exakte XGraphics Koordinaten. Manuelle Positionierung schafft Wartungsaufwand, wenn sich Anforderungen ändern.

Kein CSS-Support: Kein Stilsystem — Schriftarten und Farben werden pro Element im Code verwaltet.

Kein JavaScript Rendering: Dynamische Webinhalte können während der PDF-Generierung nicht gerendert oder JavaScript ausgeführt werden.

Kein nativer HTML-zu-PDF: ZetPDFs dokumentierte Feature-Liste enthält keinen HTML-zu-PDF- oder URL-zu-PDF-Konverter; Das Rendern erfolgt ausschließlich auf niedriger Ebene über XGraphics Zeichnungen.

Kein NuGet, eingestellte Veröffentlichungen: Die Distribution erfolgt über einen Anbieter-ZIP von https://zetpdf.com/download/, ohne öffentliche Veröffentlichungsaktivität seit 2021.

Manuelle Seitenumbrüche: Seitenüberlauf muss manuell berechnet und verwaltet werden, anstatt über automatische Paginierung.

Textmessung erforderlich: Manuelle Berechnung für Textumbruch fügt Entwicklungsaufwand hinzu.

Das grundsätzliche Problem

ZetPDF und PDFsharp zwingen Sie, jedes Element mit exakten Koordinaten zu positionieren:

// ZetPDF: Handbuch 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: Handbuch 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: Handbuch 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 verwendet HTML/CSS- die Layout-Engine kümmert sich um alles:

// 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: Funktionsvergleich

Das Verständnis der architektonischen Unterschiede hilft technischen Entscheidungsträgern, die Investition in die Migration zu bewerten:

Feature ZetPDF IronPDF
API-Stil PDFsharp-geformte XGraphics Zeichnungen Hochwertiges HTML-Rendering
HTML-zu-PDF-Konvertierung Nicht in der dokumentierten Feature-Liste Ja (Vollständiges Chromium)
Kommerzielle Lizenz Ja, unbefristet ($299 / $449 / $599) Ja
Verteilung ZIP-Download (kein NuGet-Paket) NuGet (IronPdf)
Letzte öffentliche Aktivität Keine Veröffentlichungen seit 2021 gelistet Aktiv, häufige Veröffentlichungen
CSS-Unterstützung Nein Vollständig CSS3
JavaScript Nein Vollständiger ES2024
Automatisches Layout Nein Ja
Automatische Seitenumbrüche Nein Ja
Tabellen Handzeichnung HTML <table>
Kopf-/Fußzeilen Handbuch HTML/CSS
Wasserzeichen Manueller Code Eingebaut
PDFs zusammenführen Kein erstklassiger Helfer Ja
PDFs aufteilen Kein erstklassiger Helfer Ja
Digitale Signaturen Nein Ja
PDF/A Nein Ja

Schnellstart: ZetPDFzu IronPDF Migration

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Ersetzen Sie den ZetPDF-Verweis durch das IronPDF NuGet-Paket

ZetPDF ist nicht auf NuGet – es wird als ZIP von https://zetpdf.com/download/bereitgestellt und wird durch Hinzufügen von ZetPDF.dll zu Ihrem Projekt referenziert. Nach der Migration entfernen Sie diesen DLL-Verweis und installieren IronPDF von 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

Schritt 2: Namespaces aktualisieren

Ersetzen Sie ZiePDF-Namespaces durch den IronPDF-Namespace:

// 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

Schritt 3: Lizenz initialisieren

Hinzufügen der Lizenzinitialisierung beim Start der Anwendung:

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

Beispiele für die Code-Migration

Konvertierung von HTML in PDF

ZetPDFs veröffentlichte Feature-Liste enthält keinen nativen HTML-zu-PDF- oder URL-zu-PDF-Konverter — seine dokumentierte Oberfläche deckt PDF-Ansicht/Druck, Anmerkungen, AES256-Verschlüsselung, Formularfelder und Textextraktion ab. Der Pseudo-Wrapper unten ist illustrativ, wie Teams typischerweise einen HTML-zu-PDF-Einstiegspunkt auf ZetPDFaufsetzen; In der Praxis fällt die Arbeit auf einen externen HTML-Renderer oder auf niedrigstufiges XGraphics Zeichnen zurück.

ZetPDF Ansatz (veranschaulichend – kein natives HTML-zu-PDF):

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

class Program
{
    static void Main()
    {
        //Neinnative HtmlToPdfConverter exists in ZetPDF— 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()
    {
        //Neinnative HtmlToPdfConverter exists in ZetPDF— 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()
        ' Neinnative 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

IronPDF-Ansatz:

// 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 stellt ChromePdfRenderer mit RenderHtmlAsPdf() bereit, welches ein PdfDocument Objekt zurückgibt – Sie können es in eine Datei speichern, Binärdaten abrufen oder zusätzliche Operationen durchführen, bevor Sie speichern.

Für fortgeschrittene HTML-zu-PDF-Szenarien siehe den HTML-zu-PDF-Konvertierungsleitfaden.

Konvertierung von URLs zu PDF

ZetPDF hat auch keinen nativen URL-zu-PDF-Konverter; HTML/URL-Rendering ist nicht Teil der dokumentierten Feature-Liste. Praktische Migrationspfade paaren ZetPDFtypischerweise mit einem externen HTML-Renderer oder ziehen eine Bibliothek auf Chromium-Basis wie IronPDF in Betracht.

ZetPDF-Ansatz (illustrativ — kein nativer URL-zu-PDF):

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

class Program
{
    static void Main()
    {
        //Neinnative ConvertUrlToPdf exists in ZetPDF— 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()
    {
        //Neinnative ConvertUrlToPdf exists in ZetPDF— 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()
        ' Neinnative ConvertUrlToPdf exists in ZetPDF— 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

IronPDF-Ansatz:

// 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

IronPDF's RenderUrlAsPdf() auf ChromePdfRenderer nutzt eine vollständige Chromium-Rendering-Engine für das Erfassen von Webseiten einschließlich JavaScript-Ausführung und moderner CSS.

In der URL zur PDF-Dokumentation finden Sie Informationen zur Authentifizierung und zu benutzerdefinierten Kopfzeilenoptionen.

Mehrere PDFs zusammenführen

ZetPDF liefert keinen einzeiligen PdfMerger.MergeFiles() Helfer. Das Zusammenführen folgt demselben Muster wie PDFsharp (dem ZetPDFähnelt): Öffnen Sie jede Eingabe mit PdfReader, dann schleifen Sie Seiten in eine Ausgabe-PdfDocument und Save(). Der illustrative Wrapper unten spiegelt die IronPDF-Oberfläche zum Vergleich wider; in echtem ZetPDF-Code schreiben Sie die manuelle Schleife.

ZetPDF-Ansatz (illustrativ — kein eingebauter PdfMerger):

// 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

IronPDF-Ansatz:

// 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 lädt Dokumente als PdfDocument Objekte mit PdfDocument.FromFile(), dann werden sie mit der statischen PdfDocument.Merge() Methode zusammengeführt. Der objektorientierte Ansatz ermöglicht zusätzliche Operationen am zusammengeführten Dokument vor dem Speichern.

In der PDF-Zusammenführungsdokumentation finden Sie weitere Zusammenführungsoptionen.

Koordinatenbasiertes Zeichnen vs. HTML

Für Entwickler mit vorhandenem ZetPDF-Code, der koordinatenbasierte Grafiken verwendet, beinhaltet der Migrationspfad die Konvertierung von Zeichenbefehlen in HTML/CSS.

ZetPDF koordinatenbasierter Ansatz:

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

IronPDF HTML-Ansatz:

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

Der ZetPDF-Ansatz erfordert die Erstellung von Schriftobjekten, die Berechnung genauer Pixelpositionen und die manuelle Verwaltung des Grafikkontexts. Der IronPDF-Ansatz verwendet Standard-HTML und CSS, die Webentwickler bereits kennen - Schriftarten, Farben und Layout werden über bekannte CSS-Eigenschaften gehandhabt.

ZetPDFAPI zu IronPDF Mapping Referenz

Dieses Mapping beschleunigt die Migration, indem es direkte API-Entsprechungen aufzeigt:

ZetPDF IronPDF
new PdfDocument() new ChromePdfRenderer()
document.AddPage() Automatisch
XGraphics.FromPdfPage(page) N/A (HTML/CSS stattdessen)
graphics.DrawString() HTML-Textelemente
graphics.DrawImage() <img> tag
graphics.DrawLine() CSS-Ränder / <hr>
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()

Gängige Migrationsprobleme und Lösungen

Ausgabe 1: Koordinatenbasiertes Layout

ZetPDF: Alles erfordert genaue X,Y-Koordinaten mit manueller Positionierung.

Lösung: Verwenden Sie HTML/CSS-Flow-Layout. Verwenden Sie bei Bedarf CSS für die absolute Positionierung:

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

Ausgabe 2: Font-Objekt-Verwaltung

ZetPDF: Erstellen Sie XFont Objekte für jede Schriftartvariation.

Lösung: Verwenden Sie CSS font-family - Schriftarten werden automatisch behandelt:

<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

Ausgabe 3: Farbverarbeitung

ZetPDF: Verwenden Sie XBrushes und Farbobjekte.

Lösung: Verwenden Sie Standard-CSS-Farben:

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

Ausgabe 4: Manuelle Seitenumbrüche

ZetPDF: Verfolgen Sie die Y-Position und erstellen Sie manuell neue Seiten, wenn der Inhalt überläuft.

Lösung:IronPDF sorgt für automatische Seitenumbrüche. Verwenden Sie CSS zur eindeutigen Steuerung:

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

Ausgabe 5: Tabellenerstellung

ZetPDF: Erfordert manuelles Zeichnen von Rechtecken, Linien und Textpositionierung.

Lösung: Verwenden Sie Standard-HTML-Tabellen mit CSS-Styling:

<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

ZetPDF-Migrations-Checkliste

Vor der Migration anfallende Aufgaben

Überprüfen Sie Ihre Codebasis, um die Verwendung von ZetPDFzu identifizieren:

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

Dokumentieren Sie koordinatenbasierten Zeichencode, der in HTML konvertiert werden muss. Beachten Sie die Verwendung von Schriftarten und Farben. Layout-Strukturen auf HTML-Äquivalente abbilden.

Aufgaben der Code-Aktualisierung

  1. Entfernen Sie den manuellen ZetPDF.dll Verweis aus Ihrem .csproj
  2. Installieren Sie das IronPDF NuGet-Paket (dotnet add package IronPdf)
  3. Aktualisieren Sie die Namensraumimporte von ZetPDF zu IronPdf
  4. Ersetzen Sie jegliche eigenen HTML-zu-PDF-Wrapper um ZetPDFmit ChromePdfRenderer.RenderHtmlAsPdf()
  5. Ersetzen Sie jegliche URL-zu-PDF-Wrapper mit ChromePdfRenderer.RenderUrlAsPdf()
  6. Ersetzen Sie manuelle Seitenkopie-Zusammenführungsschleifen mit PdfDocument.Merge()
  7. Konvertieren Sie DrawString() Aufrufe in HTML-Text-Elemente
  8. Konvertieren Sie XFont in CSS font-family
  9. Ersetzen Sie XBrushes mit CSS-Farben
  10. Fügen Sie die IronPDF Lizenzinitialisierung beim Start hinzu (IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";)

Post-Migrationstests

Überprüfen Sie diese Aspekte nach der Migration:

  • Vergleichen Sie die visuelle Ausgabe, um sicherzustellen, dass das Erscheinungsbild übereinstimmt oder verbessert wird
  • Überprüfen Sie, ob die Schriftarten mit CSS-Styling wie erwartet dargestellt werden
  • Testen Sie, ob die Seitenumbrüche bei der automatischen Paginierung korrekt erfolgen
  • Überprüfen Sie, ob die Bilder richtig positioniert und angezeigt werden
  • Testen Sie, ob PDF-Zusammenführungsvorgänge eine korrekte Ausgabe erzeugen
  • Bestätigen Sie, dass alle vorhandenen Funktionen mit der neuen Implementierung funktionieren

Die wichtigsten Vorteile der Migration zu IronPDF

Der Wechsel von ZetPDFzu IronPDF bietet mehrere entscheidende Vorteile:

Moderne Chromium-Rendering-Engine:IronPDF verwendet Chromium für die HTML-zu-PDF-Konvertierung und gewährleistet so die volle Unterstützung von CSS3 und ES2024 JavaScript . Moderne Frameworks und responsive Designs werden korrekt wiedergegeben.

HTML-basierte Inhaltserstellung: Webentwickler können ihre vorhandenen HTML- und CSS-Kenntnisse nutzen. Es besteht keine Notwendigkeit, koordinatenbasierte Zeichen-APIs zu erlernen oder Schriftobjekte zu verwalten.

Automatisches Layout und Paginierung: Textumbruch, Seitenumbrüche und Layoutfluss erfolgen automatisch. Keine manuelle Berechnung von Elementpositionen.

Vereinfachte API: Aufrufe einzelner Methoden für gängige Operationen. PdfDocument.Merge() ersetzt komplexe Datei-Pfadbearbeitungsmuster.

Aktive Entwicklung: IronPDFs regelmäßiger Release-Rhythmus hält die Bibliothek im Einklang mit modernen .NET-Versionen, im Gegensatz zu ZetPDFs fehlender öffentlicher Veröffentlichungsaktivität seit 2021.

Umfassende Funktionsvielfalt: Eingebaute Wasserzeichen, digitale Signaturen, PDF/A-Konformität und erweiterte PDF-Bearbeitungsfunktionen, die in der dokumentierten Oberfläche von ZetPDFnicht vorhanden sind.

Hinweis:PDFSharp und ZetPDFsind eingetragene Marken ihrer jeweiligen Eigentümer. Diese Seite ist nicht mit ZetPDFoder empira Software GmbH verbunden, genehmigt oder gesponsert. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron-Support-Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an