In modernen .NET-Anwendungen ist das Erstellen und Verwalten von PDF-Dateien eine häufige Anforderung - sei es für die Erstellung von Berichten, Rechnungen oder digitalen Aufzeichnungen. Entwickler greifen oft auf Drittanbieter-PDF-Bibliotheken für diese Aufgabe zurück, und zwei der beliebtesten Optionen im .NET-Ökosystem sind IronPDF und iText (der Nachfolger von iText).
Jede Bibliothek bietet ein leistungsstarkes Toolset für unterschiedliche Anwendungsfälle. Aber welche ist am besten geeignet, um ein PDF aus einem [Byte-Array](https://learn.microsoft.com/en-us/previous-versions/visualstudio/visual-studio-2013/dd831853(v=vs.120) in C# zu generieren? Dieser Artikel stellt alles in den Vergleich, bietet Codebeispiele und Einblicke, um .NET-Entwicklern zu helfen, die richtige Wahl zu treffen.
Egal, ob Sie Unternehmensanwendungen oder kleine interne Tools entwickeln, die Wahl der richtigen PDF-Bibliothek kann Ihnen Entwicklungszeit sparen und ein robustes Ergebnis gewährleisten. Lassen Sie uns erkunden, was jede Bibliothek bietet.
PDF-Bibliotheken in C# ermöglichen es Entwicklern, PDF-Dateien programmgesteuert zu erstellen, zu manipulieren und zu lesen. Sie dienen einer Vielzahl von Anwendungsfällen, wie z.B.:
Sie spielen auch eine entscheidende Rolle in der Datenportabilität und der Einhaltung von Normen wie PDF/A für Archivierung oder Zugänglichkeitsanforderungen.
Unter den verfügbaren .NET PDF-Bibliotheken haben sich iText und IronPDF als führende Lösungen herausgebildet – jede mit einzigartigen Stärken:
Die Wahl zwischen den beiden ist nicht nur eine Frage der Präferenz - sie wirkt sich auf Produktivität, Wartung, Leistung und sogar rechtliche Lizenzkonformität aus. Projekte, die schnelle Umsetzungen, häufige Formatänderungen oder PDF-Renderings aus HTML-Vorlagen erfordern, profitieren von einer schnellen Entwicklung, während Unternehmensanwendungen möglicherweise Standardskonformität und langfristige Wartbarkeit priorisieren.
iText ist der offizielle Nachfolger von iText und bietet eine komplett überarbeitete Architektur. Es ist eine leistungsstarke und erweiterbare Bibliothek, die sich für die Erstellung, Bearbeitung und Validierung von PDFs in Compliance-intensiven Branchen wie Jura, Finanzen und Regierung eignet. Die iText Suite umfasst Unterstützung für PDF/A, PDF/UA, digitale Signaturen, Schwärzung und Formularerstellung.
Obwohl es immer noch Open-Source unter der AGPL-Lizenz ist, ist kommerzielle Lizenzierung für proprietäre Projekte verfügbar.
Um das Kernpaket von iText für die PDF-Generierung herunterzuladen:
Sie können iText auch über den Paketmanager für Bildschirm der Lösung installieren. Gehen Sie dazu zuerst zum Tools-Dropdown-Menü und dann zu "NuGet-Paketmanager > NuGet-Pakete für die Lösung verwalten".
Dann einfach nach iText suchen und auf "Installieren" klicken.
using System.IO;
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIText7();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIText7()
{
using (var ms = new MemoryStream())
{
var writer = new PdfWriter(ms);
var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
var doc = new Document(pdf);
doc.Add(new Paragraph("Hello from iText 7 for .NET!"));
doc.Close(); // Always close the document to finalize content
return ms.ToArray();
}
}
}Imports System.IO
Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIText7()
' Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfWithIText7() As Byte()
Using ms = New MemoryStream()
Dim writer = New PdfWriter(ms)
Dim pdf = New iText.Kernel.Pdf.PdfDocument(writer)
Dim doc = New Document(pdf)
doc.Add(New Paragraph("Hello from iText 7 for .NET!"))
doc.Close() ' Always close the document to finalize content
Return ms.ToArray()
End Using
End Function
End ClassAusgabe-PDF-Datei
Erklärung
PdfWriter schreibt den Inhalt in ein MemoryStream.PdfDocument verwaltet die interne Struktur des PDF.Document wird verwendet, um hochgradige Inhalte hinzuzufügen (Text, Bilder, Tabellen).doc.Close() ist der PDF-Inhalt vollständig geschrieben und bereit, als Byte-Array zurückgegeben zu werden.Dieses Beispiel zeigt die modularere und lesbarere API von iText im Vergleich zu iText. Es fehlt jedoch immer noch an nativer Unterstützung für das Rendern von HTML/CSS, es sei denn, Sie fügen pdfhtml hinzu, das separat lizenziert wird.
Vorteile:
Umfassende PDF-Kontrolle
iText bietet vollständige Kontrolle über PDF-Elemente, wie Tabellen, Formulare und digitale Signaturen. Dies macht es ideal für Compliance-intensive Anwendungen, die spezielle PDF-Standards wie PDF/A oder PDF/UA erfordern.
Modular und skalierbar
iText ist modular aufgebaut, was bedeutet, dass Sie nur die spezifischen Module installieren können, die Sie benötigen (z. B. pdfhtml für HTML-zu-PDF-Konvertierung). Dies ermöglicht eine leichtere Implementierung, wenn Sie nicht alle Funktionen nutzen.
Unterstützt komplexe PDF-Standards
iText unterstützt ISO-Standards wie PDF/A (Archivierung), PDF/UA (Barrierefreiheit) und PDF/X (Drucken), was es für professionelle und rechtliche Umgebungen geeignet macht, in denen Konformität entscheidend ist.
Reiche Dokumentation & Unterstützung
iText hat umfassende Dokumentation und eine große Community. Das Unternehmen bietet auch professionellen Support und stellt sicher, dass Entwickler bei Bedarf Unterstützung erhalten.
Freie Version verfügbar (AGPL)
Entwickler können iText kostenlos unter der AGPL-Lizenz verwenden, was ideal für Open-Source-Projekte oder den persönlichen Gebrauch ist.
Nachteile:
AGPL-Lizenz für kommerzielle Nutzung
Obwohl iText eine kostenlose Version bietet, müssen kommerzielle Anwender die AGPL-Lizenz einhalten, die die Freigabe des Quellcodes jeder Software, die iText verwendet, oder den Kauf einer kommerziellen Lizenz erfordert.
Steile Lernkurve
Die API von iText ist komplexer und funktionsreicher, was zu einer steileren Lernkurve im Vergleich zu einfacheren Bibliotheken wie IronPDF führen kann. Entwickler müssen sich mit der Low-Level-Dokumentenstruktur und der modularen Architektur vertraut machen.
Schwergewicht für einfache Aufgaben
iText kann sich für grundlegende PDF-Aufgaben, wie die einfache Dokumenterstellung oder grundlegende HTML-zu-PDF-Konvertierung, sperrig anfühlen, besonders im Vergleich zu Bibliotheken wie IronPDF, die den Prozess vereinfachen.
Benötigt externe Module für HTML zu PDF
Die HTML-zu-PDF-Konvertierung in iText ist nur über das zusätzliche pdfhtml-Modul verfügbar, das eine separate Installation erfordert und möglicherweise moderne Webinhalte nicht so nahtlos wie IronPDF behandelt.
IronPDF ist eine höherstufige .NET-Bibliothek, die entwickelt wurde, um die PDF-Dokumentenerstellung mit einem Fokus auf Produktivität der Entwickler zu vereinfachen. Es ist besonders effektiv für das Rendern von HTML-Inhalten und -Stilen und macht es ideal für moderne Web-to-PDF-Workflows.
IronPDF kann auch über NuGet installiert werden, indem der folgende Befehl in der NuGet Paketmanager-Konsole ausgeführt wird:
Alternativ können Sie es über den NuGet-Paketmanager für Lösungen installieren. Navigieren Sie dazu zu "Tools > NuGet Paketmanager > NuGet-Pakete für Lösung verwalten".
Dann suchen Sie nach IronPDF und klicken Sie auf "Installieren".
Nach der Installation können Sie in wenigen Sekunden komplette HTML-Seiten in PDF rendern - keine zusätzlichen Module erforderlich. Es unterstützt modernes CSS, JavaScript und sogar interaktive Webinhalte ohne zusätzliche Konfiguration.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfWithIronPdf()
{
var renderer = new ChromePdfRenderer();
var pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>");
return pdfDoc.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfWithIronPdf()
' Save the PDF to a file
File.WriteAllBytes("output.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfWithIronPdf() As Byte()
Dim renderer = New ChromePdfRenderer()
Dim pdfDoc = renderer.RenderHtmlAsPdf("<h1>Hello from IronPDF!</h1>")
Return pdfDoc.BinaryData
End Function
End ClassAusgabe-PDF-Datei
Erklärung
using IronPdf Anweisung importiert die IronPDF-Bibliothek für den Zugriff auf alle PDF-bezogenen Klassen.var renderer = new ChromePdfRenderer() erstellt einen neuen HTML-zu-PDF-Renderer, der von einer Headless-Chromium-Engine betrieben wird.renderer.RenderHtmlAsPdf(...) konvertiert den gegebenen HTML-String in ein PDF-Dokument. Sie können auch Dateipfade oder URLs übergeben.pdfDoc.BinaryData gibt das endgültige PDF als Byte-Array zurück, bereit zum Speichern, Streamen oder zur Datenbank-Speicherung.Vorteile:
Mühelose HTML-zu-PDF-Konvertierung
Rendern Sie HTML-, CSS- und JavaScript-Inhalte direkt in PDFs mit vollständigem Styling, einschließlich Bootstrap und benutzerdefinierter Schriftarten - kein Bedarf an komplexem Layout-Code oder zusätzlichen Modulen.
Schneller Einstieg & intuitive API
Erstellen Sie vollständig gestylte PDF-Dateien mit nur wenigen Codezeilen, mit sauberer Syntax und vollständiger .NET-Core- und .NET-Framework-Kompatibilität.
Umfassende Unterstützung für Web-Technologien
IronPDF unterstützt JavaScript, modernes CSS, SVGs und Media Queries - etwas, womit die meisten Bibliotheken zu kämpfen haben, es sei denn, sie verwenden headless Browser wie Chromium (was IronPDF intern tut).
Integrierter Bild- & Asset-Support
Bilder, lokale Dateien oder sogar Assets von entfernten URLs einfach einbinden, ohne zusätzliche Konfiguration.
Unbegrenzte Lizenzierung & keine AGPL
Im Gegensatz zu iText bietet IronPDF flexible kommerzielle Lizenzierung, ohne die Beschränkungen von Open-Source-AGPL-Verpflichtungen.
Ausgezeichnet für MVC- & Razor-Ansichten
Konvertiert nahtlos .cshtml Razor-Ansichten in ASP.NET-Anwendungen in druckbare PDFs.
Nachteile:
Kommerzielle Nutzung erfordert Lizenz
Auch wenn es eine kostenlose Testversion gibt, ist IronPDF nicht Open Source. Projekte mit engen Budgets müssen möglicherweise die Lizenzkosten bewerten.
Größere anfängliche Paketgröße
Da es eine headless Chromium-Engine bündelt, ist das NuGet-Paket schwerer als einige Alternativen.
Die folgenden Codebeispiele in diesem Abschnitt zeigen diese Bibliotheken in Aktion, während wir IronPDF und iText mit denselben Aufgaben vergleichen. Beide Bibliotheken werden durch dieselben Szenarien getestet: Erstellen eines PDFs von einer URL, Rendern eines Bildes als PDF und Konvertieren von gestyltem HTML zu PDF, während Byte-Arrays zur Handhabung unserer PDF-Inhalte verwendet werden. Dies wird es Entwicklern ermöglichen zu bewerten, wie jede Bibliothek diese häufigen Anwendungsfälle angeht.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.GeneratePdfFromUrlWithIronPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] GeneratePdfFromUrlWithIronPdf()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitForJavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
return pdf.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.GeneratePdfFromUrlWithIronPdf()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-from-url.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function GeneratePdfFromUrlWithIronPdf() As Byte()
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitForJavaScript(5000)
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
Dim pdf = renderer.RenderUrlAsPdf("https://www.apple.com")
Return pdf.BinaryData
End Function
End ClassAusgabe-PDF
IronPDF verwendet eine headless Chromium-Engine zur pixelgenauen Renderung von Webseiten mit vollständiger JavaScript- und CSS-Unterstützung.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
using System.IO;
class Program
{
static async Task Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = await pdfGenerator.GeneratePdfFromUrlWithIText7Async();
// Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes);
}
}
class PdfGenerator
{
public async Task<byte[]> GeneratePdfFromUrlWithIText7Async()
{
using var httpClient = new HttpClient();
string html = await httpClient.GetStringAsync("https://www.apple.com");
using var stream = new MemoryStream();
HtmlConverter.ConvertToPdf(html, stream);
return stream.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.Layout.Element
Imports System.Net.Http
Imports System.Threading.Tasks
Imports iText.Html2pdf
Imports System.IO
Friend Class Program
Shared Async Function Main(ByVal args() As String) As Task
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = Await pdfGenerator.GeneratePdfFromUrlWithIText7Async()
' Save the PDF to a file
File.WriteAllBytes("itext7-from-url.pdf", pdfBytes)
End Function
End Class
Friend Class PdfGenerator
Public Async Function GeneratePdfFromUrlWithIText7Async() As Task(Of Byte())
Dim httpClient As New HttpClient()
Dim html As String = Await httpClient.GetStringAsync("https://www.apple.com")
Dim stream = New MemoryStream()
HtmlConverter.ConvertToPdf(html, stream)
Return stream.ToArray()
End Function
End ClassAusgabe
iText ruft rohes HTML mit dem HttpClient ab und rendert es mit HtmlConverter, unterstützt jedoch keine JavaScript-Ausführung (wie durch die offizielle Dokumentation von iText bestätigt, die empfiehlt, Selenium oder ähnliche Browserautomatisierung für die JavaScript-Vorverarbeitung zu verwenden) und hat eingeschränkte CSS-Styling. Während iText in Version 7.1.15 (2021) partielle Flexbox-Unterstützung hinzugefügt hat, bleiben viele CSS3-Eigenschaften ununterstützt, insbesondere für komplexe moderne Layouts.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
var pdf = ImageToPdfConverter.ImageToPdf("example.png");
return pdf.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-with-image.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreatePdfWithImage() As Byte()
Dim pdf = ImageToPdfConverter.ImageToPdf("example.png")
Return pdf.BinaryData
End Function
End ClassAusgabe
Einfache Bild-zu-PDF-Erstellung mit dem ImageToPdfConverter-Tool von IronPDF. Damit können Sie leicht PDFs aus Bildern wie PNG-Dateien oder JPGs erstellen.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreatePdfWithImage();
// Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreatePdfWithImage()
{
using var ms = new MemoryStream();
using var writer = new PdfWriter(ms);
using var pdfDoc = new iText.Kernel.Pdf.PdfDocument(writer);
var document = new Document(pdfDoc);
var img = new Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"));
document.Add(img);
document.Close();
return ms.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreatePdfWithImage()
' Save the PDF to a file
File.WriteAllBytes("iText-with-image.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreatePdfWithImage() As Byte()
Dim ms = New MemoryStream()
Dim writer = New PdfWriter(ms)
Dim pdfDoc = New iText.Kernel.Pdf.PdfDocument(writer)
Dim document As New Document(pdfDoc)
Dim img = New Image(ImageDataFactory.Create("https://itextpdf.com/sites/default/files/2018-11/iText%207%20Product%20software%20-%20webimages_509x339px_V2_iText%207%20Core.png"))
document.Add(img)
document.Close()
Return ms.ToArray()
End Function
End ClassAusgabe
Manuelle Erstellung des Dokumentlayouts und explizite Bild-Einfügung mit ImageDataFactory.
using IronPdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>";
var pdf = new ChromePdfRenderer().RenderHtmlAsPdf(html);
return pdf.BinaryData;
}
}Imports IronPdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()
' Save the PDF to a file
File.WriteAllBytes("ironpdf-styled-html.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreateStyledPdf() As Byte()
Dim html As String = "
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to IronPDF</h1>
<p>This is a simple PDF document generated using IronPDF.</p>
</body>
</html>"
Dim pdf = (New ChromePdfRenderer()).RenderHtmlAsPdf(html)
Return pdf.BinaryData
End Function
End ClassAusgabe
IronPDF unterstützt dank seiner Chromium-Engine voll CSS in Tags oder externen Stylesheets.
using iText.Kernel.Pdf;
using iText.Html2pdf;
using System.IO;
class Program
{
static void Main(string[] args)
{
var pdfGenerator = new PdfGenerator();
byte[] pdfBytes = pdfGenerator.CreateStyledPdf();
// Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes);
}
}
class PdfGenerator
{
public byte[] CreateStyledPdf()
{
string html = @"
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>";
using var ms = new MemoryStream();
ConverterProperties properties = new ConverterProperties();
HtmlConverter.ConvertToPdf(new MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties);
return ms.ToArray();
}
}Imports iText.Kernel.Pdf
Imports iText.Html2pdf
Imports System.IO
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim pdfGenerator As New PdfGenerator()
Dim pdfBytes() As Byte = pdfGenerator.CreateStyledPdf()
' Save the new document to the specified file location
File.WriteAllBytes("iText-styled-html.pdf", pdfBytes)
End Sub
End Class
Friend Class PdfGenerator
Public Function CreateStyledPdf() As Byte()
Dim html As String = "
<html>
<head>
<style>
body {
background-color: #f0f0f0;
margin: 20px;
padding: 20px;
border-radius: 5px;
box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
}
h1 {
color: navy;
font-size: 32px;
text-align: center;
}
p {
font-size: 16px;
font-weight: bold;
}
</style>
</head>
<body>
<h1>Welcome to iText 7</h1>
<p>This is a simple PDF document generated using iText 7 and pdfHTML.</p>
</body>
</html>"
Dim ms = New MemoryStream()
Dim properties As New ConverterProperties()
HtmlConverter.ConvertToPdf(New MemoryStream(System.Text.Encoding.UTF8.GetBytes(html)), ms, properties)
Return ms.ToArray()
End Function
End ClassAusgabe
Erfordert die Installation des kostenpflichtigen Add-ons pdfHTML, um HTML-Konvertierungsaufgaben zu handhaben.
| Funktion | IronPDF | iText (with pdfHTML) |
|---|---|---|
| URL zu PDF rendern | Volle Chromium-Renderung | HTML abrufen, ohne native JS-Unterstützung |
| Bild hinzufügen | Einbettung über HTML oder das spezielle Bild-Stanz-Tool | Manuelle Bildfabrik |
| Gestyltes HTML rendern | Vollständige CSS-Unterstützung | CSS-Unterstützung nur durch pdfHTML |
| Liefert Byte-Array | Ja | Ja |
| Einrichtungs-Komplexität | Einfach | Mittel (manuelles Layout) |
| Ausgabequalität | Pixelgenau | Gut, aber statisch |
Die Wahl zwischen IronPDF und iText hängt von den Bedürfnissen Ihres Projekts ab – wenn es jedoch um Entwicklererfahrung, Benutzerfreundlichkeit und moderne Rendergenauigkeit geht, ist IronPDF eindeutig überlegen.
Wenn Sie mit dynamischen HTML-Inhalten, Web-Renderings arbeiten oder PDF-Dateien aus URLs erstellen müssen mit voller Unterstützung for JavaScript und CSS, liefert IronPDFs auf Chromium basierende Engine unvergleichliche Treue. Seine intuitive API und schnelle Einrichtung machen es ideal für die schnelle Entwicklung und den Einsatz im echten Produktionseinsatz - insbesondere bei der Arbeit mit Byte-Arrays, Dateiströmen oder web-basierter PDF-Erstellung.
Andererseits ist iText eine leistungsstarke und angesehene Bibliothek mit einem eher traditionellen, layoutgetriebenen Ansatz. Es bietet solide Kontrolle über die Dokumentstruktur und ist großartig für Entwickler, die feinkörnige Manipulation benötigen, hat aber eine steilere Lernkurve und fehlt moderne HTML-Rendering-Funktionen.
Hier ist das Fazit:
Bereit für den Einstieg in IronPDF? Laden Sie die kostenlose Testversion herunter und sehen Sie, wie einfach es ist, professionelle, auf Byte-Arrays basierende PDFs in C# mit nur wenigen Codezeilen zu erstellen.
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.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
