Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. Migrationsleitfäden
  4. migration von zetpdf zu IronPDF
MIGRATIONSLEITFäDEN

Wie man von ZetPDF zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

ZetPDF ist eine kommerziell lizenzierte PDF-Bibliothek für C#-Anwendungen, die auf der Grundlage der weit verbreiteten Open-Source-Bibliothek PDFSharp aufgebaut ist. ZetPDF bietet zwar kommerzielle Unterstützung und grundlegende Funktionen zur PDF-Bearbeitung, hat aber erhebliche Einschränkungen von seiner PDFSharp-Grundlage geerbt. Die Bibliothek basiert vor allem auf koordinatenbasierter Grafikprogrammierung und bietet im Vergleich zu modernen Alternativen nur begrenzte HTML-zu-PDF-Konvertierungsmöglichkeiten.

Dieser Leitfaden bietet einen vollständigen Migrationspfad von ZetPDF zu IronPDF mit Schritt-für-Schritt-Anleitungen, Code-Vergleichen und praktischen Beispielen für professionelle .NET-Entwickler, die diesen Übergang evaluieren.

Warum von ZetPDF migrieren

ZetPDF ist eine Abspaltung von PDFSharp und erbt die gleichen architektonischen Einschränkungen, die seine Effektivität für moderne Workflows zur Dokumentenerstellung einschränken. Zu den wichtigsten Gründen, warum Entwicklerteams eine Migration in Betracht ziehen, gehören:

Koordinatenbasierte API: ZetPDF zwingt Entwickler dazu, jedes Element mit exakten Koordinaten zu positionieren. Die komplexe manuelle Positionierung der einzelnen Elemente stellt eine Herausforderung für die Wartung dar, wenn sich die Anforderungen ändern.

Eingeschränkte CSS-Unterstützung: Fehlendes Styling-System bedeutet manuelle Schriftart- und Farbverwaltung für jedes Element.

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

Begrenztes Alleinstellungsmerkmal: Im Vergleich zur kostenlosen direkten Nutzung von PDFSharp bietet ZetPDF nur wenige überzeugende Gründe, die eine kommerzielle Lizenzierung erforderlich machen.

Manuelle Seitenumbrüche: Der Seitenüberlauf muss manuell berechnet und verwaltet werden, anstatt sich auf die automatische Seitennummerierung zu verlassen.

Textmessung erforderlich: Die manuelle Berechnung des Textumbruchs verursacht zusätzlichen Entwicklungsaufwand.

Das grundsätzliche Problem

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

// ZetPDF: Manual 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: Manual 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: Manual 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
Basierend auf PDFSharp Yes No
HTML-zu-PDF-Konvertierung Beschränkt Yes (Vollständiges Chromium)
Kommerzielle Lizenz Yes, Perpetual Yes
Open Source Foundation PDFSharp (MIT-Lizenz) Chromium-basiert
CSS-Unterstützung No Vollständig CSS3
JavaScript No Vollständiger ES2024
Automatisches Layout No Yes
Automatische Seitenumbrüche No Yes
Tabellen Handzeichnung HTML <table>
Kopf-/Fußzeilen Handbuch HTML/CSS
Wasserzeichen Manueller Code Eingebaut
PDFs zusammenführen Beschränkt Yes
PDFs aufteilen Beschränkt Yes
Digitale Signaturen No Yes
PDF/A No Yes
Einfachheit und Benutzerfreundlichkeit Mäßig Hoch

Schnellstart: ZetPDF zu IronPDF Migration

Mit diesen grundlegenden Schritten kann die Migration sofort beginnen.

Schritt 1: Ersetzen des NuGet-Pakets

ZetPDF entfernen:

# Remove ZetPDF
dotnet remove package ZetPDF
# Remove ZetPDF
dotnet remove package ZetPDF
SHELL

IronPDF installieren:

# Install IronPDF
dotnet add package IronPdf
# Install IronPDF
dotnet add package IronPdf
SHELL

Schritt 2: Namespaces aktualisieren

Ersetzen Sie die ZetPDF-Namensräume durch den IronPDF-Namensraum:

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

Der HTML-zu-PDF-Vorgang demonstriert die API-Unterschiede zwischen diesen .NET-PDF-Bibliotheken.

ZetPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var htmlContent = "<html><body><h1>Hello World</h1></body></html>";
        converter.ConvertHtmlToPdf(htmlContent, "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}
// NuGet: Install-Package ZetPDF
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        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

Module Program
    Sub Main()
        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 Module
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        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()
    {
        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

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim htmlContent = "<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 Class
$vbLabelText   $csharpLabel

ZetPDF verwendet HtmlToPdfConverter mit ConvertHtmlToPdf(), das direkt in einen Dateipfad schreibt.IronPDF bietet ChromePdfRenderer mit RenderHtmlAsPdf(), das ein PdfDocument-Objekt zurückgibt und Ihnen so mehr Flexibilität bei der Ausgabe bietet – Sie können in einer Datei speichern, Binärdaten abrufen oder vor dem Speichern zusätzliche Operationen durchführen.

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

Konvertierung von URLs zu PDF

Die URL-zu-PDF-Konvertierung zeigt die Musterunterschiede deutlich auf.

ZetPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        converter.ConvertUrlToPdf(url, "webpage.pdf");
        Console.WriteLine("PDF from URL created successfully");
    }
}
// NuGet: Install-Package ZetPDF
using ZetPDF;
using System;

class Program
{
    static void Main()
    {
        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

Module Program
    Sub Main()
        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 Module
$vbLabelText   $csharpLabel

IronPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        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()
    {
        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

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim url = "https://www.example.com"
        Dim pdf = renderer.RenderUrlAsPdf(url)
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("PDF from URL created successfully")
    End Sub
End Class
$vbLabelText   $csharpLabel

ZetPDF verwendet dieselbe Klasse HtmlToPdfConverter wie ConvertUrlToPdf().IronPDF bietet RenderUrlAsPdf() auf ChromePdfRenderer an, das eine vollständige Chromium-Rendering-Engine für die genaue Erfassung von Webseiten einschließlich JavaScript Ausführung und modernem CSS nutzt.

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

Mehrere PDFs zusammenführen

Bei der Zusammenführung von PDF-Dokumenten zeigen sich erhebliche API-Unterschiede in der Handhabung von Dokumenten.

ZetPDF-Ansatz:

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

class Program
{
    static void Main()
    {
        var merger = new PdfMerger();
        var files = new List<string> { "document1.pdf", "document2.pdf" };
        merger.MergeFiles(files, "merged.pdf");
        Console.WriteLine("PDFs merged successfully");
    }
}
// NuGet: Install-Package ZetPDF
using ZetPDF;
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        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()
        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()
    {
        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()
    {
        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()
        Dim pdfs As New List(Of PdfDocument) From {
            PdfDocument.FromFile("document1.pdf"),
            PdfDocument.FromFile("document2.pdf")
        }
        Dim merged = PdfDocument.Merge(pdfs)
        merged.SaveAs("merged.pdf")
        Console.WriteLine("PDFs merged successfully")
    End Sub
End Module
$vbLabelText   $csharpLabel

ZetPDF verwendet eine spezielle Klasse PdfMerger, die mit Dateipfaden mit MergeFiles() arbeitet.IronPDF lädt Dokumente als PdfDocument Objekte mithilfe von PdfDocument.FromFile() und führt sie dann mit der statischen Methode PdfDocument.Merge() zusammen. Dieser 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.

ZetPDF API 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) Nicht anwendbar
graphics.DrawString() HTML-Textelemente
graphics.DrawImage() <img> Tag
graphics.DrawLine() CSS-Rahmen
graphics.DrawRectangle() CSS border + div
new XFont() CSS font-family
XBrushes.Black CSS color
document.Save() pdf.SaveAs()
PdfReader.Open() PdfDocument.FromFile()
HtmlToPdfConverter ChromePdfRenderer
ConvertHtmlToPdf() RenderHtmlAsPdf()
ConvertUrlToPdf() RenderUrlAsPdf()
PdfMerger 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 Schriftvariante.

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 färben Sie Objekte ein.

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 ZetPDF zu identifizieren:

grep -r "using ZetPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|PdfMerger\|XGraphics" --include="*.cs" .
grep -r "using ZetPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|PdfMerger\|XGraphics" --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. ZetPDF NuGet-Paket entfernen
  2. IronPDF NuGet-Paket installieren
  3. Namespace-Importe von ZetPDF auf IronPdf aktualisieren
  4. Ersetzen Sie HtmlToPdfConverter durch ChromePdfRenderer
  5. Konvertiere ConvertHtmlToPdf()-Aufrufe in RenderHtmlAsPdf() + SaveAs()
  6. Konvertiere ConvertUrlToPdf()-Aufrufe in RenderUrlAsPdf() + SaveAs()
  7. Ersetzen Sie PdfMerger.MergeFiles() durch PdfDocument.Merge()
  8. Konvertieren Sie DrawString()-Aufrufe in HTML-Textelemente.
  9. Konvertiere XFont in CSS font-family
  10. Ersetzen Sie XBrushes durch CSS-Farben
  11. IronPDF-Lizenzinitialisierung beim Start hinzufügen

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 ZetPDF zu 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 Dateipfadverarbeitungsmuster.

Aktive Weiterentwicklung: Da die Verbreitung von .NET 10 und C# 14 bis 2026 zunimmt, gewährleisten die regelmäßigen Updates von IronPDF die Kompatibilität mit aktuellen und zukünftigen .NET Versionen.

Umfassender Funktionsumfang: Integrierte Wasserzeichen, digitale Signaturen, PDF/A-Konformität und erweiterte PDF-Bearbeitungsfunktionen, die ZetPDF nicht bietet.

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