Die C# PDF-Bibliothek
using IronPdf;
// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;
// Instantiate Renderer
var renderer = new ChromePdfRenderer();
// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");
// Export to a file or Stream
pdf.SaveAs("output.pdf");
// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");
Install-Package IronPdf
In modernen .NET-Anwendungen ist das Erstellen und Verwalten von PDF-Dateien eine häufige Anforderung – unabhängig davon, ob Sie Berichte, Rechnungen oder digitale Aufzeichnungen erstellen. Entwickler wenden sich häufig an PDF-Bibliotheken von Drittanbietern für diese Aufgabe, und zwei der beliebtesten Optionen im .NET-Ökosystem sind IronPDF und iText 7 (der Nachfolger von iTextSharp).
Jede Bibliothek bietet ein leistungsstarkes Toolset für unterschiedliche Anwendungsfälle. Aber welches ist am besten geeignet, um ein PDF aus einem Byte-Array in C# zu generieren? Dieser Artikel erklärt alles mit Vergleichen, Codebeispielen und Einblicken, um .NET-Entwicklern bei der richtigen Entscheidung zu helfen.
Unabhängig davon, ob Sie Unternehmensanwendungen oder kleine interne Tools erstellen, kann die Wahl der richtigen PDF-Bibliothek Entwicklungszeit sparen und ein zuverlässiges Ergebnis sicherstellen. Lassen Sie uns erkunden, was jede Bibliothek bietet.
PDF-Bibliotheken in C# ermöglichen es Entwicklern, PDF-Dateien programmatisch zu erstellen, zu bearbeiten und zu lesen. Sie bedienen eine Vielzahl von Anwendungsfällen, wie zum Beispiel:
Digitale Signatur von PDFs
Sie spielen auch eine entscheidende Rolle bei der Datenportabilität und der Einhaltung von Standards wie PDF/A für Archivierungs- oder Barrierefreiheitsanforderungen.
Unter den verfügbaren .NET PDF-Bibliotheken haben sich iTextSharp und IronPDF als führende Lösungen herauskristallisiert – jede mit einzigartigen Stärken:
Die Entscheidung zwischen den beiden ist nicht nur eine Frage der Präferenz – sie beeinflusst die Produktivität, Wartung, Leistung und sogar die Einhaltung rechtlicher Lizenzbestimmungen. Projekte, die eine schnelle Umsetzung, häufige Formatänderungen oder PDF-Rendering aus HTML-Vorlagen erfordern, profitieren von einer schnellen Entwicklung, während unternehmensweite Anwendungen möglicherweise die Einhaltung von Standards und langfristige Wartbarkeit priorisieren.
iText 7 ist der offizielle Nachfolger von iTextSharp und bietet eine komplett neu gestaltete Architektur. Es ist eine leistungsstarke, erweiterbare Bibliothek, die sich für das Erstellen, Bearbeiten und Validieren von PDFs in regulierungsintensiven Branchen wie Recht, Finanzen und Regierung eignet. Die iText 7 Suite umfasst Unterstützung für PDF/A, PDF/UA, digitale Signaturen, Schwärzung und Formularerstellung.
Obwohl es unter der AGPL-Lizenz immer noch Open Source ist, sind kommerzielle Lizenzen für proprietäre Projekte verfügbar.
Ideal für PDF/A, Barrierefreiheit, Compliance
⚠️ Hinweis: Sie müssen itext7 für grundlegende PDF-Operationen verwenden und können optional Add-ons wie html2pdf separat einbinden.
Um das Kernpaket von iText 7 für die PDF-Erstellung herunterzuladen:
Install-Package itextInstall-Package itext'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package itext
Sie können auch iText 7 über den Paket-Manager für Lösungsbildschirm installieren. Dazu müssen Sie zunächst zum Dropdown-Menü „Tools“ gehen und dann „NuGet-Paket-Manager > Verwalten von NuGet-Paketen für die Lösung“ finden.
Anschließend suchen Sie einfach nach iText 7 und klicken auf "Installieren".
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())
{
PdfWriter writer = new PdfWriter(ms);
var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
Document 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();
}
}
}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())
{
PdfWriter writer = new PdfWriter(ms);
var pdf = new iText.Kernel.Pdf.PdfDocument(writer);
Document 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 As New PdfWriter(ms)
Dim pdf = New iText.Kernel.Pdf.PdfDocument(writer)
Dim doc As 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
Nach dem Aufruf von doc.Close() wird der PDF-Inhalt vollständig geschrieben und kann als Byte-Array zurückgegeben werden.
Dieses Beispiel zeigt die modularere und lesbarere API von iText 7 im Vergleich zu iTextSharp. Es fehlt jedoch weiterhin die native Unterstützung für das Rendern von HTML/CSS, es sei denn, Sie fügen pdfhtml hinzu, das separat lizenziert ist.
Vorteile:
Umfassende PDF-Kontrolle
iText 7 bietet vollständige Kontrolle über PDF-Elemente wie Tabellen, Formulare und digitale Signaturen. Dies macht es ideal für regulierungsintensive Anwendungen, die spezifische PDF-Standards wie PDF/A oder PDF/UA erfordern.
Modular und skalierbar
iText 7 ist modular aufgebaut, was bedeutet, dass Sie nur die spezifischen Module installieren können, die Sie benötigen (z. B. pdfhtml für die Konvertierung von HTML in PDF). Dies ermöglicht eine leichtere Implementierung, wenn Sie nicht alle Funktionen verwenden.
Unterstützt komplexe PDF-Standards
iText 7 unterstützt ISO-Standards wie PDF/A (Archivierung), PDF/UA (Barrierefreiheit) und PDF/X (Druck), was es für professionelle und rechtliche Umgebungen geeignet macht, in denen die Einhaltung von Vorschriften entscheidend ist.
Umfassende Dokumentation & Unterstützung
iText 7 verfügt über umfassende Dokumentation und eine große Community. Das Unternehmen bietet auch professionellen Support an, um sicherzustellen, dass Entwickler bei Bedarf Unterstützung erhalten können.
Kostenlose Version verfügbar (AGPL)
Entwickler können iText 7 kostenlos unter der AGPL-Lizenz nutzen, was ideal für Open-Source-Projekte oder den persönlichen Gebrauch ist.
Nachteile:
AGPL-Lizenz für kommerzielle Nutzung
Obwohl iText 7 eine kostenlose Version anbietet, müssen kommerzielle Nutzer die AGPL-Lizenz einhalten, die die Veröffentlichung des Quellcodes jeder Software, die iText 7 verwendet, oder den Erwerb einer kommerziellen Lizenz erfordert.
Steile Lernkurve
Die API von iText 7 ist komplexer und funktionsreicher, was zu einer steileren Lernkurve im Vergleich zu einfacheren Bibliotheken wie IronPDF führen kann. Entwickler müssen sich mit seiner Low-Level-Dokumentstruktur und der modularen Architektur vertraut machen.
Schwergewicht für einfache Aufgaben
iText 7 kann sich für grundlegende PDF-Aufgaben, wie einfache Dokumentenerstellung oder grundlegende HTML-zu-PDF-Konvertierung, umständlich anfühlen, insbesondere im Vergleich zu Bibliotheken wie IronPDF, die den Prozess vereinfachen.
Erfordert externe Module für HTML zu PDF
Die Konvertierung von HTML zu PDF in iText 7 ist nur über das zusätzliche pdfhtml-Modul verfügbar, das eine separate Installation erfordert und moderne Webinhalte möglicherweise nicht so nahtlos wie IronPDF verarbeitet.
IronPDF ist eine hochentwickelte .NET-Bibliothek, die entwickelt wurde, um die Erstellung von PDF-Dokumenten zu vereinfachen, mit einem besonderen Fokus auf die Produktivität von Entwicklern. Es ist besonders effektiv für das Rendern von HTML-Inhalten und Styling, was es ideal für moderne Web-zu-PDF-Workflows macht.
IronPDF kann auch über NuGet installiert werden, indem der folgende Befehl in der NuGet-Paket-Manager-Konsole ausgeführt wird:
Install-Package IronPdfInstall-Package IronPdf'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf
Alternativ können Sie es über den NuGet-Paket-Manager auf dem Solution-Bildschirm installieren. Um dies zu tun, navigieren Sie zu "Tools > NuGet-Paket-Manager > NuGet-Pakete für Lösung verwalten".
Dann suchen Sie nach IronPDF und klicken auf "Installieren".
Nach der Installation können Sie vollständige HTML-Seiten in Sekunden in PDF rendern – keine zusätzlichen Module erforderlich. Es unterstützt modernes CSS, JavaScript und sogar interaktive Webinhalte ohne zusätzliche Konfiguration.
using IronPdf;
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;
}
}using IronPdf;
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
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
Vorteile:
Mühelose HTML-zu-PDF-Konvertierung
Rendern Sie HTML-, CSS- und JavaScript-Inhalte direkt in PDFs mit vollständiger Formatierung, einschließlich Bootstrap und benutzerdefinierter Schriftarten – keine Notwendigkeit für komplexen Layout-Code oder zusätzliche Module.
Schnellstart & Intuitive API
Erstellen Sie PDF-Dateien, die vollständig gestylt sind, mit nur wenigen Codezeilen, sauberer Syntax und voller Kompatibilität mit .NET Core und dem .NET Framework.
Umfassende Unterstützung für Webtechnologien
IronPDF unterstützt JavaScript, modernes CSS, SVGs und Medienabfragen – etwas, woran die meisten Bibliotheken scheitern, es sei denn, sie verwenden headless Browser wie Chromium (was IronPDF intern tut).
Eingebautes Bild- und Asset-Handling
Fügen Sie problemlos Bilder, lokale Dateien oder sogar Ressourcen von entfernten URLs ein, ohne zusätzliche Konfiguration.
Unbefristete Lizenzierung & Keine AGPL
Im Gegensatz zu iText 7 bietet IronPDF flexible kommerzielle Lizenzen ohne die Einschränkungen der Open-Source-AGPL-Verpflichtungen.
Ausgezeichnet für MVC- und Razor-Ansichten
Wandelt nahtlos .cshtml Razor Views in ASP.NET-Anwendungen in druckbare PDFs um.
Nachteile:
Kommerzielle Nutzung erfordert Lizenz
Obwohl es eine kostenlose Testversion gibt, ist IronPDF nicht Open Source. Projekte mit knappen Budgets müssen möglicherweise die Lizenzierungskosten 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 demonstrieren diese Bibliotheken in Aktion, wobei wir IronPDF und iText 7 bei denselben Aufgaben vergleichen. Beide Bibliotheken werden durch die gleichen Szenarien getestet: Erstellen einer PDF aus einer URL, Rendern eines Bildes als PDF und Konvertieren von gestyltem HTML in PDF, während Byte-Arrays zur Handhabung unseres PDF-Inhalts verwendet werden. Dies wird Entwicklern ermöglichen, zu bewerten, wie jede Bibliothek diese gängigen 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.WaitFor.JavaScript(5000);
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
var pdf = renderer.RenderUrlAsPdf("https://www.apple.com");
return pdf.BinaryData;
}
}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.WaitFor.JavaScript(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.WaitFor.JavaScript(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 für pixelgenaues Rendering von Webseiten mit voller 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;
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();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.Layout.Element;
using System.Net.Http;
using System.Threading.Tasks;
using iText.Html2pdf;
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
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 7 ruft rohes HTML mit dem HttpClient ab und rendert es mit dem HtmlConverter, aber es unterstützt kein JavaScript und hat eingeschränkte CSS-Stiloptionen.
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;
}
}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 ganz einfach PDF-Dateien aus Bildern wie PNG- oder JPG-Dateien 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();
}
}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 mithilfe der ImageDataFactory.
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.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;
}
}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.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 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.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 vollständig CSS in Tags oder externen Stylesheets.
using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
using iText.Html2pdf;
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();
}
}using iText.Kernel.Pdf;
using iText.Layout;
using iText.IO.Image;
using iText.Layout.Element;
using System.IO;
using iText.Html2pdf;
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.Layout
Imports iText.IO.Image
Imports iText.Layout.Element
Imports System.IO
Imports iText.Html2pdf
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 bewältigen.
Funktion IronPDF iText 7 (mit pdfHTML)
URL in PDF rendern ✅ Vollständiges Chromium-Rendering ⚠️ HTML abrufen, keine native JS-Unterstützung
Bild hinzufügen ✅ Einbetten über HTML oder das dedizierte Bild-Stempel-Tool ✅ Manuelle Bildfabrik
Gestyltes HTML rendern ✅ Volle CSS-Unterstützung ⚠️ CSS-Unterstützung nur durch pdfHTML
Gibt Byte-Array zurück ✅ Ja ✅ Ja
Einrichtungs-Komplexität ⭐ Einfach ⭐⭐ Mäßig (manuelles Layout)
Ausgabequalität ⭐⭐⭐⭐⭐ Pixel-perfekt ⭐⭐⭐ Gut, aber statisch
Die Wahl zwischen IronPDF und iText 7 hängt von den Bedürfnissen Ihres Projekts ab — aber wenn es um Entwicklererfahrung, Benutzerfreundlichkeit und moderne Renderinggenauigkeit geht, sticht IronPDF deutlich hervor.
Wenn Sie mit dynamischen HTML-Inhalten, Web-Rendering arbeiten oder PDF-Dateien aus URLs mit voller JavaScript- und CSS-Unterstützung erstellen müssen, bietet die Chromium-basierte Engine von IronPDF unvergleichliche Wiedergabetreue. Seine intuitive API und die schnelle Einrichtung machen es ideal für die schnelle Entwicklung und den Einsatz in der realen Produktion – insbesondere bei der Arbeit mit Byte-Arrays, Dateistreames oder der webbasierten PDF-Erzeugung.
Andererseits ist iText 7 eine leistungsstarke und angesehene Bibliothek mit einem eher traditionellen, layoutgesteuerten Ansatz. Es bietet solide Kontrolle über die Dokumentstruktur und ist ideal für Entwickler, die eine feingliedrige Manipulation benötigen, aber es kommt mit einer steileren Lernkurve und fehlt an modernen HTML-Darstellungsfähigkeiten.
Hier ist das Fazit:
Benötigen Sie PDF-Erstellungswerkzeuge auf niedriger Ebene mit granularer Kontrolle? iText 7 könnte die richtige Wahl sein.
🚀 Bereit, mit IronPDF zu beginnen?
Laden Sie die kostenlose Testversion herunter und sehen Sie, wie einfach es ist, mit nur wenigen Zeilen Code professionelle, bytearray-basierte PDFs in C# zu erstellen.
Install-Package IronPdf
Keine Kreditkarte erforderlich
Ihr Testschlüssel sollte in der E-Mail sein.
Das Testformular wurde
erfolgreich übermittelt.
Wenn nicht, kontaktieren Sie bitte
support@ironsoftware.com
Keine Kreditkarte erforderlich
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Keine Kreditkarte oder Kontoerstellung erforderlich
Ihr Testschlüssel sollte sich in der E-Mail befinden.
Falls nicht, kontaktieren Sie bitte
support@ironsoftware.com
Starten Sie kostenlos
Keine Kreditkarte erforderlich
Testen Sie in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es benötigen.
Erhalten Sie 30 Tage lang ein voll funktionsfähiges Produkt.
Haben Sie es in wenigen Minuten einsatzbereit.
Vollständiger Zugang zu unserem technischen Support-Team während Ihrer Produkttestphase
Lizenzen ab $749. Haben Sie eine Frage? Kontaktieren Sie uns.
Buchen Sie eine persönliche 30-minütige Demo.
Kein Vertrag, keine Kartendetails, keine Verpflichtungen.
10 .NET API-Produkte für Ihre Bürodokumente
