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

Wie man von PeachPDF zu IronPDF in C# migriert

Curtis Chau
Curtis Chau
Aktualisiert:

Die Migration von PeachPDF zu IronPDF bietet Zugang zu einer PDF-Generierung auf Unternehmensniveau mit umfassenden Funktionen, aktiver Entwicklung und professionellem Support. Dieser Leitfaden bietet einen vollständigen, schrittweisen Migrationspfad, der Ihren grundlegenden HTML-zu-PDF-Workflow in eine vollwertige PDF-Lösung mit modernem Chromium-Rendering, fortschrittlichen Sicherheitsoptionen und umfangreichen Manipulationsmöglichkeiten umwandelt.

Warum von PeachPDF zu IronPDF migrieren

PeachPDF verstehen

PeachPDF ist ein relativ neuer Anbieter im .NET-Ökosystem, der für Entwickler entwickelt wurde, die HTML in PDF konvertieren müssen. Als Bibliothek verspricht PeachPDF eine reine .NET-Implementierung, die sich dadurch auszeichnet, dass sie nicht auf externe Prozesse angewiesen ist und sich nahtlos in alle Plattformen integrieren lässt, die .NET unterstützen. Diese Eigenschaft macht PeachPDF zu einer attraktiven Wahl für Projekte, die nach einer leichtgewichtigen, verwalteten Bibliothekslösung suchen.

Trotz seines Potenzials befindet sich PeachPDF noch in der Entwicklung, was sowohl spannende Möglichkeiten als auch bemerkenswerte Einschränkungen aufzeigt. PeachPDF besticht durch seinen reinen .NET Core, der eine unkomplizierte Bereitstellung in verschiedenen Umgebungen verspricht. Allerdings bedeutet dies auch eine begrenzte Akzeptanz, mit einer kleineren Benutzerbasis und einem Community-getriebenen Support.

Die Beschränkungen von PeachPDF

PeachPDF ist eine relativ neue, weniger bekannte PDF-Bibliothek, der es an Reife, Funktionen und Unterstützung gegenüber etablierten Lösungen mangelt. Hauptgründe für die Migration:

  1. Begrenzter Funktionsumfang: PeachPDF bietet keine erweiterten Funktionen wie digitale Signaturen, PDF/A-Konformität und ausgefeilte Textextraktion.

  2. Kleine Community: Begrenzte Dokumentation, Beispiele und Unterstützung durch die Community. Bei einer kleineren Benutzerbasis ist die Unterstützung durch die Community möglicherweise spärlich, was es schwierig macht, Hilfe zu erhalten oder umfassende Dokumentation zu finden.

  3. Ungewisse Zukunft: Neue Bibliotheken ohne etablierte Erfolgsbilanz bergen ein Akzeptanzrisiko.

  4. Grundlegende HTML-Unterstützung: Eingeschränkte CSS- und JavaScriptRendering-Funktionen.

  5. Kein Enterprise Support: Keine Professional Unterstützung oder SLA-Optionen.

Vergleich zwischen PeachPDF und IronPDF

Merkmal/Charakteristik PeachPDF IronPDF
Implementierung Reines .NET Verwaltet mit breiter Kompatibilität
Lizenz Offene Quelle (BSD-3-Klausel) Kommerziell
Benutzerbasis Klein Groß (40M+ Downloads)
Unterstützung Community-gesteuert Professionell mit engagiertem Support
HTML-Rendering Basic Vollständiges Chromium
CSS-Unterstützung Beschränkt Vollständig CSS3
JavaScript Basic Vollständiger ES2024
Digitale Signaturen Nein Ja
PDF/A-Konformität Nein Ja
Dokumentation Beschränkt Umfangreiche
Entwicklungsstatus In der Entwicklung Ausgereifte, stabile Version

IronPDF zeichnet sich durch einen breiteren Funktionsumfang aus und unterstützt nicht nur die Konvertierung von HTML in PDF, sondern auch OCR, Wasserzeichen und andere erweiterte Funktionen. Die professionelle Support-Struktur ist ein definitiver Vorteil, da sie schnelle Lösungen für Probleme der Entwickler bietet.

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet IronPDF umfassende Funktionen und aktive Wartung, die langfristige Stabilität und Kompatibilität mit modernen .NET Frameworks gewährleisten.

Bevor Sie beginnen

Voraussetzungen

  1. .NET -Umgebung: .NET Framework 4.6.2+ oder .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. NuGet -Zugriff: Möglichkeit zur Installation von NuGet -Paketen
  3. IronPDF -Lizenz: Ihren Lizenzschlüssel erhalten Sie unter IronPDF.

NuGet-Paketänderungen

# Remove PeachPDF
dotnet remove package PeachPDF

# Install IronPDF
dotnet add package IronPdf
# Remove PeachPDF
dotnet remove package PeachPDF

# Install IronPDF
dotnet add package IronPdf
SHELL

Lizenz-Konfiguration

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

PeachPDF-Verwendung identifizieren

# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|Convert\|ConvertUrl" --include="*.cs" .
# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "HtmlToPdfConverter\|Convert\|ConvertUrl" --include="*.cs" .
SHELL

Komplette API-Referenz

Namensraumänderungen

// Before: PeachPDF
using PeachPDF;
using System.IO;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
// Before: PeachPDF
using PeachPDF;
using System.IO;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO
$vbLabelText   $csharpLabel

Kern-API-Zuordnungen

PeachPDF IronPDF
new HtmlToPdfConverter() new ChromePdfRenderer()
converter.Convert(html) renderer.RenderHtmlAsPdf(html)
converter.ConvertUrl(url) renderer.RenderUrlAsPdf(url)
converter.Header renderer.RenderingOptions.HtmlHeader
converter.Footer renderer.RenderingOptions.HtmlFooter
File.WriteAllBytes(path, pdf) pdf.SaveAs(path)
pdf (byte[]) pdf.BinaryData
PdfReader.LoadFromFile(path) PdfDocument.FromFile(path)
document.MergeWith(other) PdfDocument.Merge(pdfs)

Beispiele für die Code-Migration

Beispiel 1: Konvertierung von HTML-Strings in PDF

Vor (PeachPDF):

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("output.pdf", pdf);
    }
}
Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = converter.Convert(html)
        File.WriteAllBytes("output.pdf", pdf)
    End Sub
End Class
$vbLabelText   $csharpLabel

Nach (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var html = "<html><body><h1>Hello World</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim html = "<html><body><h1>Hello World</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

Dieses Beispiel verdeutlicht den grundlegenden Unterschied zwischen den beiden Bibliotheken. PeachPDF verwendet HtmlToPdfConverter mit einer Convert() Methode, die einen byte[] zurückgibt, für deren Speicherung File.WriteAllBytes() erforderlich ist.IronPDF verwendet ChromePdfRenderer mit RenderHtmlAsPdf(), das ein PdfDocument-Objekt mit einer eingebauten SaveAs()-Methode zurückgibt.

Die wichtigsten Vorteile des Ansatzes von IronPDF: Das PdfDocument-Objekt kann vor dem Speichern weiter bearbeitet werden (Hinzufügen von Wasserzeichen, Zusammenführen, Sicherheitseinstellungen), während das Byte-Array von PeachPDF ein endgültiges Ergebnis darstellt. Der Ansatz von IronPDF bietet eine sauberere Syntax und eine bessere Integration in moderne .NET-Anwendungen. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vor (PeachPDF):

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        var pdf = converter.ConvertUrl(url);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        var url = "https://www.example.com";
        var pdf = converter.ConvertUrl(url);
        File.WriteAllBytes("webpage.pdf", pdf);
    }
}
Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        Dim url = "https://www.example.com"
        Dim pdf = converter.ConvertUrl(url)
        File.WriteAllBytes("webpage.pdf", pdf)
    End Sub
End Class
$vbLabelText   $csharpLabel

Nach (IronPDF):

// 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");
    }
}
// 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");
    }
}
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")
    End Sub
End Class
$vbLabelText   $csharpLabel

PeachPDF verwendet ConvertUrl(), während IronPDFRenderUrlAsPdf() verwendet. Die Methodenbenennung in IronPDF ist anschaulicher - sie gibt ausdrücklich an, dass eine URL als PDF gerendert wird. Beide Bibliotheken handhaben die URL-zu-PDF-Konvertierung ähnlich, aber die vollständige Chromium-Engine von IronPDF bietet ein besseres Rendering von modernen Webseiten mit komplexem CSS und JavaScript. Erfahren Sie mehr in unseren Tutorials.

Beispiel 3: Hinzufügen von Kopf- und Fußzeilen

Vor (PeachPDF):

using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        converter.Header = "<div style='text-align:center'>My Header</div>";
        converter.Footer = "<div style='text-align:center'>Page {page}</div>";
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("document.pdf", pdf);
    }
}
using PeachPDF;
using System.IO;

class Program
{
    static void Main()
    {
        var converter = new HtmlToPdfConverter();
        converter.Header = "<div style='text-align:center'>My Header</div>";
        converter.Footer = "<div style='text-align:center'>Page {page}</div>";
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = converter.Convert(html);
        File.WriteAllBytes("document.pdf", pdf);
    }
}
Imports PeachPDF
Imports System.IO

Class Program
    Shared Sub Main()
        Dim converter = New HtmlToPdfConverter()
        converter.Header = "<div style='text-align:center'>My Header</div>"
        converter.Footer = "<div style='text-align:center'>Page {page}</div>"
        Dim html = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = converter.Convert(html)
        File.WriteAllBytes("document.pdf", pdf)
    End Sub
End Class
$vbLabelText   $csharpLabel

Nach (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>My Header</div>" };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>Page {page}</div>" };
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>My Header</div>" };
        renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() { HtmlFragment = "<div style='text-align:center'>Page {page}</div>" };
        var html = "<html><body><h1>Document Content</h1></body></html>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("document.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {.HtmlFragment = "<div style='text-align:center'>My Header</div>"}
        renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {.HtmlFragment = "<div style='text-align:center'>Page {page}</div>"}
        Dim html As String = "<html><body><h1>Document Content</h1></body></html>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("document.pdf")
    End Sub
End Module
$vbLabelText   $csharpLabel

Dieses Beispiel zeigt einen wichtigen architektonischen Unterschied. PeachPDF verwendet einfache String-Eigenschaften (converter.Header und converter.Footer) für Kopf- und Fußzeilen.IronPDF verwendet HtmlHeaderFooter Objekte, die RenderingOptions.HtmlHeader und RenderingOptions.HtmlFooter zugewiesen sind.

Der IronPDF Ansatz bietet mehr Flexibilität: HtmlHeaderFooter-Objekte können zusätzliche Eigenschaften wie MaxHeight zur Steuerung der Kopf- und Fußzeilengröße enthalten. Beachten Sie, dass beide Bibliotheken {page} als Platzhalter für die Seitenzahl verwenden.IronPDF unterstützt außerdem {total-pages} für die Gesamtzahl der Seiten.

Beachten Sie den zusätzlichen Namespace, der für IronPDF benötigt wird: using IronPdf.Rendering; wird für die Klasse HtmlHeaderFooter benötigt.

Kritische Hinweise zur Migration

Änderung der Konverterklasse

PeachPDF verwendet HtmlToPdfConverter;IronPDF verwendet ChromePdfRenderer:

// PeachPDF
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
// PeachPDF
var converter = new HtmlToPdfConverter();

// IronPDF
var renderer = new ChromePdfRenderer();
' PeachPDF
Dim converter As New HtmlToPdfConverter()

' IronPDF
Dim renderer As New ChromePdfRenderer()
$vbLabelText   $csharpLabel

Rückgabetyp ändern

PeachPDF gibt byte[] zurück;IronPDF gibt PdfDocument zurück:

// PeachPDF: Returns byte array
byte[] pdf = converter.Convert(html);
File.WriteAllBytes("output.pdf", pdf);

// IronPDF: Returns PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;
// PeachPDF: Returns byte array
byte[] pdf = converter.Convert(html);
File.WriteAllBytes("output.pdf", pdf);

// IronPDF: Returns PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;
' PeachPDF: Returns byte array
Dim pdf As Byte() = converter.Convert(html)
File.WriteAllBytes("output.pdf", pdf)

' IronPDF: Returns PdfDocument object
Dim pdfDoc As PdfDocument = renderer.RenderHtmlAsPdf(html)
pdfDoc.SaveAs("output.pdf")
' Or get bytes: Dim bytes As Byte() = pdfDoc.BinaryData
$vbLabelText   $csharpLabel

Kopf-/Fußzeile Eigenschaftsänderung

// PeachPDF: Simple string properties
converter.Header = "<div>Header</div>";
converter.Footer = "<div>Footer</div>";

// IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() 
{ 
    HtmlFragment = "<div>Header</div>" 
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() 
{ 
    HtmlFragment = "<div>Footer</div>" 
};
// PeachPDF: Simple string properties
converter.Header = "<div>Header</div>";
converter.Footer = "<div>Footer</div>";

// IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter() 
{ 
    HtmlFragment = "<div>Header</div>" 
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter() 
{ 
    HtmlFragment = "<div>Footer</div>" 
};
' PeachPDF: Simple string properties
converter.Header = "<div>Header</div>"
converter.Footer = "<div>Footer</div>"

' IronPDF: HtmlHeaderFooter objects
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div>Header</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter() With {
    .HtmlFragment = "<div>Footer</div>"
}
$vbLabelText   $csharpLabel

Änderung von Methodennamen

PeachPDF IronPDF
Convert(html) RenderHtmlAsPdf(html)
ConvertUrl(url) RenderUrlAsPdf(url)
File.WriteAllBytes() SaveAs()

Neue Funktionen nach der Migration

Nach der Umstellung auf IronPDF erhalten Sie Funktionen, die PeachPDF nicht bieten kann:

PDF-Zusammenführung

var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
var pdf1 = PdfDocument.FromFile("doc1.pdf");
var pdf2 = PdfDocument.FromFile("doc2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
CONVERTER NOT RUNNING
$vbLabelText   $csharpLabel

Wasserzeichen mit HTML

var pdf = PdfDocument.FromFile("document.pdf");
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");
pdf.SaveAs("watermarked.pdf");
var pdf = PdfDocument.FromFile("document.pdf");
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>");
pdf.SaveAs("watermarked.pdf");
Dim pdf = PdfDocument.FromFile("document.pdf")
pdf.ApplyWatermark("<div style='color: red; font-size: 48pt;'>DRAFT</div>")
pdf.SaveAs("watermarked.pdf")
$vbLabelText   $csharpLabel

Passwortschutz

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;

pdf.SaveAs("protected.pdf");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>");

pdf.SecuritySettings.OwnerPassword = "owner123";
pdf.SecuritySettings.UserPassword = "user123";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;

pdf.SaveAs("protected.pdf");
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential</h1>")

pdf.SecuritySettings.OwnerPassword = "owner123"
pdf.SecuritySettings.UserPassword = "user123"
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint

pdf.SaveAs("protected.pdf")
$vbLabelText   $csharpLabel

Digitale Signaturen

using IronPdf.Signing;

var pdf = PdfDocument.FromFile("document.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Document Approval",
    SigningLocation = "New York"
};
pdf.Sign(signature);
pdf.SaveAs("signed.pdf");
using IronPdf.Signing;

var pdf = PdfDocument.FromFile("document.pdf");
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningReason = "Document Approval",
    SigningLocation = "New York"
};
pdf.Sign(signature);
pdf.SaveAs("signed.pdf");
Imports IronPdf.Signing

Dim pdf = PdfDocument.FromFile("document.pdf")
Dim signature = New PdfSignature("certificate.pfx", "password") With {
    .SigningReason = "Document Approval",
    .SigningLocation = "New York"
}
pdf.Sign(signature)
pdf.SaveAs("signed.pdf")
$vbLabelText   $csharpLabel

Asynchrone Operationen

var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>");
pdf.SaveAs("async_output.pdf");
var renderer = new ChromePdfRenderer();
var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>");
pdf.SaveAs("async_output.pdf");
Dim renderer As New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Async PDF</h1>")
pdf.SaveAs("async_output.pdf")
$vbLabelText   $csharpLabel

Zusammenfassung des Funktionsvergleichs

Feature PeachPDF IronPDF
HTML zu PDF Basic Vollständiges Chromium
URL zu PDF Beschränkt Ja
CSS-Gitter/Flexbox Nein Ja
JavaScript Beschränkt Vollständiger ES2024
PDFs zusammenführen Ja Ja
PDFs teilen Beschränkt Ja
Wasserzeichen Beschränkt Vollständiges HTML
Kopf-/Fußzeilen Basic Vollständiges HTML
Digitale Signaturen Nein Ja
PDF/A Nein Ja
Formular ausfüllen Beschränkt Ja
Textextraktion Basic Ja
Bildextraktion Nein Ja
Async-Unterstützung Beschränkt Ja
Plattformübergreifend Unbekannt Ja

Gängige Probleme bei der Migration

Ausgabe 1: Verschiedene API-Muster

Problem: PeachPDF verwendet ein Konvertierungsmuster mit Byte-Array-Ausgabe;IronPDF verwendet ein Renderer-Muster mit PdfDocument-Ausgabe.

Lösung:

// PeachPDFpattern
var converter = new HtmlToPdfConverter();
var pdf = converter.Convert(html);
File.WriteAllBytes(path, pdf);

//IronPDFpattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);
// PeachPDFpattern
var converter = new HtmlToPdfConverter();
var pdf = converter.Convert(html);
File.WriteAllBytes(path, pdf);

//IronPDFpattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);
' PeachPDFpattern
Dim converter As New HtmlToPdfConverter()
Dim pdf = converter.Convert(html)
File.WriteAllBytes(path, pdf)

' IronPDFpattern
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(path)
$vbLabelText   $csharpLabel

Ausgabe 2: Unterschiedliche Speichermethoden

Problem: PeachPDF benötigt File.WriteAllBytes();IronPDF verfügt über integrierte SaveAs().

Lösung: Ersetzen Sie File.WriteAllBytes("path", pdf) durch pdf.SaveAs("path").

Problem: PeachPDF verwendet String-Eigenschaften;IronPDF verwendet Objekteigenschaften.

Lösung: HTML-Strings in HtmlHeaderFooter Objekte mit der Eigenschaft HtmlFragment einbetten.

Migrations-Checkliste

Vor der Migration

  • Überprüfung der PeachPDF-Nutzung im Quellcode
  • Dokumentation benutzerdefinierter Konfigurationen
  • Beachten Sie alle Header-/Footer-Implementierungen
  • Den IronPDF Lizenzschlüssel erhalten Sie unter IronPDF
  • Zuerst mit der IronPDF Testlizenz testen

Paketänderungen

  • Entfernen Sie das NuGet Paket PeachPDF
  • Installieren Sie das NuGet Paket IronPdf: dotnet add package IronPdf

Code-Änderungen

  • Namespace-Importe aktualisieren (using PeachPDF; → using IronPdf;)
  • Fügen Sie using IronPdf.Rendering; für die Kopf-/Fußzeilenfunktionalität hinzu.
  • Ersetzen Sie HtmlToPdfConverter durch ChromePdfRenderer
  • Ersetzen Sie converter.Convert(html) durch renderer.RenderHtmlAsPdf(html)
  • Ersetzen Sie converter.ConvertUrl(url) durch renderer.RenderUrlAsPdf(url)
  • Ersetzen Sie File.WriteAllBytes(path, pdf) durch pdf.SaveAs(path)
  • Ersetzen Sie Footer durch HtmlFooter Objekte
  • Lizenzinitialisierung beim Anwendungsstart hinzufügen

Nach der Migration

  • Test der HTML-Renderingqualität
  • Überprüfen der PDF-Ausgabe auf Übereinstimmung mit den Erwartungen
  • Test der Kopf-/Fußzeilendarstellung mit Seitenzahlen
  • Fügen Sie bei Bedarf neue Funktionen hinzu (Sicherheit, Wasserzeichen, Zusammenführung).
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