Migrieren von PDFreactor zu IronPDF in C#

PDFreactor kennenlernen

PDFreactor ist ein leistungsstarker HTML-zu-PDF-Konvertierungsserver, der sich in verschiedene Plattformen integrieren lässt. Als kommerzielle Lösung nutzt PDFreactor seine proprietäre Technologie, um HTML- und CSS-Inhalte in hochwertige PDF-Dokumente zu konvertieren. Zu den bemerkenswerten Eigenschaften von PDFreactor gehört, dass es eine Vielzahl von CSS-Eigenschaften unterstützt, was es zu einem guten Kandidaten für komplexes Layout-Rendering macht.

Die Tatsache, dass PDFreactor auf Java basiert, stellt jedoch in .NET-Umgebungen eine gewisse Herausforderung dar, da die nicht-native Natur von Java den Einsatz und die Integration erschweren kann. Die Abhängigkeit von Java führt zu zusätzlichem Aufwand in .NET-Anwendungen und erfordert oft zusätzliche Integrationsarbeit.

Das Java-Abhängigkeitsproblem

Die Architektur von PDFreactor bringt einige Herausforderungen in .NET-Umgebungen mit sich:

1. Java Runtime erforderlich: Die Installation von JRE/JDK ist auf allen Servern notwendig.

2. Serverarchitektur: Läuft als separater Dienst und erfordert zusätzliche Infrastruktur. Als serverbasierte Lösung benötigt PDFreactor für jede Konvertierung einen REST-API-Aufruf.

3. Komplexe Bereitstellung: Die Verwaltung von Java-Abhängigkeiten in einem primär auf .NET basierenden Ökosystem kann die Einrichtung verkomplizieren und die Wartungskosten erhöhen. Zwei Laufzeiten (Java + .NET) zur Verwaltung in CI/CD-Pipelines.

4. Interprozesskommunikation: Die Kommunikation über REST-API oder Sockets führt zu Latenz. Jede PDF-Konvertierung erfordert einen HTTP-Roundtrip zum Server.

5. Separates Lizenzmanagement: Die Lizenz ist an die Serverinstanz und nicht an die Anwendung gebunden. Die Lizenzierung pro Server ist an die Java-Service-Instanz gebunden.

6. Ressourcenisolation: Trennung von Prozessspeicher und CPU-Verwaltung. Zusätzlicher Server zur Überwachung, Skalierung und Wartung.

PDFreactor vs IronPDF Vergleich

Im Gegensatz zu PDFreactor präsentiert sich IronPDF als native .NET-Bibliothek, die speziell für die nahtlose Integration in .NET-Projekte ohne externe Abhängigkeiten wie Java entwickelt wurde.IronPDF verwendet eine gebündelte Chromium-Rendering-Engine, die es ermöglicht, HTML mit nur wenigen Codezeilen in PDF zu konvertieren.

Für Teams, die die Einführung von .NET 10 und C# 14 bis 2025 und 2026 planen, bietet IronPDF eine native .NET-Lösung, die die Komplexität von Java-Servern eliminiert und gleichzeitig ein umfassendes PDF-Lifecycle-Management bietet.

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 PDFreactor NuGet packages
dotnet remove package PDFreactor.NET
dotnet remove package PDFreactor.Native.Windows.x64

# Stop PDFreactorserver service (if running locally)
# Windows: net stop PDFreactor
# Linux: sudo systemctl stop pdfreactor

# Install IronPDF
dotnet add package IronPdf

# Remove PDFreactor NuGet packages
dotnet remove package PDFreactor.NET
dotnet remove package PDFreactor.Native.Windows.x64

# Stop PDFreactorserver service (if running locally)
# Windows: net stop PDFreactor
# Linux: sudo systemctl stop pdfreactor

# Install IronPDF
dotnet add package IronPdf

Lizenz-Konfiguration

PDFreactor (serverbasiert):

// License configured on server via config file or command line
// Client connects to licensed server
var pdfReactor = new PDFreactor("http://pdfreactor-server:9423");

// License configured on server via config file or command line
// Client connects to licensed server
var pdfReactor = new PDFreactor("http://pdfreactor-server:9423");

' License configured on server via config file or command line
' Client connects to licensed server
Dim pdfReactor = New PDFreactor("http://pdfreactor-server:9423")

IronPDF (Anwendungsebene):

// One-time setup at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

// One-time setup at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY";

' One-time setup at application startup
IronPdf.License.LicenseKey = "YOUR-IRONPDF-LICENSE-KEY"

PDFreactor-Verwendung identifizieren

# Find PDFreactorusage
grep -r "PDFreactor\|RealObjects\|Configuration.*Document" --include="*.cs" .

# Find CSS Paged Mediarules to convert
grep -r "@page\|counter(page)\|counter(pages)" --include="*.cs" --include="*.css" .

# Find PDFreactorusage
grep -r "PDFreactor\|RealObjects\|Configuration.*Document" --include="*.cs" .

# Find CSS Paged Mediarules to convert
grep -r "@page\|counter(page)\|counter(pages)" --include="*.cs" --include="*.css" .

Namensraumänderungen

// Before: PDFreactor
using RealObjects.PDFreactor;
using System.IO;

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

// Before: PDFreactor
using RealObjects.PDFreactor;
using System.IO;

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

Imports IronPdf
Imports IronPdf.Rendering
Imports System.IO

Kernklassen-Zuordnungen

Zuordnungen von Konfigurationseigenschaften

Neue Funktionen, die in PDFreactor nicht verfügbar sind

Beispiel 1: Konvertierung von HTML-Strings in PDF

Vor (PDFreactor):

// NuGet: Install-Package PDFreactor.Native.Windows.x64
using RealObjects.PDFreactor;
using System.IO;

class Program
{
    static void Main()
    {
        PDFreactorpdfReactor = new PDFreactor();

        string html = "<html><body><h1>Hello World</h1></body></html>";

        Configuration config = new Configuration();
        config.Document = html;

        Result result = pdfReactor.Convert(config);

        File.WriteAllBytes("output.pdf", result.Document);
    }
}

// NuGet: Install-Package PDFreactor.Native.Windows.x64
using RealObjects.PDFreactor;
using System.IO;

class Program
{
    static void Main()
    {
        PDFreactorpdfReactor = new PDFreactor();

        string html = "<html><body><h1>Hello World</h1></body></html>";

        Configuration config = new Configuration();
        config.Document = html;

        Result result = pdfReactor.Convert(config);

        File.WriteAllBytes("output.pdf", result.Document);
    }
}

Imports RealObjects.PDFreactor
Imports System.IO

Class Program
    Shared Sub Main()
        Dim pdfReactor As New PDFreactor()

        Dim html As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim config As New Configuration()
        config.Document = html

        Dim result As Result = pdfReactor.Convert(config)

        File.WriteAllBytes("output.pdf", result.Document)
    End Sub
End Class

Nach (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        string 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();

        string 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 As String = "<html><body><h1>Hello World</h1></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("output.pdf")
    End Sub
End Class

Der grundlegende Unterschied ist das Architekturmuster. PDFreactor erfordert die Erstellung einer PDFreactor Instanz (die eine Verbindung zum Java-Server herstellt), eines separaten Configuration Objekts zur Speicherung von Einstellungen und HTML-Inhalten, den Aufruf von Convert(), der ein Result Objekt zurückgibt, und schließlich das Schreiben der result.Document Bytes in eine Datei mithilfe von File.WriteAllBytes().

IronPDF vereinfacht dies, indem es ein ChromePdfRenderer erstellt, RenderHtmlAsPdf() direkt mit der HTML-Zeichenkette aufruft und die integrierte Methode SaveAs() auf dem zurückgegebenen PdfDocument anwendet. Keine Serververbindung, kein Konfigurationsobjekt, keine manuelle Byte-Verarbeitung. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: Konvertierung von URL in PDF

Vor (PDFreactor):

// NuGet: Install-Package PDFreactor.Native.Windows.x64
using RealObjects.PDFreactor;
using System.IO;

class Program
{
    static void Main()
    {
        PDFreactorpdfReactor = new PDFreactor();

        Configuration config = new Configuration();
        config.Document = "https://www.example.com";

        Result result = pdfReactor.Convert(config);

        File.WriteAllBytes("webpage.pdf", result.Document);
    }
}

// NuGet: Install-Package PDFreactor.Native.Windows.x64
using RealObjects.PDFreactor;
using System.IO;

class Program
{
    static void Main()
    {
        PDFreactorpdfReactor = new PDFreactor();

        Configuration config = new Configuration();
        config.Document = "https://www.example.com";

        Result result = pdfReactor.Convert(config);

        File.WriteAllBytes("webpage.pdf", result.Document);
    }
}

Imports RealObjects.PDFreactor
Imports System.IO

Class Program
    Shared Sub Main()
        Dim pdfReactor As New PDFreactor()

        Dim config As New Configuration()
        config.Document = "https://www.example.com"

        Dim result As Result = pdfReactor.Convert(config)

        File.WriteAllBytes("webpage.pdf", result.Document)
    End Sub
End Class

Nach (IronPDF):

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");

        pdf.SaveAs("webpage.pdf");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");

        pdf.SaveAs("webpage.pdf");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")

        pdf.SaveAs("webpage.pdf")
    End Sub
End Class

PDFreactor verwendet die gleiche config.Document Eigenschaft sowohl für HTML-Strings als auch für URLs und bestimmt den Typ automatisch.IronPDF bietet explizite Methoden: RenderHtmlAsPdf() für HTML-Strings und RenderUrlAsPdf() für URLs. Dieser explizite Ansatz verbessert die Klarheit des Codes und die IntelliSense-Unterstützung. Erfahren Sie mehr in unseren Tutorials.

Beispiel 3: Kopf- und Fußzeilen mit Seitenzahlen

Vor (PDFreactor):

// NuGet: Install-Package PDFreactor.Native.Windows.x64
using RealObjects.PDFreactor;
using System.IO;

class Program
{
    static void Main()
    {
        PDFreactorpdfReactor = new PDFreactor();

        string html = "<html><body><h1>Document with Headers</h1><p>Content here</p></body></html>";

        Configuration config = new Configuration();
        config.Document = html;
        config.AddUserStyleSheet("@page { @top-center { content: 'Header Text'; } @bottom-center { content: 'Page ' counter(page); } }");

        Result result = pdfReactor.Convert(config);

        File.WriteAllBytes("document.pdf", result.Document);
    }
}

// NuGet: Install-Package PDFreactor.Native.Windows.x64
using RealObjects.PDFreactor;
using System.IO;

class Program
{
    static void Main()
    {
        PDFreactorpdfReactor = new PDFreactor();

        string html = "<html><body><h1>Document with Headers</h1><p>Content here</p></body></html>";

        Configuration config = new Configuration();
        config.Document = html;
        config.AddUserStyleSheet("@page { @top-center { content: 'Header Text'; } @bottom-center { content: 'Page ' counter(page); } }");

        Result result = pdfReactor.Convert(config);

        File.WriteAllBytes("document.pdf", result.Document);
    }
}

Imports RealObjects.PDFreactor
Imports System.IO

Module Program
    Sub Main()
        Dim pdfReactor As New PDFreactor()

        Dim html As String = "<html><body><h1>Document with Headers</h1><p>Content here</p></body></html>"

        Dim config As New Configuration()
        config.Document = html
        config.AddUserStyleSheet("@page { @top-center { content: 'Header Text'; } @bottom-center { content: 'Page ' counter(page); } }")

        Dim result As Result = pdfReactor.Convert(config)

        File.WriteAllBytes("document.pdf", result.Document)
    End Sub
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.TextHeader = new TextHeaderFooter()
        {
            CenterText = "Header Text"
        };

        renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
        {
            CenterText = "Page {page}"
        };

        string html = "<html><body><h1>Document with Headers</h1><p>Content here</p></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.TextHeader = new TextHeaderFooter()
        {
            CenterText = "Header Text"
        };

        renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
        {
            CenterText = "Page {page}"
        };

        string html = "<html><body><h1>Document with Headers</h1><p>Content here</p></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.TextHeader = New TextHeaderFooter() With {
            .CenterText = "Header Text"
        }

        renderer.RenderingOptions.TextFooter = New TextHeaderFooter() With {
            .CenterText = "Page {page}"
        }

        Dim html As String = "<html><body><h1>Document with Headers</h1><p>Content here</p></body></html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)

        pdf.SaveAs("document.pdf")
    End Sub
End Module

Dieses Beispiel zeigt den größten Unterschied in der Syntax. PDFreactor verwendet die CSS Paged MediaSyntax mit @page Regeln, @bottom-center Regionen und counter(page) für Seitenzahlen, die über AddUserStyleSheet() eingefügt werden.

IronPDF verwendet eine native .NET API mit TextHeaderFooter-Objekten, die RenderingOptions.TextHeader und RenderingOptions.TextFooter zugewiesen sind. Seitenzahlen verwenden den Platzhalter {page} anstelle des CSS-Platzhalters counter(page). Beachten Sie, dass IronPDF außerdem den Import des Namespace IronPdf.Rendering für Header-/Footer-Klassen erfordert.

Kein Server erforderlich

IronPDF wird prozessintern ausgeführt - es muss kein Java-Server konfiguriert werden:

// PDFreactor: Requires server connection
var pdfReactor = new PDFreactor("http://localhost:9423");

// IronPDF: No server URL needed
var renderer = new ChromePdfRenderer();

// PDFreactor: Requires server connection
var pdfReactor = new PDFreactor("http://localhost:9423");

// IronPDF: No server URL needed
var renderer = new ChromePdfRenderer();

' PDFreactor: Requires server connection
Dim pdfReactor = New PDFreactor("http://localhost:9423")

' IronPDF: No server URL needed
Dim renderer = New ChromePdfRenderer()

CSS Paged Mediazu IronPDFAPI

Ersetzen Sie die CSS-Regeln @page durch RenderingOptions:

// PDFreactorCSS: @page { @bottom-center { content: 'Page ' counter(page); } }
//IronPDFequivalent:
renderer.RenderingOptions.TextFooter = new TextHeaderFooter 
{ 
    CenterText = "Page {page}" 
};

// PDFreactorCSS: @page { @bottom-center { content: 'Page ' counter(page); } }
//IronPDFequivalent:
renderer.RenderingOptions.TextFooter = new TextHeaderFooter 
{ 
    CenterText = "Page {page}" 
};

' PDFreactorCSS: @page { @bottom-center { content: 'Page ' counter(page); } }
' IronPDFequivalent:
renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .CenterText = "Page {page}"
}

Seitennummern-Platzhalter-Syntax

// PDFreactorCSS: counter(page)
// IronPDF: {page}

// PDFreactorCSS: counter(pages)  
// IronPDF: {total-pages}

// PDFreactorCSS: counter(page)
// IronPDF: {page}

// PDFreactorCSS: counter(pages)  
// IronPDF: {total-pages}

' PDFreactorCSS: counter(page)
' IronPDF: {page}

' PDFreactorCSS: counter(pages)
' IronPDF: {total-pages}

Änderung der Ergebnisbehandlung

Konfiguration + Ergebnismuster wird direkt zu PdfDocument:

// PDFreactor: Configuration → Convert → Result → bytes
Result result = pdfReactor.Convert(config);
byte[] bytes = result.Document;
File.WriteAllBytes("output.pdf", bytes);

// IronPDF: Direct PdfDocument with built-in methods
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or: byte[] bytes = pdf.BinaryData;

// PDFreactor: Configuration → Convert → Result → bytes
Result result = pdfReactor.Convert(config);
byte[] bytes = result.Document;
File.WriteAllBytes("output.pdf", bytes);

// IronPDF: Direct PdfDocument with built-in methods
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");
// Or: byte[] bytes = pdf.BinaryData;

' PDFreactor: Configuration → Convert → Result → bytes
Dim result As Result = pdfReactor.Convert(config)
Dim bytes As Byte() = result.Document
File.WriteAllBytes("output.pdf", bytes)

' IronPDF: Direct PdfDocument with built-in methods
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")
' Or: Dim bytes As Byte() = pdf.BinaryData

Margeneinheiten ändern

PDFreactor verwendet Zeichenketten;IronPDF arbeitet mit Millimetern:

// PDFreactor: config.PageMargins.Top = "1in"
// IronPDF: renderer.RenderingOptions.MarginTop = 25.4  // 1 inch in mm

// PDFreactor: config.PageMargins.Top = "1in"
// IronPDF: renderer.RenderingOptions.MarginTop = 25.4  // 1 inch in mm

' PDFreactor: config.PageMargins.Top = "1in"
' IronPDF: renderer.RenderingOptions.MarginTop = 25.4  ' 1 inch in mm

PDF-Zusammenführung

var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

var pdf1 = PdfDocument.FromFile("document1.pdf");
var pdf2 = PdfDocument.FromFile("document2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");

Dim pdf1 = PdfDocument.FromFile("document1.pdf")
Dim pdf2 = PdfDocument.FromFile("document2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Wasserzeichen

pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>");

pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>");

pdf.ApplyWatermark("<h2 style='color:red;'>CONFIDENTIAL</h2>")

Textextraktion

string text = pdf.ExtractAllText();

string text = pdf.ExtractAllText();

Dim text As String = pdf.ExtractAllText()

Passwortschutz

pdf.SecuritySettings.UserPassword = "userpassword";
pdf.SecuritySettings.OwnerPassword = "ownerpassword";

pdf.SecuritySettings.UserPassword = "userpassword";
pdf.SecuritySettings.OwnerPassword = "ownerpassword";

pdf.SecuritySettings.UserPassword = "userpassword"
pdf.SecuritySettings.OwnerPassword = "ownerpassword"

Vor der Migration

• Erfassung aller PDFreactor-Nutzungen im Quellcode
• Alle verwendeten CSS-Regeln für Seitenmedien dokumentieren
• Notieren Sie alle Konfigurationseinstellungen (Ränder, Seitengröße, JavaScript)
• Speicherung des IronPDF-Lizenzschlüssels (Umgebungsvariablen empfohlen)
• Zuerst mit der IronPDF Testlizenz testen

Paketänderungen

• Entfernen Sie das NuGet Paket PDFreactor.NET
• Entfernen Sie das NuGet Paket PDFreactor.Native.Windows.x64
• Installieren Sie das NuGet Paket IronPdf: dotnet add package IronPdf

Code-Änderungen

• Namespace-Importe aktualisieren (using RealObjects.PDFreactor; → using IronPdf;)
• Fügen Sie using IronPdf.Rendering; für Kopf-/Fußzeilenklassen hinzu
• Ersetzen Sie die Klasse PDFreactor durch ChromePdfRenderer
• Konvertiere Configuration Objekte in RenderingOptions Eigenschaften
• Ersetzen Sie config.Document = html durch renderer.RenderHtmlAsPdf(html)
• Ersetzen Sie config.Document = url durch renderer.RenderUrlAsPdf(url)
• Ersetzen Sie File.WriteAllBytes(path, result.Document) durch pdf.SaveAs(path)
• CSS-Regeln vom Typ @page in Objekte vom Typ TextFooter konvertieren
• Seitenzahl-Platzhalter aktualisieren (counter(page) → {page})
• Umrechnung von Randeinheiten von Zeichenketten in Millimeter

Infrastruktur-Migration

• Java-Laufzeitvoraussetzung entfernen
• PDFreactor-Server außer Betrieb nehmen
• Docker-/Bereitstellungskonfigurationen aktualisieren
• CI/CD-Pipelines aktualisieren

Nach der Migration

• Testen Sie, ob die Qualität der PDF-Ausgabe den Erwartungen entspricht
• Überprüfung der Darstellung von Kopf- und Fußzeile
• Überprüfen Sie die JavaScript Ausführung, falls verwendet
• Fügen Sie bei Bedarf neue Funktionen hinzu (Zusammenführung, Wasserzeichen, Sicherheit).