Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. HTML to PDF Converter C# Open Source
IRONPDF NUTZEN

HTML zu PDF Converter C# Open Source (.NET Bibliothekenvergleich)

Curtis Chau
Curtis Chau
Aktualisiert:

Die Umwandlung von HTML in PDF ist eine häufige Anforderung in vielen Softwareanwendungen, wie das Erstellen von Berichten, Rechnungen oder das Speichern von Webseiten als PDFs. In diesem Artikel werden wir drei beliebte Open-Source-Bibliotheken für die Konvertierung von HTML in PDF in C# untersuchen, ihre Stärken und Einschränkungen überprüfen und besprechen, warum IronPDF in vielen Fällen eine bessere Alternative ist.

HTML-zu-PDF-Konverter C# Open Source

1. PuppeteerSharp

HTML-zu-PDF-Konverter C# Open Source (.NET Bibliotheken Vergleich): Abbildung 1

PuppeteerSharp ist ein .NET Wrapper für Puppeteer, einen headless Chromium-Browser. Es ermöglicht Entwicklern, HTML-Dokumente in PDFs zu konvertieren, indem es die Chromium-Rendering-Engine nutzt.

PuppeteerSharp bietet präzise Kontrolle über den Rendering-Prozess. Hier ist ein Beispiel:

using PuppeteerSharp;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Download Chromium to ensure compatibility with PuppeteerSharp
        await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultChromiumRevision);

        // Launch a headless instance of Chromium browser
        using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true }))
        {
            // Open a new browser page
            var page = await browser.NewPageAsync();

            // Set the HTML content for the page
            await page.SetContentAsync("<html><body><h1>Hello, PuppeteerSharp!</h1></body></html>");

            // Generate a PDF from the rendered HTML content
            await page.PdfAsync("output.pdf");
            Console.WriteLine("PDF Generated Successfully!");
        }
    }
}
using PuppeteerSharp;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Download Chromium to ensure compatibility with PuppeteerSharp
        await new BrowserFetcher().DownloadAsync(BrowserFetcher.DefaultChromiumRevision);

        // Launch a headless instance of Chromium browser
        using (var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true }))
        {
            // Open a new browser page
            var page = await browser.NewPageAsync();

            // Set the HTML content for the page
            await page.SetContentAsync("<html><body><h1>Hello, PuppeteerSharp!</h1></body></html>");

            // Generate a PDF from the rendered HTML content
            await page.PdfAsync("output.pdf");
            Console.WriteLine("PDF Generated Successfully!");
        }
    }
}
Imports PuppeteerSharp
Imports System.Threading.Tasks

Friend Class Program
	Shared Async Function Main(ByVal args() As String) As Task
		' Download Chromium to ensure compatibility with PuppeteerSharp
		Await (New BrowserFetcher()).DownloadAsync(BrowserFetcher.DefaultChromiumRevision)

		' Launch a headless instance of Chromium browser
		Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {.Headless = True})
			' Open a new browser page
			Dim page = Await browser.NewPageAsync()

			' Set the HTML content for the page
			Await page.SetContentAsync("<html><body><h1>Hello, PuppeteerSharp!</h1></body></html>")

			' Generate a PDF from the rendered HTML content
			Await page.PdfAsync("output.pdf")
			Console.WriteLine("PDF Generated Successfully!")
		End Using
	End Function
End Class
$vbLabelText   $csharpLabel

Code-Erklärung

  1. Chromium herunterladen: PuppeteerSharp lädt automatisch die erforderliche Chromium-Version herunter, um die Kompatibilität zu gewährleisten.

  2. Browser starten: Starten Sie eine headless Instanz von Chromium mit Puppeteer.LaunchAsync().

  3. HTML-Inhalt festlegen: Laden Sie das gewünschte HTML in die Browser-Seite mit page.SetContentAsync().

  4. PDF erstellen: Verwenden Sie die Methode page.PdfAsync(), um ein PDF des gerenderten Inhalts zu erstellen.

Das Ergebnis ist ein hochwertiges PDF (output.pdf), das die HTML-Struktur und das Design genau repliziert.

Vorteile

  • Hochwertiges Rendering: Unterstützt moderne Webtechnologien, einschließlich fortgeschrittenem CSS und JavaScript.
  • Automatisierungsmöglichkeiten: Neben PDFs kann PuppeteerSharp auch das Browsen im Web, Testen und Datenerfassung automatisieren.
  • Aktive Entwicklung: PuppeteerSharp wird aktiv gewartet und regelmäßig aktualisiert.

Nachteile

  • Große Dateigröße: Erfordert das Herunterladen und EINbinden des Chromium-Browsers, was die Bereitstellungsgröße erhöht.
  • Ressourcenintensiv: Das Ausführen einer Browserinstanz kann ressourcenintensiv sein, insbesondere für groß angelegte Anwendungen.
  • Begrenzte PDF-spezifische Funktionen: PuppeteerSharp konzentriert sich auf das Rendering und nicht auf die Verbesserung von PDFs (z. B. das Hinzufügen von Kopf- oder Fußzeilen).

2. PdfSharp

HTML-zu-PDF-Konverter C# Open Source (.NET Bibliotheken Vergleich): Abbildung 2

PdfSharp ist eine leistungsstarke Open-Source-Bibliothek zum Erstellen und Bearbeiten von PDF-Dateien in C#. Obwohl es das HTML-Rendering nicht direkt unterstützt, bietet es Entwicklern hervorragende Werkzeuge zur programmatischen Erstellung und Bearbeitung von PDF-Dokumenten.

Hauptmerkmale von PdfSharp

  1. PDF-Erstellung: PdfSharp ermöglicht es Entwicklern, neue PDF-Dateien von Grund auf zu erstellen, indem sie Seitengrößen definieren, Text, Formen, Bilder und mehr hinzufügen.

  2. Bearbeitung bestehender PDFs: Sie können bestehende PDF-Dokumente ändern, z. B. zusammenführen, trennen oder Inhalte extrahieren.

  3. Zeichenfähigkeiten: PdfSharp bietet robuste Grafikfähigkeiten für benutzerdefinierte Designs auf PDF-Dateien mit der XGraphics-Klasse.

  4. Leichtgewichtig: Es ist eine leichtgewichtige Bibliothek, die sich ideal für Projekte eignet, bei denen Einfachheit und Geschwindigkeit Priorität haben.
using PdfSharp.Pdf;
using PdfSharp.Drawing;
using HtmlAgilityPack;

class Program
{
    static void Main(string[] args)
    {
        // Example HTML content
        string htmlContent = "<html><body><h1>Hello, PdfSharp!</h1><p>This is an example of HTML to PDF.</p></body></html>";

        // Parse HTML using HtmlAgilityPack (You need to add HtmlAgilityPack via NuGet)
        var htmlDoc = new HtmlDocument();
        htmlDoc.LoadHtml(htmlContent);

        // Create a new PDF document
        PdfDocument pdfDocument = new PdfDocument
        {
            Info = { Title = "HTML to PDF Example" }
        };

        // Add a new page to the document
        PdfPage page = pdfDocument.AddPage();

        XGraphics gfx = XGraphics.FromPdfPage(page);
        XFont titleFont = new XFont("Arial", 20, XFontStyle.Bold);
        XFont textFont = new XFont("Arial", 12, XFontStyle.Regular);

        // Draw the parsed HTML content
        int yPosition = 50; // Starting Y position
        foreach (var node in htmlDoc.DocumentNode.SelectNodes("//h1 | //p"))
        {
            if (node.Name == "h1")
            {
                gfx.DrawString(node.InnerText, titleFont, XBrushes.Black, new XRect(50, yPosition, page.Width - 100, page.Height - 100), XStringFormats.TopLeft);
                yPosition += 30; // Adjust spacing
            }
            else if (node.Name == "p")
            {
                gfx.DrawString(node.InnerText, textFont, XBrushes.Black, new XRect(50, yPosition, page.Width - 100, page.Height - 100), XStringFormats.TopLeft);
                yPosition += 20; // Adjust spacing
            }
        }

        // Save the PDF document
        string outputFilePath = "HtmlToPdf.pdf";
        pdfDocument.Save(outputFilePath);
        System.Console.WriteLine($"PDF file created: {outputFilePath}");
    }
}
using PdfSharp.Pdf;
using PdfSharp.Drawing;
using HtmlAgilityPack;

class Program
{
    static void Main(string[] args)
    {
        // Example HTML content
        string htmlContent = "<html><body><h1>Hello, PdfSharp!</h1><p>This is an example of HTML to PDF.</p></body></html>";

        // Parse HTML using HtmlAgilityPack (You need to add HtmlAgilityPack via NuGet)
        var htmlDoc = new HtmlDocument();
        htmlDoc.LoadHtml(htmlContent);

        // Create a new PDF document
        PdfDocument pdfDocument = new PdfDocument
        {
            Info = { Title = "HTML to PDF Example" }
        };

        // Add a new page to the document
        PdfPage page = pdfDocument.AddPage();

        XGraphics gfx = XGraphics.FromPdfPage(page);
        XFont titleFont = new XFont("Arial", 20, XFontStyle.Bold);
        XFont textFont = new XFont("Arial", 12, XFontStyle.Regular);

        // Draw the parsed HTML content
        int yPosition = 50; // Starting Y position
        foreach (var node in htmlDoc.DocumentNode.SelectNodes("//h1 | //p"))
        {
            if (node.Name == "h1")
            {
                gfx.DrawString(node.InnerText, titleFont, XBrushes.Black, new XRect(50, yPosition, page.Width - 100, page.Height - 100), XStringFormats.TopLeft);
                yPosition += 30; // Adjust spacing
            }
            else if (node.Name == "p")
            {
                gfx.DrawString(node.InnerText, textFont, XBrushes.Black, new XRect(50, yPosition, page.Width - 100, page.Height - 100), XStringFormats.TopLeft);
                yPosition += 20; // Adjust spacing
            }
        }

        // Save the PDF document
        string outputFilePath = "HtmlToPdf.pdf";
        pdfDocument.Save(outputFilePath);
        System.Console.WriteLine($"PDF file created: {outputFilePath}");
    }
}
Imports PdfSharp.Pdf
Imports PdfSharp.Drawing
Imports HtmlAgilityPack

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Example HTML content
		Dim htmlContent As String = "<html><body><h1>Hello, PdfSharp!</h1><p>This is an example of HTML to PDF.</p></body></html>"

		' Parse HTML using HtmlAgilityPack (You need to add HtmlAgilityPack via NuGet)
		Dim htmlDoc = New HtmlDocument()
		htmlDoc.LoadHtml(htmlContent)

		' Create a new PDF document
		Dim pdfDocument As New PdfDocument With {
			.Info = { Title = "HTML to PDF Example" }
		}

		' Add a new page to the document
		Dim page As PdfPage = pdfDocument.AddPage()

		Dim gfx As XGraphics = XGraphics.FromPdfPage(page)
		Dim titleFont As New XFont("Arial", 20, XFontStyle.Bold)
		Dim textFont As New XFont("Arial", 12, XFontStyle.Regular)

		' Draw the parsed HTML content
		Dim yPosition As Integer = 50 ' Starting Y position
		For Each node In htmlDoc.DocumentNode.SelectNodes("//h1 | //p")
			If node.Name = "h1" Then
				gfx.DrawString(node.InnerText, titleFont, XBrushes.Black, New XRect(50, yPosition, page.Width - 100, page.Height - 100), XStringFormats.TopLeft)
				yPosition += 30 ' Adjust spacing
			ElseIf node.Name = "p" Then
				gfx.DrawString(node.InnerText, textFont, XBrushes.Black, New XRect(50, yPosition, page.Width - 100, page.Height - 100), XStringFormats.TopLeft)
				yPosition += 20 ' Adjust spacing
			End If
		Next node

		' Save the PDF document
		Dim outputFilePath As String = "HtmlToPdf.pdf"
		pdfDocument.Save(outputFilePath)
		System.Console.WriteLine($"PDF file created: {outputFilePath}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Code-Erklärung

  1. HTML-Parsen: Das Beispiel verwendet HtmlAgilityPack (eine Open-Source-Bibliothek zum Parsen und Bearbeiten von HTML), um Textinhalte aus <h1> und <p> Tags zu extrahieren.

  2. Zeichnen von Inhalten: Die XGraphics-Klasse von PdfSharp wird verwendet, um die geparsten HTML-Inhalte als Text auf einer PDF-Seite darzustellen.

  3. Einschränkungen: Dieser Ansatz funktioniert für einfache HTML-Strukturen, aber nicht für komplexe Layouts, Stile oder JavaScript.

Vorteile und Nachteile von PdfSharp

Vorteile

  • Leicht und einfach zu verwenden: PdfSharp ist intuitiv und unkompliziert, ideal für Entwickler, die mit der PDF-Erstellung beginnen.
  • Open-Source und kostenlos: Keine Lizenzgebühren, und der Quellcode ist zur Anpassung verfügbar.
  • Individuelles Zeichnen: Bietet hervorragende Fähigkeiten zur Erstellung von PDFs von Grund auf mit benutzerdefinierten Designs.

Nachteile

  • Keine HTML-zu-PDF-Konvertierung: PdfSharp unterstützt das native Rendern von HTML in PDF nicht, es sind zusätzliche Bibliotheken zum Parsen von HTML erforderlich.
  • Begrenzte Unterstützung für moderne Funktionen: Bietet keine erweiterten Funktionen wie interaktive PDFs, digitale Signaturen oder Anmerkungen.
  • Leistungsbeschränkungen: Möglicherweise nicht so optimiert wie professionelle Bibliotheken für groß angelegte oder unternehmensweite Anwendungen.

3. Pdfium.NET SDK

HTML-zu-PDF-Konverter C# Open Source (.NET Bibliotheken Vergleich): Abbildung 3

Pdfium.NET ist eine umfassende Bibliothek basierend auf dem Open-Source-Projekt PDFium, die für das Anzeigen, Bearbeiten und Bearbeiten von PDF-Dateien in .NET-Anwendungen entwickelt wurde. Es bietet Entwicklern leistungsstarke Tools zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDFs, was es für ein breites Spektrum an Anwendungsfällen geeignet macht. Es ist im Wesentlichen eine kostenlose HTML-zu-PDF-Konverter-Bibliothek.

Hauptmerkmale des Pdfium.NET SDK

  1. PDF-Erstellung und -Bearbeitung:

    • PDFs von Grund auf oder aus gescannten Bildern generieren.
    • Vorhandene PDFs bearbeiten, indem Text, Bilder oder Anmerkungen hinzugefügt werden.

  2. Text- und Bilderextrahierung:

    • Text und Bilder aus PDF-Dokumenten im Dateiformat zur weiteren Verarbeitung extrahieren.
    • Nach bestimmten Texten in einem PDF-Dokument suchen.

  3. PDF-Viewer-Steuerelement:

    • Einen eigenständigen PDF-Viewer in WinForms- oder WPF-Anwendungen einbetten.
    • Unterstützt Zoomen, Scrollen, Lesezeichen und Textsuche.

  4. Kompatibilität:

    • Funktioniert mit .NET Framework, .NET Core, .NET Standard und .NET 6+.
    • Kompatibel mit Windows- und macOS-Plattformen.
  5. Erweiterte Funktionen:
    • PDF-Dateien zusammenführen und trennen.
    • PDFs zum Anzeigen oder Drucken als Bilder rendern.
using Pdfium.Net.SDK;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Initialize Pdfium.NET SDK functionalities
        PdfCommon.Initialize();

        // Create a new PDF document
        PdfDocument pdfDocument = PdfDocument.CreateNew();

        // Add a page to the document (A4 size in points: 8.27 x 11.69 inches)
        var page = pdfDocument.Pages.InsertPageAt(pdfDocument.Pages.Count, 595, 842);

        // Sample HTML content to be parsed and rendered manually
        var htmlContent = "<h1>Hello, Pdfium.NET SDK!</h1><p>This is an example of HTML to PDF.</p>";

        // Example: Manually render text since Pdfium.NET doesn't render HTML directly
        var font = PdfFont.CreateFont(pdfDocument, "Arial");
        page.AddText(72, 750, font, 20, "Hello, Pdfium.NET SDK!");
        page.AddText(72, 700, font, 14, "This is an example of HTML to PDF.");

        // Save the document to a file
        string outputFilePath = "HtmlToPdfExample.pdf";
        pdfDocument.Save(outputFilePath, SaveFlags.Default);
        Console.WriteLine($"PDF created successfully: {outputFilePath}");
    }
}
using Pdfium.Net.SDK;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Initialize Pdfium.NET SDK functionalities
        PdfCommon.Initialize();

        // Create a new PDF document
        PdfDocument pdfDocument = PdfDocument.CreateNew();

        // Add a page to the document (A4 size in points: 8.27 x 11.69 inches)
        var page = pdfDocument.Pages.InsertPageAt(pdfDocument.Pages.Count, 595, 842);

        // Sample HTML content to be parsed and rendered manually
        var htmlContent = "<h1>Hello, Pdfium.NET SDK!</h1><p>This is an example of HTML to PDF.</p>";

        // Example: Manually render text since Pdfium.NET doesn't render HTML directly
        var font = PdfFont.CreateFont(pdfDocument, "Arial");
        page.AddText(72, 750, font, 20, "Hello, Pdfium.NET SDK!");
        page.AddText(72, 700, font, 14, "This is an example of HTML to PDF.");

        // Save the document to a file
        string outputFilePath = "HtmlToPdfExample.pdf";
        pdfDocument.Save(outputFilePath, SaveFlags.Default);
        Console.WriteLine($"PDF created successfully: {outputFilePath}");
    }
}
Imports Pdfium.Net.SDK
Imports System

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Initialize Pdfium.NET SDK functionalities
		PdfCommon.Initialize()

		' Create a new PDF document
		Dim pdfDocument As PdfDocument = PdfDocument.CreateNew()

		' Add a page to the document (A4 size in points: 8.27 x 11.69 inches)
		Dim page = pdfDocument.Pages.InsertPageAt(pdfDocument.Pages.Count, 595, 842)

		' Sample HTML content to be parsed and rendered manually
		Dim htmlContent = "<h1>Hello, Pdfium.NET SDK!</h1><p>This is an example of HTML to PDF.</p>"

		' Example: Manually render text since Pdfium.NET doesn't render HTML directly
		Dim font = PdfFont.CreateFont(pdfDocument, "Arial")
		page.AddText(72, 750, font, 20, "Hello, Pdfium.NET SDK!")
		page.AddText(72, 700, font, 14, "This is an example of HTML to PDF.")

		' Save the document to a file
		Dim outputFilePath As String = "HtmlToPdfExample.pdf"
		pdfDocument.Save(outputFilePath, SaveFlags.Default)
		Console.WriteLine($"PDF created successfully: {outputFilePath}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Code-Erklärung

  1. SDK-Initialisierung: Die Methode PdfCommon.Initialize() initialisiert die Funktionen von Pdfium.NET.

  2. PDF-Erzeugung: Ein neues PDF-Dokument wird mit PdfDocument.CreateNew() erstellt.

  3. Seiten hinzufügen: Seiten werden mit angegebenen Dimensionen (z. B. A4-Größe) in das PDF eingefügt.

  4. Rendern von HTML-Inhalten: Da das Pdfium.NET SDK das HTML-Rendern nicht nativ unterstützt, müssen Sie HTML-Elemente manuell als Text, Formen oder Bilder parsen und rendern.

  5. Speichern des PDFs: Das Dokument wird mit der Methode Save() an einem Dateipfad gespeichert.

Pros

  • Ermöglicht die volle Kontrolle über die PDF-Erstellung und -Bearbeitung.
  • Flexibel beim Zeichnen und Hinzufügen von Text, Bildern und Formen.
  • Leistungsstarke Fähigkeiten zum Anzeigen und Bearbeiten von PDFs in Desktop-Anwendungen.

Kosten

  • Konvertiert HTML nicht direkt in PDF.
  • Das manuelle Parsen und Rendern von HTML kann komplex und zeitaufwendig sein.
  • Am besten geeignet für Anwendungen, die sich auf die Bearbeitung und Bearbeitung von PDFs konzentrieren, anstatt auf die HTML-Konvertierung.

Einführung in IronPDF

HTML-zu-PDF-Konverter C# Open Source (.NET Bibliotheken Vergleich): Abbildung 4

IronPDF ist eine professionelle Bibliothek, die speziell für .NET-Entwickler konzipiert ist, um HTML-Inhalte mühelos in hochwertige PDFs zu konvertieren. IronPDF ist bekannt für seine Zuverlässigkeit, erweiterten Funktionen und Benutzerfreundlichkeit und rationalisiert den Entwicklungsprozess, während es präzises Rendering und eine robuste Funktionalität bietet. Hier sind die Gründe, warum IronPDF eine herausragende Lösung ist:

Wichtige Merkmale

  1. Direkte HTML-zu-PDF-Konvertierung: Erstellen Sie PDF-Dokumente direkt mit IronPDF mit HTML-Inhalten, einschließlich CSS und JavaScript, in vollständig formatierte PDFs. Mit nur wenigen Codezeilen können Entwickler PDF-Dateien aus Webseiten, rohen HTML-Zeichenfolgen oder lokalen HTML-Dateien erstellen.

  2. Moderne Rendering-Fähigkeiten: IronPDF unterstützt die neuesten Webstandards und sorgt für ein genaues Rendering komplexer Layouts, Stile und interaktiver Elemente, um HTML-Seiten in PDF zu konvertieren.

  3. Erweiterte PDF-Funktionen: IronPDF bietet umfangreiche Anpassungsoptionen, wie das Hinzufügen von Kopf- und Fußzeilen, Wasserzeichen, Anmerkungen und Lesezeichen. Es unterstützt auch das Zusammenführen, Splitten und Bearbeiten bestehender PDFs.

  4. Leistung und Skalierbarkeit: IronPDF ist sowohl für kleine als auch für große Unternehmensumgebungen optimiert und liefert eine schnelle und zuverlässige Leistung für Projekte jeder Größe.

  5. Leichte Integration: IronPDF wurde für das .NET Framework und .NET Core entwickelt und integriert sich nahtlos in C#-Anwendungen, bietet Entwicklern einen einfachen Einrichtungsprozess und umfassende Dokumentation.

Warum IronPDF wählen?

IronPDF sticht unter anderen Lösungen durch seine Kombination aus Funktionen, Entwicklerunterstützung und Leistung heraus. Im Gegensatz zu Open-Source-Alternativen, die oft eine umfangreiche Konfiguration oder externe Abhängigkeiten erfordern, ist IronPDF eine in sich geschlossene Lösung, die die Entwicklung vereinfacht, ohne auf Funktionalität zu verzichten. Ob es um die Erstellung von Rechnungen, Berichten oder die Archivierung von Webinhalten geht, IronPDF bietet Entwicklern die Werkzeuge, die sie benötigen, um schnell und effizient Ergebnisse in professioneller Qualität zu erzielen.

IronPDF ist eine praktische Wahl für Entwickler, die in ihren HTML-zu-PDF-Workflows Wert auf Zuverlässigkeit, Skalierbarkeit und Benutzerfreundlichkeit legen.

So konvertieren Sie HTML in PDF mit IronPDF

using IronPdf;

class Program
{
    static void Main()
    {
        // Specify license key
        IronPdf.License.LicenseKey = "Your Key";

        // Create a new HtmlToPdf object using ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();

        // Define the HTML string to be converted
        string htmlContent = "<html><body><h1>IronPDF: Better than Open source</h1></body></html>";

        // Convert the HTML string to a PDF document
        var document = Renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document to a file
        document.SaveAs("html2Pdf.pdf");

        Console.WriteLine("PDF generated and saved successfully!");
    }
}
using IronPdf;

class Program
{
    static void Main()
    {
        // Specify license key
        IronPdf.License.LicenseKey = "Your Key";

        // Create a new HtmlToPdf object using ChromePdfRenderer
        var Renderer = new ChromePdfRenderer();

        // Define the HTML string to be converted
        string htmlContent = "<html><body><h1>IronPDF: Better than Open source</h1></body></html>";

        // Convert the HTML string to a PDF document
        var document = Renderer.RenderHtmlAsPdf(htmlContent);

        // Save the PDF document to a file
        document.SaveAs("html2Pdf.pdf");

        Console.WriteLine("PDF generated and saved successfully!");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main()
		' Specify license key
		IronPdf.License.LicenseKey = "Your Key"

		' Create a new HtmlToPdf object using ChromePdfRenderer
		Dim Renderer = New ChromePdfRenderer()

		' Define the HTML string to be converted
		Dim htmlContent As String = "<html><body><h1>IronPDF: Better than Open source</h1></body></html>"

		' Convert the HTML string to a PDF document
		Dim document = Renderer.RenderHtmlAsPdf(htmlContent)

		' Save the PDF document to a file
		document.SaveAs("html2Pdf.pdf")

		Console.WriteLine("PDF generated and saved successfully!")
	End Sub
End Class
$vbLabelText   $csharpLabel

Code-Snippet-Erklärung

  1. Lizenzschlüsseleinstellung: Das Programm beginnt mit dem Einrichten des IronPDF-Lizenzschlüssels, der notwendig ist, um die volle Funktionalität der Bibliothek freizuschalten.

  2. Anlegen des Renderers: Eine Instanz von ChromePdfRenderer wird initialisiert. Diese Komponente ist verantwortlich für die Umwandlung von HTML-Inhalt in ein PDF-Dokument und dient als Brücke zwischen dem rohen HTML und dem endgültigen Ergebnis.

  3. HTML-Inhalt definieren: Eine Zeichenfolgenvariable, htmlContent, wird erstellt, um die HTML-Struktur zu speichern, die in ein PDF konvertiert wird. In diesem Beispiel enthält sie eine einfache Überschrift.

  4. Konvertierung von HTML in PDF: Die Methode RenderHtmlAsPdf() wird auf der Instanz von ChromePdfRenderer aufgerufen und übergibt die HTML-Zeichenfolge als Eingabe. Diese Funktion verarbeitet den Inhalt und wandelt ihn in ein PDF-Dokument um.

  5. PDF speichern: Schließlich wird das erstellte PDF mit der Methode SaveAs() in einer Datei mit dem Namen "html2Pdf.pdf" gespeichert und für zukünftigen Zugriff auf der Festplatte gespeichert.

Ausgabe-PDF

HTML-zu-PDF-Konverter C# Open Source (.NET Bibliotheken Vergleich): Abbildung 5

Lizenzinformation (Testversion verfügbar)

IronPDF erfordert einen gültigen Lizenzschlüssel für die volle Funktionalität. Sie können eine Testlizenz von der offiziellen Website erhalten. Vor der Verwendung der IronPDF-Bibliothek richten Sie den Lizenzschlüssel wie folgt ein:

IronPdf.License.LicenseKey = "your key";
IronPdf.License.LicenseKey = "your key";
IronPdf.License.LicenseKey = "your key"
$vbLabelText   $csharpLabel

Dies stellt sicher, dass die Bibliothek ohne Einschränkungen funktioniert.

Abschluss

PuppeteerSharp ist eine ausgezeichnete Wahl für Entwickler, die eine präzise Wiedergabe von HTML in PDF benötigen, insbesondere wenn es um komplexe Webseiten geht. Für Anwendungen, die jedoch erweiterte PDF-spezifische Funktionen, Leistungsoptimierung und eine leichte Integration erfordern, sind professionelle Tools wie IronPDF oft die bessere Option.

PdfSharp ist eine großartige Wahl für die leichte, programmatische Erstellung und Bearbeitung von PDF-Dokumenten, insbesondere für Projekte mit einfachen Anforderungen. Wenn Ihre Anwendung jedoch das Konvertieren von HTML in PDF oder erweiterte PDF-Funktionen erfordert, bietet IronPDF eine effizientere und funktionsreichere Lösung.

Während Pdfium.NET SDK ein robustes Tool zur Bearbeitung von PDFs ist, bietet IronPDF native Unterstützung für die direkte HTML-zu-PDF-Konvertierung, einschließlich der Wiedergabe moderner HTML-, CSS- und JavaScript-Inhalte. IronPDF vereinfacht den Workflow mit eingebauten Methoden wie HtmlToPdf.RenderHtmlAsPdf(), was es Entwicklern schneller und effizienter macht.

Ob es um die Erstellung von Rechnungen, Berichten oder die Archivierung von Webinhalten geht, IronPDF bietet Entwicklern die Werkzeuge, die sie benötigen, um schnell und effizient Ergebnisse in professioneller Qualität zu erzielen.

IronPDF ist eine praktische Wahl für Entwickler, die in ihren HTML-zu-PDF-Workflows Wert auf Zuverlässigkeit, Skalierbarkeit und Benutzerfreundlichkeit legen.

Häufig gestellte Fragen

Wie kann ich HTML in PDF in C# konvertieren?

Sie können die IronPDF-Methode RenderHtmlAsPdf verwenden, um HTML-Strings in PDFs umzuwandeln. Darüber hinaus unterstützt IronPDF die direkte Konvertierung von HTML-Dateien in PDFs mit der Methode RenderHtmlFileAsPdf.

Was sind die Vorteile der Verwendung von IronPDF gegenüber Open-Source-Bibliotheken zur PDF-Konvertierung?

IronPDF bietet direkte HTML-zu-PDF-Konvertierung mit Unterstützung für moderne Webstandards, erweiterte PDF-Funktionen und einfache Integration mit .NET-Anwendungen. Es bietet eine professionelle Lösung im Vergleich zu Open-Source-Alternativen wie PuppeteerSharp, PdfSharp und Pdfium.NET SDK.

Kann IronPDF komplexes HTML, CSS und JavaScript während der PDF-Konvertierung handhaben?

Ja, IronPDF unterstützt die neuesten Webstandards und gewährleistet eine genaue Wiedergabe komplexer Layouts, Stile und interaktiver Elemente während der HTML-zu-PDF-Konvertierung.

Was wird benötigt, um IronPDF für die HTML-zu-PDF-Konvertierung zu verwenden?

Um IronPDF zu verwenden, wird ein gültiger Lizenzschlüssel benötigt. Entwickler können eine Testlizenz von der offiziellen Website erhalten, um die volle Funktionalität freizuschalten.

Was macht IronPDF zu einer praktischen Wahl für Entwickler?

IronPDF ist praktisch aufgrund seiner Zuverlässigkeit, Skalierbarkeit, Benutzerfreundlichkeit und robuster Funktionen für die HTML-zu-PDF-Konvertierung. Es ist ideal, um professionell gestaltete PDFs effizient und effektiv zu erstellen.

Was sind einige Einschränkungen bei der Verwendung von PuppeteerSharp zur PDF-Generierung?

PuppeteerSharp erfordert das Herunterladen und Bündeln des Chromium-Browsers, was die Dateigröße erhöht und ressourcenintensiv sein kann. Es konzentriert sich auf das Rendern, anstatt PDFs mit zusätzlichen Funktionen zu verbessern.

Wie unterscheidet sich das Pdfium.NET SDK von IronPDF in Bezug auf die HTML-zu-PDF-Konvertierung?

Das Pdfium.NET SDK unterstützt die HTML-zu-PDF-Konvertierung nicht nativ und erfordert das manuelle Rendern von HTML-Elementen. Im Gegensatz dazu bietet IronPDF integrierte Methoden für die direkte Konvertierung, was den Prozess vereinfacht.

Ist PdfSharp geeignet, um komplexe HTML-Strukturen in PDF darzustellen?

PdfSharp unterstützt die HTML-zu-PDF-Konvertierung nicht nativ und kann mit komplexen Layouts, Stilen oder JavaScript Schwierigkeiten haben, wodurch zusätzliche Bibliotheken für das Parsen von HTML erforderlich sind.

Welche Funktionen bietet IronPDF für die PDF-Bearbeitung?

IronPDF bietet Werkzeuge zum Erstellen, Bearbeiten und Extrahieren von Inhalten aus PDFs. Es unterstützt direkte HTML-zu-PDF-Konvertierung, Text-/Bildextraktion und das Einbetten eines PDF-Viewers in Anwendungen.

Ist IronPDF mit .NET 10 kompatibel und welche Vorteile bietet es bei der Verwendung in .NET 10-Projekten?

Ja – IronPDF ist vollständig mit .NET 10 kompatibel. Es unterstützt .NET 10-Projekte ohne dass spezielle Workarounds erforderlich sind, und nutzt Laufzeitverbesserungen wie die Devirtualisierung von Array-Schnittstellenmethoden, eine verbesserte Leistung und einen reduzierten Speicherverbrauch.

Welche neuen Verbesserungen bietet IronPDF für die HTML-zu-PDF-Konvertierung in .NET 10?

In .NET 10 bietet IronPDF ab der neuesten Version sofortige Unterstützung und ist somit vollständig mit der neuen Laufzeitumgebung kompatibel. Entwickler profitieren von kürzeren Startzeiten, besserer Speichernutzung und verbesserter Rendering-Performance dank Optimierungen der .NET 10-Rendering- und JIT-Engine.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion