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

' 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

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)

' 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)

##IronPDF vs. ZetPDF: Funktionsvergleich

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

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

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

Imports IronPdf

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"

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

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");
    }
}

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

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

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");
    }
}

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

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

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");
    }
}

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

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

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")

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")

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");

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:

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;
}

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

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); }

.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; }

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

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

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.