Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. .NET PDF Api W Erledigt
IRONPDF NUTZEN

Wie man einen zentralen PDF-Generierungsdienst mit ASP.NET Core und IronPDF erstellt

Curtis Chau
Curtis Chau
Aktualisiert:

Entwickeln Sie eine produktionsreife .NET PDF-API mit ASP.NET Core und IronPDF, um die Logik der PDF-Generierung zu zentralisieren und so eine konsistente Dokumentenerstellung in all Ihren Anwendungen zu ermöglichen. Dies wird durch RESTful-Endpunkte für die HTML-zu-PDF-Konvertierung, das Zusammenführen, das Hinzufügen von Wasserzeichen und die dynamische Vorlagenverarbeitung ermöglicht.

Bei der Arbeit mit modernen Anwendungen benötigen .NET-Entwickler häufig einen zentralen PDF-Generierungsdienst. Ob Rechnungen, Berichte, Zertifikate oder Verträge erstellt werden – eine dedizierte .NET-PDF-API optimiert den Workflow der PDF-Generierung. Wie hilft das? Es sorgt für Konsistenz, Wartbarkeit und Skalierbarkeit Ihrer Desktop- und Webanwendungen. Die Verwaltung von Dokumentinhalten, PDF-Seiten und PDF-Formularfeldern wird dadurch unkompliziert.

In diesem Tutorial lernen Sie, wie Sie mit ASP.NET Core und IronPDF, einer leistungsstarken .NET-PDF-Bibliothek, eine produktionsreife PDF-API erstellen können. Wir erstellen RESTful-Endpunkte, die PDFs aus HTML generieren, Dokumente zusammenführen , Wasserzeichen hinzufügen und verschiedene reale PDF-Szenarien in Ihrer Web-API verarbeiten.

Warum eine dedizierte PDF-API erstellen?

Architekturdiagramm, das Client-Anwendungen (Web, Desktop, Mobil) zeigt, die HTML-Inhalte, URLs oder dynamische Daten an eine PDF-Controller-/Service-API-Schicht senden, welche PDF-Dokumente ausgibt.

Bevor wir in den Code eintauchen, lassen Sie uns verstehen, warum die Erstellung einer dedizierten PDF-API sinnvoll ist:

  • Zentralisierte Logik : Die gesamte Logik zur PDF-Generierung befindet sich an einem Ort, was die Wartung und Aktualisierung vereinfacht.
  • Microservice-Architektur : Ideal für serviceorientierte Architekturen, bei denen verschiedene Anwendungen PDF-Funktionen benötigen.
  • Leistungsoptimierung : Durch die Verwendung von asynchronen Operationen und Leistungstechniken lässt sich ein dedizierter Dienst für große PDFs, mehrere Seiten und dynamische Daten leichter skalieren und optimieren.
  • Sprachunabhängig : Jede Clientanwendung kann die API unabhängig von der Programmiersprache nutzen.
  • Einheitliche Ausgabe : Gewährleistet, dass alle PDFs in Ihrem Unternehmen ein einheitliches Layout, eine einheitliche Formatierung und einheitliche Inhalte aufweisen.

Bereit, loszulegen? Laden Sie die kostenlose Testversion von IronPDF herunter und folgen Sie diesem Tutorial, um Programm-gesteuert PDF-Dateien in Ihren .NET-Framework-Projekten zu erstellen.

Was macht IronPDF zur umfassendsten .NET-PDF-Bibliothek?

Die IronPDF-Homepage für .NET zeigt C#-Codebeispiele für die Konvertierung von HTML in PDF mit Funktionen wie HTML-Rendering, Dateispeicherung und NuGet-Installationsbefehl.

IronPDF ist die führende PDF-Bibliothek für .NET-Entwickler und bietet eine umfassende Reihe von Funktionen, die die PDF-Erzeugung in Web-API-Projekten einfach und zuverlässig machen. Es basiert auf einer Chrome-Rendering-Engine und gewährleistet pixelgenaue HTML-zu-PDF-Konvertierungen mit nur wenigen Codezeilen, wobei sämtliche Stile, die JavaScript-Ausführung und responsive Layouts erhalten bleiben.

Schlüsselfähigkeiten, die IronPDF ideal für die .NET PDF-API-Entwicklung machen:

Wie richtet man Ihr PDF-Dokument-API-Projekt ein?

Beginnen wir mit der Erstellung eines neuen ASP.NET Core Web API-Projekts und der Installation der erforderlichen Pakete.

Was sind die Voraussetzungen?

  • .NET 6.0 SDK oder höher
  • Visual Studio 2022 oder Visual Studio Code
  • Postman oder ein ähnliches API-Testtool zum Testen Ihrer PDF-REST-API

Wie erstelle ich das Projekt?

Als Erstes erstellen wir das Projekt, in dem wir unser PDF-Generierungstool entwickeln werden.

dotnet new webapi -n PdfApiService
cd PdfApiService
dotnet new webapi -n PdfApiService
cd PdfApiService
SHELL

Wie installiere ich IronPDF?

Fügen Sie als Nächstes IronPDF über NuGet zu Ihrem Projekt hinzu:

dotnet add package IronPDF
dotnet add package IronPDF
SHELL

Oder mit der NuGet-Paket-Manager-Konsole in Visual Studio:

Install-Package IronPDF

Erweiterte Installationsoptionen, einschließlich plattformspezifischer Pakete , Docker-Setup oder Linux-Konfigurationen , finden Sie in der IronPDF-Installationsdokumentation .

Welche Projektstruktur sollte ich verwenden?

Eine gute C#-Entwicklung erfordert die Pflege eines sauberen und gut strukturierten Projektordners. Zum Beispiel:

Der Visual Studio Projektmappen-Explorer zeigt die Ordnerstruktur eines .NET PDF API-Dienstprojekts mit den Verzeichnissen Controller, Modelle und Dienste an.

Wie erstellen Sie Ihren ersten PDF-Endpunkt?

Lassen Sie uns einen einfachen Endpunkt erstellen, der HTML in PDF-Format konvertiert. Zuerst erstellen Sie die Service-Schnittstelle und -Implementierung:

Wie erstelle ich den PDF-Dienst?

Fügen Sie zunächst Folgendes zu Ihrer IPdfService.cs Datei hinzu:

public interface IPdfService
{
    byte[] GeneratePdfFromHtml(string htmlContent);
    byte[] GeneratePdfFromUrl(string url);
}
public interface IPdfService
{
    byte[] GeneratePdfFromHtml(string htmlContent);
    byte[] GeneratePdfFromUrl(string url);
}
$vbLabelText   $csharpLabel

Fügen Sie in der Datei PdfService.cs Folgendes hinzu:

using IronPdf;
public class PdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;
    public PdfService()
    {
        _renderer = new ChromePdfRenderer();
        // Configure rendering options for optimal PDF generation in .NET
        _renderer.RenderingOptions.MarginTop = 20;
        _renderer.RenderingOptions.MarginBottom = 20;
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
    }
    public byte[] GeneratePdfFromHtml(string htmlContent)
    {
        // Generate PDF from HTML using the .NET PDF API
        var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
        return pdf.BinaryData;
    }
    public byte[] GeneratePdfFromUrl(string url)
    {
        // Convert URL to PDF in the REST API
        var pdf = _renderer.RenderUrlAsPdf(url);
        return pdf.BinaryData;
    }
}
using IronPdf;
public class PdfService : IPdfService
{
    private readonly ChromePdfRenderer _renderer;
    public PdfService()
    {
        _renderer = new ChromePdfRenderer();
        // Configure rendering options for optimal PDF generation in .NET
        _renderer.RenderingOptions.MarginTop = 20;
        _renderer.RenderingOptions.MarginBottom = 20;
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
    }
    public byte[] GeneratePdfFromHtml(string htmlContent)
    {
        // Generate PDF from HTML using the .NET PDF API
        var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
        return pdf.BinaryData;
    }
    public byte[] GeneratePdfFromUrl(string url)
    {
        // Convert URL to PDF in the REST API
        var pdf = _renderer.RenderUrlAsPdf(url);
        return pdf.BinaryData;
    }
}
$vbLabelText   $csharpLabel

Der PdfService ist für die Konvertierung von HTML in PDF zuständig. Mithilfe des ChromePdfRenderer von IronPDF konfiguriert diese Klasse Standardeinstellungen wie Seitenränder und Hintergrunddarstellung für professionelle Ergebnisse. Für erweiterte Rendering-Konfigurationen erkunden Sie die Rendering-Optionen von IronPDF .

Wenn der Controller rohes HTML übergibt, rendert der Dienst es in ein hochwertiges PDF und gibt die Byte-Daten zum Download zurück. Außerdem wandelt es ganze Webseiten direkt in PDFs um, indem es die URL-zu-PDF-Konvertierung nutzt.

Wie erstelle ich den Controller?

Erstellen Sie nun den Controller für Ihre API. Dies stellt einen Endpunkt bereit, der PDF-Dateien aus HTML generiert und es Ihnen ermöglicht , PDF-Dokumente auf Ihr System herunterzuladen und zu speichern .

// Controllers/PdfController.cs
using Microsoft.AspNetCore.Mvc;
[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly IPdfService _pdfService;
    public PdfController(IPdfService pdfService)
    {
        _pdfService = pdfService;
    }
    [HttpPost("html-to-pdf")]
    public IActionResult ConvertHtmlToPdf([FromBody] HtmlRequest request)
    {
        try
        {
            var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
            // Return as downloadable file
            return File(pdfBytes, "application/pdf", "document.pdf");
        }
        catch (Exception ex)
        {
            return BadRequest($"Error generating PDF: {ex.Message}");
        }
    }
}
// Controllers/PdfController.cs
using Microsoft.AspNetCore.Mvc;
[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly IPdfService _pdfService;
    public PdfController(IPdfService pdfService)
    {
        _pdfService = pdfService;
    }
    [HttpPost("html-to-pdf")]
    public IActionResult ConvertHtmlToPdf([FromBody] HtmlRequest request)
    {
        try
        {
            var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
            // Return as downloadable file
            return File(pdfBytes, "application/pdf", "document.pdf");
        }
        catch (Exception ex)
        {
            return BadRequest($"Error generating PDF: {ex.Message}");
        }
    }
}
$vbLabelText   $csharpLabel

Fügen Sie anschließend in der Datei HtmlRequest.cs Folgendes hinzu:

// Models/HtmlRequest.cs
public class HtmlRequest
{
    public string HtmlContent { get; set; }
    public string FileName { get; set; } = "document.pdf";
}
// Models/HtmlRequest.cs
public class HtmlRequest
{
    public string HtmlContent { get; set; }
    public string FileName { get; set; } = "document.pdf";
}
$vbLabelText   $csharpLabel

Hiermit wird ein API-Endpunkt eingerichtet, der HTML in ein herunterladbares PDF umwandelt. Wenn jemand HTML an api/pdf/html-to-pdf sendet, delegiert der PdfController die Konvertierung an den Dienst.

Nach der Erstellung gibt der Controller die PDF-Datei als herunterladbare Datei zurück. Die Anfrage verwendet das HtmlRequest Modell und enthält den HTML-Code sowie optional einen Dateinamen. Dadurch wird es für Kunden vereinfacht, HTML zu senden und ein optimiertes PDF zu erhalten.

Wie registriere ich Dienstleistungen?

Aktualisieren Sie Ihr Program.cs, um den PDF-Dienst zu registrieren:

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// Register PDF service
builder.Services.AddSingleton<IPdfService, PdfService>();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.MapControllers();
app.Run();
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
// Register PDF service
builder.Services.AddSingleton<IPdfService, PdfService>();
var app = builder.Build();
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
app.UseHttpsRedirection();
app.MapControllers();
app.Run();
$vbLabelText   $csharpLabel

Wie behandelt man verschiedene Antworttypen?

Ihre API sollte verschiedene Wege unterstützen, PDFs basierend auf den Anforderungen zurückzugeben:

[HttpPost("generate")]
public IActionResult GeneratePdf([FromBody] PdfRequest request)
{
    var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
    switch (request.ResponseType?.ToLower())
    {
        case "base64":
            return Ok(new
            {
                data = Convert.ToBase64String(pdfBytes),
                filename = request.FileName
            });
        case "inline":
            return File(pdfBytes, "application/pdf");
        default: // download
            return File(pdfBytes, "application/pdf", request.FileName);
    }
}
[HttpPost("generate")]
public IActionResult GeneratePdf([FromBody] PdfRequest request)
{
    var pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent);
    switch (request.ResponseType?.ToLower())
    {
        case "base64":
            return Ok(new
            {
                data = Convert.ToBase64String(pdfBytes),
                filename = request.FileName
            });
        case "inline":
            return File(pdfBytes, "application/pdf");
        default: // download
            return File(pdfBytes, "application/pdf", request.FileName);
    }
}
$vbLabelText   $csharpLabel

Dies fügt einen flexiblen Endpunkt zur PDF-Generierung hinzu. Anstatt Downloads zu erzwingen, ermöglicht die GeneratePdf Methode den Clients, zu wählen, wie sie die Ergebnisse erhalten: als Download, direkt im Browser oder Base64-kodiert für die API-Nutzung.

Das PdfRequest Modell erweitert HtmlRequest um die Option ResponseType . Dies ermöglicht Nutzern die Kontrolle über die PDF-Auslieferung und macht die API vielseitiger. Informationen zur Verarbeitung von PDFs im Arbeitsspeicher ohne Dateisystemzugriff finden Sie in der Dokumentation zu Speicherstreams von IronPDF .

Wenn wir unser Programm ausführen, sehen wir diese Ausgabe in Swagger:

! Swagger UI-Dokumentation, die PdfApiService-Endpunkte mit drei POST-Methoden für PDF-Operationen zeigt: html-to-pdf, generate und url-to-pdf, zusammen mit Anforderungsschemas.

Wie implementiert man gängige PDF-Operationen?

Lassen Sie uns unseren Service erweitern, um verschiedene PDF-Generierungsszenarien zu behandeln:

Wie konvertiere ich URLs in PDF?

[HttpPost("url-to-pdf")]
public async Task<IActionResult> ConvertUrlToPdf([FromBody] UrlRequest request)
{
    try
    {
        var pdfBytes = await Task.Run(() =>
            _pdfService.GeneratePdfFromUrl(request.Url));
        return File(pdfBytes, "application/pdf",
            $"{request.FileName ?? "website"}.pdf");
    }
    catch (Exception ex)
    {
        return BadRequest($"Failed to convert URL: {ex.Message}");
    }
}
public class UrlRequest
{
    public string Url { get; set; }
    public string FileName { get; set; }
}
[HttpPost("url-to-pdf")]
public async Task<IActionResult> ConvertUrlToPdf([FromBody] UrlRequest request)
{
    try
    {
        var pdfBytes = await Task.Run(() =>
            _pdfService.GeneratePdfFromUrl(request.Url));
        return File(pdfBytes, "application/pdf",
            $"{request.FileName ?? "website"}.pdf");
    }
    catch (Exception ex)
    {
        return BadRequest($"Failed to convert URL: {ex.Message}");
    }
}
public class UrlRequest
{
    public string Url { get; set; }
    public string FileName { get; set; }
}
$vbLabelText   $csharpLabel

Dieser Endpunkt wandelt URLs in herunterladbare PDFs um. Wenn eine POST-Anfrage an /api/pdf/url-to-pdf gesendet wird, verwendet der Controller _pdfService , um die URL im Hintergrund in PDF-Bytes umzuwandeln und diese dann zum Download zurückzugeben. Schlägt die Konvertierung fehl, wird eine eindeutige Fehlermeldung ausgegeben. Für Websites mit Authentifizierung konsultieren Sie bitte die Anmeldedokumentation von IronPDF .

Versuchen wir es mit der URL "https://www.apple.com/nz und testen Sie die POST-Anfrage. Nachfolgend die Ausgabe, die wir erhalten haben:

Wie sieht die Ausgabe aus?

Die Startseite der Apple-Website in Neuseeland zeigt verschiedene Produktbereiche, darunter iPhone 16, MacBook Air, Apple Watch und AirPods mit den Schaltflächen "Mehr erfahren" und "Kaufen" – eine Demonstration der URL-zu-PDF-Konvertierung.

Wie füge ich benutzerdefinierte Wasserzeichen hinzu?

public byte[] AddWatermarkFromFile(string filePath, string watermarkText)
{
    // Load PDF directly from file
    var pdf = PdfDocument.FromFile(filePath);
    pdf.ApplyWatermark(
        $"<h1 style='color:red;font-size:72px;'>{watermarkText}</h1>",
        75,
        IronPdf.Editing.VerticalAlignment.Middle,
        IronPdf.Editing.HorizontalAlignment.Center
    );
    return pdf.BinaryData;
}
public byte[] AddWatermarkFromFile(string filePath, string watermarkText)
{
    // Load PDF directly from file
    var pdf = PdfDocument.FromFile(filePath);
    pdf.ApplyWatermark(
        $"<h1 style='color:red;font-size:72px;'>{watermarkText}</h1>",
        75,
        IronPdf.Editing.VerticalAlignment.Middle,
        IronPdf.Editing.HorizontalAlignment.Center
    );
    return pdf.BinaryData;
}
$vbLabelText   $csharpLabel

Hiermit wird manuell eine lokale Datei zum Testen geladen. Sie können dies so einstellen, dass Ihre PDF-API eine PDF-Datei generiert und anschließend problemlos benutzerdefinierte Wasserzeichen anwendet. Erweiterte Optionen für Wasserzeichen, einschließlich Bildwasserzeichen und benutzerdefinierter Positionierung, finden Sie im Wasserzeichenleitfaden .

Wie sieht das ausgegebene Wasserzeichen aus?

Ein sicheres Dokument mit dem diagonal über eine leere Seite verlaufenden Wasserzeichen "VERTRAULICH" und der oben angezeigten Dokument-ID: BA811648DCE1FF2AAA55E7CE

Wie fügt man dynamische Daten mithilfe von Vorlagen hinzu?

Für reale Anwendungen benötigen Sie oft PDF-Generierungen aus Vorlagen mit dynamischen Daten:

[HttpPost("from-template")]
public IActionResult GenerateFromTemplate([FromBody] TemplateRequest request)
{
    // Simple template replacement
    var html = request.Template;
    foreach (var item in request.Data)
    {
        html = html.Replace($"{{{{{item.Key}}}}}", item.Value);
    }
    var pdfBytes = _pdfService.GeneratePdfFromHtml(html);
    return File(pdfBytes, "application/pdf", request.FileName);
}
public class TemplateRequest
{
    public string Template { get; set; }
    public Dictionary<string, string> Data { get; set; }
    public string FileName { get; set; } = "document.pdf";
}
[HttpPost("from-template")]
public IActionResult GenerateFromTemplate([FromBody] TemplateRequest request)
{
    // Simple template replacement
    var html = request.Template;
    foreach (var item in request.Data)
    {
        html = html.Replace($"{{{{{item.Key}}}}}", item.Value);
    }
    var pdfBytes = _pdfService.GeneratePdfFromHtml(html);
    return File(pdfBytes, "application/pdf", request.FileName);
}
public class TemplateRequest
{
    public string Template { get; set; }
    public Dictionary<string, string> Data { get; set; }
    public string FileName { get; set; } = "document.pdf";
}
$vbLabelText   $csharpLabel

Für fortgeschrittene Template-Szenarien mit Razor, Handlebars oder anderen Engines konsultieren Sie die HTML-zu-PDF-Dokumentation von IronPDF . Sie können auch CSHTML-zu-PDF-Konvertierung für MVC-Anwendungen und Razor-zu-PDF für Blazor-Anwendungen erkunden. Informationen zum Headless-Razor-Rendering finden Sie im CSHTML Headless Guide .

Wie optimiere ich die Leistung?

Beim Aufbau einer Produktions-PDF-API ist Leistung entscheidend. Hier sind die wichtigen Optimierungsstrategien:

Warum asynchrone Operationen verwenden?

Verwenden Sie asynchrone Codierung, wenn Ihre Projekte E/A-Operationen beinhalten. Dies ist besonders hilfreich, wenn Ihre PDF-Inhalte aus externen Quellen stammen, wie zum Beispiel:

  • Herunterladen von HTML-Seiten (RenderUrlAsPdf)
  • Abrufen von Bildern, CSS oder Schriften über HTTP
  • Lesen/Schreiben von Dateien auf Festplatte oder Cloud-Speicher

Diese Operationen können Threads blockieren, aber asynchrone Operationen verhindern, dass API-Threads im Leerlauf warten. Ausführliche Muster zur asynchronen PDF-Generierung finden Sie im Leitfaden zur asynchronen PDF-Generierung .

Beispiel:

public async Task<byte[]> GeneratePdfFromHtmlAsync(string htmlContent)
{
    return await Task.Run(() =>
    {
        var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
        return pdf.BinaryData;
    });
}
public async Task<byte[]> GeneratePdfFromHtmlAsync(string htmlContent)
{
    return await Task.Run(() =>
    {
        var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
        return pdf.BinaryData;
    });
}
$vbLabelText   $csharpLabel

Für Szenarien der parallelen PDF-Generierung sollten Multithreading- und Parallelverarbeitungstechniken untersucht werden.

Welche Rendering-Optionen sollte ich konfigurieren?

Konfigurieren Sie IronPDF für optimale Leistung:

_renderer.RenderingOptions.EnableJavaScript = false; // If JS not needed
_renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
_renderer.RenderingOptions.RenderDelay = 0; // Remove if no JS
_renderer.RenderingOptions.Timeout = 30; // Set reasonable timeout
_renderer.RenderingOptions.EnableJavaScript = false; // If JS not needed
_renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
_renderer.RenderingOptions.RenderDelay = 0; // Remove if no JS
_renderer.RenderingOptions.Timeout = 30; // Set reasonable timeout
$vbLabelText   $csharpLabel

Ausführliche Informationen zu den Rendering-Konfigurationsoptionen, einschließlich Ansichtsfenstereinstellungen , benutzerdefinierten Papierformaten und Seitenausrichtung , finden Sie in der Dokumentation zu den Rendering-Optionen .

Wie sichern Sie Ihre PDF-API?

Sicherheit ist wesentlich für jede Produktions-API. Hier ist ein einfacher Ansatz zur API-Schlüssel-Authentifizierung:

// Middleware/ApiKeyMiddleware.cs
public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private const string ApiKeyHeader = "X-API-Key";
    public ApiKeyMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        if (!context.Request.Headers.TryGetValue(ApiKeyHeader, out var apiKey))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("API Key required");
            return;
        }
        // Validate API key (in production, check against database)
        var validApiKey = context.RequestServices
            .GetRequiredService<IConfiguration>()["ApiKey"];
        if (apiKey != validApiKey)
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Invalid API Key");
            return;
        }
        await _next(context);
    }
}
// In Program.cs
app.UseMiddleware<ApiKeyMiddleware>();
// Middleware/ApiKeyMiddleware.cs
public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private const string ApiKeyHeader = "X-API-Key";
    public ApiKeyMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        if (!context.Request.Headers.TryGetValue(ApiKeyHeader, out var apiKey))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("API Key required");
            return;
        }
        // Validate API key (in production, check against database)
        var validApiKey = context.RequestServices
            .GetRequiredService<IConfiguration>()["ApiKey"];
        if (apiKey != validApiKey)
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Invalid API Key");
            return;
        }
        await _next(context);
    }
}
// In Program.cs
app.UseMiddleware<ApiKeyMiddleware>();
$vbLabelText   $csharpLabel

Für fortgeschrittene Authentifizierungsszenarien sollten Sie Folgendes beachten:

Für die Sicherheit von PDFs sollten Sie Passwortschutz , digitale Signaturen und die PDF-Bereinigung implementieren, um potenziell schädliche Inhalte zu entfernen.

Wie entwickelt man eine praxisnahe API zur Rechnungserstellung?

Lasst uns einen praktischen Endpunkt zur Rechnungserstellung entwickeln, der eine vollständige Implementierung demonstriert. Dieses Beispiel zeigt, wie eine .NET PDF-API für den Produktiveinsatz professionelle Rechnungen mit dynamischen Daten generiert.

Starten Sie jetzt mit IronPDF.
green arrow pointer

Erstellen Sie zunächst eine neue Datei in Ihrem Models-Ordner. Hier habe ich meine Übersetzung Invoice.cs genannt. Fügen Sie anschließend folgenden Code hinzu:

public class Invoice
{
    public string InvoiceNumber { get; set; }
    public DateTime Date { get; set; }
    public string CustomerName { get; set; }
    public string CustomerAddress { get; set; }
    public List<InvoiceItem> Items { get; set; }
    public decimal Tax { get; set; }
}
public class InvoiceItem
{
    public string Description { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total => Quantity * UnitPrice;
}
public class Invoice
{
    public string InvoiceNumber { get; set; }
    public DateTime Date { get; set; }
    public string CustomerName { get; set; }
    public string CustomerAddress { get; set; }
    public List<InvoiceItem> Items { get; set; }
    public decimal Tax { get; set; }
}
public class InvoiceItem
{
    public string Description { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal Total => Quantity * UnitPrice;
}
$vbLabelText   $csharpLabel

Als Nächstes erstellen Sie eine neue Servicedatei für den Rechnungsgenerator. In Ihrem Services-Ordner fügen Sie den folgenden Code hinzu. Ich habe eine Datei namens InvoiceService.cs erstellt. Dieser Code regelt das Styling und Layout Ihrer PDF-Rechnung:

public class InvoiceService
{
    private readonly ChromePdfRenderer _renderer;
    public InvoiceService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.MarginTop = 10;
        _renderer.RenderingOptions.MarginBottom = 10;
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
    }
    public byte[] GenerateInvoice(Invoice invoice)
    {
        var html = BuildInvoiceHtml(invoice);
        // Add footer with page numbers
        _renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
        {
            MaxHeight = 15,
            HtmlFragment = "<center><i>{page} of {total-pages}</i></center>",
            DrawDividerLine = true
        };
        var pdf = _renderer.RenderHtmlAsPdf(html);
        return pdf.BinaryData;
    }
    private string BuildInvoiceHtml(Invoice invoice)
    {
        var subtotal = invoice.Items.Sum(i => i.Total);
        var taxAmount = subtotal * (invoice.Tax / 100);
        var total = subtotal + taxAmount;
        var itemsHtml = string.Join("", invoice.Items.Select(item =>
            $@"<tr>
                <td>{item.Description}</td>
                <td class='text-center'>{item.Quantity}</td>
                <td class='text-right'>${item.UnitPrice:F2}</td>
                <td class='text-right'>${item.Total:F2}</td>
            </tr>"));
        return $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .invoice-header {{
                    background-color: #f8f9fa;
                    padding: 20px;
                    margin-bottom: 20px;
                }}
                table {{
                    width: 100%;
                    border-collapse: collapse;
                }}
                th, td {{
                    padding: 10px;
                    border-bottom: 1px solid #ddd;
                }}
                th {{
                    background-color: #007bff;
                    color: white;
                }}
                .text-right {{ text-align: right; }}
                .text-center {{ text-align: center; }}
                .total-section {{
                    margin-top: 20px;
                    text-align: right;
                }}
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #{invoice.InvoiceNumber}</h1>
                <p>Date: {invoice.Date:yyyy-MM-dd}</p>
            </div>
            <div>
                <h3>Bill To:</h3>
                <p>{invoice.CustomerName}<br/>{invoice.CustomerAddress}</p>
            </div>
            <table>
                <thead>
                    <tr>
                        <th>Description</th>
                        <th>Quantity</th>
                        <th>Unit Price</th>
                        <th>Total</th>
                    </tr>
                </thead>
                <tbody>
                    {itemsHtml}
                </tbody>
            </table>
            <div class='total-section'>
                <p>Subtotal: ${subtotal:F2}</p>
                <p>Tax ({invoice.Tax}%): ${taxAmount:F2}</p>
                <h3>Total: ${total:F2}</h3>
            </div>
        </body>
        </html>";
    }
}
public class InvoiceService
{
    private readonly ChromePdfRenderer _renderer;
    public InvoiceService()
    {
        _renderer = new ChromePdfRenderer();
        _renderer.RenderingOptions.MarginTop = 10;
        _renderer.RenderingOptions.MarginBottom = 10;
        _renderer.RenderingOptions.PrintHtmlBackgrounds = true;
    }
    public byte[] GenerateInvoice(Invoice invoice)
    {
        var html = BuildInvoiceHtml(invoice);
        // Add footer with page numbers
        _renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
        {
            MaxHeight = 15,
            HtmlFragment = "<center><i>{page} of {total-pages}</i></center>",
            DrawDividerLine = true
        };
        var pdf = _renderer.RenderHtmlAsPdf(html);
        return pdf.BinaryData;
    }
    private string BuildInvoiceHtml(Invoice invoice)
    {
        var subtotal = invoice.Items.Sum(i => i.Total);
        var taxAmount = subtotal * (invoice.Tax / 100);
        var total = subtotal + taxAmount;
        var itemsHtml = string.Join("", invoice.Items.Select(item =>
            $@"<tr>
                <td>{item.Description}</td>
                <td class='text-center'>{item.Quantity}</td>
                <td class='text-right'>${item.UnitPrice:F2}</td>
                <td class='text-right'>${item.Total:F2}</td>
            </tr>"));
        return $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .invoice-header {{
                    background-color: #f8f9fa;
                    padding: 20px;
                    margin-bottom: 20px;
                }}
                table {{
                    width: 100%;
                    border-collapse: collapse;
                }}
                th, td {{
                    padding: 10px;
                    border-bottom: 1px solid #ddd;
                }}
                th {{
                    background-color: #007bff;
                    color: white;
                }}
                .text-right {{ text-align: right; }}
                .text-center {{ text-align: center; }}
                .total-section {{
                    margin-top: 20px;
                    text-align: right;
                }}
            </style>
        </head>
        <body>
            <div class='invoice-header'>
                <h1>Invoice #{invoice.InvoiceNumber}</h1>
                <p>Date: {invoice.Date:yyyy-MM-dd}</p>
            </div>
            <div>
                <h3>Bill To:</h3>
                <p>{invoice.CustomerName}<br/>{invoice.CustomerAddress}</p>
            </div>
            <table>
                <thead>
                    <tr>
                        <th>Description</th>
                        <th>Quantity</th>
                        <th>Unit Price</th>
                        <th>Total</th>
                    </tr>
                </thead>
                <tbody>
                    {itemsHtml}
                </tbody>
            </table>
            <div class='total-section'>
                <p>Subtotal: ${subtotal:F2}</p>
                <p>Tax ({invoice.Tax}%): ${taxAmount:F2}</p>
                <h3>Total: ${total:F2}</h3>
            </div>
        </body>
        </html>";
    }
}
$vbLabelText   $csharpLabel

Erstellen Sie abschließend einen neuen Controller, um mithilfe der API auf Rechnungen zuzugreifen und diese zu erstellen:

[ApiController]
[Route("api/[controller]")]
public class InvoiceController : ControllerBase
{
    private readonly InvoiceService _invoiceService;
    public InvoiceController(InvoiceService invoiceService)
    {
        _invoiceService = invoiceService;
    }
    [HttpPost("generate")]
    public IActionResult GenerateInvoice([FromBody] Invoice invoice)
    {
        try
        {
            var pdfBytes = _invoiceService.GenerateInvoice(invoice);
            var fileName = $"Invoice_{invoice.InvoiceNumber}.pdf";
            return File(pdfBytes, "application/pdf", fileName);
        }
        catch (Exception ex)
        {
            return StatusCode(500, $"Error generating invoice: {ex.Message}");
        }
    }
}
[ApiController]
[Route("api/[controller]")]
public class InvoiceController : ControllerBase
{
    private readonly InvoiceService _invoiceService;
    public InvoiceController(InvoiceService invoiceService)
    {
        _invoiceService = invoiceService;
    }
    [HttpPost("generate")]
    public IActionResult GenerateInvoice([FromBody] Invoice invoice)
    {
        try
        {
            var pdfBytes = _invoiceService.GenerateInvoice(invoice);
            var fileName = $"Invoice_{invoice.InvoiceNumber}.pdf";
            return File(pdfBytes, "application/pdf", fileName);
        }
        catch (Exception ex)
        {
            return StatusCode(500, $"Error generating invoice: {ex.Message}");
        }
    }
}
$vbLabelText   $csharpLabel

Für erweiterte Rechnungsfunktionen sollten Sie Barcodes , QR-Codes , Seitenzahlen und benutzerdefinierte Kopf-/Fußzeilen hinzufügen. Sie können auch die PDF/A-Konformität für die Langzeitarchivierung implementieren oder in Workflows für elektronische Signaturen integrieren.

Wie sieht die Rechnungsausgabe aus?

! PDF-Rechnungsdokument mit der Rechnungsnummer INV-1023 vom 22.08.2025, mit einer einzelnen Position für "Sonstige Gegenstände" in Höhe von 495,00 $ inklusive Steuern.

Welche Aspekte sind bei der Containerbereitstellung zu berücksichtigen?

Obwohl sich dieses Tutorial auf lokale Entwicklung konzentriert, hier eine kurze Übersicht über die Containerisierung Ihrer PDF-API:

Wie erstelle ich ein einfaches Dockerfile?

FROM mcr.microsoft.com/dotnet/aspnet:6.0 AS base
WORKDIR /app
EXPOSE 80
FROM mcr.microsoft.com/dotnet/sdk:6.0 AS build
WORKDIR /src
COPY ["PdfApiService.csproj", "."]
RUN dotnet restore
COPY . .
RUN dotnet build -c Release -o /app/build
FROM build AS publish
RUN dotnet publish -c Release -o /app/publish
FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
# IronPDF requires additional dependencies on Linux
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-dev \
    && rm -rf /var/lib/apt/lists/*
ENTRYPOINT ["dotnet", "PdfApiService.dll"]

Für detaillierte Deployment-Anleitungen Ihrer .NET PDF-API beachten Sie:

Was sind die besten Vorgehensweisen bei der Fehlerbehandlung?

Implementieren Sie für fehlertolerante Programme eine globale Fehlerbehandlung für konsistente Fehlerreaktionen:

// Middleware/ErrorHandlingMiddleware.cs
public class ErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ErrorHandlingMiddleware> _logger;
    public ErrorHandlingMiddleware(RequestDelegate next, ILogger<ErrorHandlingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred processing request {Path}", context.Request.Path);
            await HandleExceptionAsync(context, ex);
        }
    }
    private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
    {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = ex switch
        {
            ArgumentNullException => 400,
            UnauthorizedAccessException => 401,
            _ => 500
        };
        var response = new
        {
            error = "An error occurred processing your request",
            message = ex.Message,
            statusCode = context.Response.StatusCode
        };
        await context.Response.WriteAsync(JsonSerializer.Serialize(response));
    }
}
// Middleware/ErrorHandlingMiddleware.cs
public class ErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<ErrorHandlingMiddleware> _logger;
    public ErrorHandlingMiddleware(RequestDelegate next, ILogger<ErrorHandlingMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An error occurred processing request {Path}", context.Request.Path);
            await HandleExceptionAsync(context, ex);
        }
    }
    private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
    {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = ex switch
        {
            ArgumentNullException => 400,
            UnauthorizedAccessException => 401,
            _ => 500
        };
        var response = new
        {
            error = "An error occurred processing your request",
            message = ex.Message,
            statusCode = context.Response.StatusCode
        };
        await context.Response.WriteAsync(JsonSerializer.Serialize(response));
    }
}
$vbLabelText   $csharpLabel

Spezifische Szenarien zur Fehlerbehebung bei IronPDF finden Sie hier:

Sind Sie bereit, Ihre produktionsreife .NET PDF-API zu entwickeln?

Sie haben nun eine robuste .NET PDF-API mit ASP.NET Core und IronPDF erstellt, die verschiedene Dokumentgenerierungsszenarien abdeckt. Diese REST-API bietet eine solide Grundlage für zentrale PDF-Operationen in Ihren Anwendungen.

Wichtige Punkte:

  • IronPDF vereinfacht die PDF-Generierung in Web-API-Projekten durch Chrome-basiertes Rendering .
  • Mit den fortschrittlichen Bearbeitungswerkzeugen von IronPDF können Sie bestehende PDFs ganz einfach bearbeiten.
  • RESTful-Design-Prinzipien gewährleisten, dass Ihre PDF-API intuitiv und wartbar ist.
  • Eine korrekte Fehlerbehandlung und Sicherheitsmaßnahmen sind für die Produktion unerlässlich.
  • Die Leistungsoptimierung durch asynchrone Operationen und Caching verbessert die Skalierbarkeit.
  • Umfassende Unterstützung für Desktop- und Webanwendungen mit skalierbaren Dokumentenlösungen.

Mit IronPDF können Entwickler PDFs erstellen, PDF-Dateien speichern und HTML effizient konvertieren. Damit ist es die unverzichtbare PDF-API für moderne .NET Framework-Anwendungen.

Was sind die nächsten Schritte?

Bereit, IronPDF in Ihrer produktiven .NET PDF-API zu implementieren? Dies sind Ihre nächsten Aktionen:

  1. Starten Sie Ihre kostenlose Testversion - Testen Sie IronPDF mit voller Funktionalität in Ihrer Entwicklungsumgebung.
  2. Entdecken Sie erweiterte Funktionen – Sehen Sie sich digitale Signaturen , PDF-Formulare , PDF/A-Konformität , Metadatenverwaltung und andere erweiterte PDF-Funktionen an.
  3. Skalieren Sie mit Zuversicht – Prüfen Sie die Lizenzierungsoptionen für Ihre Produktions-API-Anforderungen, einschließlich Erweiterungen und Upgrades .

Erstellen Sie noch heute Ihre .NET PDF-API und optimieren Sie die Dokumentenerstellung in Ihrem gesamten Anwendungsökosystem mit IronPDF!

Häufig gestellte Fragen

Wofür wird IronPDF in .NET-Anwendungen verwendet?

IronPDF wird zum Erzeugen, Bearbeiten und Konvertieren von PDFs innerhalb von .NET-Anwendungen verwendet und ist damit ideal für die Erstellung zentraler PDF-Dienste.

Wie kann IronPDF in ASP.NET Core integriert werden?

IronPDF kann in ASP.NET Core integriert werden, indem das IronPDF NuGet-Paket installiert wird, mit dem Sie einen zentralen PDF-Erzeugungsdienst aufbauen können.

Was sind die wichtigsten Funktionen von IronPDF für die PDF-Erstellung?

Zu den wichtigsten Funktionen von IronPDF gehören die Konvertierung von HTML in PDF, das Zusammenführen und Aufteilen von PDFs, das Hinzufügen von Kopf- und Fußzeilen sowie das Extrahieren von Text und Bildern.

Kann IronPDF komplexe PDF-Layouts verarbeiten?

IronPDF kann komplexe PDF-Layouts verarbeiten, da es HTML- und CSS-Inhalte in präzise gerenderte PDF-Dokumente umwandeln kann.

Ist es möglich, die PDF-Erstellung mit IronPDF anzupassen?

Ja, IronPDF ermöglicht die Anpassung der PDF-Erstellung, einschließlich der Einstellung der Seitengröße, der Ränder und des Hinzufügens von Wasserzeichen oder Kommentaren.

Unterstützt IronPDF PDF-Sicherheitsfunktionen?

IronPDF unterstützt PDF-Sicherheitsfunktionen wie Passwortschutz und Verschlüsselung, um die generierten PDF-Dokumente zu schützen.

Welche Formate kann IronPDF in PDFs konvertieren?

IronPDF kann verschiedene Formate in PDFs konvertieren, darunter HTML, URLs und ASPX-Dateien, und ist somit vielseitig einsetzbar.

Wie handhabt IronPDF die PDF-Generierung in großem Maßstab?

IronPDF ist auf Leistung optimiert, so dass es umfangreiche PDF-Generierungsaufgaben innerhalb von .NET-Anwendungen effizient bewältigen kann.

Kann IronPDF in cloudbasierten Anwendungen verwendet werden?

Ja, IronPDF kann in Cloud-basierten Anwendungen verwendet werden und unterstützt die Bereitstellung auf Plattformen wie Azure und AWS für skalierbare PDF-Dienste.

Welche Versionen von .NET werden von IronPDF unterstützt?

IronPDF unterstützt mehrere .NET-Versionen, einschließlich .NET Core und .NET Framework, und gewährleistet so die Kompatibilität mit einer Vielzahl von Projekten.

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