Wie man PDF-Dateien zu einem Dokument kombiniert

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.

iText Hauptmerkmale

• Moderne API, ersetzt die ältere Struktur von iText
• 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 das Kernpaket von iText für die PDF-Generierung herunterzuladen:

Install-Package itext7

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.

Codebeispiel: Erstellen von PDF-Dokumenten aus Byte-Array mit iText

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 PDF.
• Document wird verwendet, um hochgradige Inhalte hinzuzufügen (Text, Bilder, Tabellen).
• Nach dem Aufruf von 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.

Vor- und Nachteile von iText

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.

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 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.

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 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.

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

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 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.

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

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 + 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.