Kostenlose PDF-Bibliotheken für .NET: Versteckte Kosten und bessere Alternativen in C#

Was bedeutet eigentlich "frei" in .NET PDF-Bibliotheken?

Wenn Sie in NuGet nach "PDF" suchen, finden Sie Bibliotheken für fünf Lizenzmodelle, die jeweils unterschiedliche Einschränkungen für die .NET-Bereitstellung aufweisen:

MIT/Apache (wirklich zulässig): PdfSharp. Verwenden Sie es in kommerziellen Anwendungen, Docker-Containern, Azure Functions, AWS Lambda - keine Einschränkungen, keine Umsatzschwellen, keine Offenlegung des Quellcodes. Der Haken: HTML kann nicht in PDF umgewandelt werden.

AGPL (Copyleft-Falle): iText-Kern(früher iTextSharp). Wenn Sie sie in einer beliebigen netzwerkfähigen Anwendung - Webanwendungen, REST-APIs, Microservices - einsetzen, müssen Sie Ihren gesamten Quellcode unter AGPL veröffentlichen. SaaS-Unternehmen sind davon nicht ausgenommen.

Umsatzabhängig: QuestPDF Community Lizenz. Frei unter $1M Bruttojahresumsatz. Wenn Sie diese Schwelle überschreiten, benötigen Sie eine kommerzielle Lizenz. Der Übergang ist nicht allmählich - er ist eine Klippe.

Aufgegeben: wkhtmltopdf und alle .NET-Wrapper. Archiviert mit ungepatchten CVEs der Bewertung 9.8 Kritisch. Keine Sicherheitspflege. Eine Verpflichtung bei jedem Compliance-Audit.

Betrieblich teuer: PuppeteerSharpund Playwright für .NET. Keine Lizenzbeschränkungen, volle moderne CSS-Unterstützung - aber Sie verwalten externe Browser-Prozesse, Chromium-Downloads und den Speicherlebenszyklus in der Produktion.

Jede Kategorie birgt unterschiedliche Risiken für .NET-Implementierungen. Im weiteren Verlauf dieses Artikels werden diese Risiken anhand von Code, Zahlen und Daten zum NuGet-Ökosystem aufgezeigt.

Warum ist die Preisgestaltung von iText die wahre Geschichte?

Die meisten Artikel über iText konzentrieren sich auf den Aspekt der AGPL-Durchsetzung. Das wird an anderer Stelle behandelt. Die wichtigere Frage für .NET-Teams, die PDF-Bibliotheken evaluieren, ist, was passiert, wenn Sie eine kommerzielle Lizenz benötigen.

Was sind die Beschränkungen von PdfSharp für .NET-Einsätze?

PdfSharp ist die Ausnahme unter den freien Bibliotheken: MIT-Lizenz, mehr als 34 Millionen NuGet-Downloads, echte Erlaubnis für die kommerzielle Nutzung. Keine Umsatzschwellen. Keine Offenlegung des Quellcodes.

Die Einschränkung ist architektonischer Natur. PdfSharp arbeitet auf der Ebene der PDF-Koordinaten. Es gibt keinen HTML-Parser, keine CSS-Engine und kein DOM-Rendering.

var document = new PdfDocument();
var page = document.AddPage();
var gfx = XGraphics.FromPdfPage(page);

// Every element needs manual coordinates
var titleFont = new XFont("Arial", 18, XFontStyleEx.Bold);
var bodyFont = new XFont("Arial", 10);

gfx.DrawString("INVOICE #2024-0847", titleFont, XBrushes.Black, 72, 72);
gfx.DrawString("Date: 2024-12-15", bodyFont, XBrushes.Gray, 72, 100);

// Table header - manual line drawing
gfx.DrawLine(XPens.Black, 72, 140, 540, 140);
gfx.DrawString("Item", bodyFont, XBrushes.Black, 72, 155);
gfx.DrawString("Qty", bodyFont, XBrushes.Black, 300, 155);
gfx.DrawString("Price", bodyFont, XBrushes.Black, 400, 155);
gfx.DrawLine(XPens.Black, 72, 170, 540, 170);

// Row data - every cell is a manual coordinate
gfx.DrawString("Annual License", bodyFont, XBrushes.Black, 72, 185);
gfx.DrawString("1", bodyFont, XBrushes.Black, 300, 185);
gfx.DrawString("$749.00", bodyFont, XBrushes.Black, 400, 185);

document.Save("invoice.pdf");

var document = new PdfDocument();
var page = document.AddPage();
var gfx = XGraphics.FromPdfPage(page);

// Every element needs manual coordinates
var titleFont = new XFont("Arial", 18, XFontStyleEx.Bold);
var bodyFont = new XFont("Arial", 10);

gfx.DrawString("INVOICE #2024-0847", titleFont, XBrushes.Black, 72, 72);
gfx.DrawString("Date: 2024-12-15", bodyFont, XBrushes.Gray, 72, 100);

// Table header - manual line drawing
gfx.DrawLine(XPens.Black, 72, 140, 540, 140);
gfx.DrawString("Item", bodyFont, XBrushes.Black, 72, 155);
gfx.DrawString("Qty", bodyFont, XBrushes.Black, 300, 155);
gfx.DrawString("Price", bodyFont, XBrushes.Black, 400, 155);
gfx.DrawLine(XPens.Black, 72, 170, 540, 170);

// Row data - every cell is a manual coordinate
gfx.DrawString("Annual License", bodyFont, XBrushes.Black, 72, 185);
gfx.DrawString("1", bodyFont, XBrushes.Black, 300, 185);
gfx.DrawString("$749.00", bodyFont, XBrushes.Black, 400, 185);

document.Save("invoice.pdf");

Imports PdfSharp.Pdf
Imports PdfSharp.Drawing

Dim document As New PdfDocument()
Dim page As PdfPage = document.AddPage()
Dim gfx As XGraphics = XGraphics.FromPdfPage(page)

' Every element needs manual coordinates
Dim titleFont As New XFont("Arial", 18, XFontStyleEx.Bold)
Dim bodyFont As New XFont("Arial", 10)

gfx.DrawString("INVOICE #2024-0847", titleFont, XBrushes.Black, 72, 72)
gfx.DrawString("Date: 2024-12-15", bodyFont, XBrushes.Gray, 72, 100)

' Table header - manual line drawing
gfx.DrawLine(XPens.Black, 72, 140, 540, 140)
gfx.DrawString("Item", bodyFont, XBrushes.Black, 72, 155)
gfx.DrawString("Qty", bodyFont, XBrushes.Black, 300, 155)
gfx.DrawString("Price", bodyFont, XBrushes.Black, 400, 155)
gfx.DrawLine(XPens.Black, 72, 170, 540, 170)

' Row data - every cell is a manual coordinate
gfx.DrawString("Annual License", bodyFont, XBrushes.Black, 72, 185)
gfx.DrawString("1", bodyFont, XBrushes.Black, 300, 185)
gfx.DrawString("$749.00", bodyFont, XBrushes.Black, 400, 185)

document.Save("invoice.pdf")

Das sind 20 Zeilen für eine einzeilige Rechnung ohne Styling, ohne responsives Layout, ohne CSS. Stellen Sie sich nun vor, Sie erstellen einen 15-seitigen Compliance-Bericht mit dynamischen Daten, Diagrammen und Corporate Branding.

Wann hört QuestPDF auf, kostenlos zu sein?

QuestPDF verfolgte einen anderen Design-Ansatz als PdfSharp: eine fließende API, die sich eher wie eine Layout-Beschreibung als eine Koordinaten-Mathematik liest. Das API-Design ist wirklich gut.

Document.Create(container =>
{
    container.Page(page =>
    {
        page.Size(PageSizes.A4);
        page.Margin(2, Unit.Centimetre);

        page.Content().Column(column =>
        {
            column.Item().Text("Invoice #2024-0847").FontSize(18).Bold();
            column.Item().Table(table =>
            {
                table.ColumnsDefinition(columns =>
                {
                    columns.RelativeColumn(3);
                    columns.RelativeColumn(1);
                    columns.RelativeColumn(1);
                });

                table.Cell().Text("Item").Bold();
                table.Cell().Text("Qty").Bold();
                table.Cell().Text("Price").Bold();

                table.Cell().Text("Annual License");
                table.Cell().Text("1");
                table.Cell().Text("$749.00");
            });
        });
    });
}).GeneratePdf("invoice.pdf");

Document.Create(container =>
{
    container.Page(page =>
    {
        page.Size(PageSizes.A4);
        page.Margin(2, Unit.Centimetre);

        page.Content().Column(column =>
        {
            column.Item().Text("Invoice #2024-0847").FontSize(18).Bold();
            column.Item().Table(table =>
            {
                table.ColumnsDefinition(columns =>
                {
                    columns.RelativeColumn(3);
                    columns.RelativeColumn(1);
                    columns.RelativeColumn(1);
                });

                table.Cell().Text("Item").Bold();
                table.Cell().Text("Qty").Bold();
                table.Cell().Text("Price").Bold();

                table.Cell().Text("Annual License");
                table.Cell().Text("1");
                table.Cell().Text("$749.00");
            });
        });
    });
}).GeneratePdf("invoice.pdf");

Document.Create(Sub(container)
    container.Page(Sub(page)
        page.Size(PageSizes.A4)
        page.Margin(2, Unit.Centimetre)

        page.Content().Column(Sub(column)
            column.Item().Text("Invoice #2024-0847").FontSize(18).Bold()
            column.Item().Table(Sub(table)
                table.ColumnsDefinition(Sub(columns)
                    columns.RelativeColumn(3)
                    columns.RelativeColumn(1)
                    columns.RelativeColumn(1)
                End Sub)

                table.Cell().Text("Item").Bold()
                table.Cell().Text("Qty").Bold()
                table.Cell().Text("Price").Bold()

                table.Cell().Text("Annual License")
                table.Cell().Text("1")
                table.Cell().Text("$749.00")
            End Sub)
        End Sub)
    End Sub)
End Sub).GeneratePdf("invoice.pdf")

Das ist aussagekräftiger als das Koordinatensystem von PdfSharp. Sie hat jedoch dieselbe grundlegende Einschränkung: keine HTML-Darstellung.

Warum sollten Sie wkhtmltopdf in jeder .NET-Implementierung vermeiden?

Ich habe diesen Artikel aus einem bestimmten Grund mit CVE-2022-35583 eröffnet. Diese SSRF-Schwachstelle ist nicht theoretisch - Proof-of-Concept-Exploits sind öffentlich verfügbar und werden aktiv genutzt.

Was sind die wahren Betriebskosten von PuppeteerSharp?

Dies ist der Bereich, in dem die meisten Artikel über "kostenlose PDF-Bibliotheken" falsch sind. PuppeteerSharpund Playwright für .NET sind technisch hervorragend - sie rendern HTML über echtes Chromium und unterstützen jede CSS-Funktion und JavaScript-API. Keine Lizenzierungsbeschränkungen. Keine Umsatzschwellen.

Die Kosten sind operativ. So sieht die PDF-Erstellung für PuppeteerSharpin der Produktion aus:

using PuppeteerSharp;

public class PuppeteerPdfService : IDisposable
{
    private IBrowser _browser;
    private readonly SemaphoreSlim _semaphore;
    private long _pdfCount = 0;

    public PuppeteerPdfService()
    {
        // Limit concurrent pages to prevent memory exhaustion
        _semaphore = new SemaphoreSlim(3, 3);
    }

    public async Task InitializeAsync()
    {
        // Step 1: Download Chromium binary (~280MB)
        var fetcher = new BrowserFetcher();
        await fetcher.DownloadAsync();

        // Step 2: Launch with production-hardened flags
        _browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true,
            Args = new[]
            {
                "--no-sandbox",              // Required in Docker
                "--disable-setuid-sandbox",  // Required in Docker
                "--disable-dev-shm-usage",   // Prevent /dev/shm exhaustion
                "--disable-gpu",
                "--no-zygote",
                "--single-process",
                "--disable-extensions",
                "--max_old_space_size=4096"
            },
            Timeout = 30000
        });
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _semaphore.WaitAsync();
        IPage page = null;

        try
        {
            Interlocked.Increment(ref _pdfCount);
            page = await _browser.NewPageAsync();

            await page.SetContentAsync(html, new NavigationOptions
            {
                WaitUntil = new[] { WaitUntilNavigation.Networkidle0 },
                Timeout = 20000
            });

            var pdfBytes = await page.PdfAsync(new PdfOptions
            {
                Format = PaperFormat.A4,
                PrintBackground = true,
                MarginOptions = new MarginOptions
                {
                    Top = "20mm", Bottom = "20mm",
                    Left = "15mm", Right = "15mm"
                }
            });

            return pdfBytes;
        }
        finally
        {
            if (page != null)
            {
                try { await page.CloseAsync(); }
                catch { /* Disposal can hang — GitHub issue #1489 */ }
            }
            _semaphore.Release();
        }
    }

    // Restart browser periodically to reclaim leaked memory
    public async Task RecycleBrowserAsync()
    {
        var oldBrowser = _browser;
        await InitializeAsync();
        try { oldBrowser?.Dispose(); } catch { }
    }

    public void Dispose()
    {
        _browser?.Dispose();
        _semaphore?.Dispose();
    }
}

using PuppeteerSharp;

public class PuppeteerPdfService : IDisposable
{
    private IBrowser _browser;
    private readonly SemaphoreSlim _semaphore;
    private long _pdfCount = 0;

    public PuppeteerPdfService()
    {
        // Limit concurrent pages to prevent memory exhaustion
        _semaphore = new SemaphoreSlim(3, 3);
    }

    public async Task InitializeAsync()
    {
        // Step 1: Download Chromium binary (~280MB)
        var fetcher = new BrowserFetcher();
        await fetcher.DownloadAsync();

        // Step 2: Launch with production-hardened flags
        _browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true,
            Args = new[]
            {
                "--no-sandbox",              // Required in Docker
                "--disable-setuid-sandbox",  // Required in Docker
                "--disable-dev-shm-usage",   // Prevent /dev/shm exhaustion
                "--disable-gpu",
                "--no-zygote",
                "--single-process",
                "--disable-extensions",
                "--max_old_space_size=4096"
            },
            Timeout = 30000
        });
    }

    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        await _semaphore.WaitAsync();
        IPage page = null;

        try
        {
            Interlocked.Increment(ref _pdfCount);
            page = await _browser.NewPageAsync();

            await page.SetContentAsync(html, new NavigationOptions
            {
                WaitUntil = new[] { WaitUntilNavigation.Networkidle0 },
                Timeout = 20000
            });

            var pdfBytes = await page.PdfAsync(new PdfOptions
            {
                Format = PaperFormat.A4,
                PrintBackground = true,
                MarginOptions = new MarginOptions
                {
                    Top = "20mm", Bottom = "20mm",
                    Left = "15mm", Right = "15mm"
                }
            });

            return pdfBytes;
        }
        finally
        {
            if (page != null)
            {
                try { await page.CloseAsync(); }
                catch { /* Disposal can hang — GitHub issue #1489 */ }
            }
            _semaphore.Release();
        }
    }

    // Restart browser periodically to reclaim leaked memory
    public async Task RecycleBrowserAsync()
    {
        var oldBrowser = _browser;
        await InitializeAsync();
        try { oldBrowser?.Dispose(); } catch { }
    }

    public void Dispose()
    {
        _browser?.Dispose();
        _semaphore?.Dispose();
    }
}

Imports PuppeteerSharp
Imports System.Threading

Public Class PuppeteerPdfService
    Implements IDisposable

    Private _browser As IBrowser
    Private ReadOnly _semaphore As SemaphoreSlim
    Private _pdfCount As Long = 0

    Public Sub New()
        ' Limit concurrent pages to prevent memory exhaustion
        _semaphore = New SemaphoreSlim(3, 3)
    End Sub

    Public Async Function InitializeAsync() As Task
        ' Step 1: Download Chromium binary (~280MB)
        Dim fetcher = New BrowserFetcher()
        Await fetcher.DownloadAsync()

        ' Step 2: Launch with production-hardened flags
        _browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
            .Headless = True,
            .Args = {
                "--no-sandbox",              ' Required in Docker
                "--disable-setuid-sandbox",  ' Required in Docker
                "--disable-dev-shm-usage",   ' Prevent /dev/shm exhaustion
                "--disable-gpu",
                "--no-zygote",
                "--single-process",
                "--disable-extensions",
                "--max_old_space_size=4096"
            },
            .Timeout = 30000
        })
    End Function

    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Await _semaphore.WaitAsync()
        Dim page As IPage = Nothing

        Try
            Interlocked.Increment(_pdfCount)
            page = Await _browser.NewPageAsync()

            Await page.SetContentAsync(html, New NavigationOptions With {
                .WaitUntil = {WaitUntilNavigation.Networkidle0},
                .Timeout = 20000
            })

            Dim pdfBytes = Await page.PdfAsync(New PdfOptions With {
                .Format = PaperFormat.A4,
                .PrintBackground = True,
                .MarginOptions = New MarginOptions With {
                    .Top = "20mm", .Bottom = "20mm",
                    .Left = "15mm", .Right = "15mm"
                }
            })

            Return pdfBytes
        Finally
            If page IsNot Nothing Then
                Try
                    Await page.CloseAsync()
                Catch
                    ' Disposal can hang — GitHub issue #1489
                End Try
            End If
            _semaphore.Release()
        End Try
    End Function

    ' Restart browser periodically to reclaim leaked memory
    Public Async Function RecycleBrowserAsync() As Task
        Dim oldBrowser = _browser
        Await InitializeAsync()
        Try
            oldBrowser?.Dispose()
        Catch
        End Try
    End Function

    Public Sub Dispose() Implements IDisposable.Dispose
        _browser?.Dispose()
        _semaphore?.Dispose()
    End Sub
End Class

Das sind mehr als 80 Zeilen, bevor Sie eine einzige PDF-Datei erstellt haben. Außerdem fehlen noch Fehlerbehebungen, Zustandsprüfungen, Metriken und der Timer für die Speicherwiederverwendung, den Produktionssysteme benötigen.

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 20;
renderer.RenderingOptions.MarginBottom = 20;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 20
renderer.RenderingOptions.MarginBottom = 20

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

.NET Ecosystem Health: NuGet-Paketvergleich

Bevor Sie sich für eine Bibliothek entscheiden, sollten Sie den Zustand ihres NuGet-Ökosystems überprüfen. Abhängigkeitsketten, Versionshäufigkeit und Problemlösungszeit sagen mehr aus als Feature-Listen:

Hohe Download-Zahlen bei nicht mehr genutzten Paketen wie DinkToPdfspiegeln die Akzeptanz von Altbewährtem wider, nicht den aktuellen Zustand. Die mehr als 300 offenen Fragen, auf die es keine Antworten gibt, erzählen die wahre Geschichte.

Für .NET 8-Anwendungen, die auf net8.0 TFM abzielen: PdfSharp, QuestPDF, iText-Kernund IronPDFunterstützen es alle von Haus aus. wkhtmltopdf-Wrapper nicht - erwarten Sie DllNotFoundException und NU1202 Zielframework-Inkompatibilitätsfehler.

Entscheidungsmatrix

Wenn Sie nur programmatische PDF-Erstellung aus strukturierten Daten benötigen: PdfSharp (MIT, keine Einschränkungen) oder QuestPDF (bessere API, achten Sie auf die Umsatzschwelle).

Wenn Sie HTML-zu-PDF mit modernem CSS benötigen und keine Browser-Infrastruktur verwalten möchten: IronPDF. Embedded Chromium verwaltet den Lebenszyklus der Rendering-Engine. Veröffentlichte Preise zu einem Bruchteil des Abonnementmodells von iText.

Wenn Sie HTML-zu-PDF benötigen und mit der Verwaltung von Browser-Prozessen vertraut sind: PuppeteerSharpgibt Ihnen die volle Kontrolle. Budget für den operativen Overhead.

Wenn Sie derzeit wkhtmltopdf oder einen seiner Wrapperverwenden: Migrieren Sie. Allein das Sicherheitsrisiko rechtfertigt den Aufwand - und mit jedem Monat, den Sie sich verspäten, bleibt die CVE-Liste ungepatched.