Erstellen Sie PDF aus Byte-Array C# iTextSharp (vs IronPDF)

iText 7 ist der offizielle Nachfolger von iTextSharp und bietet eine vollständig neu gestaltete 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 7 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.

iText 7 Hauptmerkmale

• Moderne API, die iTextSharps ältere Struktur ersetzt
• Modulare Unterstützung: HTML zu PDF, PDF/A, Formulare, Schwärzung, digitale Signaturen
• Hohe Leistung für Unternehmensanwendungen
• Ideal für PDF/A, Zugänglichkeit, Compliance

Installation (NuGet)

Um iText 7's Kernpaket zur PDF-Erzeugung herunterzuladen:

Install-Package itext7

Sie können iText 7 auch über den Paketmanager für die Lösungsebene installieren. Gehen Sie dazu zuerst zum Tools-Dropdown-Menü und dann zu "NuGet-Paketmanager > NuGet-Pakete für die Lösung verwalten".

Dann suchen Sie einfach nach iText 7 und klicken auf "Installieren".

Code-Beispiel: PDF-Dokumente aus Byte-Array mit iText 7 erstellen

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();
        }
    }
}

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 Class

Ausgabe-PDF-Datei

Erklärung

• PdfWriter schreibt den Inhalt in ein MemoryStream.
• PdfDocument verwaltet die interne Struktur des PDFs.
• Document wird verwendet, um Inhalte höherer Ebene (Text, Bilder, Tabellen) hinzuzufügen. Nach dem Aufruf von doc.Close() ist 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 immer noch die native Unterstützung für das Rendern von HTML/CSS, es sei denn, Sie fügen pdfhtml hinzu, das separat lizenziert wird.

Vor- und Nachteile von iText 7

Vorteile:

• Umfassende PDF-Kontrolle\ iText 7 bietet die 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 7 ist modular aufgebaut, sodass Sie nur die spezifischen Module installieren können, die Sie benötigen (z. B. pdfhtml zur HTML-zu-PDF-Konvertierung). Dies ermöglicht eine leichtere Implementierung, wenn Sie nicht alle Funktionen nutzen.

• Unterstützt komplexe PDF-Standards\ iText 7 unterstützt ISO-Standards wie PDF/A (Archivierung), PDF/UA (Zugänglichkeit) und PDF/X (Druck), was es für professionelle und juristische Umgebungen geeignet macht, in denen Compliance entscheidend ist.

• Reiche Dokumentation & Unterstützung\ iText 7 bietet umfangreiche 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 7 kostenlos unter der AGPL-Lizenz nutzen, was ideal für Open-Source-Projekte oder persönliche Verwendung ist.

Nachteile:

• AGPL-Lizenz für kommerzielle Nutzung\ Während iText 7 eine kostenlose Version bietet, müssen kommerzielle Nutzer die AGPL-Lizenz einhalten, die die Offenlegung des Quellcodes jeder Software, die iText 7 verwendet, erfordert oder für eine kommerzielle Lizenz bezahlt werden muss.

• 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 der Low-Level-Dokumentenstruktur und der modularen Architektur vertraut machen.

• Schwergewicht für einfache Aufgaben\ iText 7 kann sich für grundlegende PDF-Aufgaben wie einfache Dokumenterstellung oder grundlegende HTML-zu-PDF-Konvertierung schwerfällig anfühlen, insbesondere im Vergleich zu Bibliotheken wie IronPDF, die den Prozess vereinfachen.

• Benötigt externe Module für HTML zu PDF\ Die Konvertierung von HTML zu PDF in iText 7 steht nur über das zusätzliche pdfhtml-Modul zur Verfügung, das eine separate Installation erfordert und moderne Webinhalte möglicherweise nicht so nahtlos handhabt wie IronPDF.

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.

Wichtige Merkmale:

• Erstellen von PDF-Dateien aus Byte-Arrays und Arbeiten mit PDF-Dokumenten, ohne Adobe Reader installieren zu müssen
• Direktes HTML-zu-PDF-Rendering mit der kompletten Chromium-Engine zur Erstellung von PDF-Dokumenten aus HTML-Inhalten
• Funktioniert mit MVC-Ansichten, Razor-Seiten und lokalen/fernen URLs
• Unterstützt Bilddateien, JavaScript, CSS und responsive Layouts out-of-the-box
• Einfach zu verwendende Syntax und minimal erforderliche Einrichtung
• Unbegrenzte Lizenzierung und keine AGPL-Beschränkungen

IronPDF kann auch über NuGet installiert werden, indem der folgende Befehl in der NuGet Paketmanager-Konsole ausgeführt wird:

Install-Package IronPdf

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.

Code-Beispiel: PDF-Dokumente aus einem Byte-Array mit IronPDF erstellen

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;
    }
}

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 Class

Ausgabe-PDF-Datei

Erklärung

• Die Anweisung using IronPdf importiert die IronPDF -Bibliothek, um Zugriff auf alle PDF-bezogenen Klassen zu erhalten.
• var renderer = new ChromePdfRenderer() erstellt einen neuen HTML-zu-PDF-Renderer, der auf einer Headless-Chromium-Engine basiert.
• renderer.RenderHtmlAsPdf(...) wandelt die angegebene HTML-Zeichenkette in ein PDF-Dokument um. Sie können auch Dateipfade oder URLs übergeben.
• pdfDoc.BinaryData gibt das endgültige PDF als Byte-Array zurück, das zum Speichern, Streamen oder zur Speicherung in einer Datenbank bereit ist.

Vor- und Nachteile von IronPDF

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 7 bietet IronPDF flexible kommerzielle Lizenzierung ohne die Einschrä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.

IronPDF

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;
    }
}

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 Class

Ausgabe-PDF

IronPDF verwendet eine headless Chromium-Engine zur pixelgenauen Renderung von Webseiten mit vollständiger JavaScript- und CSS-Unterstützung.

iText 7

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();
    }
}

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 Class

Ausgabe

iText 7 ruft rohen HTML-Code mit dem HttpClient ab und rendert ihn mit HtmlConverter, unterstützt jedoch kein JavaScript (gemäß der offiziellen Dokumentation von iText, die die Verwendung von Selenium oder ähnlichen Browser-Automatisierungstools zur JavaScript-Vorverarbeitung empfiehlt) und hat begrenzte CSS-Stile. Während iText7 im Jahr 2021 (Version 7.1.15) Unterstützung für Flexbox eingeführt hat, bleiben viele CSS3-Eigenschaften besonders für komplexe moderne Layouts weiterhin ununterstützt.

IronPDF

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 Class

Ausgabe

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.

iText 7

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 Class

Ausgabe

Manuelle Erstellung des Dokumentlayouts und explizite Bild-Einfügung mit ImageDataFactory.

IronPDF

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;
    }
}

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 Class

Ausgabe

IronPDF unterstützt dank seiner Chromium-Engine voll CSS in Tags oder externen Stylesheets.

iText 7 + pdfHTML

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();
    }
}

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 Class

Ausgabe

Erfordert die Installation des kostenpflichtigen Add-ons pdfHTML, um HTML-Konvertierungsaufgaben zu handhaben.