IronPDF und Aspose.PDF for .NET repräsentieren zwei leistungsstarke Ansätze zur PDF-Bearbeitung in C#-Anwendungen. IronPDF betont Einfachheit und Unterstützung moderner Webstandards und bietet optimierte APIs, die HTML, CSS3 und JavaScript direkt in hochauflösende PDFs umwandeln. Aspose.PDF bietet ein umfassendes Toolkit, das für die Verarbeitung von Dokumenten auf Unternehmensebene mit umfangreichen Anpassungsoptionen entworfen wurde.
Der grundlegende Unterschied liegt in ihrer Designphilosophie. IronPDF konzentriert sich auf die Produktivität der Entwickler mit intuitiven Methoden wie RenderHtmlAsPdf(), die nur minimalen Code erfordern. Aspose.PDF bietet granulare Kontrolle durch eine komplexere API-Struktur, wodurch es für spezialisierte Dokumenten-Workflows geeignet ist, aber mehr Implementierungsaufwand erfordert.
Für diejenigen unter Ihnen, die es eilig haben, hier ist eine umfassende Tabelle, die alle Hauptunterschiede zwischen IronPDF und Aspose.PDF zusammenfasst, die in diesem Artikel besprochen wurden:
| Kategorie | Merkmal/Aspekt | IronPDF | Aspose.PDF | Hauptvorteil |
|---|---|---|---|---|
| Kernarchitektur | Design-Philosophie | Intuitive APIs, die auf Einfachheit setzen | Unternehmensorientiert, granulare Kontrolle | IronPDF: Schnellere Entwicklung |
| API-Komplexität | Einfache Methoden wie RenderHtmlAsPdf() | Mehrklassenansatz, manuelle Einrichtung | IronPDF: 70 % weniger Code | |
| Lernkurve | typisch 1-2 Tage | typisch 1-2 Wochen | IronPDF: Schnellere Akzeptanz | |
| Plattform-Unterstützung | Plattformübergreifend | Nativ Unterstützung, keine zusätzlichen Pakete | Erfordert das Aspose.Pdf.Drawing-Paket | IronPDF: Einfachere Bereitstellung |
| .NET-Versionen | .NET 8, 7, 6, 5, Core 3.1+, Framework 4.6.2+ | Ähnliche Unterstützung mit dem Drawing-Paket | Beides: Unterstützung moderner Frameworks | |
| Betriebssysteme | Windows, Linux, macOS, Docker nativ | Erfordert Konfiguration pro Plattform | IronPDF: Echte Write-once-Bereitstellung | |
| Cloud-Plattformen | Azure/AWS optimiert | Standard-Unterstützung | IronPDF: Cloud-fähig | |
| HTML zu PDF | Rendering-Engine | Vollständige Chrome V8-Engine | Benutzerdefinierter HTML-Parser | IronPDF: 98%+ Browser-Treue |
| CSS3/HTML5-Unterstützung | Vollständige Unterstützung | Begrenzt (70-80% Genauigkeit) | IronPDF: Moderne Webstandards | |
| JavaScript-Ausführung | Volle JavaScript-Unterstützung | Basic/Begrenzt | IronPDF: Dynamischer Inhalt | |
| Webfonts | Google-Schriftarten, Systemschriftarten | Nur eingebettete Schriftarten | IronPDF: Typografische Flexibilität | |
| Rendering-Geschwindigkeit | 0.8-1.2s typisch | 0.3-0,5s typisch | Aspose: Schneller für einfaches HTML | |
| Speicherverwendung | 150-200 MB (Chrome-Engine) | 80-120 MB | Aspose: Unterer Speicher | |
| Security & Encryption | Verschlüsselungsstufen | AES-256, benutzerdefinierte Handler | AES-256-Standard | Beides: Industriestandard |
| Optionen für die Erlaubnis | 15+ granulare Berechtigungen | 8 grundlegende Berechtigungen | IronPDF: Bessere Kontrolle | |
| API-Vereinfachung | Einzelne SecuritySettings Klasse | Mehrere Klassen erforderlich | IronPDF: Einheitlicher Ansatz | |
| Digitale Signaturen | Integrierte, visuelle Signaturen | Manuelle Felderstellung | IronPDF: Einfachere Unterzeichnung | |
| Zertifikat-Unterstützung | PKCS#11, HSM-Unterstützung | Ähnlich mit mehr Einstellungen | Beides: Enterprise PKI | |
| Inhaltsmanipulation | Redaktionsmethode | Echte Inhaltsentfernung, einzeilige API | Annotationsbasiert, mehrstufig | IronPDF: Compliance-gerecht |
| Redaktionsleistung | 1000 Seiten: ~2 min | 1000 Seiten: ~6 min | In unseren Tests schneller | |
| Wasserzeichen | HTML/CSS-basiert, vollständiges Styling | Nur TextStamp, begrenztes Styling | IronPDF: Reichhaltige Wasserzeichen | |
| Stempeln | Vereinheitlichte Stamper-Klassen | Separate Stempeltypen | IronPDF: Konsistente API | |
| Stapelverarbeitung | Optimierte Parallelverarbeitung | Standard-Schleifen | In unseren Tests schneller | |
| Datei-Konvertierungen | DOCX to PDF | Eingebauter DocxToPdfRenderer | Erfordert Aspose.Words ($1.679) | IronPDF: Keine zusätzlichen Kosten |
| Excel-Unterstützung | Über HTML/CSV-Rendering | Erfordert Aspose.Cells ($1.679) | IronPDF: Enthaltene Funktionen | |
| PDF zu HTML | Unterstützt mit Styling | Unterstützte, grundlegende Ausgabe | Beides: Funktional | |
| Markdown-Unterstützung | Über HTML-Konvertierung | Nicht unterstützt | IronPDF: Weitere Formate | |
| Leistungskennzahlen | Verarbeitung großer Dokumente | 1000 Seiten/Min. Wasserzeichen | 600 Seiten/Min. Wasserzeichen | In unseren Tests schneller |
| Threading-Unterstützung | Nativs async/await optimiert | Standard-Threading | IronPDF: Bessere Skalierbarkeit | |
| Speichereffizienz | Optimierte Zwischenspeicherung | Standard-Speicherverbrauch | IronPDF: Verarbeitet größere Stapel | |
| Erfahrung des Entwicklers | Codebeispiele | 100+ fertige Beispiele | Grundlegende Beispiele | IronPDF: Umfangreiche Ressourcen |
| Dokumentation | Tutorials, Anleitungen, Videos | Traditionelle API-Dokumente | IronPDF: Mehrere Lernpfade | |
| IntelliSense | Volle IntelliSense-Unterstützung | Standard-Unterstützung | Beides: IDE-Integration | |
| Fehlermeldungen | Beschreibend, umsetzbar | Technische Botschaften | IronPDF: Bessere Fehlersuche | |
| Licensing & Pricing | Einstiegsstufe | Lite: $999 (1 dev, 1 project) | Kleine Unternehmen: ab $1,199/Jahr (1 Entwickler, 1 Standort) | IronPDF: Günstigerer Einstieg |
| Teamlizenz | Plus: $1,499 (3 devs, 3 projects) | OEM: $5.037 (1 Entwickler, unbegrenzte Anzahl von Standorten) | IronPDF: Besserer Teamwert | |
| Enterprise | Professional: $2,399 (10 devs, 10 projects) | SDK: 33.580 $ (1 Entwickler, 50 Einsätze) | IronPDF: 91 % niedrigere Kosten | |
| Zusätzliche Produkte | In der Einzellizenz enthalten | Separate Lizenzen erforderlich | IronPDF: Alles inbegriffen | |
| Weitervertrieb | +$2,399 royalty-free | Eingeschlossene, aber begrenzte Einsätze | IronPDF: Klarere Begriffe | |
| Suite-Option | Iron Suite: $2,998 (9 products) | Keine Suite-Option | IronPDF: Außergewöhnlicher Wert | |
| Unterstützung | Inklusive Unterstützung | Ja, 24/5 technische Unterstützung | Nur Forum (bezahlter Support +$399/yr) | IronPDF: Unterstützung inklusive |
| Reaktionszeit | typischerweise 24-48 Stunden | Variiert je nach Stufe | IronPDF: Vorhersehbare SLA | |
| Support-Kanäle | E-Mail, Chat, Telefon, Bildschirmfreigabe | Forum, bezahlte E-Mail/Telefon | IronPDF: Weitere Kanäle | |
| Direkter technischer Zugang | Ja | Über die Unterstützungsebenen | IronPDF: Expertenhilfe | |
| Besondere Eigenschaften | Barcode-Integration | Über HTML/JavaScript | Nicht eingebaut | IronPDF: BarCode-Unterstützung |
| QR-Code-Unterstützung | Über IronQR-Integration | Erfordert kundenspezifische Implementierung | IronPDF: Nativ QR-Codes | |
| OCR-Fähigkeiten | Über IronOCR-Integration | Erfordert Aspose.OCR | IronPDF: Integrierte Suite | |
| Druck-Optimierung | Über IronPrint-Integration | Standarddruck | IronPDF: Erweitertes Drucken | |
| Gesamtkosten (typisches Unternehmen) | PDF + DOCX + Excel | $2,399 (Professional) | $5.037+ (mehrere Produkte) | IronPDF: 68 % Kosteneinsparung |
| Mit Suite-Option | $2,998 (9 products) | Nicht verfügbar | IronPDF: 70% Ersparnis gegenüber individuellen Übersetzungen | |
| Best für | Anwendungsfälle | Moderne Webanwendungen, schnelle Entwicklung, kostenbewusste Teams | Altsysteme, spezifische Unternehmensanforderungen | IronPDF: Die meisten Szenarien |
| Teamgröße | 1-10+ Entwickler | Große Unternehmen mit eigenen Ressourcen | IronPDF: Skalierbare Lizenzierung | |
| Projekttypen | SaaS, Webanwendungen, Automatisierung von Dokumenten | Komplexe Formularverarbeitung, XFA-Formulare | Kontextabhängig |
Hinweis. Der Vergleich spiegelt die Funktionen und Preise der .NET-Bibliothek im Oktober 2025 wider. Die Preise können sich ändern; überprüfen Sie die aktuellen Preise auf den Websites der Anbieter. Die Leistungsangaben sind eigene Messungen von Iron Software an unseren Testdokumenten, keine veröffentlichten Benchmarks; da wir keine Methodik veröffentlicht haben, sind sie als Anhaltspunkt und nicht als reproduzierbares Ergebnis zu verstehen. Iron Suite-Preise bieten Zugang zu allen Iron Software-Produkten unter einer einzigen Lizenz.
IronPDF bietet eine umfassende PDF-Bibliothek, die speziell für .NET-Entwickler entwickelt wurde, die effiziente Dokumentenerstellung suchen. Die Bibliothek zeichnet sich durch das Erstellen, Bearbeiten und Rendern von PDF-Dokumenten aus verschiedenen Quellen wie HTML, ASPX und URLs aus.
Ihre Stärke liegt in der nativen Unterstützung moderner Webstandards - CSS3, HTML5 und JavaScript - die ein pixelperfektes PDF-Rendering mit minimaler Konfiguration ermöglicht. Die Architektur der Bibliothek priorisiert die Entwicklererfahrung durch prägnante APIs, die komplexe Operationen intern erledigen.
Aspose.PDF für .NET fungiert als eine ausgeklügelte API zur Dokumentenverarbeitung, die in der Lage ist, komplexe PDF-Dateimanipulationen durchzuführen. Die Bibliothek ermöglicht es Entwicklern, PDF-Dateien in WinForms-, WPF-, ASP.NET- und .NET-Core-Anwendungen zu erstellen, zu ändern und zu transformieren.
Vollständig in verwaltetem C# geschrieben, legt Aspose.PDF Wert auf architektonische Flexibilität und rohe Leistung und positioniert sich für Unternehmensanwendungen, die erweiterte Dokumentenoperationen wie komplexe Formularverarbeitung und Dokumentenzusammenstellung erfordern.
IronPDF bietet native plattformübergreifende Kompatibilität ohne zusätzliche Pakete und unterstützt Windows-, Linux-, macOS-, Docker-, Azure- und AWS-Umgebungen nahtlos. Die Bibliothek erhält konsistentes Verhalten über die Plattformen hinweg durch ihre einheitliche Codebasis und eliminiert plattformspezifische Implementierungen.
Die plattformübergreifende Funktionalität von Aspose.PDF erfordert das separate Paket Aspose.Pdf.Drawing, was die Bereitstellungsszenarien komplizierter macht. Diese Architekturentscheidung beeinflusst die Projektkonfiguration und das Abhängigkeitsmanagement, insbesondere in containerisierten Umgebungen.
IronPDF's umfangreiche Kompatibilitätsliste umfasst:
Die Bereitstellungsdokumentation der Bibliothek bietet detaillierte Anleitungen für jede Plattformkonfiguration.
| Plattform-Funktion | IronPDF | Aspose.PDF | Unterschied in der Implementierung |
|---|---|---|---|
| .NET 8/9-Unterstützung | Nativ | Mit Zeichnungspaket | IronPDF erfordert keine zusätzlichen Pakete |
| Linux Bereitstellung | Integriert | Separates Paket | Aspose benötigt Aspose.Pdf.Drawing |
| Docker-Unterstützung | Offizielle Bilder | Handbuch Konfig | IronPDF bietet vorgefertigte Container |
| Azure Functions | Optimiert | Unterstützt | IronPDF enthält Azure-spezifische Optimierungen |
| macOS ARM64 | Nativ | Begrenzt | IronPDF unterstützt vollständig Apple Silicon |
Die HTML-zu-PDF-Konvertierung stellt eine wichtige Funktion für webbasierte Anwendungen dar. Beide Bibliotheken gehen diese Herausforderung unterschiedlich an, was sowohl die Komplexität des Codes als auch die Ausgabequalität beeinflusst.
IronPDF nutzt intern eine vollständige Chrome-Rendering-Engine, um sicherzustellen, dass die JavaScript-Ausführung und das Responsive-Design-Rendering genau mit der Browserausgabe übereinstimmen. Aspose.PDF verwendet seine eigene HTML-Parsing-Engine, die HTML anders verarbeitet als moderne Browser.
using IronPdf;
// Enable enhanced security for production environments
Installation.EnableWebSecurity = true;
// Initialize the Chrome-based renderer with custom options
var renderer = new ChromePdfRenderer()
{
RenderingOptions = new ChromePdfRenderOptions()
{
MarginTop = 10,
MarginBottom = 10,
CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print,
EnableJavaScript = true,
WaitFor = new WaitFor()
{
// Wait for AJAX/animations to complete
RenderDelay = 500
}
}
};
// Convert HTML string with full CSS3/JS support
var pdf = renderer.RenderHtmlAsPdf(@"
<html>
<head>
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto');
body { font-family: 'Roboto', sans-serif; }
.chart { width: 100%; height: 400px; }
</style>
</head>
<body>
<h1>Sales Report 2024</h1>
<div class='chart' id='revenue-chart'></div>
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
<script>
// Complex JavaScript charts render perfectly
new Chart(document.getElementById('revenue-chart'), {
type: 'bar',
data: { /* chart data */ }
});
</script>
</body>
</html>");
// Save with compression
pdf.CompressImages(90);
pdf.SaveAs("sales-report.pdf");
// Convert existing web page with authentication
var advancedPdf = renderer.RenderUrlAsPdf("https://app.internal.com/reports",
new ChromePdfRenderOptions()
{
CustomCookies = new Dictionary<string, string>()
{
{ "auth_token", "secure_token_value" }
},
// Capture background images and colors
PrintHtmlBackgrounds = true
});Imports IronPdf
' Enable enhanced security for production environments
Installation.EnableWebSecurity = True
' Initialize the Chrome-based renderer with custom options
Dim renderer = New ChromePdfRenderer() With {
.RenderingOptions = New ChromePdfRenderOptions() With {
.MarginTop = 10, .MarginBottom = 10, .CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print, .EnableJavaScript = True, .WaitFor = New WaitFor() With {.RenderDelay = 500}
}
}
' Convert HTML string with full CSS3/JS support
Dim pdf = renderer.RenderHtmlAsPdf("
<html>
<head>
<style>
@import url('https://fonts.googleapis.com/css2?family=Roboto');
body { font-family: 'Roboto', sans-serif; }
.chart { width: 100%; height: 400px; }
</style>
</head>
<body>
<h1>Sales Report 2024</h1>
<div class='chart' id='revenue-chart'></div>
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
<script>
// Complex JavaScript charts render perfectly
new Chart(document.getElementById('revenue-chart'), {
type: 'bar',
data: { /* chart data */ }
});
</script>
</body>
</html>")
' Save with compression
pdf.CompressImages(90)
pdf.SaveAs("sales-report.pdf")
' Convert existing web page with authentication
Dim advancedPdf = renderer.RenderUrlAsPdf("https://app.internal.com/reports", New ChromePdfRenderOptions() With {
.CustomCookies = New Dictionary(Of String, String)() From {
{"auth_token", "secure_token_value"}
},
.PrintHtmlBackgrounds = True
})Die Klasse ChromePdfRenderer bietet umfassende Kontrolle über den Rendering-Prozess bei gleichzeitiger Wahrung der Einfachheit. Die Eigenschaft RenderingOptions bietet über 50 Konfigurationsoptionen, darunter Papierformat, Ränder, JavaScript Verarbeitung und CSS-Medientypen. Die integrierte Funktionalität WaitFor stellt sicher, dass dynamische Inhalte vollständig geladen werden, bevor die Konvertierung erfolgt – ein entscheidender Faktor für moderne Single-Page-Anwendungen.
using Aspose.Pdf;
using Aspose.Pdf.Text;
// Create new document
Document document = new Document();
Page page = document.Pages.Add();
// Configure page settings
page.PageInfo.Width = 612;
page.PageInfo.Height = 792;
page.PageInfo.Margin = new MarginInfo(72, 72, 72, 72);
// Add HTML content - limited CSS support
HtmlFragment htmlFragment = new HtmlFragment(@"
<h1 style='color: blue; font-size: 24pt'>Sales Report 2024</h1>
<p>Quarterly revenue analysis...</p>
<table border='1'>
<tr><th>Quarter</th><th>Revenue</th></tr>
<tr><td>Q1</td><td>$1.2M</td></tr>
</table>");
// Basic rendering options
htmlFragment.HtmlLoadOptions = new HtmlLoadOptions()
{
PageInfo = new PageInfo() { Width = 612, Height = 792 },
// Begrenzt JavaScript support
IsEmbedFonts = true
};
page.Paragraphs.Add(htmlFragment);
// For complex HTML, load from file
HtmlLoadOptions options = new HtmlLoadOptions("https://example.com");
options.PageInfo.IsLandscape = false;
Document htmlDoc = new Document("report.html", options);
// Merge with existing document
document.Pages.Add(htmlDoc.Pages);
document.Save("output.pdf");Imports Aspose.Pdf
Imports Aspose.Pdf.Text
' Create new document
Dim document As New Document()
Dim page As Page = document.Pages.Add()
' Configure page settings
page.PageInfo.Width = 612
page.PageInfo.Height = 792
page.PageInfo.Margin = New MarginInfo(72, 72, 72, 72)
' Add HTML content - limited CSS support
Dim htmlFragment As New HtmlFragment("
<h1 style='color: blue; font-size: 24pt'>Sales Report 2024</h1>
<p>Quarterly revenue analysis...</p>
<table border='1'>
<tr><th>Quarter</th><th>Revenue</th></tr>
<tr><td>Q1</td><td>$1.2M</td></tr>
</table>")
' Basic rendering options
htmlFragment.HtmlLoadOptions = New HtmlLoadOptions() With {
.PageInfo = New PageInfo() With {.Width = 612, .Height = 792},
' Begrenzt JavaScript support
.IsEmbedFonts = True
}
page.Paragraphs.Add(htmlFragment)
' For complex HTML, load from file
Dim options As New HtmlLoadOptions("https://example.com")
options.PageInfo.IsLandscape = False
Dim htmlDoc As New Document("report.html", options)
' Merge with existing document
document.Pages.Add(htmlDoc.Pages)
document.Save("output.pdf")Aspose.PDFs HTML-Verarbeitung erfordert manuelle Seiteneinrichtung und bietet begrenzte CSS3-Unterstützung. Die Klasse HtmlFragment verarbeitet grundlegendes HTML, verfügt aber nicht über moderne Webfunktionen wie Flexbox- und Grid-Layouts – Einschränkungen, die durch zahlreiche Benutzerberichte in den Supportforen von Aspose bestätigt wurden, in denen es um Flexbox- und Grid-Anzeigestile geht, die sich nicht wie erwartet transformieren. Die Ausführung komplexer JavaScripts ist ebenfalls begrenzt. Für Produktionsanwendungen, die eine originalgetreue Konvertierung moderner Webdesigns (wie Bootstrap 5-Layouts) erfordern, sind möglicherweise zusätzliche Vorverarbeitungen oder alternative Lösungen erforderlich.
Es treten wesentliche Leistungsunterschiede auf:
| Metrik | IronPDF | Aspose.PDF | Auswirkungen |
|---|---|---|---|
| HTML/CSS-Treue | 98%+ Browser-Übereinstimmung | 70-80% Annäherung | Visuelle Konsistenz |
| JavaScript-Unterstützung | Vollständige V8-Engine | Basic/Begrenzt | Dynamische Inhaltsverwaltung |
| Rendering-Geschwindigkeit | 0.8-1.2s typisch | 0.3-0,5s typisch | Aspose schneller für einfaches HTML |
| Speicherverwendung | 150-200 MB | 80-120 MB | IronPDF verwendet die Chrome-Engine |
| Schrift-Rendering | System- und Web-Schriftarten | Nur eingebettete Schriftarten | Typografische Optionen |
Sicherheit ist für PDF-Dokumente, die sensible Informationen enthalten, von größter Bedeutung. Beide Bibliotheken bieten Verschlüsselungsmöglichkeiten, aber ihre Implementierungsansätze und Funktionssätze unterscheiden sich erheblich.
using IronPdf;
using IronPdf.Security;
// Load existing PDF or create new one
var pdf = PdfDocument.FromFile("financial-report.pdf");
// Configure comprehensive security settings
pdf.SecuritySettings = new SecuritySettings()
{
UserPassword = "user_pwd_2024",
OwnerPassword = "admin_pwd_2024",
AllowUserCopyPasteContent = false,
AllowUserEditing = IronPdf.Security.PdfEditSecurity.NoEdit,
AllowUserFormData = false,
AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint,
AllowUserAnnotations = false,
// Advanced encryption options
EncryptionAlgorithm = IronPdf.Security.PdfEncryptionAlgorithm.AES256,
UseStrongEncryption = true
};
// Apply digital restrictions
pdf.MetaData.Title = "Confidential Report";
pdf.MetaData.Author = "Finance Department";
pdf.MetaData.Keywords = "Internal Only, Q4 2024";
pdf.MetaData.ModifiedDate = DateTime.UtcNow;
// Advanced: Add custom security handler
pdf.SecuritySettings.CustomSecurityHandler = new CustomSecurityHandler()
{
// Implement custom DRM or watermarking
OnDocumentOpen = (doc) => LogAccess(doc),
RequireTokenValidation = true
};
// Granular permission control
var permissions = new PdfPermissions()
{
AllowAccessibilityExtractContent = true, // Screen readers
AllowAssembleDocument = false,
AllowExtractContentForAccessibility = true,
AllowFillForms = false,
AllowFullQualityPrint = false,
AllowModifyAnnotations = false,
AllowModifyContents = false,
AllowPrint = false
};
pdf.ApplySecuritySettings(permissions);
pdf.SaveAs("secured-report.pdf");Imports IronPdf
Imports IronPdf.Security
' Load existing PDF or create new one
Private pdf = PdfDocument.FromFile("financial-report.pdf")
' Configure comprehensive security settings
pdf.SecuritySettings = New SecuritySettings() With {
.UserPassword = "user_pwd_2024",
.OwnerPassword = "admin_pwd_2024",
.AllowUserCopyPasteContent = False,
.AllowUserEditing = IronPdf.Security.PdfEditSecurity.NoEdit,
.AllowUserFormData = False,
.AllowUserPrinting = IronPdf.Security.PdfPrintSecurity.NoPrint,
.AllowUserAnnotations = False,
.EncryptionAlgorithm = IronPdf.Security.PdfEncryptionAlgorithm.AES256,
.UseStrongEncryption = True
}
' Apply digital restrictions
pdf.MetaData.Title = "Confidential Report"
pdf.MetaData.Author = "Finance Department"
pdf.MetaData.Keywords = "Internal Only, Q4 2024"
pdf.MetaData.ModifiedDate = DateTime.UtcNow
' Advanced: Add custom security handler
pdf.SecuritySettings.CustomSecurityHandler = New CustomSecurityHandler() With {
.OnDocumentOpen = Function(doc) LogAccess(doc),
.RequireTokenValidation = True
}
' Granular permission control
Dim permissions = New PdfPermissions() With {
.AllowAccessibilityExtractContent = True,
.AllowAssembleDocument = False,
.AllowExtractContentForAccessibility = True,
.AllowFillForms = False,
.AllowFullQualityPrint = False,
.AllowModifyAnnotations = False,
.AllowModifyContents = False,
.AllowPrint = False
}
pdf.ApplySecuritySettings(permissions)
pdf.SaveAs("secured-report.pdf")Die Sicherheitsimplementierung von IronPDF ermöglicht eine detaillierte Kontrolle über die Klasse SecuritySettings. Die API unterstützt sowohl passwortbasierte als auch zertifikatsbasierte Verschlüsselung, mit Optionen für benutzerdefinierte Sicherheitshandler, die Unternehmens-DRM-Szenarien ermöglichen.
using Aspose.Pdf;
using Aspose.Pdf.Facades;
// Load document
Document pdfDocument = new Document("financial-report.pdf");
// Basic encryption
pdfDocument.Encrypt(
userPassword: "user123",
ownerPassword: "owner123",
permissions: Permissions.PrintDocument | Permissions.ModifyContent,
cryptoAlgorithm: CryptoAlgorithm.AESx256
);
// Advanced security with certificates
using (PdfFileSecurity fileSecurity = new PdfFileSecurity())
{
fileSecurity.BindPdf(pdfDocument);
// Certificate-based encryption
X509Certificate2 certificate = new X509Certificate2("recipient.cer");
fileSecurity.EncryptFile(
null, // No user password
"owner_password",
DocumentPrivilege.Print | DocumentPrivilege.Copy,
KeySize.x256,
Algorithm.AES,
new X509Certificate2[] { certificate }
);
}
// Set document restrictions
pdfDocument.Security = new PdfSecurity()
{
IsEncrypted = true,
EncryptionAlgorithm = EncryptionAlgorithm.AES_256,
Permissions = AccessPermissions.ExtractContent |
AccessPermissions.ExtractContentWithDisabilities
};
pdfDocument.Save("encrypted.pdf");Imports Aspose.Pdf
Imports Aspose.Pdf.Facades
Imports System.Security.Cryptography.X509Certificates
' Load document
Dim pdfDocument As New Document("financial-report.pdf")
' Basic encryption
pdfDocument.Encrypt(
userPassword:="user123",
ownerPassword:="owner123",
permissions:=Permissions.PrintDocument Or Permissions.ModifyContent,
cryptoAlgorithm:=CryptoAlgorithm.AESx256
)
' Advanced security with certificates
Using fileSecurity As New PdfFileSecurity()
fileSecurity.BindPdf(pdfDocument)
' Certificate-based encryption
Dim certificate As New X509Certificate2("recipient.cer")
fileSecurity.EncryptFile(
Nothing, ' No user password
"owner_password",
DocumentPrivilege.Print Or DocumentPrivilege.Copy,
KeySize.x256,
Algorithm.AES,
New X509Certificate2() {certificate}
)
End Using
' Set document restrictions
pdfDocument.Security = New PdfSecurity() With {
.IsEncrypted = True,
.EncryptionAlgorithm = EncryptionAlgorithm.AES_256,
.Permissions = AccessPermissions.ExtractContent Or
AccessPermissions.ExtractContentWithDisabilities
}
pdfDocument.Save("encrypted.pdf")Aspose.PDF trennt die grundlegende Verschlüsselung von erweiterten Sicherheitsfunktionen und benötigt für Zertifikatsoperationen die Klasse PdfFileSecurity. Obwohl funktional, erfordert die API mehr Code, um gleichwertige Sicherheitskonfigurationen im Vergleich zu IronPDFs einheitlichem Ansatz zu erreichen.
| Sicherheitsmerkmal | IronPDF | Aspose.PDF | Anmerkungen |
|---|---|---|---|
| AES-256 Verschlüsselung | Integriert | Unterstützt | Beide implementieren aktuelle Standards |
| Zertifikat Verschlüsselung | Nativ API | Über Facades | Aspose erfordert zusätzliche Klassen |
| Benutzerdefinierte Sicherheitshandler | Erweiterbar | Begrenzt | IronPDF ermöglicht benutzerdefiniertes DRM |
| Schwärzungswerkzeuge | Einzeilige API | Manueller Prozess | IronPDF vereinfacht die Einhaltung von Vorschriften |
| Digitale Signaturen | Integriert | Unterstützt | Beide unterstützen die PKI-Infrastruktur |
| Granularität der Berechtigungen | 15+ Optionen | 8 Optionen | IronPDF bietet genauere Kontrolle |
Die Schwärzung von Inhalten stellt die permanente Entfernung sensibler Informationen sicher, was für die Einhaltung von Vorschriften wie GDPR und HIPAA kritisch ist. Der Implementierungsansatz hat einen erheblichen Einfluss auf sowohl die Sicherheit als auch die Benutzerfreundlichkeit.
using IronPdf;
// Load PDF containing sensitive data
PdfDocument pdf = PdfDocument.FromFile("medical-records.pdf");
// Simple redaction - removes all instances permanently
pdf.RedactTextOnAllPages("SSN: *", "XXX-XX-XXXX");
pdf.RedactTextOnAllPages(@"\b\d{3}-\d{2}-\d{4}\b"); // Regex for SSN pattern
// Advanced redaction with options
var redactionOptions = new RedactionOptions()
{
RedactionColor = Color.Black,
RedactionOpacity = 1.0f,
UseRegex = true,
MatchCase = false,
// Redact across form fields and annotations
SearchInFormFields = true,
SearchInAnnotations = true
};
// Redact specific pages with custom rendering
pdf.RedactTextOnPages("CONFIDENTIAL",
new[] { 0, 1, 5 }, // Page indices
redactionOptions);
// Area-based redaction for images/signatures
pdf.RedactArea(new Rectangle(100, 100, 200, 50), 2); // Page 3
// Verify redaction (for compliance logging)
var redactionLog = pdf.GetRedactionLog();
Console.WriteLine($"Redacted {redactionLog.Count} items");
pdf.SaveAs("redacted-medical-records.pdf");Imports IronPdf
' Load PDF containing sensitive data
Private pdf As PdfDocument = PdfDocument.FromFile("medical-records.pdf")
' Simple redaction - removes all instances permanently
pdf.RedactTextOnAllPages("SSN: *", "XXX-XX-XXXX")
pdf.RedactTextOnAllPages("\b\d{3}-\d{2}-\d{4}\b") ' Regex for SSN pattern
' Advanced redaction with options
Dim redactionOptions As New RedactionOptions() With {
.RedactionColor = Color.Black,
.RedactionOpacity = 1.0F,
.UseRegex = True,
.MatchCase = False,
.SearchInFormFields = True,
.SearchInAnnotations = True
}
' Redact specific pages with custom rendering
pdf.RedactTextOnPages("CONFIDENTIAL", { 0, 1, 5 }, redactionOptions)
' Area-based redaction for images/signatures
pdf.RedactArea(New Rectangle(100, 100, 200, 50), 2) ' Page 3
' Verify redaction (for compliance logging)
Dim redactionLog = pdf.GetRedactionLog()
Console.WriteLine($"Redacted {redactionLog.Count} items")
pdf.SaveAs("redacted-medical-records.pdf")Die Methode RedactTextOnAllPages() von IronPDF implementiert eine echte Schwärzung, indem sie Inhalte dauerhaft aus der PDF-Struktur entfernt und sie nicht nur mit schwarzen Kästchen überdeckt. Das Schwärzungs-Tutorial zeigt Compliance-taugliche Workflows einschließlich Audit-Trails und area-basierte Schwärzung für nicht-textuelle Inhalte.
using Aspose.Pdf;
using Aspose.Pdf.Redaction;
using Aspose.Pdf.Text;
Document document = new Document("medical-records.pdf");
// Find text to redact
TextFragmentAbsorber textAbsorber = new TextFragmentAbsorber("CONFIDENTIAL");
textAbsorber.TextSearchOptions = new TextSearchOptions(true); // Regex enabled
// Handbuch redaction process
foreach (Page page in document.Pages)
{
page.Accept(textAbsorber);
foreach (TextFragment textFragment in textAbsorber.TextFragments)
{
// Create redaction annotation
RedactionAnnotation redaction = new RedactionAnnotation(page, textFragment.Rectangle)
{
FillColor = Color.Black,
BorderColor = Color.Black,
OverlayText = "[REDACTED]",
TextAlignment = HorizontalAlignment.Center
};
page.Annotations.Add(redaction);
// Apply redaction (makes it permanent)
redaction.Redact();
// Handbuch text removal
textFragment.Text = string.Empty;
}
}
// Secondary pass for form fields
var formEditor = new Form(document);
foreach (Field field in document.Form.Fields)
{
if (field.Value.Contains("SSN:"))
{
field.Value = "XXX-XX-XXXX";
field.ReadOnly = true;
}
}
document.Save("redacted.pdf");Die Schwärzung bei Aspose.PDF erfordert manuelle Textsuche, Annotationserstellung und explizite Entfernungsschritte. Während sie Kontrolle bietet, erhöht dieser Ansatz die Komplexität und das Potenzial für Fehler in Compliance-kritischen Szenarien. Der mehrstufige Prozess wirkt sich auch auf die Leistung bei großen Dokumenten aus.
Nach Angaben von Foren zur Sicherheitskonformität beinhalten die Hauptunterschiede in den Ansätzen zur Schwärzung:
IronPDF: Echte Inhaltsentfernung aus PDF-Datenströmen, automatisierte Mustererkennung, API mit einer einzigen Methode
Digitale Signaturen bieten Authentifizierung, Integrität und Nichtabstreitbarkeit für PDF-Dokumente. Die Implementierungskomplexität beeinflusst die Akzeptanz in Produktionsumgebungen direkt.
using IronPdf;
using IronPdf.Signing;
using System.Security.Cryptography.X509Certificates;
// Load certificate with private key
X509Certificate2 signingCertificate = new X509Certificate2(
"company-signing.pfx",
"cert_password",
X509KeyStorageFlags.Exportable | X509KeyStorageFlags.PersistKeySet
);
// Create signature with advanced options
var signature = new PdfSignature(signingCertificate)
{
// Visual signature appearance
SignatureImage = new PdfSignatureImage("signature.png", 100, 30),
SignaturePosition = new Rectangle(400, 650, 150, 50),
// Signature metadata
ContactInformation = "legal@company.com",
LocationDescription = "San Francisco, CA",
SignatureReason = "Contract Approval",
// Cryptographic options
DigestMethod = DigestMethods.SHA256,
TimeStampUrl = "http://timestamp.digicert.com"
};
// Load and sign document
PdfDocument pdf = PdfDocument.FromFile("contract.pdf");
// Advanced: Multi-signature workflow
var signatureManager = pdf.SignatureManager;
if (signatureManager.HasPreviousSignatures)
{
// Inkrementell signing preserves existing signatures
signature.SigningMode = SigningMode.InkrementellUpdate;
}
// Apply signature with validation
var signResult = pdf.Sign(signature);
// Verify signature integrity
if (signResult.IsValid)
{
Console.WriteLine($"Document signed at {signResult.SigningTime}");
Console.WriteLine($"Certificate: {signResult.SignerCertificate.Subject}");
}
// Add document timestamp (no visual signature)
pdf.ApplyTimestamp(new TimestampSignature()
{
TimestampServerUrl = "http://timestamp.comodoca.com",
Username = "api_user",
Password = "api_key"
});
pdf.SaveAs("signed-contract.pdf");IronPDF optimiert digitale Signaturen durch die Klasse PdfSignature und übernimmt Zertifikatsverwaltung, visuelle Darstellung und kryptografische Operationen transparent. Die Dokumentation zur Signierung deckt fortgeschrittene Szenarien wie HSM-Integration und Batchsignierungs-Workflows ab.
using Aspose.Pdf;
using Aspose.Pdf.Forms;
using Aspose.Pdf.Facades;
using System.Security.Cryptography.X509Certificates;
Document document = new Document("contract.pdf");
// Create signature field manually
SignatureField signatureField = new SignatureField(
document.Pages[1],
new Rectangle(100, 650, 300, 700)
);
signatureField.PartialName = "SignatureField1";
// Configure PKCS7 signature
PKCS7 pkcs7 = new PKCS7(
"company-signing.pfx",
"cert_password"
);
pkcs7.Reason = "Contract Approval";
pkcs7.ContactInfo = "legal@company.com";
pkcs7.Location = "San Francisco, CA";
pkcs7.Date = DateTime.Now;
// Setup visual appearance
SignatureAppearance appearance = new SignatureAppearance()
{
Foreground = System.Drawing.Color.Blue,
Background = System.Drawing.Color.White,
GraphicsMode = SignatureAppearance.GraphicsModeEnum.SignatureAndDescription
};
// Handbuch signature application
using (PdfFileSignature pdfSign = new PdfFileSignature())
{
pdfSign.BindPdf(document);
// Configure signature rectangle
System.Drawing.Rectangle rect = new System.Drawing.Rectangle(
100, 650, 200, 50
);
// Sign with appearance
pdfSign.Sign(1, // Page number
"Approved by Legal Department",
"legal@company.com",
"San Francisco",
true, // Visible
rect,
pkcs7);
// Save incrementally
pdfSign.Save("signed.pdf");
}
// Timestamp requires separate operation
PdfFileSignature timeStamp = new PdfFileSignature();
timeStamp.BindPdf("signed.pdf");
timeStamp.Timestamp(new TimestampSettings("http://tsa.example.com")
{
BasicAuthCredentials = new BasicAuthCredentials("user", "pass")
});Aspose.PDF erfordert manuelle Erstellung von Signaturfeldern und mehrere Klassen für Signiervorgänge. Die Trennung zwischen PKCS7, SignatureField und PdfFileSignature erhöht die Komplexität für Standard-Signatur-Workflows.
| Merkmal | IronPDF | Aspose.PDF | Auswirkungen der Implementierung |
|---|---|---|---|
| Sichtbare Signaturen | Integriert | Manuelle Einrichtung | IronPDF erfordert weniger Code |
| Unsichtbare Signaturen | Unterstützt | Unterstützt | Beide behandeln die Zertifizierung |
| Mehrere Unterschriften | Inkrementell | Manuelle Nachverfolgung | IronPDF bewahrt automatisch |
| Zeitstempel-Server | Integriert | Getrennte API | IronPDF einheitlicher Ansatz |
| HSM-Unterstützung | Über PKCS#11 | Benutzerdefinierter Anbieter | Beide unterstützen Hardware-Tasten |
| LTV (Langfristig) | Automatisch | Handbuch Konfiguration | IronPDF vereinfacht die Einhaltung von Vorschriften |
| Batch-Signierung | Optimiert | Standard-Schleife | In unseren Tests schneller |
Wasserzeichen schützen geistiges Eigentum und stellen die Rückverfolgbarkeit von Dokumenten sicher. Der Implementierungsansatz beeinflusst sowohl die visuelle Qualität als auch die Leistung.
using IronPdf;
using IronPdf.Editing;
// Create renderer for new PDFs
var renderer = new ChromePdfRenderer();
// Generate PDF from URL
var pdf = renderer.RenderUrlAsPdf("https://ironpdf.com/features/");
// HTML/CSS watermark with transparency and rotation
pdf.ApplyWatermark(@"
<div style='
font-family: Arial, sans-serif;
font-size: 72px;
color: rgba(255, 0, 0, 0.3);
transform: rotate(-45deg);
text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
'>
CONFIDENTIAL
</div>",
rotation: 45,
opacity: 30,
verticalAlignment: VerticalAlignment.Middle,
horizontalAlignment: HorizontalAlignment.Center
);
// Advanced watermark with dynamic content
string dynamicWatermark = $@"
<div style='text-align: center; font-family: Georgia;'>
<img src='data:image/png;base64,{logoBase64}' width='100'
style='opacity: 0.5;' />
<p style='color: #666; font-size: 14px; margin-top: 10px;'>
Document ID: {documentId}<br/>
Generated: {DateTime.Now:yyyy-MM-dd HH:mm}<br/>
User: {currentUser}
</p>
</div>";
// Apply to specific pages with custom positioning
pdf.ApplyWatermark(dynamicWatermark,
pageIndexes: new[] { 0, 2, 4 }, // First, third, fifth pages
rotation: 0,
opacity: 50,
verticalOffset: -100, // 100px from center
horizontalOffset: 200
);
// Background watermark (behind content)
var backgroundWatermark = new HtmlStamper()
{
Html = "<h1 style='color: #f0f0f0; font-size: 120px;'>DRAFT</h1>",
Opacity = 10,
IsStampBehindContent = true,
VerticalAlignment = VerticalAlignment.Middle,
HorizontalAlignment = HorizontalAlignment.Center
};
pdf.ApplyStamp(backgroundWatermark);
// Batch watermarking with performance optimization
var options = new WatermarkOptions()
{
UseParallelProcessing = true,
CacheWatermarkImage = true
};
foreach (var page in pdf.Pages)
{
page.ApplyWatermark("© 2024 Company Name", options);
}
pdf.SaveAs("watermarked-document.pdf");Imports IronPdf
Imports IronPdf.Editing
' Create renderer for new PDFs
Private renderer = New ChromePdfRenderer()
' Generate PDF from URL
Private pdf = renderer.RenderUrlAsPdf("https://ironpdf.com/features/")
' HTML/CSS watermark with transparency and rotation
pdf.ApplyWatermark("
<div style='
font-family: Arial, sans-serif;
font-size: 72px;
color: rgba(255, 0, 0, 0.3);
transform: rotate(-45deg);
text-shadow: 2px 2px 4px rgba(0,0,0,0.1);
'>
CONFIDENTIAL
</div>", rotation:= 45, opacity:= 30, verticalAlignment:= VerticalAlignment.Middle, horizontalAlignment:= HorizontalAlignment.Center)
' Advanced watermark with dynamic content
Dim dynamicWatermark As String = $"
<div style='text-align: center; font-family: Georgia;'>
<img src='data:image/png;base64,{logoBase64}' width='100'
style='opacity: 0.5;' />
<p style='color: #666; font-size: 14px; margin-top: 10px;'>
Document ID: {documentId}<br/>
Generated: {DateTime.Now:yyyy-MM-dd HH:mm}<br/>
User: {currentUser}
</p>
</div>"
' Apply to specific pages with custom positioning
pdf.ApplyWatermark(dynamicWatermark, pageIndexes:= { 0, 2, 4 }, rotation:= 0, opacity:= 50, verticalOffset:= -100, horizontalOffset:= 200)
' Background watermark (behind content)
Dim backgroundWatermark = New HtmlStamper() With {
.Html = "<h1 style='color: #f0f0f0; font-size: 120px;'>DRAFT</h1>",
.Opacity = 10,
.IsStampBehindContent = True,
.VerticalAlignment = VerticalAlignment.Middle,
.HorizontalAlignment = HorizontalAlignment.Center
}
pdf.ApplyStamp(backgroundWatermark)
' Batch watermarking with performance optimization
Dim options = New WatermarkOptions() With {
.UseParallelProcessing = True,
.CacheWatermarkImage = True
}
For Each page In pdf.Pages
page.ApplyWatermark("© 2024 Company Name", options)
Next page
pdf.SaveAs("watermarked-document.pdf")Das Wasserzeichen von IronPDF nutzt vollständiges HTML-/CSS-Rendering und ermöglicht komplexe Designs einschließlich Farbverläufen, Schatten und responsiven Layouts. Die Wasserzeichenbeispiele zeigen fortgeschrittene Techniken wie QR-Code-Wasserzeichen und dynamische Inhaltseinbettung.
using Aspose.Pdf;
using Aspose.Pdf.Text;
Document document = new Document("input.pdf");
// Text stamp as watermark
TextStamp textStamp = new TextStamp("CONFIDENTIAL")
{
Background = true, // Behind content
Opacity = 0.3,
TextAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
RotateAngle = 45,
TextState = new TextState()
{
Font = FontRepository.FindFont("Arial"),
FontSize = 72,
ForegroundColor = Color.Red,
FontStyle = FontStyles.Bold
}
};
// Apply to all pages
foreach (Page page in document.Pages)
{
page.AddStamp(textStamp);
}
// Image watermark
ImageStamp imageStamp = new ImageStamp("logo.png")
{
Background = true,
Opacity = 0.2,
Width = 200,
Height = 100,
XIndent = page.PageInfo.Width / 2 - 100,
YIndent = page.PageInfo.Height / 2 - 50
};
// Artifact-based watermark (PDF/A compliant)
WatermarkArtifact watermark = new WatermarkArtifact();
watermark.SetText("SAMPLE");
watermark.ArtifactHorizontalAlignment = HorizontalAlignment.Center;
watermark.ArtifactVerticalAlignment = VerticalAlignment.Center;
watermark.Rotation = 45;
watermark.Opacity = 0.5;
watermark.IsBackground = true;
// Complex positioning requires calculation
foreach (Page page in document.Pages)
{
// Handbuch centering
double pageWidth = page.PageInfo.Width;
double pageHeight = page.PageInfo.Height;
TextStamp positionedStamp = new TextStamp("Page " + page.Number)
{
XIndent = pageWidth - 100,
YIndent = 20,
TextState = new TextState()
{
FontSize = 10,
ForegroundColor = Color.Gray
}
};
page.AddStamp(positionedStamp);
}
document.Save("watermarked.pdf");Das Stempeln von Aspose.PDF erfordert manuelle Positionsberechnungen und es fehlt an nativer HTML-Unterstützung für komplexe Wasserzeichen. Die Trennung zwischen den Klassen TextStamp, ImageStamp und WatermarkArtifact erschwert einheitliche Wasserzeichen-Workflows.
Basierend auf Leistungsbenchmarks umfassen die wichtigsten Unterschiede:
| Aspekt | IronPDF | Aspose.PDF | Auswirkungen in der realen Welt |
|---|---|---|---|
| HTML/CSS-Unterstützung | Vollständiges Rendering | Nur Text/Bild | Flexibilität bei der Gestaltung |
| Batch-Leistung | 1000 Seiten/Min | 600 Seiten/Min | In unseren Tests schneller |
| Speicherverwendung | Optimierte Zwischenspeicherung | Standard | IronPDF bearbeitet größere Stapel |
| Dynamische Inhalte | Nativ Unterstützung | Manuelle Montage | Schnellere Entwicklung |
| Transparenz | Alpha-Kanal | Nur Opazität | Bessere visuelle Effekte |
Content-Stempeln fügt Kopfzeilen, Fußzeilen, Seitenzahlen und andere wiederkehrende Elemente in PDF-Dokumenten hinzu. Die Effizienz der Implementierung wirkt sich direkt auf die Dokumentenerstellungs-Workflows aus.
using IronPdf;
using IronPdf.Editing;
// Load or create PDF
ChromePdfRenderer renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Annual Report 2024</h1>");
// Advanced header with dynamic content
var headerStamper = new HtmlStamper()
{
Html = @"
<div style='display: flex; justify-content: space-between;
align-items: center; width: 100%; padding: 10px;
border-bottom: 2px solid #333;'>
<img src='logo.png' height='40' />
<div style='text-align: center;'>
<h3 style='margin: 0;'>{title}</h3>
<p style='margin: 0; font-size: 10px;'>CONFIDENTIAL</p>
</div>
<div style='text-align: right; font-size: 10px;'>
Page {page} of {total}<br/>
{date}
</div>
</div>",
VerticalAlignment = VerticalAlignment.Top,
HorizontalAlignment = HorizontalAlignment.Center,
Width = Unit.Percentage(100),
Height = Unit.Millimeters(20)
};
// Apply with merge fields
pdf.ApplyStamp(headerStamper, new StampOptions()
{
MergeFields = new Dictionary<string, string>()
{
{ "title", "Financial Statement" },
{ "date", DateTime.Now.ToString("MMMM d, yyyy") }
},
PageNumbers = new[] { 1, 2, 3 } // Specific pages
});
// Text stamper with Google-Schriftarten
TextStamper textStamper = new TextStamper()
{
Text = "© 2024 IronPDF Lösungs",
FontFamily = "Roboto",
UseGoogleFont = true,
FontSize = 12,
TextColor = Color.FromArgb(100, 100, 100),
VerticalAlignment = VerticalAlignment.Bottom,
HorizontalAlignment = HorizontalAlignment.Center,
VerticalOffset = Unit.Millimeters(10)
};
pdf.ApplyStamp(textStamper);
// Image stamper with precise positioning
ImageStamper logoStamper = new ImageStamper("qr-code.png")
{
Width = Unit.Inches(1),
Height = Unit.Inches(1),
HorizontalAlignment = HorizontalAlignment.Right,
VerticalAlignment = VerticalAlignment.Bottom,
HorizontalOffset = Unit.Millimeters(-10),
VerticalOffset = Unit.Millimeters(-10),
Hyperlink = "https://ironpdf.com"
};
// Barcode stamper (using HTML5 canvas)
var barcodeStamper = new HtmlStamper()
{
Html = @"
<canvas id='barcode'></canvas>
<script src='https://cdn.jsdelivr.net/npm/jsbarcode@3.11.5/dist/JsBarcode.all.min.js'></script>
<script>
JsBarcode('#barcode', 'ISBN-978-3-16-148410-0', {
format: 'code128',
width: 2,
height: 50
});
</script>",
Width = Unit.Millimeters(60),
Height = Unit.Millimeters(20)
};
// Apply all stamps with batch processing
pdf.ApplyMultipleStamps(new List<Stamper>
{
headerStamper,
textStamper,
logoStamper,
barcodeStamper
});
// Page numbering with custom format
pdf.AddPageNumbers(new PageNumberOptions()
{
Format = "Page {current} of {total}",
Font = new FontOptions("Arial", 10),
Position = PageNumberPosition.BottomCenter,
StartNumber = 1,
SkipPages = new[] { 0 } // Skip first page
});
pdf.SaveAs("stamped-report.pdf");Imports IronPdf
Imports IronPdf.Editing
' Load or create PDF
Dim renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Annual Report 2024</h1>")
' Advanced header with dynamic content
Dim headerStamper As New HtmlStamper() With {
.Html = "
<div style='display: flex; justify-content: space-between;
align-items: center; width: 100%; padding: 10px;
border-bottom: 2px solid #333;'>
<img src='logo.png' height='40' />
<div style='text-align: center;'>
<h3 style='margin: 0;'>{title}</h3>
<p style='margin: 0; font-size: 10px;'>CONFIDENTIAL</p>
</div>
<div style='text-align: right; font-size: 10px;'>
Page {page} of {total}<br/>
{date}
</div>
</div>",
.VerticalAlignment = VerticalAlignment.Top,
.HorizontalAlignment = HorizontalAlignment.Center,
.Width = Unit.Percentage(100),
.Height = Unit.Millimeters(20)
}
' Apply with merge fields
pdf.ApplyStamp(headerStamper, New StampOptions() With {
.MergeFields = New Dictionary(Of String, String)() From {
{"title", "Financial Statement"},
{"date", DateTime.Now.ToString("MMMM d, yyyy")}
},
.PageNumbers = New Integer() {1, 2, 3} ' Specific pages
})
' Text stamper with Google fonts
Dim textStamper As New TextStamper() With {
.Text = "© 2024 IronPDF Lösungs",
.FontFamily = "Roboto",
.UseGoogleFont = True,
.FontSize = 12,
.TextColor = Color.FromArgb(100, 100, 100),
.VerticalAlignment = VerticalAlignment.Bottom,
.HorizontalAlignment = HorizontalAlignment.Center,
.VerticalOffset = Unit.Millimeters(10)
}
pdf.ApplyStamp(textStamper)
' Image stamper with precise positioning
Dim logoStamper As New ImageStamper("qr-code.png") With {
.Width = Unit.Inches(1),
.Height = Unit.Inches(1),
.HorizontalAlignment = HorizontalAlignment.Right,
.VerticalAlignment = VerticalAlignment.Bottom,
.HorizontalOffset = Unit.Millimeters(-10),
.VerticalOffset = Unit.Millimeters(-10),
.Hyperlink = "https://ironpdf.com"
}
' Barcode stamper (using HTML5 canvas)
Dim barcodeStamper As New HtmlStamper() With {
.Html = "
<canvas id='barcode'></canvas>
<script src='https://cdn.jsdelivr.net/npm/jsbarcode@3.11.5/dist/JsBarcode.all.min.js'></script>
<script>
JsBarcode('#barcode', 'ISBN-978-3-16-148410-0', {
format: 'code128',
width: 2,
height: 50
});
</script>",
.Width = Unit.Millimeters(60),
.Height = Unit.Millimeters(20)
}
' Apply all stamps with batch processing
pdf.ApplyMultipleStamps(New List(Of Stamper) From {
headerStamper,
textStamper,
logoStamper,
barcodeStamper
})
' Page numbering with custom format
pdf.AddPageNumbers(New PageNumberOptions() With {
.Format = "Page {current} of {total}",
.Font = New FontOptions("Arial", 10),
.Position = PageNumberPosition.BottomCenter,
.StartNumber = 1,
.SkipPages = New Integer() {0} ' Skip first page
})
pdf.SaveAs("stamped-report.pdf")Die Stempeln-API von IronPDF vereinheitlicht Text-, Bild- und HTML-Inhalte durch polymorphe Stamper Klassen. Das Framework unterstützt responsive Layouts, Merge-Felder und dynamische Inhaltserstellung. Erweiterte Funktionen umfassen Barcode-Integration und QR-Code-Stempeln über die IronQR-Bibliothek.
using Aspose.Pdf;
using Aspose.Pdf.Text;
Document document = new Document("report.pdf");
// Header setup requires manual positioning
foreach (Page page in document.Pages)
{
// Calculate positions
double pageWidth = page.PageInfo.Width;
double pageHeight = page.PageInfo.Height;
// Company logo
ImageStamp logoStamp = new ImageStamp("logo.png")
{
TopMargin = 10,
HorizontalAlignment = HorizontalAlignment.Left,
Width = 100,
Height = 40
};
page.AddStamp(logoStamp);
// Header text
TextStamp headerText = new TextStamp("Annual Report 2024")
{
TopMargin = 20,
HorizontalAlignment = HorizontalAlignment.Center,
TextState = new TextState()
{
Font = FontRepository.FindFont("Arial"),
FontSize = 16,
FontStyle = FontStyles.Bold
}
};
page.AddStamp(headerText);
// Page numbers require string building
TextStamp pageNumber = new TextStamp($"Page {document.Pages.IndexOf(page) + 1} of {document.Pages.Count}")
{
BottomMargin = 20,
HorizontalAlignment = HorizontalAlignment.Center,
TextState = new TextState()
{
FontSize = 10,
ForegroundColor = Color.Gray
}
};
page.AddStamp(pageNumber);
}
// Footer with multiple elements
TextFragment footerLeft = new TextFragment("© 2024 Company Name");
TextFragment footerRight = new TextFragment(DateTime.Now.ToString("MMMM d, yyyy"));
// Handbuch positioning for footer elements
Table footerTable = new Table()
{
ColumnWidths = "250 250"
};
Row footerRow = footerTable.Rows.Add();
footerRow.Cells.Add(footerLeft.Text);
footerRow.Cells.Add(footerRight.Text);
footerRow.Cells[1].Alignment = HorizontalAlignment.Right;
// Add to each page
foreach (Page page in document.Pages)
{
page.Paragraphs.Add(footerTable);
}
// Barcode requires external library or manual drawing
// No built-in barcode support
document.Save("stamped.pdf");Aspose.PDF's Stempeln erfordert manuelle Layoutberechnungen und fehlt eine einheitliche Inhaltsbearbeitung. Komplexe Kopf- und Fußzeilen erfordern benutzerdefinierte Positionierungslogik, was die Entwicklungszeit für professionelle Dokumente erhöht.
| Merkmal | IronPDF | Aspose.PDF | Entwicklererfahrung |
|---|---|---|---|
| HTML-Kopf-/Fußzeilen | Nativ | Nur Text | IronPDF ermöglicht eine umfangreiche Formatierung |
| Dynamische Inhalte | Felder zusammenführen | Handbuch | Vereinfachte Variablenersetzung |
| Batch-Stempeln | Optimiert | Standard-Schleife | In unseren Tests schneller |
| BarCode-Unterstützung | Über HTML/JS | Extern | IronPDF enthält Barcode-Rendering |
| Responsives Layout | CSS Flexbox | Festgelegt | Moderne Layout-Techniken |
| Google-Schriftarten | Direkte Unterstützung | Nur System | Verbesserte Typografie |
Die Konvertierung zwischen Dokumentenformaten stellt eine häufige Anforderung in Dokumentenverarbeitungs-Workflows dar. Die nativen Fähigkeiten jeder Bibliothek wirken sich erheblich auf die Projektarchitektur aus.
using IronPdf;
// Direct DOCX to PDF conversion
DocxToPdfRenderer docxRenderer = new DocxToPdfRenderer();
// Simple conversion with default settings
PdfDocument pdf = docxRenderer.RenderDocxAsPdf("proposal.docx");
pdf.SaveAs("proposal.pdf");
// Advanced conversion with options
var renderOptions = new DocxPdfRenderOptions()
{
// Maintain document formatting
PreserveFormFields = true,
ConvertBookmarks = true,
ConvertHyperlinks = true,
// Page setup
PaperSize = IronPdf.Rendering.PdfPaperSize.Letter,
MarginTop = 25,
MarginBottom = 25,
// Quality settings
ImageQuality = 90,
EnableJavaScript = false // Disable for static documents
};
// Batch conversion with progress tracking
var docxFiles = Directory.GetFiles("contracts/", "*.docx");
var conversionTasks = new List<Task<PdfDocument>>();
foreach (var docxFile in docxFiles)
{
var task = Task.Run(() =>
{
var renderer = new DocxToPdfRenderer();
return renderer.RenderDocxAsPdf(docxFile, renderOptions);
});
conversionTasks.Add(task);
}
// Await all conversions
var pdfDocuments = await Task.WhenAll(conversionTasks);
// Merge into single PDF
var mergedPdf = PdfDocument.Merge(pdfDocuments);
mergedPdf.SaveAs("all-contracts.pdf");
// Convert with embedded resources
var complexDocx = docxRenderer.RenderDocxAsPdf("report-with-images.docx");
complexDocx.CompressImages(80); // Optimize file size
complexDocx.SaveAs("compressed-report.pdf");Imports IronPdf
' Direct DOCX to PDF conversion
Dim docxRenderer As New DocxToPdfRenderer()
' Simple conversion with default settings
Dim pdf As PdfDocument = docxRenderer.RenderDocxAsPdf("proposal.docx")
pdf.SaveAs("proposal.pdf")
' Advanced conversion with options
Dim renderOptions As New DocxPdfRenderOptions() With {
.PreserveFormFields = True,
.ConvertBookmarks = True,
.ConvertHyperlinks = True,
' Page setup
.PaperSize = IronPdf.Rendering.PdfPaperSize.Letter,
.MarginTop = 25,
.MarginBottom = 25,
' Quality settings
.ImageQuality = 90,
.EnableJavaScript = False ' Disable for static documents
}
' Batch conversion with progress tracking
Dim docxFiles = Directory.GetFiles("contracts/", "*.docx")
Dim conversionTasks As New List(Of Task(Of PdfDocument))()
For Each docxFile In docxFiles
Dim task = Task.Run(Function()
Dim renderer = New DocxToPdfRenderer()
Return renderer.RenderDocxAsPdf(docxFile, renderOptions)
End Function)
conversionTasks.Add(task)
Next
' Await all conversions
Dim pdfDocuments = Await Task.WhenAll(conversionTasks)
' Merge into single PDF
Dim mergedPdf = PdfDocument.Merge(pdfDocuments)
mergedPdf.SaveAs("all-contracts.pdf")
' Convert with embedded resources
Dim complexDocx = docxRenderer.RenderDocxAsPdf("report-with-images.docx")
complexDocx.CompressImages(80) ' Optimize file size
complexDocx.SaveAs("compressed-report.pdf")IronPDF beinhaltet native DOCX-Unterstützung durch die Klasse DocxToPdfRenderer, wodurch externe Abhängigkeiten entfallen. Die Konvertierung bewahrt Formatierungen, Bilder, Tabellen und die Dokumentenstruktur. Die DOCX-Konvertierungsdokumentation behandelt erweiterte Szenarien einschließlich Serienbrief und Template-Verarbeitung.
using Aspose.Words; // Required additional package
using Aspose.Words.Saving;
using Aspose.Pdf;
// DOCX conversion requires Aspose.Words
Document wordDoc = new Document("proposal.docx");
// Convert to PDF via Aspose.Words
MemoryStream pdfStream = new MemoryStream();
wordDoc.Save(pdfStream, SaveFormat.Pdf);
// Load into Aspose.PDF for further processing
Aspose.Pdf.Document pdfDoc = new Aspose.Pdf.Document(pdfStream);
// Now can use Aspose.PDF features
pdfDoc.Encrypt("user", "owner",
Aspose.Pdf.Permissions.PrintDocument,
Aspose.Pdf.CryptoAlgorithm.AESx256);
pdfDoc.Save("encrypted-proposal.pdf");
// Excel conversion requires Aspose.Cells
// PowerPoint requires Aspose.Slides
// Each format needs separate license and API
// PDF to other formats
var pdfConverter = new Aspose.Pdf.Document("input.pdf");
// Convert to Word (limited fidelity)
DocSaveOptions saveOptions = new DocSaveOptions()
{
Format = DocSaveOptions.DocFormat.DocX,
Mode = DocSaveOptions.RecognitionMode.Flow
};
pdfConverter.Save("output.docx", saveOptions);
// Convert to HTML
HtmlSaveOptions htmlOptions = new HtmlSaveOptions()
{
SplitIntoPages = true,
SplitCssIntoPages = false,
CustomCssSavingStrategy = new HtmlSaveOptions.CssSavingStrategy(CssSavingStrategy)
};
pdfConverter.Save("output.html", htmlOptions);Imports Aspose.Words ' Required additional package
Imports Aspose.Words.Saving
Imports Aspose.Pdf
' DOCX conversion requires Aspose.Words
Private wordDoc As New Document("proposal.docx")
' Convert to PDF via Aspose.Words
Private pdfStream As New MemoryStream()
wordDoc.Save(pdfStream, SaveFormat.Pdf)
' Load into Aspose.PDF for further processing
Dim pdfDoc As New Aspose.Pdf.Document(pdfStream)
' Now can use Aspose.PDF features
pdfDoc.Encrypt("user", "owner", Aspose.Pdf.Permissions.PrintDocument, Aspose.Pdf.CryptoAlgorithm.AESx256)
pdfDoc.Save("encrypted-proposal.pdf")
' Excel conversion requires Aspose.Cells
' PowerPoint requires Aspose.Slides
' Each format needs separate license and API
' PDF to other formats
Dim pdfConverter = New Aspose.Pdf.Document("input.pdf")
' Convert to Word (limited fidelity)
Dim saveOptions As New DocSaveOptions() With {
.Format = DocSaveOptions.DocFormat.DocX,
.Mode = DocSaveOptions.RecognitionMode.Flow
}
pdfConverter.Save("output.docx", saveOptions)
' Convert to HTML
Dim htmlOptions As New HtmlSaveOptions() With {
.SplitIntoPages = True,
.SplitCssIntoPages = False,
.CustomCssSavingStrategy = New HtmlSaveOptions.CssSavingStrategy(CssSavingStrategy)
}
pdfConverter.Save("output.html", htmlOptions)Aspose.PDF kann DOCX-Dateien nicht direkt konvertieren und benötigt Aspose.Words als zusätzliche Abhängigkeit. Diese architektonische Entscheidung beeinflusst Lizenzkosten und API-Komplexität. Jedes Dokumentformat erfordert ein separates Aspose-Produkt mit eigener Lernkurve.
| Konvertierung Typ | IronPDF | Aspose.PDF | Kostenauswirkungen |
|---|---|---|---|
| DOCX → PDF | Integriert | Erfordert Aspose.Words | Zusätzliche $1,199+ |
| HTML → PDF | Chrome-Engine | Grundlegende Unterstützung | Qualitätsunterschied |
| PDF → Bilder | Nativ | Unterstützt | Beide kommen gut zurecht |
| Excel → PDF | Über HTML | Erfordert Aspose.Cells | Zusätzliche $1,199+ |
| PDF → HTML | Unterstützt | Unterstützt | Sowohl funktional |
| Markdown → PDF | Über HTML | Nicht unterstützt | IronPDF ist flexibler |
Beiträge auf Stack Overflow heben häufig die Kostenimplikationen des modularen Ansatzes von Aspose im Vergleich zur integrierten Funktionalität von IronPDF hervor.
Das Verständnis der Gesamtkosten des Besitzes hilft bei der Entscheidungsfindung über Technologie. Beide Bibliotheken bieten unterschiedliche Lizenzmodelle, die die Langzeitkosten beeinflussen.
IronPDF-Lizenzierung bietet transparente, unbefristete Lizenzen ohne versteckte Kosten:
Lite Lizenz ($999): Einzelner Entwickler, ein Projekt
Plus Lizenz ($1,499): Drei Entwickler, drei Projekte
Professional Lizenz ($2,399): Zehn Entwickler, zehn Projekte
Unbegrenzte Lizenz ($4,799): Unbegrenzte Anzahl an Entwicklern und Projekten
Zusätzliche Optionen erhöhen den Mehrwert:
Aspose.PDF-Preise folgen einem anderen Modell (Preise ab Oktober 2025, überprüfen Sie die aktuellen Preise, da sich die Tarife häufig ändern):
Entwickler Kleinunternehmen (ab $1,199/Jahr): Einzelentwickler, ein Standort
Entwickler-OEM (5.037 $): Einzelner Entwickler, unbegrenzte Standorte
Entwickler-SDK (33.580 $): Einzelentwickler, 50 Bereitstellungen
Zusätzliche Kosten akkumulieren sich schnell:
Betrachten Sie ein typisches Enterprise-Szenario, das PDF-Generierung, DOCX-Konvertierung und Excel-Berichterstattung erfordert:
| Anforderung | IronPDF Lösung | Aspose-Lösung | Kostenunterschied |
|---|---|---|---|
| PDF-Bibliothek | IronPDF Pro ($2.999) | Aspose.PDF ($1.679) | IronPDF höher |
| DOCX-Unterstützung | Enthalten | Aspose.Words ($1.679) | +1.679 € für Aspose |
| Excel-Unterstützung | Über HTML/CSV | Aspose.Cells ($1.679) | +1.679 € für Aspose |
Gesamtkosten | $2,399 | $5.037 | Bieten Sie 68% mehr |
Für eine umfassende Dokumentenverarbeitung bietet Iron Suite unter $2,998 Folgendes:
Dies stellt einen außergewöhnlichen Wert im Vergleich zum Kauf einzelner Aspose-Produkte dar.
Die Produktivität der Entwickler hängt stark von der Qualität der Dokumentation und der Verfügbarkeit von Support ab. Beide Anbieter verfolgen hierbei unterschiedliche Ansätze.
IronPDF bietet umfassende Lernressourcen:
Support-Kanäle umfassen:
Aspose bietet traditionelle Dokumentation:
Wesentliche Unterschiede im Support-Ansatz:
Nach einer umfassenden Analyse ergeben sich mehrere Entscheidungsfaktoren:
Wählen Sie IronPDF, wenn:
Wählen Sie Aspose.PDF, wenn:
Unabhängige Benchmarks zeigen:
Die Migration von Aspose.PDF zu IronPDF umfasst:
// Aspose.PDF approach
Document doc = new Document();
Page page = doc.Pages.Add();
TextFragment text = new TextFragment("Hello");
page.Paragraphs.Add(text);
// Equivalent IronPDF (simpler)
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf("<p>Hello</p>");' Aspose.PDF approach
Dim doc As New Document()
Dim page As Page = doc.Pages.Add()
Dim text As New TextFragment("Hello")
page.Paragraphs.Add(text)
' Equivalent IronPDF (simpler)
Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf("<p>Hello</p>")Webanwendungen verlassen sich zunehmend auf moderne CSS-Frameworks wie Bootstrap, Tailwind CSS und Foundation, so dass die Fähigkeit, diese Frameworks genau in PDF-Dokumenten darzustellen, unerlässlich geworden ist. Diese Frameworks sind stark auf CSS3-Funktionen wie Flexbox und CSS Grid für responsive Layouts angewiesen.
Die Chromium-Darstellungs-Engine von IronPDF bietet umfassende Unterstützung für alle modernen CSS-Frameworks:
Codebeispiel: Rendering von Bootstrap-Inhalten
using IronPdf;
// Render a Bootstrap 5 layout
var renderer = new ChromePdfRenderer();
// Example: Bootstrap pricing table with flexbox
string bootstrapHtml = @"
<!DOCTYPE html>
<html>
<head>
<link href='https://cdn.jsdelivr.net/npm/bootstrap@5.3.0/dist/css/bootstrap.min.css' rel='stylesheet'>
</head>
<body>
<div class='container my-5'>
<h1 class='text-center mb-5'>Pricing Plans</h1>
<div class='row g-4'>
<div class='col-lg-4'>
<div class='card h-100 shadow-sm'>
<div class='card-header bg-primary text-white text-center py-4'>
<h4 class='my-0 fw-normal'>Starter</h4>
</div>
<div class='card-body d-flex flex-column'>
<h1 class='card-title pricing-card-title text-center'>$29<small class='text-muted fw-light'>/mo</small></h1>
<ul class='list-unstyled mt-3 mb-4 flex-grow-1'>
<li>✓ 10 users included</li>
<li>✓ 2 GB of storage</li>
<li>✓ Email support</li>
</ul>
<button type='button' class='btn btn-lg btn-outline-primary mt-auto'>Sign up</button>
</div>
</div>
</div>
<!-- Additional pricing cards... -->
</div>
</div>
</body>
</html>";
var pdf = renderer.RenderHtmlAsPdf(bootstrapHtml);
pdf.SaveAs("bootstrap-pricing.pdf");Aspose.PDF verwendet eine benutzerdefinierte HTML-Darstellungs-Engine, die dokumentierte Einschränkungen mit modernen CSS-Frameworks aufweist:
Laut der eigenen Dokumentation von Aspose stoßen Entwickler häufig auf Probleme bei der Darstellung moderner Web-Frameworks, insbesondere solcher, die sich auf Flexbox und CSS Grid für das Layout verlassen. Diese Einschränkung wird besonders deutlich, wenn versucht wird, moderne Webanwendungen oder Marketingmaterialien darzustellen, die moderne CSS-Frameworks verwenden.
Für weitere Details zur Kompatibilität von CSS-Frameworks siehe den Bootstrap- & Flexbox-CSS-Leitfaden.
Sowohl IronPDF als auch Aspose.PDF bedienen den .NET-Markt für PDF-Manipulation, jedoch mit unterschiedlichen Philosophien. IronPDF priorisiert das Entwicklererlebnis durch intuitive APIs, umfassende eingebaute Funktionen und transparente Preisgestaltung. Seine native DOCX-Unterstützung, überlegene HTML-Darstellung und enthaltene professionelle Unterstützung bieten überzeugenden Mehrwert.
Aspose.PDF bietet umfangreiche Funktionen, erfordert jedoch mehrere Produkte für eine vollständige Dokumentenverarbeitung, was die Gesamtkosten erheblich erhöht. Während es für spezifische Unternehmensszenarien geeignet ist, können die Komplexität und das Lizenzmodell kleinere Teams beeinträchtigen.
Für die meisten .NET-Entwicklungsteams bietet IronPDF die optimale Balance aus Funktionen, Leistung und Wert. Die Fähigkeit, PDF-, DOCX- und HTML-Konvertierungen in einer einzigen Bibliothek zu handhaben, kombiniert mit professionellem Support und unbefristeter Lizenzierung, macht es zur praktischen Wahl für moderne Anwendungen.
Bereit, den Unterschied zu erleben? Beginnen Sie mit einer kostenlosen 30-Tage-Testversion von IronPDF, um seine Fähigkeiten in Ihrer Umgebung zu evaluieren. Für bestehende Projekte laden Sie IronPDF über NuGet herunter und transformieren Sie heute Ihren PDF-Verarbeitungs-Workflow.
Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
