Iron Suite for .NET

10 .NET-Bibliotheken. Eine komplette Dokumenten-Suite.

Entdecken Sie Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

VERGLEICH

Telerik Document Processing vs. IronPDF: Leitfaden für einen technischen Vergleich

Curtis Chau

Updated: 8. Mai 2026

mit .NET 8 wurden Laufzeitänderungen eingeführt, die die Kompatibilität mit vielen herkömmlichen PDF-Bibliotheken aufheben. System.Drawing.Common ist auf Nicht-Windows-Plattformen veraltet, Native AOT stellt neue Anforderungen an reflexionslastige Bibliotheken und das Container-First-Deployment-Modell bringt Abhängigkeitsprobleme mit sich, die auf Windows-Entwicklungsmaschinen nicht auftraten. Bibliotheken, die in .NET Framework oder sogar .NET 6 funktioniert haben, können in .NET 8 mit NU1202, DllNotFoundException oder PlatformNotSupportedException Fehlern scheitern.

Dieser Artikel dokumentiert, welche PDF-Bibliotheken mit .NET 8 funktionieren, zeigt die spezifischen Fehler auf, die bei inkompatiblen Bibliotheken auftreten, und bietet Bereitstellungskonfigurationen für Docker und Azure Functions.

Schnellstart: Erzeugen von PDF aus HTML in .NET 8

using IronPdf;

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

var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
    <head><style>
        body { font-family: 'Segoe UI', sans-serif; padding: 40px; }
        h1 { color: #2563eb; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th { background: #2563eb; color: white; padding: 12px; text-align: left; }
        td { padding: 10px; border-bottom: 1px solid #e5e7eb; }
    </style></head>
    <body>
        <h1>Q4 Report</h1>
        <table>
            <tr><th>Metric</th><th>Value</th><th>Change</th></tr>
            <tr><td>Revenue</td><td>$1.2M</td><td>+12%</td></tr>
            <tr><td>Users</td><td>45,230</td><td>+23%</td></tr>
        </table>
    </body></html>");

pdf.SaveAs("report.pdf");

using IronPdf;

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

var pdf = renderer.RenderHtmlAsPdf(@"
    <html>
    <head><style>
        body { font-family: 'Segoe UI', sans-serif; padding: 40px; }
        h1 { color: #2563eb; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th { background: #2563eb; color: white; padding: 12px; text-align: left; }
        td { padding: 10px; border-bottom: 1px solid #e5e7eb; }
    </style></head>
    <body>
        <h1>Q4 Report</h1>
        <table>
            <tr><th>Metric</th><th>Value</th><th>Change</th></tr>
            <tr><td>Revenue</td><td>$1.2M</td><td>+12%</td></tr>
            <tr><td>Users</td><td>45,230</td><td>+23%</td></tr>
        </table>
    </body></html>");

pdf.SaveAs("report.pdf");

Imports IronPdf

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

Dim pdf = renderer.RenderHtmlAsPdf("
    <html>
    <head><style>
        body { font-family: 'Segoe UI', sans-serif; padding: 40px; }
        h1 { color: #2563eb; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th { background: #2563eb; color: white; padding: 12px; text-align: left; }
        td { padding: 10px; border-bottom: 1px solid #e5e7eb; }
    </style></head>
    <body>
        <h1>Q4 Report</h1>
        <table>
            <tr><th>Metric</th><th>Value</th><th>Change</th></tr>
            <tr><td>Revenue</td><td>$1.2M</td><td>+12%</td></tr>
            <tr><td>Users</td><td>45,230</td><td>+23%</td></tr>
        </table>
    </body></html>")

pdf.SaveAs("report.pdf")

Imports IronPdf

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

Dim pdf = renderer.RenderHtmlAsPdf("
    <html>
    <head><style>
        body { font-family: 'Segoe UI', sans-serif; padding: 40px; }
        h1 { color: #2563eb; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; }
        th { background: #2563eb; color: white; padding: 12px; text-align: left; }
        td { padding: 10px; border-bottom: 1px solid #e5e7eb; }
    </style></head>
    <body>
        <h1>Q4 Report</h1>
        <table>
            <tr><th>Metric</th><th>Value</th><th>Change</th></tr>
            <tr><td>Revenue</td><td>$1.2M</td><td>+12%</td></tr>
            <tr><td>Users</td><td>45,230</td><td>+23%</td></tr>
        </table>
    </body></html>")

pdf.SaveAs("report.pdf")

Installation über NuGet: Install-Package IronPdf. Zielt auf net8.0 ohne zusätzliche Konfiguration. Kann auf Windows, Linux, macOS, Docker und Azure ohne plattformspezifisches Setup bereitgestellt werden.

Warum scheitern ältere PDF-Bibliotheken in .NET 8?

iText— Nicht kompatibel mit .NET 8

iText (der ursprüngliche .NET-Port von iText) wurde seit 2018 nicht mehr aktualisiert. Es zielt nur auf das .NET Framework:

fehler NU1202: Das Paket iTextSharp 5.5.13 ist nicht kompatibel mit net8.0

fehler NU1202: Das Paket iTextSharp 5.5.13 ist nicht kompatibel mit net8.0

Text

Der Migrationsweg ist iText, das eine andere API hat und entweder die AGPL-Konformität (Open-Source für Ihre gesamte Anwendung) oder eine kommerzielle Lizenzierung erfordert. Die Preise werden nicht veröffentlicht - Daten von Drittanbietern deuten auf $15.000-$210.000/Jahr hin.

wkhtmltopdf Wrappers - DLL-Ladefehler unter .NET 8

C#-Wrapper um wkhtmltopdf (DinkToPdf, Rotativa, NReco.PdfGenerator) schlagen mit plattformspezifischen Fehlern fehl, die nur im .NET 8-Bereitstellungsmodell auftreten:

DinkToPdf - native Bibliothek nicht gefunden:

System.DllNotFoundException: DLL 'libwkhtmltox' kann nicht geladen werden

System.DllNotFoundException: DLL 'libwkhtmltox' kann nicht geladen werden

Text

Rotativa.AspNetCore - erfordert eine manuelle Konfiguration des Binärpfads, die mit der Container-First-Bereitstellung von .NET 8 in Konflikt steht:

// This pattern requires deploying wkhtmltopdf binaries alongside your app
// and breaks in Docker containers without explicit path configuration
RotativaConfiguration.Setup(env.WebRootPath, "wkhtmltopdf");

// This pattern requires deploying wkhtmltopdf binaries alongside your app
// and breaks in Docker containers without explicit path configuration
RotativaConfiguration.Setup(env.WebRootPath, "wkhtmltopdf");

' This pattern requires deploying wkhtmltopdf binaries alongside your app
' and breaks in Docker containers without explicit path configuration
RotativaConfiguration.Setup(env.WebRootPath, "wkhtmltopdf")

' This pattern requires deploying wkhtmltopdf binaries alongside your app
' and breaks in Docker containers without explicit path configuration
RotativaConfiguration.Setup(env.WebRootPath, "wkhtmltopdf")

TuesPechkin / NReco - Unstimmigkeiten in der Architektur:

System.BadImageFormatException: Datei oder Baugruppe konnte nicht geladen werden

System.BadImageFormatException: Datei oder Baugruppe konnte nicht geladen werden

Text

Diese Fehler spiegeln ein tiefer liegendes Problem wider: wkhtmltopdf wurde im Juli 2024 archiviert mit ungepatchten CVEs. Die native Binärarchitektur ist älter als die Verbesserungen der Plattformerkennung von .NET 8. Es gibt keinen Fix - nur die Migration zu einer anderen Bibliothek.

PDFSharp— System.Drawing.Common-Fehler unter Linux

PDFSharp ist abhängig von System.Drawing.Common, das Microsoft für Nicht-Windows-Plattformen in .NET 6 eingestellt hat. In .NET 8 führt dies zu Laufzeitfehlern bei der Bereitstellung unter Linux oder Docker:

using PdfSharp.Pdf;
using PdfSharp.Drawing;

var document = new PdfDocument();
// PlatformNotSupportedException on Linux:
// System.Drawing.Common is not supported on this platform

using PdfSharp.Pdf;
using PdfSharp.Drawing;

var document = new PdfDocument();
// PlatformNotSupportedException on Linux:
// System.Drawing.Common is not supported on this platform

Imports PdfSharp.Pdf
Imports PdfSharp.Drawing

Dim document As New PdfDocument()
' PlatformNotSupportedException on Linux:
' System.Drawing.Common is not supported on this platform

Imports PdfSharp.Pdf
Imports PdfSharp.Drawing

Dim document As New PdfDocument()
' PlatformNotSupportedException on Linux:
' System.Drawing.Common is not supported on this platform

PDFSharp 6.x arbeitet daran, diese Abhängigkeit zu entfernen, aber die plattformübergreifende Unterstützung ist bis Anfang 2026 noch unvollständig. Für Windows-only Bereitstellungen funktioniertPDFSharpmit .NET 8. Für Linux, Docker oder Cloud-Bereitstellungen ist es unzuverlässig.

Welche PDF-Bibliotheken funktionieren mit .NET 8?

IronPDF- Volle Unterstützung für .NET 8, plattformübergreifend

IronPDF zielt nativ auf net8.0 mit eingebetteter Chromium-Darstellung. Keine System.Drawing.Common-Abhängigkeit, keine native Binärverwaltung, keine plattformspezifische Konfiguration.

Minimale API-Integration (das primäre .NET 8-Muster):

using IronPdf;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/invoice/{id}/pdf", async (int id, InvoiceService service) =>
{
    var invoice = await service.GetInvoiceAsync(id);
    var renderer = new ChromePdfRenderer();

    var pdf = renderer.RenderHtmlAsPdf(invoice.ToHtml());

    return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
});

app.Run();

using IronPdf;

var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();

app.MapGet("/invoice/{id}/pdf", async (int id, InvoiceService service) =>
{
    var invoice = await service.GetInvoiceAsync(id);
    var renderer = new ChromePdfRenderer();

    var pdf = renderer.RenderHtmlAsPdf(invoice.ToHtml());

    return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf");
});

app.Run();

Imports IronPdf

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/invoice/{id}/pdf", Async Function(id As Integer, service As InvoiceService) 
    Dim invoice = Await service.GetInvoiceAsync(id)
    Dim renderer = New ChromePdfRenderer()

    Dim pdf = renderer.RenderHtmlAsPdf(invoice.ToHtml())

    Return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf")
End Function)

app.Run()

Imports IronPdf

Dim builder = WebApplication.CreateBuilder(args)
Dim app = builder.Build()

app.MapGet("/invoice/{id}/pdf", Async Function(id As Integer, service As InvoiceService) 
    Dim invoice = Await service.GetInvoiceAsync(id)
    Dim renderer = New ChromePdfRenderer()

    Dim pdf = renderer.RenderHtmlAsPdf(invoice.ToHtml())

    Return Results.File(pdf.BinaryData, "application/pdf", $"invoice-{id}.pdf")
End Function)

app.Run()

Für Teams, die das Controller-Pattern verwenden, funktioniert derselbe Code innerhalb einer Controller-Aktion — RenderHtmlAsPdf gibt ein PdfDocument zurück, das Sie mit .BinaryData in Bytes umwandeln können.

Lizenzierung: Unbefristete Lizenz ab $liteLicense (Lite — 1 Entwickler, 1 Projekt). Professional: 1.499 $ (10 Entwickler). Enterprise: $2.999 (unbegrenzt). Veröffentlicht auf ironpdf.com.

QuestPDF - .NET 8-kompatibel, kein HTML

QuestPDF arbeitet mit .NET 8 ohne Plattformabhängigkeiten. Die fließende C#-API erstellt Dokumente programmatisch - kein HTML-Parser, keine CSS-Engine, keine Browser-Engine:

using QuestPDF.Fluent;
using QuestPDF.Infrastructure;

QuestPDF.Settings.License = LicenseType.Community; // Free under $1M revenue

Document.Create(container =>
{
    container.Page(page =>
    {
        page.Size(PageSizes.A4);
        page.Margin(2, Unit.Centimetre);
        page.Content().Column(col =>
        {
            col.Item().Text("Q4 Report").FontSize(24).Bold();
            col.Item().Table(table =>
            {
                table.ColumnsDefinition(c => { c.RelativeColumn(2); c.RelativeColumn(1); c.RelativeColumn(1); });
                table.Header(h =>
                {
                    h.Cell().Text("Metric").Bold();
                    h.Cell().Text("Value").Bold();
                    h.Cell().Text("Change").Bold();
                });
                table.Cell().Text("Revenue"); table.Cell().Text("$1.2M"); table.Cell().Text("+12%");
                table.Cell().Text("Users"); table.Cell().Text("45,230"); table.Cell().Text("+23%");
            });
        });
    });
}).GeneratePdf("report.pdf");

using QuestPDF.Fluent;
using QuestPDF.Infrastructure;

QuestPDF.Settings.License = LicenseType.Community; // Free under $1M revenue

Document.Create(container =>
{
    container.Page(page =>
    {
        page.Size(PageSizes.A4);
        page.Margin(2, Unit.Centimetre);
        page.Content().Column(col =>
        {
            col.Item().Text("Q4 Report").FontSize(24).Bold();
            col.Item().Table(table =>
            {
                table.ColumnsDefinition(c => { c.RelativeColumn(2); c.RelativeColumn(1); c.RelativeColumn(1); });
                table.Header(h =>
                {
                    h.Cell().Text("Metric").Bold();
                    h.Cell().Text("Value").Bold();
                    h.Cell().Text("Change").Bold();
                });
                table.Cell().Text("Revenue"); table.Cell().Text("$1.2M"); table.Cell().Text("+12%");
                table.Cell().Text("Users"); table.Cell().Text("45,230"); table.Cell().Text("+23%");
            });
        });
    });
}).GeneratePdf("report.pdf");

Imports QuestPDF.Fluent
Imports QuestPDF.Infrastructure

QuestPDF.Settings.License = LicenseType.Community ' Free under $1M revenue

Document.Create(Sub(container)
    container.Page(Sub(page)
        page.Size(PageSizes.A4)
        page.Margin(2, Unit.Centimetre)
        page.Content().Column(Sub(col)
            col.Item().Text("Q4 Report").FontSize(24).Bold()
            col.Item().Table(Sub(table)
                table.ColumnsDefinition(Sub(c)
                    c.RelativeColumn(2)
                    c.RelativeColumn(1)
                    c.RelativeColumn(1)
                End Sub)
                table.Header(Sub(h)
                    h.Cell().Text("Metric").Bold()
                    h.Cell().Text("Value").Bold()
                    h.Cell().Text("Change").Bold()
                End Sub)
                table.Cell().Text("Revenue")
                table.Cell().Text("$1.2M")
                table.Cell().Text("+12%")
                table.Cell().Text("Users")
                table.Cell().Text("45,230")
                table.Cell().Text("+23%")
            End Sub)
        End Sub)
    End Sub)
End Sub).GeneratePdf("report.pdf")

Imports QuestPDF.Fluent
Imports QuestPDF.Infrastructure

QuestPDF.Settings.License = LicenseType.Community ' Free under $1M revenue

Document.Create(Sub(container)
    container.Page(Sub(page)
        page.Size(PageSizes.A4)
        page.Margin(2, Unit.Centimetre)
        page.Content().Column(Sub(col)
            col.Item().Text("Q4 Report").FontSize(24).Bold()
            col.Item().Table(Sub(table)
                table.ColumnsDefinition(Sub(c)
                    c.RelativeColumn(2)
                    c.RelativeColumn(1)
                    c.RelativeColumn(1)
                End Sub)
                table.Header(Sub(h)
                    h.Cell().Text("Metric").Bold()
                    h.Cell().Text("Value").Bold()
                    h.Cell().Text("Change").Bold()
                End Sub)
                table.Cell().Text("Revenue")
                table.Cell().Text("$1.2M")
                table.Cell().Text("+12%")
                table.Cell().Text("Users")
                table.Cell().Text("45,230")
                table.Cell().Text("+23%")
            End Sub)
        End Sub)
    End Sub)
End Sub).GeneratePdf("report.pdf")

QuestPDF konvertiert kein HTML. Wenn Ihr Arbeitsablauf HTML-Vorlagen verwendet (Razor-Ansichten, Dashboard-Exporte, Archivierung von Webinhalten), benötigen Sie eine andere Bibliothek. Die Community-Lizenz gilt für Unternehmen mit einem Jahresumsatz von weniger als 1 Million US-Dollar; darüber hinaus ist eine kommerzielle Lizenzierung erforderlich.

iText— .NET 8 kompatibel, AGPL-lizenziert

iText (der Nachfolger von iText) unterstützt .NET 8. Das pdfHTML-Add-on bietet eine HTML-zu-PDF-Konvertierung mit einem benutzerdefinierten Parser — kein Browser-Engine, daher werden moderne CSS-Features (Flexbox, Grid) nicht korrekt wiedergegeben.

Lizenzierung: AGPL für Open-Source-Nutzung, kommerzielle Lizenzierung (Abonnement, Preise nicht veröffentlicht) für proprietäre Anwendungen. iTextwird 2024 auf eine kommerzielle Lizenzierung auf Abonnementbasis umgestellt.

Docker-Bereitstellung

Standard-Debian-Abbild (empfohlen)

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app

# IronPDF works without additional apt-get installs
# Chromium dependencies are handled internally

COPY --from=build /app/publish .

ENV DOTNET_RUNNING_IN_CONTAINER=true
EXPOSE 8080
ENTRYPOINT ["dotnet", "MyApp.dll"]

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:8.0
WORKDIR /app

# IronPDF works without additional apt-get installs
# Chromium dependencies are handled internally

COPY --from=build /app/publish .

ENV DOTNET_RUNNING_IN_CONTAINER=true
EXPOSE 8080
ENTRYPOINT ["dotnet", "MyApp.dll"]

Text

Alpine Image (Kleinerer Fußabdruck)

FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine
WORKDIR /app

# Alpine requires explicit Chromium dependencies
RUN apk add --no-cache chromium nss freetype harfbuzz ca-certificates ttf-freefont

COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build
WORKDIR /src
COPY ["MyApp.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet publish -c Release -o /app/publish

FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine
WORKDIR /app

# Alpine requires explicit Chromium dependencies
RUN apk add --no-cache chromium nss freetype harfbuzz ca-certificates ttf-freefont

COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyApp.dll"]

Text

Das Debian-Image erfordert keine zusätzlichen Pakete. Das Alpine-Image ist kleiner, erfordert aber eine explizite Installation der Chromium-Bibliothek. Für die meisten Einsätze ist das Standard-Debian-Image einfacher und zuverlässiger.

Azure Functions (Isolated Worker)

.NET 8 Azure Functions verwenden das isolierte Worker-Modell.IronPDF arbeitet mit diesem Modell für die On-Demand-PDF-Generierung:

using IronPdf;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;

namespace MyApp.Functions;

public class PdfFunctions
{
    [Function("GenerateInvoice")]
    public async Task<HttpResponseData> GenerateInvoice(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
    {
        var invoice = await req.ReadFromJsonAsync<InvoiceRequest>();

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(BuildInvoiceHtml(invoice));

        var response = req.CreateResponse(System.Net.HttpStatusCode.OK);
        response.Headers.Add("Content-Type", "application/pdf");
        response.Headers.Add("Content-Disposition",
            $"attachment; filename=invoice-{invoice.Id}.pdf");
        await response.Body.WriteAsync(pdf.BinaryData);

        return response;
    }

    private string BuildInvoiceHtml(InvoiceRequest invoice)
    {
        return $@"<html><body>
            <h1>Invoice #{invoice.Id}</h1>
            <p>Amount: ${invoice.Amount:F2}</p>
        </body></html>";
    }
}

public record InvoiceRequest(string Id, decimal Amount);

using IronPdf;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;

namespace MyApp.Functions;

public class PdfFunctions
{
    [Function("GenerateInvoice")]
    public async Task<HttpResponseData> GenerateInvoice(
        [HttpTrigger(AuthorizationLevel.Function, "post")] HttpRequestData req)
    {
        var invoice = await req.ReadFromJsonAsync<InvoiceRequest>();

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(BuildInvoiceHtml(invoice));

        var response = req.CreateResponse(System.Net.HttpStatusCode.OK);
        response.Headers.Add("Content-Type", "application/pdf");
        response.Headers.Add("Content-Disposition",
            $"attachment; filename=invoice-{invoice.Id}.pdf");
        await response.Body.WriteAsync(pdf.BinaryData);

        return response;
    }

    private string BuildInvoiceHtml(InvoiceRequest invoice)
    {
        return $@"<html><body>
            <h1>Invoice #{invoice.Id}</h1>
            <p>Amount: ${invoice.Amount:F2}</p>
        </body></html>";
    }
}

public record InvoiceRequest(string Id, decimal Amount);

Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http

Namespace MyApp.Functions

    Public Class PdfFunctions

        <Function("GenerateInvoice")>
        Public Async Function GenerateInvoice(
            <HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData) As Task(Of HttpResponseData)

            Dim invoice = Await req.ReadFromJsonAsync(Of InvoiceRequest)()

            Dim renderer = New ChromePdfRenderer()
            Dim pdf = renderer.RenderHtmlAsPdf(BuildInvoiceHtml(invoice))

            Dim response = req.CreateResponse(System.Net.HttpStatusCode.OK)
            response.Headers.Add("Content-Type", "application/pdf")
            response.Headers.Add("Content-Disposition", $"attachment; filename=invoice-{invoice.Id}.pdf")
            Await response.Body.WriteAsync(pdf.BinaryData)

            Return response
        End Function

        Private Function BuildInvoiceHtml(invoice As InvoiceRequest) As String
            Return $"<html><body>
            <h1>Invoice #{invoice.Id}</h1>
            <p>Amount: ${invoice.Amount:F2}</p>
        </body></html>"
        End Function

    End Class

    Public Class InvoiceRequest
        Public Property Id As String
        Public Property Amount As Decimal

        Public Sub New(id As String, amount As Decimal)
            Me.Id = id
            Me.Amount = amount
        End Sub
    End Class

End Namespace

Imports IronPdf
Imports Microsoft.Azure.Functions.Worker
Imports Microsoft.Azure.Functions.Worker.Http

Namespace MyApp.Functions

    Public Class PdfFunctions

        <Function("GenerateInvoice")>
        Public Async Function GenerateInvoice(
            <HttpTrigger(AuthorizationLevel.Function, "post")> req As HttpRequestData) As Task(Of HttpResponseData)

            Dim invoice = Await req.ReadFromJsonAsync(Of InvoiceRequest)()

            Dim renderer = New ChromePdfRenderer()
            Dim pdf = renderer.RenderHtmlAsPdf(BuildInvoiceHtml(invoice))

            Dim response = req.CreateResponse(System.Net.HttpStatusCode.OK)
            response.Headers.Add("Content-Type", "application/pdf")
            response.Headers.Add("Content-Disposition", $"attachment; filename=invoice-{invoice.Id}.pdf")
            Await response.Body.WriteAsync(pdf.BinaryData)

            Return response
        End Function

        Private Function BuildInvoiceHtml(invoice As InvoiceRequest) As String
            Return $"<html><body>
            <h1>Invoice #{invoice.Id}</h1>
            <p>Amount: ${invoice.Amount:F2}</p>
        </body></html>"
        End Function

    End Class

    Public Class InvoiceRequest
        Public Property Id As String
        Public Property Amount As Decimal

        Public Sub New(id As String, amount As Decimal)
            Me.Id = id
            Me.Amount = amount
        End Sub
    End Class

End Namespace

Berücksichtigung der Bereitstellung: Die Chromium-Binärdatei von IronPDF fügt dem Bereitstellungspaket ~200 MB hinzu. Der Azure Functions-Verbrauchsplan hat eine Größenbeschränkung von 1,5 GB für die Bereitstellung - überprüfen Sie die Gesamtgröße Ihres Pakets. Für Premium- oder Dedicated-Tarife gilt diese Begrenzung nicht. Die Kaltstart-Latenzzeit für die erste PDF-Generierung beträgt 2-5 Sekunden, wenn Chromium initialisiert wird.

Native AOT-Kompatibilität

mit .NET 8 wurde die native AOT-Unterstützung erweitert, aber PDF-Bibliotheken unterliegen grundlegenden Beschränkungen. Chromium-basierte Bibliotheken (IronPDF, Puppeteer Sharp) können AOT nicht kompilieren, da sie Browserprozesse einbetten oder erzeugen. iTextverwendet umfangreiche Reflection, die mit Trim nicht kompatibel ist.

Aktueller Status mit <PublishAot>true</PublishAot>:

Bibliothek	AOT-Status	Grund
IronPDF	Nicht kompatibel	Einbettung der Chromium-Laufzeitumgebung
iText	Nicht kompatibel	Starke Reflexion, dynamische Codegenerierung
QuestPDF	Teilweise (mit `TrimMode=partial`)	Einige Überlegungen zur Verwendung
PDFSharp	Nicht kompatibel	System.Drawing.Common-Abhängigkeit

Wenn Native AOT eine feste Anforderung ist, ist QuestPDF mit TrimMode=partial die nächstgelegene Option — jedoch nur für die programmgesteuerte Dokumentenerstellung, nicht für die HTML-Konvertierung. Für HTML-zu-PDF-Szenarien ist AOT derzeit mit keiner Bibliothek realisierbar.

Vergleich der Lizenzen

Bibliothek	Modell	Kosten	.NET 8-Unterstützung
IronPDF	Immerwährende	`$liteLicense` (Lite) / $1,499 (Pro) / $2,999 (Enterprise)	Voll
iText	AGPL oder Abonnement	Nicht veröffentlicht ($15K-$210K/Jahr geschätzt)	Voll
QuestPDF	Gemeinschaft / Kommerziell	Kostenlos <$1M Umsatz, dann kommerziell	Voll
PDFSharp	MIT (kostenlos)	$0	Nur Windows (Linux unvollständig)
Aspose.PDF	Pro-Entwickler	~$999+	Vollständig (Linux-Speicherprobleme)

.NET 9 Vorwärtskompatibilität

.NET 9 (veröffentlicht im November 2025) führt die in .NET 8 etablierten Muster fort. Bibliotheken, die mit .NET 8 funktionieren, funktionieren im Allgemeinen ohne Änderungen mit .NET 9. Die wichtigsten Ergänzungen von .NET 9, die für die PDF-Erzeugung relevant sind, sind die verbesserte ARM64-Leistung (Vorteile des Chromium-basierten Renderings auf Apple Silicon und AWS Graviton) und weitere Verbesserungen von Native AOT (obwohl die grundlegenden Einschränkungen für PDF-Bibliotheken bestehen bleiben).

Wenn Sie auf .NET 9 abzielen oder ein Upgrade planen, ist die Auswahl einer Bibliothek, die die plattformübergreifende Bereitstellung von .NET 8 vollständig unterstützt, der sicherste Weg. Bibliotheken mit plattformspezifischen Problemen (PDFSharp unter Linux, Aspose mit libgdiplus) werden diese Probleme in .NET 9 wahrscheinlich nicht beheben, da die zugrunde liegende Abhängigkeits-Abschreibung dauerhaft ist.

Migrationsanleitung

Von iTextzu IronPDF

// Before (iTextSharp — doesn't compile against net8.0)
using iTextSharp.text;
using iTextSharp.text.pdf;

var doc = new Document();
PdfWriter.GetInstance(doc, new FileStream("output.pdf", FileMode.Create));
doc.Open();
doc.Add(new Paragraph("Hello World"));
doc.Close();

// After (IronPDF — targets net8.0)
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<p>Hello World</p>");
pdf.SaveAs("output.pdf");

// Before (iTextSharp — doesn't compile against net8.0)
using iTextSharp.text;
using iTextSharp.text.pdf;

var doc = new Document();
PdfWriter.GetInstance(doc, new FileStream("output.pdf", FileMode.Create));
doc.Open();
doc.Add(new Paragraph("Hello World"));
doc.Close();

// After (IronPDF — targets net8.0)
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<p>Hello World</p>");
pdf.SaveAs("output.pdf");

Imports iTextSharp.text
Imports iTextSharp.text.pdf
Imports IronPdf
Imports System.IO

' Before (iTextSharp — doesn't compile against net8.0)
Dim doc As New Document()
PdfWriter.GetInstance(doc, New FileStream("output.pdf", FileMode.Create))
doc.Open()
doc.Add(New Paragraph("Hello World"))
doc.Close()

' After (IronPDF — targets net8.0)
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<p>Hello World</p>")
pdf.SaveAs("output.pdf")

Imports iTextSharp.text
Imports iTextSharp.text.pdf
Imports IronPdf
Imports System.IO

' Before (iTextSharp — doesn't compile against net8.0)
Dim doc As New Document()
PdfWriter.GetInstance(doc, New FileStream("output.pdf", FileMode.Create))
doc.Open()
doc.Add(New Paragraph("Hello World"))
doc.Close()

' After (IronPDF — targets net8.0)
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<p>Hello World</p>")
pdf.SaveAs("output.pdf")

Von wkhtmltopdf Wrappers zu IronPDF

// Before (DinkToPdf — DllNotFoundException on .NET 8)
var converter = new SynchronizedConverter(new PdfTools());
var doc = new HtmlToPdfDocument
{
    Objects = { new ObjectSettings { HtmlContent = html } }
};
var bytes = converter.Convert(doc);

// After (IronPDF — native .NET 8 support)
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
var bytes = pdf.BinaryData;

// Before (DinkToPdf — DllNotFoundException on .NET 8)
var converter = new SynchronizedConverter(new PdfTools());
var doc = new HtmlToPdfDocument
{
    Objects = { new ObjectSettings { HtmlContent = html } }
};
var bytes = converter.Convert(doc);

// After (IronPDF — native .NET 8 support)
using IronPdf;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
var bytes = pdf.BinaryData;

Imports IronPdf

' Before (DinkToPdf — DllNotFoundException on .NET 8)
Dim converter = New SynchronizedConverter(New PdfTools())
Dim doc = New HtmlToPdfDocument With {
    .Objects = {New ObjectSettings With {.HtmlContent = html}}
}
Dim bytes = converter.Convert(doc)

' After (IronPDF — native .NET 8 support)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
bytes = pdf.BinaryData

Imports IronPdf

' Before (DinkToPdf — DllNotFoundException on .NET 8)
Dim converter = New SynchronizedConverter(New PdfTools())
Dim doc = New HtmlToPdfDocument With {
    .Objects = {New ObjectSettings With {.HtmlContent = html}}
}
Dim bytes = converter.Convert(doc)

' After (IronPDF — native .NET 8 support)
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
bytes = pdf.BinaryData

Die API-Oberfläche ist in beiden Fällen einfacher. Die Hauptkosten für die Migration bestehen darin, Ihre vorhandenen HTML-Vorlagen mit dem neuen Renderer zu testen, um zu überprüfen, ob die Ausgabe den Erwartungen entspricht.

Die Empfehlung

Für .NET 8-Projekte, die eine HTML-zu-PDF-Konvertierung erfordern:IronPDF bietet eingebettetes Chromium-Rendering, das plattformübergreifend ohne Konfiguration funktioniert. Die Software beherrscht Docker Deployment, Azure Functions und Linux-Container von Haus aus.

Für .NET 8-Projekte, die Dokumente programmatisch aus Daten erstellen: Die fließende API von QuestPDF ist gut durchdacht und mit .NET 8 kompatibel, wobei die Community License die meisten Startups und kleinen Teams abdeckt.

Für PDF-Manipulation (Zusammenführung, Aufteilung, Formulare) unter Windows:PDFSharpbleibt eine brauchbare Option, wenn das Bereitstellungsziel nur Windows ist.

Vermeiden Sie iText(nicht kompatibel), wkhtmltopdf Wrapper (archiviert, CVEs) und jede Bibliothek, die für plattformübergreifende Bereitstellungen von System.Drawing.Common abhängt.

Hinweis:: Aspose, DinkToPdf, NReco, PDFSharp, PuppeteerSharp, QuestPDF, Rotativa, TuesPechkin, iTextund wkhtmltopdf sind eingetragene Marken ihrer jeweiligen Eigentümer. Diese Seite ist nicht assoziiert mit, unterstützt oder gesponsert von Aspose Pty Ltd, CodeFlint, DinkToPdf, NReco, PuppeteerSharp, Rotativa, TuesPechkin, empira Software GmbH, iTextGroup oder wkhtmltopdf. Alle Produktnamen, Logos und Marken sind Eigentum ihrer jeweiligen Eigentümer. Vergleiche dienen nur zu Informationszwecken und spiegeln öffentlich zugängliche Informationen zum Zeitpunkt des Schreibens wider.