Die C# PDF-Bibliothek

HTML zu PDF

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

VIDEOS

Wie man HTML-Zeichenfolgen in PDF in C# rendert

Curtis Chau

Updated: 19. Juli 2026

Durch die Migration von PrinceXMLzu IronPDF wird Ihr PDF-Erzeugungsworkflow von einem externen Befehlszeilenprozess zu einer nativen .NET-Bibliothek umgewandelt. Dieser Leitfaden bietet einen vollständigen, schrittweisen Migrationspfad, der den Aufwand für die Prozessverwaltung eliminiert, die Bereitstellung vereinfacht und umfangreiche PDF-Bearbeitungsfunktionen über die Generierung hinaus bietet.

Warum von PrinceXMLzu IronPDF migrieren

PrinceXMLkennenlernen

PrinceXML ist ein hochentwickeltes Werkzeug, das sich durch seine spezielle Unterstützung der CSS Paged Media-Spezifikationen bei der Umwandlung von HTML-Inhalten in druckfertige PDF-Dokumente auszeichnet. Diese Spezialisierung ermöglicht es PrinceXML, Dokumente mit hoher Wiedergabetreue zu den beabsichtigten Druckdesigns wiederzugeben - ein wertvolles Attribut für Branchen, die ein detailliertes Druckstyling erfordern, wie z. B. das Verlagswesen oder juristische Dokumentation.

PrinceXML ist jedoch keine .NET-Bibliothek und arbeitet als separates Befehlszeilen-Tool, was die Integration für Umgebungen, die reine .NET-Lösungen bevorzugen, erschweren kann. Die Abhängigkeit von einem separaten Serverprozess führt zu einer zusätzlichen Verwaltung der Systemressourcen und einer potenziell höheren Komplexität bei der Projektbereitstellung.

Das Problem des externen Prozesses

PrinceXML wird als separates Befehlszeilenprogramm ausgeführt, was erhebliche architektonische Herausforderungen for .NET-Anwendungen mit sich bringt:

Prozessmanagement-Overhead: Externe Prozesse müssen gestartet, überwacht und beendet werden.
Keine native .NET -Integration: Kommunikation über stdin/stdout oder temporäre Dateien.
Komplexität der Bereitstellung: Erfordert die Installation von Prince auf jedem Server.
Lizenzierung Pro Server: Jede Bereitstellung benötigt eine separate Lizenz.
Schwierigkeit der Fehlerbehandlung: Textausgabe zur Fehlererkennung analysieren.
Kein Async/Await: Blockierende Aufrufe oder komplexe asynchrone Wrapper erforderlich.
Pfadabhängigkeiten: Die ausführbare Datei Prince muss im PATH oder im absoluten Pfad gefunden werden.

Vergleich zwischen PrinceXMLund IronPDF

Aspekt	PrinceXML	IronPDF
Architektur	Externer Prozess	Native .NET-Bibliothek
Integration	Befehlszeile	Direkte API
Einsatz	Auf jedem Server installieren	Einzelnes NuGet-Paket
Fehlerbehandlung	Parsen der Textausgabe	.NET-Ausnahmen
Async-Unterstützung	Handbuch Wrapper	Natives async/await
PDF-Bearbeitung	Nur Generierung	Vollständige Manipulation (Zusammenführen, Teilen, Bearbeiten)
Lizenzierung	Desktop $495 / Server $3.800; free non-commercial use with logo watermark	Pro Entwickler
Aktualisierungen	Manuelle Neuinstallation	NuGet-Aktualisierung
Fehlersuche	Schwierig	Vollständige Debugger-Unterstützung
Digitale Signaturen	Nein	Ja
Formulare	Nein	Ja
Docker-Unterstützung	Komplex	Einfach
Cloud-Funktionen	Schwierig	Einfach

IronPDF bietet mit seinen nativen .NET-Funktionen eine Alternative, die über die reine HTML-zu-PDF-Konvertierung hinausgeht und auch erweiterte PDF-Bearbeitungsaufgaben wie das Bearbeiten, Zusammenführen und digitale Signieren umfasst. Die API von IronPDF ist auf Einfachheit und Benutzerfreundlichkeit ausgelegt und ermöglicht es Entwicklern, Konvertierungen und Manipulationen mit minimalem Boilerplate-Code durchzuführen.

Für Teams, die modernes .NET übernehmen, erfordert die nahtlose Bereitstellung von IronPDF keine externen Abhängigkeiten oder Serverprozesse und erleichtert somit die Integration in das .NET-Framework.

Bevor Sie beginnen

Voraussetzungen

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

NuGet-Paketänderungen

# Install IronPDF
dotnet add package IronPdf

# Remove Prince wrapper if using one
dotnet remove package PrinceXMLWrapper

# Install IronPDF
dotnet add package IronPdf

# Remove Prince wrapper if using one
dotnet remove package PrinceXMLWrapper

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"

' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Suchen Sie nach PrinceXML-Verwendung

# Find Prince process calls
grep -r "prince" --include="*.cs" .
grep -r "Process.Start" --include="*.cs" . | grep -i prince
grep -r "@page" --include="*.css" .
grep -r "prince-" --include="*.css" .

# Find Prince process calls
grep -r "prince" --include="*.cs" .
grep -r "Process.Start" --include="*.cs" . | grep -i prince
grep -r "@page" --include="*.css" .
grep -r "prince-" --include="*.css" .

SHELL

Komplette API-Referenz

Namensraumänderungen

// Before: PrinceXML
using PrinceXML.Wrapper;
using System.Diagnostics;
using System.IO;

// After: IronPDF
using IronPdf;

// Before: PrinceXML
using PrinceXML.Wrapper;
using System.Diagnostics;
using System.IO;

// After: IronPDF
using IronPdf;

Imports IronPdf
Imports System.Diagnostics
Imports System.IO

Imports IronPdf
Imports System.Diagnostics
Imports System.IO

Zuordnung von Befehlszeilen zu Methoden

Prince Command	IronPDF-Äquivalent
`prince input.html -o output.pdf`	`renderer.RenderHtmlFileAsPdf("input.html").SaveAs("output.pdf")`
`prince --style=custom.css input.html`	CSS in HTML einbinden oder `RenderingOptions` verwenden
`prince --javascript`	`renderer.RenderingOptions.EnableJavaScript = true`
`prince --no-javascript`	`renderer.RenderingOptions.EnableJavaScript = false`
`prince --page-size=Letter`	`renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter`
`prince --page-margin=1in`	`renderer.RenderingOptions.MarginTop = 72` (72 Punkte = 1 Zoll)
`prince --encrypt`	`pdf.SecuritySettings.OwnerPassword = "..."`
`prince --user-password=pw`	`pdf.SecuritySettings.UserPassword = "pw"`
`prince --disallow-print`	`pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint`
`prince --disallow-copy`	`pdf.SecuritySettings.AllowUserCopyPasteContent = false`
`prince --baseurl=http://...`	`renderer.RenderingOptions.BaseUrl = new Uri("http://...")`
`prince --media=print`	`renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print`
`prince --media=screen`	`renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen`

CSS @page zu RenderingOptions Mapping

CSS @page-Eigenschaft	IronPDF-Äquivalent
`size: A4`	`PaperSize = PdfPaperSize.A4`
`size: Letter`	`PaperSize = PdfPaperSize.Letter`
`size: A4landscape`	`PaperSize = PdfPaperSize.A4` + `PaperOrientation = Landscape`
`margin: 2cm`	`MarginTop/Bottom/Left/Right = 56`
`margin-top: 1in`	`MarginTop = 72`
`@top-center { content: "..." }`	`HtmlHeader` mit zentriertem div
`@bottom-right { content: counter(page) }`	`HtmlFooter` mit `{page}` Platzhalter

Seitengrößenumwandlung

Größe	Punkte	Millimeter
Brief	612 x 792	216 x 279
A4	595 x 842	210 x 297
Rechtliches	612 x 1008	216 x 356
1 Zoll	72	25.4
1 cm	28.35	10

Beispiele für die Code-Migration

Beispiel 1: Konvertierung einer HTML-Datei in ein PDF-Dokument

Vor (PrinceXML):

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXML.Wrapper;
using System;

class Program
{
    static void Main()
    {
        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        prince.Convert("input.html", "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXML.Wrapper;
using System;

class Program
{
    static void Main()
    {
        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        prince.Convert("input.html", "output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

Imports PrinceXML.Wrapper
Imports System

Class Program
    Shared Sub Main()
        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        prince.Convert("input.html", "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Imports PrinceXML.Wrapper
Imports System

Class Program
    Shared Sub Main()
        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        prince.Convert("input.html", "output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Nach (IronPDF):

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlFileAsPdf("input.html");
        pdf.SaveAs("output.pdf");
        Console.WriteLine("PDF created successfully");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Dieses Beispiel verdeutlicht den grundlegenden architektonischen Unterschied. PrinceXMLerfordert die Instanziierung eines Prince Objekts mit dem vollständigen Pfad zur ausführbaren Datei ("C:\\Program Files\\Prince\\engine\\bin\\prince.exe"), dann den Aufruf von Convert() mit Eingabe- und Ausgabepfaden.

IronPDF eliminiert Pfadabhängigkeiten vollständig: Erstellen Sie einen ChromePdfRenderer, rufen Sie RenderHtmlFileAsPdf() mit dem HTML-Dateipfad auf und verwenden Sie SaveAs(), um das Ergebnis zu schreiben. Keine ausführbaren Pfade, kein Prozessmanagement, keine Pfadabhängigkeiten. Umfassende Beispiele finden Sie in der HTML to PDF Dokumentation.

Beispiel 2: URL-zu-PDF-Konvertierung mit Optionen

Vor (PrinceXML):

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXML.Wrapper;
using System;

class Program
{
    static void Main()
    {
        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        prince.JavaScript = true;
        prince.Encrypt = true;
        prince.PdfTitle = "Website Export";
        prince.Convert("https://example.com", "webpage.pdf");
        Console.WriteLine("URL converted to PDF");
    }
}

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXML.Wrapper;
using System;

class Program
{
    static void Main()
    {
        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        prince.JavaScript = true;
        prince.Encrypt = true;
        prince.PdfTitle = "Website Export";
        prince.Convert("https://example.com", "webpage.pdf");
        Console.WriteLine("URL converted to PDF");
    }
}

Imports PrinceXML.Wrapper
Imports System

Class Program
    Shared Sub Main()
        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        prince.JavaScript = True
        prince.Encrypt = True
        prince.PdfTitle = "Website Export"
        prince.Convert("https://example.com", "webpage.pdf")
        Console.WriteLine("URL converted to PDF")
    End Sub
End Class

Imports PrinceXML.Wrapper
Imports System

Class Program
    Shared Sub Main()
        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        prince.JavaScript = True
        prince.Encrypt = True
        prince.PdfTitle = "Website Export"
        prince.Convert("https://example.com", "webpage.pdf")
        Console.WriteLine("URL converted to PDF")
    End Sub
End Class

Nach (IronPDF):

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.Title = "Website Export";

        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SecuritySettings.OwnerPassword = "owner-password";
        pdf.SecuritySettings.UserPassword = "user-password";
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("URL converted to PDF");
    }
}

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.Title = "Website Export";

        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SecuritySettings.OwnerPassword = "owner-password";
        pdf.SecuritySettings.UserPassword = "user-password";
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("URL converted to PDF");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.Title = "Website Export"

        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SecuritySettings.OwnerPassword = "owner-password"
        pdf.SecuritySettings.UserPassword = "user-password"
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("URL converted to PDF")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.Title = "Website Export"

        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SecuritySettings.OwnerPassword = "owner-password"
        pdf.SecuritySettings.UserPassword = "user-password"
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("URL converted to PDF")
    End Sub
End Class

Dieses Beispiel zeigt, wie PrinceXML-Optionen auf IronPDF-Eigenschaften abgebildet werden. PrinceXMLstellt die Konfiguration als Eigenschaften auf dem Prince Objekt zur Verfügung (JavaScript, Encrypt, PdfTitle) vor der Konvertierung.IronPDF verwendet RenderingOptions Eigenschaften für Pre-Render-Einstellungen und wendet Verschlüsselung nach dem Rendern über SecuritySettings auf dem PdfDocument an.

Schlüssel-Mappings:

prince.JavaScript = true → renderer.RenderingOptions.EnableJavaScript = true
prince.PdfTitle = "..." → renderer.RenderingOptions.Title = "..."
prince.Encrypt = true → pdf.SecuritySettings.OwnerPassword = "..." / pdf.SecuritySettings.UserPassword = "..."

Erfahren Sie mehr in unseren Tutorials.

Beispiel 3: Konvertierung von HTML-Strings in PDF

Vor (PrinceXML):

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXML.Wrapper;
using System;

class Program
{
    static void Main()
    {
        string html = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>";

        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        // ConvertString accepts a raw HTML/XML string directly
        prince.ConvertString(html, "styled-output.pdf");
        Console.WriteLine("Styled PDF created");
    }
}

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXML.Wrapper;
using System;

class Program
{
    static void Main()
    {
        string html = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>";

        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        // ConvertString accepts a raw HTML/XML string directly
        prince.ConvertString(html, "styled-output.pdf");
        Console.WriteLine("Styled PDF created");
    }
}

Imports PrinceXML.Wrapper
Imports System

Module Program
    Sub Main()
        Dim html As String = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>"

        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        ' ConvertString accepts a raw HTML/XML string directly
        prince.ConvertString(html, "styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Module

Imports PrinceXML.Wrapper
Imports System

Module Program
    Sub Main()
        Dim html As String = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>"

        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        ' ConvertString accepts a raw HTML/XML string directly
        prince.ConvertString(html, "styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Module

Nach (IronPDF):

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        string html = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("styled-output.pdf");
        Console.WriteLine("Styled PDF created");
    }
}

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

class Program
{
    static void Main()
    {
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
        string html = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>";

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("styled-output.pdf");
        Console.WriteLine("Styled PDF created");
    }
}

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim html As String = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Class

Imports IronPdf
Imports System

Class Program
    Shared Sub Main()
        IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
        Dim html As String = "<html><head><style>body { font-family: Arial; color: blue; }</style></head><body><h1>Hello World</h1></body></html>"

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Class

Beide Bibliotheken akzeptieren direkt einen HTML-String: PrinceXMLüber ConvertString() und IronPDF über RenderHtmlAsPdf(). Der architektonische Unterschied bleibt bestehen — PrinceXML's ConvertString übergibt im Hintergrund immer noch die Eingabe an das externe prince Binär, während IronPDF das Rendern intern ohne ausführbare Datei durchführt.

Migrieren von CSS-Seitenmedien

Die CSS-Paged-Media-Unterstützung von PrinceXMList zwar leistungsfähig, führt aber zu einer Herstellerbindung mit Prince-spezifischem CSS, das anderswo nicht funktioniert:

PrinceXML CSS:

@page {
    size: A4;
    margin: 2cm;
    @top-center {
        content: "Document Title";
    }
    @bottom-right {
        content: counter(page);
    }
}

/* Prince-specific extensions */
prince-pdf-page-label: "Chapter " counter(chapter);
prince-pdf-destination: attr(id);

@page {
    size: A4;
    margin: 2cm;
    @top-center {
        content: "Document Title";
    }
    @bottom-right {
        content: counter(page);
    }
}

/* Prince-specific extensions */
prince-pdf-page-label: "Chapter " counter(chapter);
prince-pdf-destination: attr(id);

Text

IronPDF C# (gleichwertig):

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 56;    // ~2cm
renderer.RenderingOptions.MarginBottom = 56;
renderer.RenderingOptions.MarginLeft = 56;
renderer.RenderingOptions.MarginRight = 56;

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:center;'>Document Title</div>",
    MaxHeight = 40
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:right;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 56;    // ~2cm
renderer.RenderingOptions.MarginBottom = 56;
renderer.RenderingOptions.MarginLeft = 56;
renderer.RenderingOptions.MarginRight = 56;

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:center;'>Document Title</div>",
    MaxHeight = 40
};

renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    HtmlFragment = "<div style='text-align:right;'>Page {page} of {total-pages}</div>",
    MaxHeight = 25
};

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 56    ' ~2cm
renderer.RenderingOptions.MarginBottom = 56
renderer.RenderingOptions.MarginLeft = 56
renderer.RenderingOptions.MarginRight = 56

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:center;'>Document Title</div>",
    .MaxHeight = 40
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:right;'>Page {page} of {total-pages}</div>",
    .MaxHeight = 25
}

renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 56    ' ~2cm
renderer.RenderingOptions.MarginBottom = 56
renderer.RenderingOptions.MarginLeft = 56
renderer.RenderingOptions.MarginRight = 56

renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:center;'>Document Title</div>",
    .MaxHeight = 40
}

renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .HtmlFragment = "<div style='text-align:right;'>Page {page} of {total-pages}</div>",
    .MaxHeight = 25
}

Gängige Probleme bei der CSS-Migration

Ausgabe 1: CSS @page funktioniert nicht

IronPDF verwendet Chromium, das eine begrenzte @page-Unterstützung bietet. CSS-Regeln in RenderingOptions umwandeln.

Problem 2: Fehlende Seitenrandkästen

CSS-Randboxen (@top-center, @bottom-right) sind spezifisch für Prince. Verwenden Sie stattdessen HtmlFooter.

Ausgabe 3: string-set/content funktioniert nicht

Die string-set CSS-Eigenschaft ist spezifisch für Prince. Verwenden Sie den {html-title} Platzhalter aus dem <title> Tag:

<title>Chapter 1: Introduction</title>

<title>Chapter 1: Introduction</title>

HTML

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div>{html-title}</div>"
};

renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    HtmlFragment = "<div>{html-title}</div>"
};

net

net

Ausgabe 4: Zähler (Seiten) Falsch

Verwenden Sie den {total-pages} Platzhalter von IronPDF anstelle von CSS-Zählern.

Leistungsvergleich

Betrieb	PrinceXML	IronPDF
Einfaches HTML	~400ms	~300ms
Komplexes CSS	~600ms	~400ms
JavaScript-Seiten	Beschränkt	~500ms
Große Dokumente	~1500ms	~1000ms
Gleichlaufend (10)	~4000ms	~1500ms
Startup-Overhead	~200ms	~50ms

Neue Funktionen nach der Migration

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

PDF-Zusammenführung

var pdf1 = PdfDocument.FromFile("chapter1.pdf");
var pdf2 = PdfDocument.FromFile("chapter2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("complete_book.pdf");

var pdf1 = PdfDocument.FromFile("chapter1.pdf");
var pdf2 = PdfDocument.FromFile("chapter2.pdf");
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("complete_book.pdf");

Dim pdf1 = PdfDocument.FromFile("chapter1.pdf")
Dim pdf2 = PdfDocument.FromFile("chapter2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("complete_book.pdf")

Dim pdf1 = PdfDocument.FromFile("chapter1.pdf")
Dim pdf2 = PdfDocument.FromFile("chapter2.pdf")
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("complete_book.pdf")

Wasserzeichen

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

IRON VB CONVERTER ERROR developers@ironsoftware.com

IRON VB CONVERTER ERROR developers@ironsoftware.com

Digitale Signaturen

var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);

Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)

Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)

Formularausfüllen

var pdf = PdfDocument.FromFile("form.pdf");
pdf.Form.GetFieldByName("Name").Value = "John Doe";
pdf.SaveAs("filled_form.pdf");

var pdf = PdfDocument.FromFile("form.pdf");
pdf.Form.GetFieldByName("Name").Value = "John Doe";
pdf.SaveAs("filled_form.pdf");

Dim pdf = PdfDocument.FromFile("form.pdf")
pdf.Form.GetFieldByName("Name").Value = "John Doe"
pdf.SaveAs("filled_form.pdf")

Dim pdf = PdfDocument.FromFile("form.pdf")
pdf.Form.GetFieldByName("Name").Value = "John Doe"
pdf.SaveAs("filled_form.pdf")

Zusammenfassung des Funktionsvergleichs

Feature	PrinceXML	IronPDF
Native .NET	Nein	Ja
Externer Prozess	Erforderlich	Nein
Async-Unterstützung	Manueller Umbruch	Natives async/await
CSS Ausgelagerte Medien	Unterstützt	Über RenderingOptions
CSS-Raster	Ja	Ja
Flexbox	Ja	Ja
JavaScript	Beschränkt	Vollständiger ES2024
Generation	Ja	Ja
Zusammenführen	Nein	Ja
Teilen	Nein	Ja
Bearbeiten	Nein	Ja
Wasserzeichen	Nur CSS	HTML/CSS + API
Digitale Signaturen	Nein	Ja
PDF/A	Ja	Ja
Verschlüsselung	Ja	Ja
Formulare	Nein	Ja
NuGet-Paket	Nein	Ja
Server installieren	Erforderlich	Nein

Migrations-Checkliste

Vor der Migration

Alle Prince-Befehlszeilenaufrufe identifizieren
Dokument-CSS-@page-Regeln verwendet
Listen Sie Prince-spezifische CSS-Eigenschaften auf (prince-*, string-set)
Beachten Sie alle Prince JavaScriptFunktionen
Identifizieren Sie die verwendeten PDF-Funktionen (Verschlüsselung, Metadaten)
Den IronPDF Lizenzschlüssel erhalten Sie unter IronPDF

Code-Änderungen

Entfernen Sie das PrinceXMLWrapper NuGet-Paket
Installieren Sie das IronPdf NuGet-Paket
Namespace-Importe aktualisieren
Ersetzen Sie die Prince Instanziierung durch ChromePdfRenderer
Ersetzen Sie prince.Convert() durch RenderHtmlFileAsPdf() oder RenderHtmlAsPdf()
Konvertieren Sie Setter-Methoden in RenderingOptions Eigenschaften
Migrieren Sie @page CSS zu RenderingOptions
Ersetzen Sie Randboxen durch HtmlFooter
Konvertieren Sie CSS-Zähler in {total-pages} Platzhalter
Entfernen der temporären Dateiverarbeitung für HTML-Zeichenketten
Lizenzinitialisierung beim Anwendungsstart hinzufügen

Nach der Migration

Test der HTML-Dateikonvertierung
Test der HTML-String-Konvertierung
URL-Konvertierung testen
Überprüfen Sie, ob die Seitengrößen übereinstimmen
Überprüfen Sie, ob die Ränder übereinstimmen
Testen Sie Kopf- und Fußzeilen
Seitenzahlen überprüfen
Verschlüsselung/Sicherheit testen
Entfernen Sie die Prince-Installation von den Servern
Bereitstellungsskripte aktualisieren

Hinweis:: PrinceXML ist eine eingetragene Marke seines jeweiligen Eigentümers. Diese Seite ist nicht verbunden mit, unterstützt von oder gesponsert von YesLogic Pty. Ltd.. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.

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 Handbücher.

...