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

Wie man eine .NET PDF-API mit IronPDF erstellt

Curtis Chau
Curtis Chau
Aktualisiert:

Wenn Sie mit modernen Anwendungen arbeiten, kann es sein, dass .NET-Entwickler wie Sie eine zentrale PDF-Generierungsdienst erstellen müssen. Egal, ob Sie Rechnungen, Berichte, Zertifikate oder Verträge erstellen, eine dedizierte .NET PDF-API kann von Vorteil sein, um PDFs effizient zu verwalten. Wie kann es Ihre PDF-Generierungsaufgaben verbessern? Dies geschieht durch Konsistenz, Wartbarkeit und Skalierbarkeit über Ihre Desktop- und Webanwendungen hinweg. Noch nie war es einfacher, Dokumenteninhalte, PDF-Seiten und PDF-Formularfelder zu verwalten.

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

Warum eine dedizierte PDF-API erstellen?

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

  • Zentrale Logik: Alle PDF-Generierungslogik befindet sich an einem Ort, was die Wartung und Updates erleichtert
  • Microservice-Architektur: Perfekt für serviceorientierte Architekturen, in denen verschiedene Anwendungen PDF-Fähigkeiten benötigen
  • Leistungsoptimierung: Einfacher, einen dedizierten Dienst für große PDF-Dateien, mehrere Seiten und dynamische Daten zu skalieren und zu optimieren.
  • Sprachunabhängig: Jede Client-Anwendung kann die API unabhängig von der Programmiersprache nutzen
  • Konsistente Ausgabe: Stellt sicher, dass alle PDF-Dokumente in Ihrem Unternehmen ein konsistentes Dokumentlayout, Absatzformatierung und PDF-Inhalte beibehalten.

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.

IronPDF: Die vollständige .NET PDF-Bibliothek

IronPDF ist die führende PDF-Bibliothek für .NET-Entwickler und bietet eine umfassende Ausstattung, die die PDF-Erstellung in Web-API-Projekten einfach und zuverlässig macht. Es basiert auf einer Chrome-Rendering-Engine, die pixelgenaue HTML-zu-PDF-Konvertierungen garantiert, oft in nur wenigen Codezeilen. All das geschieht, während alle Stilierungen, JavaScript-Ausführungen und responsive Layouts beibehalten werden.

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

  • Rendering auf Chrome-Basis: Nutzt die Rendering-Engine von Google Chrome, um PDF-Dokumente aus HTML-Inhalten präzise zu konvertieren, mit voller Unterstützung für eingebettete Bilder und andere Webressourcen
  • Rich Feature Set: Supports the editing of new and existing documents with digital signatures, PDF forms, annotations, encryption, compression, and more
  • Erstellen Sie sichere PDF-Dokumente: Verwalten Sie sensible PDF-Inhalte mit Verschlüsselung, digitalen Signaturen und Dokumentenschutz.
  • Multiple Input Formats: Use HTML, URLs, images, and Office documents to create PDF documents
  • Erweiterte Manipulation: Zusammenführen von PDF-Seiten, Aufteilen von Dokumenten, Anwenden von Wasserzeichen, Erstellen interaktiver PDF-Formulare und programmatische Manipulation von PDF-Dateien.
  • Cross-Platform Support: Works on Windows, Linux, macOS, Docker, and cloud platforms
  • Leistungsoptimiert: Async-Operationen, effizientes Speichermanagement und schnelles Rendering

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.

Voraussetzungen

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

Erstellen des Projekts

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

dotnet new webapi -n PdfApiService
cd PdfApiService

Installation von IronPDF

Der nächste Schritt besteht darin, IronPDF über NuGet in Ihr Projekt aufzunehmen:

dotnet add package IronPdf

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

Install-Package IronPdf

Projektstruktur

Ein wesentlicher Aspekt der C#-Entwicklung besteht darin, ein sauberes und gut strukturiertes Projektordnersystem aufrechtzuerhalten. Zum Beispiel:

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:

Erstellen des PDF-Services

Zuerst fügen wir der Datei IPdfService.cs Folgendes hinzu:

public interface IPdfService
{
    byte[] GeneratePdfFromHtml(string htmlContent);
    byte[] GeneratePdfFromUrl(string url);
}
public interface IPdfService
{
    byte[] GeneratePdfFromHtml(string htmlContent);
    byte[] GeneratePdfFromUrl(string url);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

In der PdfService.cs-Datei fügen wir dies 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;
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Der PdfService übernimmt den Kernprozess der Umwandlung von HTML in PDF. Unter Verwendung von IronPDFs ChromePdfRenderer ist diese Klasse mit vernünftigen Standardeinstellungen wie Seitenrändern und Hintergrund-Rendering ausgestattet, um ein poliertes Enddokument zu erstellen.

Wenn der Controller rohes HTML übergibt, verwendet der Service IronPDF, um es in einen professionell aussehenden PDF umzuwandeln und gibt das Ergebnis als Byte-Daten zurück, die zum Download bereitstehen. Zusätzlich kann er auch komplette Webseiten behandeln, indem er eine URL direkt in ein PDF umwandelt.

Controller erstellen

Jetzt ist es Zeit, den Controller für unsere API zu erstellen. Dies wird einen API-Endpunkt bereitstellen, der in der Lage ist, PDF-Dateien aus HTML zu generieren. Anschließend kann er PDF-Dokumente herunterladen und auf Ihrem System speichern, um sie weiter zu verwenden oder zu teilen.

// 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}");
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dann werden wir in der HtmlRequest.cs-Datei Folgendes hinzufügen:

// 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";
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

In der ersten Datei richten wir einen einfachen API-Endpunkt ein, der HTML in ein herunterladbares PDF umwandelt. Wenn jemand HTML-Inhalte an die API/pdf/html-to-pdf-Route mit einer einfachen POST-Anfrage sendet, gibt der PdfController den Auftrag, es in ein PDF zu konvertieren, an einen dedizierten Service weiter.

Sobald das PDF erstellt ist, gibt der Controller es als bereites Downloadangebot an den Benutzer zurück. Die Anfrage selbst wird mit dem HtmlRequest-Modell strukturiert, das sowohl das rohe HTML als auch einen optionalen Dateinamen für das endgültige Dokument trägt. Kurz gesagt, dieses Setup macht es einfach für Clients, HTML zu senden und sofort ein poliertes PDF zurückzubekommen.

Dienste registrieren

Aktualisieren Sie Ihre Program.cs, um den PDF-Service 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();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Wie behandelt man verschiedene Antworttypen?

Ihre API sollte verschiedene Möglichkeiten unterstützen, PDFs basierend auf den Anforderungen der Clients 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);
     }
 }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Hier haben wir dem Controller einen flexibleren PDF-Generierungsendpunkt hinzugefügt. Anstatt einen Datei-Download zu erzwingen, lässt die Methode GeneratePdf den Client entscheiden, wie er das Ergebnis erhalten möchte. Diese Option bietet Flexibilität, indem PDFs in verschiedenen Formaten angezeigt werden können: als herunterladbare Datei, direkt im Browser oder als Base64-codierte Zeichenfolge zur einfachen Verwendung in APIs.

Die Anfrage wird durch das PdfRequest-Modell definiert, das auf dem früheren HtmlRequest aufbaut und eine ResponseType-Option hinzufügt. Kurz gesagt, dies gibt den Benutzern mehr Kontrolle darüber, wie sie ihre PDFs erhalten, was die API vielseitiger und benutzerfreundlicher macht.

Jetzt, wenn wir unser Programm ausführen, werden wir diese Ausgabe bei Swagger sehen.

Wie man .NET PDF API mit IronPDF erstellt: Abbildung 4 - Swagger UI

Wie implementiert man gängige PDF-Operationen?

Lassen Sie uns unseren Service erweitern, um verschiedene Szenarien der PDF-Generierung abzudecken:

URL-zu-PDF-Konvertierung

[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; }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dieser Endpunkt erlaubt es den Clients, eine URL zu senden und ein fertiges PDF dieser Webseite zurückzubekommen. Wenn eine POST /api/pdf/url-to-pdf-Anfrage eingeht, verwendet der Controller _pdfService, um die angegebene URL im Hintergrund in PDF-Bytes zu konvertieren, und gibt sie dann als Datei-Download zurück. Wenn bei der Umwandlung etwas schief geht, antwortet es höflich mit einer klaren Fehlermeldung.

Versuchen wir, die URL "https://www.apple.com/nz" zu verwenden und die POST-Anfrage zu testen. Im Folgenden ist die Ausgabe, die wir erhielten.

Ausgabe

Wie man .NET PDF API mit IronPDF erstellt: Abbildung 5 - URL PDF Ausgabe

Hinzugefügt von benutzerdefinierten Wasserzeichen

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;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Hierhaben wir nur manuell eine lokale Datei zum Testzwecken geladen. Sie können jedoch anpassen, dfass Ihre PDF-API ein PDF-Dokument generiert und ein benutzerdefiniertes Wasserzeichen mit Leichtigkeit darauf anwendet.

Wasserzeichen-Ausgabe

Wie man .NET PDF API mit IronPDF erstellt: Abbildung 6 - Wasserzeichen-Ausgabe vom obigen Codebeispiel

Wie fügt man dynamische Daten mit Vorlagen ein?

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";
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Für fortgeschrittenere Vorlagenszenarien mit Razor, Handlebars oder anderen Engines beachten Sie die HTML-zu-PDF-Dokumentation von IronPDF. You can also explore CSHTML to PDF conversion for MVC applications and Razor to PDF for Blazor applications.

Wie optimiere ich die Leistung?

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

Asynchrone Operationen

Beim Aufbau von Projekten, die den Einsatz von I/O-Operationen beinhalten, ist es klug, asynchrone Codierung zu verwenden. Dies ist besonders hilfreich, wenn Ihre PDF-Inhalte aus externen Ressourcen stammen wie:

  • 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 einen Thread blockieren, aber die Verwendung von async verhindert, dass Ihr API-Thread im Leerlauf wartet.

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;
    });
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Render-Optionen

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
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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>();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Für fortgeschrittene Authentifizierungsszenarien ziehen Sie in Betracht:

Real-World Beispiel: Invoice Generation API

Lassen Sie uns ein praktisches Rechnungs-Generierungsendpunkt erstellen, das eine komplette Implementierung zeigt. Dieses Beispiel zeigt, wie eine produktionsfähige .NET PDF-API professionelle Rechnungen mit dynamischen Daten generieren kann.

Starten Sie jetzt mit IronPDF.
green arrow pointer

Zuerst erstellen wir eine neue Datei in unserem Models-Ordner. Hier habe ich meine Invoice.cs genannt. Dann fügen Sie den folgenden Code in Ihre neue Datei ein.

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;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dann müssen wir eine neue Servicedatei für unseren Rechnungsgenerator erstellen. In Ihrem Services-Ordner fügen Sie den folgenden Code hinzu. Für meine habe ich eine neue Datei namens InvoiceService.cs erstellt. Dieser Code wird das Styling und Layout unserer Rechnungs-PDF-Datei behandeln.

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>";
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Schließlich müssen Sie einen neuen Controller erstellen, um Zugang zu erhalten und eine neue Rechnung mit der API erstellen zu können.

[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}");
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Rechnungsausgabe

Wie man .NET PDF API mit IronPDF erstellt: Abbildung 7 - PDF-Rechnungs-Ausgabe

Container-Deployment-Überlegungen

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

Einfache 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"]
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"]
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Best Practices für Fehlerbehandlung

Für ein fehlertoleranteres Programm sind die besten Praktiken, einen globalen Fehlerhandler für konsistente Fehlerantworten zu implementieren, wie unten:

// Middleware/ErrorHandlingMiddleware.cs
public class ErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;
    public ErrorHandlingMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }
    private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
    {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = 500;
        var response = new
        {
            error = "An error occurred processing your request",
            message = ex.Message
        };
        await context.Response.WriteAsync(JsonSerializer.Serialize(response));
    }
}
// Middleware/ErrorHandlingMiddleware.cs
public class ErrorHandlingMiddleware
{
    private readonly RequestDelegate _next;
    public ErrorHandlingMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            await _next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }
    private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
    {
        context.Response.ContentType = "application/json";
        context.Response.StatusCode = 500;
        var response = new
        {
            error = "An error occurred processing your request",
            message = ex.Message
        };
        await context.Response.WriteAsync(JsonSerializer.Serialize(response));
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Für spezifische IronPDF-Fehlerbehebungsszenarien beachten Sie den IronPDF-Fehlerbehebung-Leitfaden.

Abschluss

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

Wichtige Erkenntnisse:

  • IronPDF macht die PDF-Erstellung in Web-API-Projekten einfach mit seiner auf Chrome basierenden Darstellung
  • Sie können Ihre Web-API leicht anpassen, um bestehende PDF-Dokumente mit IronPDF's erweiterten Bearbeitungswerkzeugen zu bearbeiten
  • RESTful Designprinzipien gewährleisten, dass Ihre PDF-API intuitiv und wartbar ist
  • Ordentliche Fehlerbehandlung und Sicherheitsmaßnahmen sind wesentlich für die Produktion
  • Leistungsoptimierung durch asynchrone Operationen und Caching verbessert die Skalierbarkeit
  • Sie haben Unterstützung für Desktop- und Web-Anwendungen mit skalierbaren Dokumentlösungen

IronPDF ermöglicht es Entwicklern, PDF-Dokumente zu erstellen, PDF-Dateien zu speichern und HTML effizient zu konvertieren, was es zur essenziellen PDF-Dokument-API für moderne .NET-Framework-Anwendungen macht.

Nächste 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. Explore advanced features - Check out digital signatures, PDF forms, and other advanced PDF features
  3. Mit Vertrauen skalieren - Schauen Sie sich die Lizenzierungsoptionen für Ihre Anforderungen an die API-Produktion an

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

Häufig gestellte Fragen

Was ist eine .NET PDF API?

Eine .NET PDF API ist eine Bibliothek, die es Entwicklern ermöglicht, PDF-Inhalte innerhalb von .NET-Anwendungen zu erstellen, zu bearbeiten und zu extrahieren. Sie vereinfacht komplexe PDF-Aufgaben und stellt sicher, dass PDF-Dateien effizient verwaltet werden.

Wie kann eine .NET PDF API meiner Anwendung zugutekommen?

Eine .NET PDF API kann Ihre Anwendung verbessern, indem sie Konsistenz, Wartbarkeit und Skalierbarkeit bei der Verwaltung von PDF-Dateien bietet, wie z. B. bei der Erstellung von Rechnungen, Berichten, Zertifikaten oder Verträgen.

Was sind einige häufige Anwendungsfälle für eine .NET PDF API?

Häufige Anwendungsfälle für eine .NET PDF API umfassen die Erstellung von Rechnungen, Berichte, die Produktion von Zertifikate und die Verwaltung von Verträgen innerhalb von Desktop- und Webanwendungen.

Wie vereinfacht IronPDF Aufgaben zur PDF-Generierung?

IronPDF vereinfacht Aufgaben zur PDF-Generierung, indem es eine robuste Bibliothek bietet, die eine einfache Verwaltung von Dokumenteninhalten, PDF-Seiten und Formularfeldern ermöglicht, was die Pflege und Skalierung von Anwendungen erleichtert.

Kann IronPDF Formularfelder in PDFs verarbeiten?

Ja, IronPDF kann PDF-Formularfelder effizient verwalten. Es ermöglicht Entwicklern das Erstellen, Ausfüllen und Extrahieren von Daten aus Formularen in PDF-Dokumenten.

Ist IronPDF für sowohl Desktop- als auch Webanwendungen geeignet?

Absolut, IronPDF ist so entwickelt, dass es nahtlos in sowohl Desktop- als auch Webanwendungen funktioniert und bietet eine konsistente und skalierbare Lösung für das PDF-Management.

Was macht IronPDF zu einer zuverlässigen Wahl für .NET-Entwickler?

IronPDF ist eine zuverlässige Wahl für .NET-Entwickler aufgrund seiner einfachen Bedienung, umfassenden Funktionen und der Fähigkeit, PDF-Aufgaben zu vereinfachen, was die Produktivität und die Leistung der Anwendung steigert.

Unterstützt IronPDF PDF-Extraktionsfähigkeiten?

Ja, IronPDF unterstützt PDF-Extraktionsfähigkeiten, sodass Sie effizient Text, Bilder und andere Daten aus PDF-Dokumenten extrahieren können.

Wie verbessert IronPDF die Skalierbarkeit bei der Verwaltung von PDFs?

IronPDF verbessert die Skalierbarkeit, indem es einen zentralisierten PDF-Generierungsdienst bietet, der wachsende Anforderungen ohne Leistungseinbußen bewältigen kann und somit ideal für wachsende Anwendungen ist.

Welche Art von Unterstützung bietet IronPDF für .NET-Anwendungen?

IronPDF bietet umfassende Unterstützung für .NET-Anwendungen, einschließlich detaillierter Dokumentation, Beispielcode und ein reaktionsschnelles Support-Team, das Entwicklern bei der Integration von PDF-Funktionalitäten hilft.

Ist IronPDF vollständig mit .NET 10 kompatibel?

Ja – IronPDF ist vollständig kompatibel mit .NET 10. Es unterstützt alle Leistungs-, Sprach- und Laufzeitverbesserungen, die .NET 10 einführt, und funktioniert sofort in .NET 10-Projekten, genau wie mit früheren Versionen wie .NET 6, 7, 8 und 9.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

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

Weiterlesen

Verwandte Artikel

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