Wie man Text und Bereiche in PDF-Dateien mit C# redigiert

PeachPDFverstehen

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 PeachPDFeine 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 PeachPDFzu einer attraktiven Wahl für Projekte, die nach einer leichtgewichtigen, verwalteten Bibliothekslösung suchen.

Trotz seines Potenzials befindet sich PeachPDFnoch in der Entwicklung, was sowohl spannende Möglichkeiten als auch bemerkenswerte Einschränkungen aufzeigt. PeachPDFbesticht 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 von einem einzelnen Entwickler betreute, vor-1.0 .NET-Bibliothek (neueste 0.7.26, Oktober 2025) unter BSD-3-Clause, veröffentlicht von jhaygood86. Es fehlt die Reife, die Funktionen und die Unterstützung etablierter Lösungen. Hauptgründe für die Migration:

1. Prä-1.0 Funktionssatz: PeachPDFhat keine integrierten digitalen Signaturen, keine PDF/A-Konformität, kein OCR, keine Formularfüllung oder seitenspezifische Kopf-/Fußzeilen-API.

2. Keine JavaScript-Engine: PeachPDFist ein Layout-Renderer, der auf PeachPDF.PdfSharpCore basiert und kein Browser ist; Skripte und komplexe Grid/Flexbox-Layouts werden nicht ausgeführt.

3. Nur net8.0: das Paket zielt auf net8.0 ab; ältere .NET Framework / .NET 6-Projekte müssen aufgerüstet werden oder eine andere Bibliothek wählen.

4. Kleine Community: ein einzelner GitHub-Betreuer, eingeschränkte Dokumentation, eingeschränkte Beispiele.

5. Kein Unternehmenssupport: keine kommerzielle Unterstützung oder SLA-Optionen.

Vergleich zwischen PeachPDFund IronPDF

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. Seine professionelle Support-Struktur bietet schnelle Lösungswege für Probleme, auf die Entwickler stoßen.

Für Teams, die modernes .NET übernehmen, bietet IronPDF umfassende Funktionen und aktive Wartung, um langfristige Stabilität über aktuelle .NET-Versionen hinweg zu unterstützen.

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

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"

PeachPDF-Verwendung identifizieren

# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "PdfGenerator\|PdfGenerateConfig\|GeneratePdf" --include="*.cs" .

# Audit PeachPDFusage in codebase
grep -r "using PeachPDF" --include="*.cs" .
grep -r "PdfGenerator\|PdfGenerateConfig\|GeneratePdf" --include="*.cs" .

Namensraumänderungen

// Before: PeachPDF
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before: PeachPDF
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO
Imports System.Threading.Tasks

Kern-API-Zuordnungen

Beispiel 1: Konvertierung von HTML-Strings in PDF

Vor (PeachPDF):

using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            PageOrientation = PageOrientation.Portrait
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("output.pdf");
        document.Save(stream);
    }
}

using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = "<html><body><h1>Hello World</h1></body></html>";

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            PageOrientation = PageOrientation.Portrait
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("output.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.PdfSharpCore
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim config As New PdfGenerateConfig With {
            .PageSize = PageSize.Letter,
            .PageOrientation = PageOrientation.Portrait
        }

        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(html, config)

        Using stream As FileStream = File.Create("output.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

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

Dieses Beispiel zeigt den grundlegenden Unterschied zwischen den beiden Bibliotheken. PeachPDFtrennt einen PdfGenerator (Engine) von einem PdfGenerateConfig (Einstellungen), bietet eine asynchrone GeneratePdf-Methode an und gibt ein Dokument zurück, dessen Save-Methode in einen Stream schreibt.IronPDF verwendet ChromePdfRenderer mit RenderHtmlAsPdf(), das ein PdfDocument-Objekt mit einer eingebauten SaveAs()-Methode zurückgibt.

Ein praktischer Vorteil des IronPDF-Ansatzes: das PdfDocument-Objekt kann weiter bearbeitet werden (z.B. Hinzufügen von Wasserzeichen, Zusammenführen, Sicherheitseinstellungen), bevor es gespeichert wird, und SaveAs nimmt einen Dateipfad direkt, ohne einen Zwischen-FileStream. Siehe die HTML-zu-PDF-Dokumentation für weitere Beispiele.

Beispiel 2: Konvertierung von URL in PDF

Vor (PeachPDF):

// PeachPDFhas no ConvertUrl-style helper; URL fetching is wired via
// HttpClientNetworkAdapter and passing null HTML so the engine fetches the page.
using PeachPDF;
using PeachPDF.Network;
using PeachPDF.PdfSharpCore;
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var http = new HttpClient();

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            NetworkAdapter = new HttpClientNetworkAdapter(http, new Uri("https://www.example.com"))
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(null, config);

        using var stream = File.Create("webpage.pdf");
        document.Save(stream);
    }
}

// PeachPDFhas no ConvertUrl-style helper; URL fetching is wired via
// HttpClientNetworkAdapter and passing null HTML so the engine fetches the page.
using PeachPDF;
using PeachPDF.Network;
using PeachPDF.PdfSharpCore;
using System;
using System.IO;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var http = new HttpClient();

        var config = new PdfGenerateConfig
        {
            PageSize = PageSize.Letter,
            NetworkAdapter = new HttpClientNetworkAdapter(http, new Uri("https://www.example.com"))
        };

        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(null, config);

        using var stream = File.Create("webpage.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.Network
Imports PeachPDF.PdfSharpCore
Imports System
Imports System.IO
Imports System.Net.Http
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim http As New HttpClient()

        Dim config As New PdfGenerateConfig With {
            .PageSize = PageSize.Letter,
            .NetworkAdapter = New HttpClientNetworkAdapter(http, New Uri("https://www.example.com"))
        }

        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(Nothing, config)

        Using stream = File.Create("webpage.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

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

PeachPDF hat keinen erstklassigen URL-zu-PDF-Helfer; Sie setzen NetworkAdapter in der Konfiguration auf ein HttpClientNetworkAdapter und übergeben null HTML, sodass die Engine die Seite abruft.IronPDF stellt RenderUrlAsPdf(url) direkt zur Verfügung. Da PeachPDFkein JavaScriptausführt, werden Single-Page-Apps und dynamische Inhalte typischerweise nicht korrekt über den Netzwerkadapterweg gerendert; Der Chromium-Engine von IronPDF verarbeitet moderne CSS und JavaScript. Erfahren Sie mehr in unseren Tutorials.

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

Vor (PeachPDF):

// PeachPDFv0.7.x has no header/footer API. The closest approach is
// to embed the header/footer markup directly inside the source HTML
// using CSS positioning.
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = @"
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>";

        var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("document.pdf");
        document.Save(stream);
    }
}

// PeachPDFv0.7.x has no header/footer API. The closest approach is
// to embed the header/footer markup directly inside the source HTML
// using CSS positioning.
using PeachPDF;
using PeachPDF.PdfSharpCore;
using System.IO;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        var html = @"
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>";

        var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
        var generator = new PdfGenerator();
        var document = await generator.GeneratePdf(html, config);

        using var stream = File.Create("document.pdf");
        document.Save(stream);
    }
}

Imports PeachPDF
Imports PeachPDF.PdfSharpCore
Imports System.IO
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Dim html As String = "
            <html><head><style>
              .header { position: fixed; top: 0; left: 0; right: 0; text-align:center; }
              .footer { position: fixed; bottom: 0; left: 0; right: 0; text-align:center; }
            </style></head>
            <body>
              <div class='header'>My Header</div>
              <h1>Document Content</h1>
              <div class='footer'>Footer text</div>
            </body></html>"

        Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
        Dim generator As New PdfGenerator()
        Dim document = Await generator.GeneratePdf(html, config)

        Using stream = File.Create("document.pdf")
            document.Save(stream)
        End Using
    End Function
End Module

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

Dieses Beispiel zeigt einen wichtigen architektonischen Unterschied. PeachPDFbietet keine Header/Footer-API auf PdfGenerator oder PdfGenerateConfig an, daher muss das Seitengerüst im Quell-HTML mit CSS-Positionierung enthalten sein.IronPDF verwendet HtmlHeaderFooter-Objekte, die RenderingOptions.HtmlHeader und RenderingOptions.HtmlFooter zugewiesen sind, und trennt das Seitengerüst vom Dokumentinhalt.

Der IronPDF-Ansatz bietet auch Eigenschaften wie MaxHeight zur Steuerung der Header-/Footer-Größe und unterstützt die Platzhalter {page} und {total-pages} für Seitenzahlen.

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

Generator/Renderer Klassenänderung

PeachPDF verwendet ein PdfGenerator + PdfGenerateConfig-Paar;IronPDF verwendet ein einzelnes ChromePdfRenderer:

// PeachPDF
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();

// IronPDF
var renderer = new ChromePdfRenderer();

// PeachPDF
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();

// IronPDF
var renderer = new ChromePdfRenderer();

' PeachPDF
Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
Dim generator As New PdfGenerator()

' IronPDF
Dim renderer As New ChromePdfRenderer()

Async vs Sync und Rückgabewert

PeachPDFs GeneratePdf ist nur asynchron und gibt ein Dokument zurück, dessen Save-Methode einen Stream benötigt. IronPDFs RenderHtmlAsPdf ist synchron (eine asynchrone Variante RenderHtmlAsPdfAsync ist ebenfalls verfügbar) und gibt ein PdfDocument zurück:

// PeachPDF: async, save to a Stream
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create("output.pdf");
document.Save(fs);

// IronPDF: synchronous PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;

// PeachPDF: async, save to a Stream
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create("output.pdf");
document.Save(fs);

// IronPDF: synchronous PdfDocument object
PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or get bytes: byte[] bytes = pdf.BinaryData;

Imports System.IO

' PeachPDF: async, save to a Stream
Dim document = Await generator.GeneratePdf(html, config)
Using fs As FileStream = File.Create("output.pdf")
    document.Save(fs)
End Using

' IronPDF: synchronous PdfDocument object
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
' Or get bytes: Dim bytes As Byte() = pdf.BinaryData

Kopf-/Fußzeile Eigenschaftsänderung

// PeachPDF: no header/footer API -- embed in source HTML
// (e.g. via CSS position:fixed)

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

// PeachPDF: no header/footer API -- embed in source HTML
// (e.g. via CSS position:fixed)

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

' PeachPDF: no header/footer API -- embed in source HTML
' (e.g. via CSS position:fixed)

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

Änderung von Methodennamen

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

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

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

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

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

Ausgabe 1: Verschiedene API-Muster

Problem: PeachPDFtrennt PdfGenerator (Engine) von PdfGenerateConfig (Einstellungen) und ist asynchron;IronPDF verwendet einen ChromePdfRenderer, der einen PdfDocument synchron zurückgibt.

Lösung:

// PeachPDFpattern (async, stream-out)
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create(path);
document.Save(fs);

//IronPDF pattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);

// PeachPDFpattern (async, stream-out)
var config = new PdfGenerateConfig { PageSize = PageSize.Letter };
var generator = new PdfGenerator();
var document = await generator.GeneratePdf(html, config);
using var fs = File.Create(path);
document.Save(fs);

//IronPDF pattern
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs(path);

Imports System.IO

' PeachPDFpattern (async, stream-out)
Dim config As New PdfGenerateConfig With {.PageSize = PageSize.Letter}
Dim generator As New PdfGenerator()
Dim document = Await generator.GeneratePdf(html, config)
Using fs As FileStream = File.Create(path)
    document.Save(fs)
End Using

' IronPDF pattern
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs(path)

Problem 2: Speichern zielt auf einen Stream, nicht auf einen Pfad

Problem: PeachPDFs document.Save(stream) akzeptiert nur einen Stream; IronPDFs pdf.SaveAs(path) akzeptiert einen Pfad-String.

Lösung: Verwenden Sie pdf.SaveAs("file.pdf") direkt in IronPDF statt ein FileStream zu öffnen.

Problem 3: Keine bestehenden PDF-Operationen

Problem: PeachPDFist nur HTML zu PDF; es kann vorhandene PDFs nicht laden, zusammenführen, teilen oder bearbeiten.

Lösung: Ersetzen Sie diese Operationen durch IronPDFs PdfDocument.FromFile, PdfDocument.Merge, und pdf.AppendPdf, sobald migriert.

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 PeachPDF NuGet-Paket
• Installieren Sie das IronPdf NuGet-Paket: dotnet add package IronPdf

Code-Änderungen

• Aktualisieren Sie die Namespace-Importe (using PeachPDF; → using IronPdf;)
• Fügen Sie using IronPdf.Rendering; für Header/Footer-Funktionalität hinzu
• Ersetzen Sie PdfGenerator + PdfGenerateConfig durch ChromePdfRenderer
• Ersetzen Sie await generator.GeneratePdf(html, config) durch renderer.RenderHtmlAsPdf(html) (oder RenderHtmlAsPdfAsync um asynchron zu bleiben)
• Ersetzen Sie HttpClientNetworkAdapter + GeneratePdf(null, config) durch renderer.RenderUrlAsPdf(url)
• Ersetzen Sie document.Save(stream) durch pdf.SaveAs(path)
• Ersetzen Sie die in HTML eingebetteten Header/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).