Nutrient.io vs IronPDF: Leitfaden für den technischen Vergleich

PrinceXMLkennenlernen

PrinceXML ist ein Werkzeug zur Konvertierung von HTML-Inhalten in hochwertige PDF-Dokumente durch Unterstützung der CSS Paged Media-Spezifikationen. Diese Fähigkeit ermöglicht es PrinceXML, Dokumente zu erstellen, die genau dem beabsichtigten Druckdesign entsprechen, was für Branchen wie das Verlagswesen oder die juristische Dokumentation, die ein detailliertes Druckstyling erfordern, sehr wertvoll ist.

PrinceXML ist jedoch keine .NET-Bibliothek. Das Werkzeug funktioniert als eigenständige Kommandozeilenanwendung, was architektonische Überlegungen for .NET-Anwendungen mit sich bringt. Die Integration umfasst die Verwaltung externer Prozesse, die Handhabung der stdin/stdout-Kommunikation oder den Umgang mit temporären Dateien. Jeder Servereinsatz erfordert eine separate PrinceXML-Installation und -Lizenz.

Die externe Prozessarchitektur bringt mehrere Herausforderungen mit sich:

• Prozessmanagement Overhead: Anwendungen müssen externe Prozesse verwalten
• Keine native .NET-Integration: Die Kommunikation erfolgt über Befehlszeilenargumente oder temporäre Dateien
• Komplexität der Bereitstellung: Prince-Installation auf jedem Server erforderlich
• Per-Server-Lizenzierung: Jede Einsatzumgebung benötigt eine eigene Lizenz
• Schwierigkeit der Fehlerbehandlung: Fehler müssen aus der Textausgabe geparst werden
• Kein natives Async/Await: Blockierende Aufrufe oder komplexe Async-Wrapper erforderlich
• Pfadabhängigkeiten: Prince muss über den PATH oder den absoluten Pfad lokalisiert werden

IronPDF verstehen

IronPDF bietet einen anderen Ansatz mit nativen .NET-Bibliotheksfunktionen. Die Bibliothek geht über die HTML-zu-PDF-Konvertierung hinaus und umfasst auch fortgeschrittene PDF-Aufgaben wie das Bearbeiten, Zusammenführen, Aufteilen und digitale Signaturen. Die API von IronPDF ist auf Einfachheit ausgelegt und ermöglicht Konvertierungen und Manipulationen mit minimalem Boilerplate-Code.

Die Architektur von IronPDF ermöglicht eine einfache Bereitstellung über ein einziges NuGet-Paket, das keine externen Abhängigkeiten oder Serverprozesse erfordert. Mit prozessinterner Ausführung und einer gebündelten Chromium-Rendering-Engine lässt sich IronPDF direkt in die Workflows von .NET-Anwendungen integrieren, ohne dass eine externe Prozessverwaltung erforderlich ist.

Das Problem des externen Prozesses

Der wichtigste architektonische Unterschied zwischen PrinceXMLund IronPDF ist der Integrationsansatz. Das externe Prozessmodell von PrinceXMLführt zu einer Komplexität, die die nativen .NET-Bibliotheken vollständig vermeiden.

HTML-Datei in PDF umwandeln

Der einfachste Vergleich ist die Konvertierung einer HTML-Datei in PDF. Die Codemuster verdeutlichen die grundlegenden API-Unterschiede zwischen den Bibliotheken.

PrinceXMLHTML-Dateikonvertierung

Das Werkzeug erfordert das Angeben des ausführbaren Pfads und das Ausführen der Umwandlung über einen Wrapper:

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXMLWrapper;
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 PrinceXMLWrapper;
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 PrinceXMLWrapper
Imports System

Module Program
    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 Module

Imports PrinceXMLWrapper
Imports System

Module Program
    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 Module

Dieses Muster erfordert:

• PrinceXML-Installation auf dem Server
• Absoluter Pfad zur ausführbaren Prince-Datei
• Wrapper-Paket zur Vereinfachung des Befehlszeilenaufrufs

IronPDF HTML-Dateikonvertierung

IronPDF bietet eine direkte API-Integration ohne externe Abhängigkeiten:

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

class Program
{
    static void Main()
    {
        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()
    {
        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()
        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()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlFileAsPdf("input.html")
        pdf.SaveAs("output.pdf")
        Console.WriteLine("PDF created successfully")
    End Sub
End Class

Der IronPDF-Ansatz eliminiert Pfadabhängigkeiten und externes Prozessmanagement. Die ChromePdfRenderer Klasse kapselt die Rendering-Engine, und RenderHtmlFileAsPdf übernimmt die Umwandlung direkt innerhalb des .NET-Prozesses.

URL zu PDF Konvertierung

Die Konvertierung von Webseiten in PDF erfordert die Bearbeitung von Netzwerkanfragen, die Ausführung von JavaScriptund das Rendern von Seiten. Beide Bibliotheken unterstützen die URL-Konvertierung, allerdings mit unterschiedlichen Ansätzen für die Konfiguration.

PrinceXML-URL-Konvertierung

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

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

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

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

Imports PrinceXMLWrapper
Imports System

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

Imports PrinceXMLWrapper
Imports System

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

Der Formatter konfiguriert Optionen über Setter-Methoden vor der Umwandlung. Die Einstellungen für Verschlüsselung und Metadaten werden während des Konvertierungsprozesses selbst vorgenommen.

IronPDF URL-Konvertierung

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.PdfTitle = "Website Export";
        
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.Encrypt("password");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("URL converted to PDF");
    }
}

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

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.PdfTitle = "Website Export";
        
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.Encrypt("password");
        pdf.SaveAs("webpage.pdf");
        Console.WriteLine("URL converted to PDF");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.PdfTitle = "Website Export"
        
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.Encrypt("password")
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("URL converted to PDF")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports System

Module Program
    Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.PdfTitle = "Website Export"
        
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.Encrypt("password")
        pdf.SaveAs("webpage.pdf")
        Console.WriteLine("URL converted to PDF")
    End Sub
End Module

IronPDF trennt die Rendering-Optionen von den Nachbearbeitungsvorgängen. Die Methode RenderUrlAsPdf übernimmt das Laden und Rendern der Seite, während das resultierende PDF-Dokumentobjekt verschlüsselt wird. Diese Trennung ermöglicht zusätzliche Operationen mit der PDF-Datei nach der Erstellung.

HTML-String in PDF-Konvertierung

Bei der direkten Konvertierung von HTML-Strings in PDF wird ein signifikanter Unterschied im Arbeitsablauf zwischen den Bibliotheken deutlich.

PrinceXMLHTML String Konvertierung

Das Werkzeug erfordert dateibasierte Eingabe, was die Erstellung temporärer Dateien für die HTML-String-Umwandlung notwendig macht:

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXMLWrapper;
using System;
using System.IO;

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>";
        File.WriteAllText("temp.html", html);
        
        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        prince.Convert("temp.html", "styled-output.pdf");
        Console.WriteLine("Styled PDF created");
    }
}

// NuGet: Install-Package PrinceXMLWrapper
using PrinceXMLWrapper;
using System;
using System.IO;

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>";
        File.WriteAllText("temp.html", html);
        
        Prince prince = new Prince("C:\\Program Files\\Prince\\engine\\bin\\prince.exe");
        prince.Convert("temp.html", "styled-output.pdf");
        Console.WriteLine("Styled PDF created");
    }
}

' NuGet: Install-Package PrinceXMLWrapper
Imports PrinceXMLWrapper
Imports System
Imports System.IO

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>"
        File.WriteAllText("temp.html", html)
        
        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        prince.Convert("temp.html", "styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Module

' NuGet: Install-Package PrinceXMLWrapper
Imports PrinceXMLWrapper
Imports System
Imports System.IO

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>"
        File.WriteAllText("temp.html", html)
        
        Dim prince As New Prince("C:\Program Files\Prince\engine\bin\prince.exe")
        prince.Convert("temp.html", "styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Module

Dieser Ansatz erfordert:

• Schreiben von HTML-Inhalten in eine temporäre Datei
• Verwaltung des Lebenszyklus temporärer Dateien
• Zusätzliche E/A-Operationen, die die Leistung beeinträchtigen
• Mögliche Bereinigungslogik für temporäre Dateien

IronPDF HTML String Konvertierung

IronPDF akzeptiert HTML-Zeichenfolgen direkt und ohne zwischengeschaltete Dateioperationen:

// NuGet: Install-Package IronPdf
using IronPdf;
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>";
        
        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()
    {
        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
Imports IronPdf
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 renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf
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 renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("styled-output.pdf")
        Console.WriteLine("Styled PDF created")
    End Sub
End Module

Die Methode RenderHtmlAsPdf akzeptiert HTML-Inhalte direkt, wodurch die Verwaltung temporärer Dateien entfällt und der E/A-Overhead reduziert wird.

Zuordnung von der Kommandozeile zur API

Teams, die von PrinceXMLauf IronPDF migrieren, können sich auf diese Zuordnung gleichwertiger Operationen beziehen:

CSS Ausgelagerte MedienÜberlegungen

Die CSS Paged Media-Unterstützung des Formatters ist mächtig, schafft jedoch herstellerspezifische Abhängigkeiten:

/* Prince-specific CSS that won't work elsewhere */
@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);

/* Prince-specific CSS that won't work elsewhere */
@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);

IronPDF bietet die gleiche Funktionalität über die RenderingOptions-API:

// Equivalent to @page { size: A4; margin: 2cm; }
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 56;    // ~2cm in points
renderer.RenderingOptions.MarginBottom = 56;
renderer.RenderingOptions.MarginLeft = 56;
renderer.RenderingOptions.MarginRight = 56;

// Equivalent to @top-center and @bottom-right margin boxes
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>"
};

// Equivalent to @page { size: A4; margin: 2cm; }
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 56;    // ~2cm in points
renderer.RenderingOptions.MarginBottom = 56;
renderer.RenderingOptions.MarginLeft = 56;
renderer.RenderingOptions.MarginRight = 56;

// Equivalent to @top-center and @bottom-right margin boxes
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>"
};

net

net

IronPDFs HTML-Kopf- und Fußzeilen unterstützen zusammenführende Felder wie {page} und {total-pages} für dynamische Inhalte.

Merkmalsvergleichsmatrix

Die Bibliotheken unterscheiden sich erheblich in ihren Fähigkeiten, die über die grundlegende PDF-Erzeugung hinausgehen:

Der Funktionsumfang von IronPDF erstreckt sich auf Dokumentenmanipulation, Sicherheit und Formularverarbeitung, die von PrinceXMLnicht abgedeckt werden.

Leistungsvergleich

Die architektonischen Unterschiede übersetzen sich in unterschiedliche Leistungsmerkmale:

Die In-Process-Ausführung von IronPDF vermeidet den Overhead von externen Prozessen, was insbesondere für Szenarien mit hohem Aufkommen an PDF-Generierungen relevant ist, bei denen sich die Prozesskosten summieren.

Umfassende Vergleichstabelle

Wenn Teams eine PrinceXML-Migration erwägen

Mehrere Faktoren veranlassen Entwicklungsteams, Alternativen zu PrinceXMLzu prüfen:

Die Komplexität des Einsatzes erhöht den Arbeitsaufwand. Die Installation und Wartung des Werkzeugs auf jedem Server, das Lizenzmanagement pro Bereitstellung und das Handhaben von Updates über Umgebungen hinweg schafft einen laufenden Overhead, den native .NET-Bibliotheken eliminieren.

Prozessverwaltungscode erhöht die Komplexität der Anwendung. Spawning-Prozesse, das Parsen von Fehlerausgaben, die Verwaltung temporärer Dateien und die Handhabung der Bereinigungslogik stellen Code dar, der ausschließlich aufgrund der Architektur des externen Tools existiert.

Einschränkte PDF-Bearbeitung erfordert zusätzliche Tools. Wenn Anwendungen Dokumente zusammenführen, Wasserzeichen hinzufügen, digitale Signaturen anwenden oder Formulare ausfüllen müssen, erfordert der generierungsorientierte Ansatz dieser Lösung getrennte Bibliotheken.

Cloud- und Container-Einsätze werden kompliziert. Azure Functions, AWS Lambda und Docker-Container funktionieren natürlicher mit NuGet-Paketen als mit externen ausführbaren Dateien, die installiert werden müssen.

Anbieterspezifisches CSS führt zu einem Lock-in. Prince-spezifische CSS-Eigenschaften wie prince-pdf-page-label und CSS-Randkästen schaffen Abhängigkeiten, die sich nicht auf andere Lösungen übertragen lassen.

Stärken und Gegensätze

PrinceXMLStärken

• Originalgetreuer Druck durch Unterstützung von CSS Paged Media
• Plattformübergreifende Kompatibilität
• Ausgereifte Implementierung der CSS Paged Media-Spezifikation
• Ideal für druckorientierte Branchen, die ein detailliertes Styling benötigen

PrinceXML-Einschränkungen

• Funktioniert als externes Befehlszeilen-Tool, nicht als .NET-Bibliothek
• Erfordert die Installation auf jedem Server
• Lizenzierungsmodell pro Server
• Nur Generierung - keine PDF-Manipulationsmöglichkeiten
• Erfordert temporäre Dateien für die Konvertierung von HTML-Strings
• Begrenzte JavaScript-Unterstützung

IronPDF Stärken

• Native .NET-Bibliothek mit direkter API-Integration
• Keine externen Abhängigkeiten oder Serverinstallationen
• Umfassende PDF-Bearbeitung über die Generierung hinaus
• Modernes Chromium-Rendering mit vollständiger JavaScript-Unterstützung
• Professionelle Unterstützung und Dokumentation
• Bereitstellung eines einzelnen NuGet-Pakets

IronPDF Überlegungen

• Kommerzielles Lizenzierungsmodell
• CSS Paged Media-Funktionen, die über RenderingOptions und nicht über CSS implementiert werden

Abschluss

PrinceXML zeichnet sich durch die Unterstützung von CSS Ausgelagerte Medienbei der Erstellung druckfertiger PDF-Dateien aus, was es für das Verlagswesen und die juristische Dokumentation wertvoll macht, wo Druckspezifikationen das Design bestimmen. Die externe Prozessarchitektur führt jedoch zu einer komplexen Bereitstellung, schränkt die Möglichkeiten der PDF-Bearbeitung ein und erfordert eine Lizenzierung pro Server.

Für .NET-Anwendungen, bei denen die PDF-Erzeugung in umfassendere Dokumenten-Workflows integriert werden soll - insbesondere solche, die Manipulation, Sicherheitsfunktionen oder modernes Web-Rendering erfordern - bietet der native Bibliotheksansatz von IronPDF eine einfachere Integration und umfassendere Funktionen. Durch den Wegfall der Verwaltung externer Prozesse, der Handhabung temporärer Dateien und der Installation auf einem Server wird die betriebliche Komplexität reduziert.

Teams, die eine PrinceXML-Migration in Erwägung ziehen, sollten ihre spezifischen Anforderungen in Bezug auf CSS Ausgelagerte Medien(wo PrinceXMLseine Stärken beibehält), PDF-Bearbeitungsanforderungen (wo IronPDF seine Stärken hat) und Bereitstellungsmodelle (wo die native .NET-Integration Vorteile bietet) berücksichtigen. Für Anwendungen, die auf .NET 10 und moderne Cloud-Bereitstellungsmuster im Jahr 2026 abzielen, passt die Architektur von IronPDF besser zu den aktuellen .NET-Entwicklungspraktiken.

Eine Anleitung zur Implementierung finden Sie im IronPDF HTML-zu-PDF-Tutorial und in der Dokumentation, die PDF-Erzeugungsmuster for .NET-Anwendungen behandelt.