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

.NET PDF API ein Tutorium für .net-Entwickler

Curtis Chau
Curtis Chau
Veröffentlicht:

Mit ASP.NET Core und IronPDF einen zentralisierten PDF-Erzeugungsdienst aufbauen

Bei der Arbeit mit modernen Anwendungen kann es für .NET-Entwickler erforderlich sein, einen zentralen PDF-Generierungsdienst zu erstellen. Ganz gleich, ob Sie Rechnungen, Berichte, Zertifikate oder Verträge generieren, eine dedizierte .NET-PDF-API kann für die effiziente Verwaltung von PDF-Dateien von Vorteil sein. Wie kann es Ihre PDF-Generierungsaufgaben verbessern? Dies geschieht durch die Gewährleistung von Konsistenz, Wartungsfreundlichkeit und Skalierbarkeit für Ihre Desktop- und Webanwendungen. Noch nie war es einfacher, Dokumenteninhalte, PDF-Seiten und PDF-Formularfelder zu verwalten.

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 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?

.NET PDF API ein Tutorial für .NET-Entwickler: Bild 1 - PDF-API-Architekturdiagramm

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

  • Zentralisierte Logik: Die gesamte Logik der PDF-Generierung befindet sich an einem Ort, was die Wartung und Aktualisierung erleichtert.
  • Microservice-Architektur: Perfekt für serviceorientierte Architekturen, in denen verschiedene Anwendungen PDF-Funktionen benötigen.
  • Optimierung der Leistung: Leichtere Skalierung und Optimierung eines speziellen Dienstes für große PDF-Dateien, mehrere Seiten und dynamische Daten.
  • 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 einheitliches Dokumentenlayout, Absatzformatierung und PDF-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.

IronPDF: Die vollständige .NET PDF-Bibliothek

.NET PDF API ein Tutorial für .NET-Entwickler: Image 2 - Image 2 of 7 related to .NET PDF API a tutorial for .NET developers

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. Sie basiert auf einer Chrome-Rendering-Engine, die pixelgenaue HTML-zu-PDF-Konvertierungen gewährleistet, 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:

  • Chrome-basiertes Rendering: Nutzt die Rendering-Engine von Google Chrome für die exakte Konvertierung von PDF-Dokumenten aus HTML-Inhalten, mit voller Unterstützung für eingebettete Bilder und andere Web-Assets.
  • Reichhaltiger Funktionsumfang: Unterstützt die Bearbeitung neuer und bestehender Dokumente mit digitalen Signaturen, PDF-Formularen, Anmerkungen, Verschlüsselung, Komprimierung und mehr.
  • Sichere PDF-Dokumente erstellen: Verwalten Sie sensible PDF-Inhalte mit Verschlüsselung, digitalen Signaturen und Dokumentenschutz.
  • Mehrere Eingabeformate: Verwenden Sie HTML, URLs, Bilder und Bürodokumente, um PDF-Dokumente zu erstellen.
  • Erweiterte Manipulation: Zusammenführen von PDF-Seiten, Aufteilen von Dokumenten, Anbringen von Wasserzeichen, Erstellen interaktiver PDF-Formulare und programmatische Bearbeitung von PDF-Dateien.
  • Plattformübergreifende Unterstützung: Funktioniert unter Windows, Linux , macOS, Docker und Cloud-Plattformen.
  • Leistungsoptimiert: Async-Operationen, effiziente Speicherverwaltung 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
dotnet new webapi -n PdfApiService
cd PdfApiService
SHELL

Installation von IronPDF

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

dotnet add package IronPDF
dotnet add package IronPDF
SHELL

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:

.NET PDF API ein Tutorial für .NET-Entwickler: Bild 3 - Projektordnerstruktur

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

Zunächst fügen wir unserer 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 Datei PdfService.cs werden wir Folgendes hinzufügen:

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 des ChromePdfRenderer von IronPDF wird diese Klasse mit sinnvollen Voreinstellungen wie Seitenrändern und Hintergrundwiedergabe eingerichtet, um ein ausgefeiltes Enddokument zu erzeugen.

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 fügen wir 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";
}
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 mit einer einfachen POST-Anfrage an die api/pdf/html-to-pdf-Route sendet, übergibt der PdfController die Aufgabe der Konvertierung in eine PDF-Datei an einen speziellen Dienst.

Sobald die PDF-Datei erstellt ist, wird sie vom Controller an den Benutzer als herunterladbare Datei zurückgegeben. Die Anforderung selbst ist mit dem HtmlRequest-Modell strukturiert, das sowohl das Roh-HTML als auch einen optionalen Dateinamen für das endgültige Dokument enthält. Kurz gesagt, dieses Setup macht es einfach für Clients, HTML zu senden und sofort ein poliertes PDF zurückzubekommen.

Dienste registrieren

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

Hier haben wir dem Controller einen flexibleren PDF-Generierungsendpunkt hinzugefügt. Anstatt immer einen Dateidownload zu erzwingen, lässt die Methode GeneratePdf den Kunden wählen, wie er das Ergebnis zurückerhalten 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.

.NET PDF API ein Tutorial für .NET-Entwickler: Bild 4 - Swagger UI

Wie implementiert man gängige PDF-Operationen?

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

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 umzuwandeln, die dann als Datei-Download zurückgegeben werden. 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

.NET PDF API ein Tutorial für .NET-Entwickler: Bild 5 - URL-PDF-Ausgabe

Benutzerdefinierte Wasserzeichen hinzufügen

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

Hier laden wir manuell eine lokale Datei zu Testzwecken. Sie können dies jedoch anpassen, damit Ihre PDF-API ein PDF-Dokument erstellt und dann problemlos ein benutzerdefiniertes Wasserzeichen darauf anwendet.

Wasserzeichen-Ausgabe

.NET PDF API ein Tutorial für .NET-Entwickler: Bild 6 - Ausgabe des Wasserzeichens aus dem 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. Sie können auch CSHTML-zu-PDF-Konvertierung für MVC-Anwendungen und Razor-zu-PDF für Blazor-Anwendungen erkunden.

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:

Realbeispiel: Rechnungs-Generierungs-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 Übersetzung 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 Übersetzung habe ich eine neue Datei mit dem Namen 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
        {

```cs
public IActionResult GeneratePDF(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
        {

```cs
public IActionResult GeneratePDF(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

.NET PDF API ein Tutorial für .NET-Entwickler: Bild 7 - PDF-Rechnungsausgabe

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"]

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 Punkte:

  • IronPDF macht die PDF-Erzeugung in Web-API-Projekten mit seinem Chrome-basierten Rendering ganz einfach.
  • Mit den fortschrittlichen Bearbeitungswerkzeugen von IronPDF können Sie Ihre Web-API problemlos anpassen, um vorhandene PDF-Dokumente zu 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.
  • Leistungsoptimierung durch asynchrone Operationen und Caching verbessert die Skalierbarkeit.
  • Sie werden Unterstützung für Desktop- und Webanwendungen mit skalierbaren Dokumentenlösungen erhalten.

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. Erweiterte Funktionen entdecken - Informieren Sie sich über digitale Signaturen, PDF forms und andere erweiterte PDF-Funktionen.

  3. Skalieren Sie mit Vertrauen - Prüfen Sie die Lizenzierungsoptionen für Ihre Produktions-API-Anforderungen.

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