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

Wie man einen zentralisierten PDF-Erstellungsdienst mit ASP.NET Core und IronPDF aufbaut

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?

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

IronPDF ist die führende PDF-Bibliothek for .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:

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

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);
}
Public Interface IPdfService
    Function GeneratePdfFromHtml(htmlContent As String) As Byte()
    Function GeneratePdfFromUrl(url As String) As Byte()
End Interface
$vbLabelText   $csharpLabel

Fügen Sie Folgendes in die Datei PdfService.cs ein:

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;
    }
}
Imports IronPdf

Public Class PdfService
    Implements IPdfService

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        ' Configure rendering options for optimal PDF generation in .NET
        _renderer.RenderingOptions.MarginTop = 20
        _renderer.RenderingOptions.MarginBottom = 20
        _renderer.RenderingOptions.PrintHtmlBackgrounds = True
    End Sub

    Public Function GeneratePdfFromHtml(htmlContent As String) As Byte()
        ' Generate PDF from HTML using the .NET PDF API
        Dim pdf = _renderer.RenderHtmlAsPdf(htmlContent)
        Return pdf.BinaryData
    End Function

    Public Function GeneratePdfFromUrl(url As String) As Byte()
        ' Convert URL to PDF in the REST API
        Dim pdf = _renderer.RenderUrlAsPdf(url)
        Return pdf.BinaryData
    End Function

End Class
$vbLabelText   $csharpLabel

Der Code PdfService übernimmt die Konvertierung von HTML in PDF. Mithilfe von IronPDFs ChromePdfRenderer konfiguriert diese Klasse Standardeinstellungen wie Seitenränder und Hintergrunddarstellung für Professional 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}");
        }
    }
}
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _pdfService As IPdfService

    Public Sub New(pdfService As IPdfService)
        _pdfService = pdfService
    End Sub

    <HttpPost("html-to-pdf")>
    Public Function ConvertHtmlToPdf(<FromBody> request As HtmlRequest) As IActionResult
        Try
            Dim pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent)
            ' Return as downloadable file
            Return File(pdfBytes, "application/pdf", "document.pdf")
        Catch ex As Exception
            Return BadRequest($"Error generating PDF: {ex.Message}")
        End Try
    End Function
End Class
$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";
}
' Models/HtmlRequest.vb
Public Class HtmlRequest
    Public Property HtmlContent As String
    Public Property FileName As String = "document.pdf"
End Class
$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 PdfController die Konvertierung an den Dienst.

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

Wie registriere ich Dienstleistungen?

Aktualisieren Sie Ihren 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();
Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
builder.Services.AddEndpointsApiExplorer()
builder.Services.AddSwaggerGen()
' Register PDF service
builder.Services.AddSingleton(Of IPdfService, PdfService)()
Dim app = builder.Build()
If app.Environment.IsDevelopment() Then
    app.UseSwagger()
    app.UseSwaggerUI()
End If
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);
    }
}
Imports Microsoft.AspNetCore.Mvc

<HttpPost("generate")>
Public Function GeneratePdf(<FromBody> request As PdfRequest) As IActionResult
    Dim pdfBytes = _pdfService.GeneratePdfFromHtml(request.HtmlContent)
    Select Case request.ResponseType?.ToLower()
        Case "base64"
            Return Ok(New With {
                .data = Convert.ToBase64String(pdfBytes),
                .filename = request.FileName
            })
        Case "inline"
            Return File(pdfBytes, "application/pdf")
        Case Else ' download
            Return File(pdfBytes, "application/pdf", request.FileName)
    End Select
End Function
$vbLabelText   $csharpLabel

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

Das Modell PdfRequest erweitert HtmlRequest um eine Option ResponseType. Dies gibt 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 mit den PdfApiService-Endpunkten und drei POST-Methoden für PDF-Operationen: html-to-pdf, generate und url-to-pdf, sowie den zugehörigen Anfrageschemas.

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; }
}
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

<HttpPost("url-to-pdf")>
Public Async Function ConvertUrlToPdf(<FromBody> request As UrlRequest) As Task(Of IActionResult)
    Try
        Dim pdfBytes = Await Task.Run(Function() _pdfService.GeneratePdfFromUrl(request.Url))
        Return File(pdfBytes, "application/pdf", $"{If(request.FileName, "website")}.pdf")
    Catch ex As Exception
        Return BadRequest($"Failed to convert URL: {ex.Message}")
    End Try
End Function

Public Class UrlRequest
    Public Property Url As String
    Public Property FileName As String
End Class
$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?

Startseite der Apple-Website Neuseeland mit mehreren Produktbereichen, darunter iPhone 16, MacBook Air, Apple Watch und AirPods mit Schaltflächen

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;
}
Imports IronPdf

Public Function AddWatermarkFromFile(filePath As String, watermarkText As String) As Byte()
    ' Load PDF directly from file
    Dim 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
End Function
$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 einem diagonal über eine leere Seite verlaufenden Wasserzeichen

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";
}
Imports Microsoft.AspNetCore.Mvc

<HttpPost("from-template")>
Public Function GenerateFromTemplate(<FromBody> request As TemplateRequest) As IActionResult
    ' Simple template replacement
    Dim html As String = request.Template
    For Each item In request.Data
        html = html.Replace($"{{{{{item.Key}}}}}", item.Value)
    Next
    Dim pdfBytes As Byte() = _pdfService.GeneratePdfFromHtml(html)
    Return File(pdfBytes, "application/pdf", request.FileName)
End Function

Public Class TemplateRequest
    Public Property Template As String
    Public Property Data As Dictionary(Of String, String)
    Public Property FileName As String = "document.pdf"
End Class
$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;
    });
}
Imports System.Threading.Tasks

Public Async Function GeneratePdfFromHtmlAsync(htmlContent As String) As Task(Of Byte())
    Return Await Task.Run(Function()
                              Dim pdf = _renderer.RenderHtmlAsPdf(htmlContent)
                              Return pdf.BinaryData
                          End Function)
End Function
$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>();
Imports Microsoft.AspNetCore.Http
Imports Microsoft.Extensions.Configuration
Imports System.Threading.Tasks

' Middleware/ApiKeyMiddleware.vb
Public Class ApiKeyMiddleware
    Private ReadOnly _next As RequestDelegate
    Private Const ApiKeyHeader As String = "X-API-Key"

    Public Sub New(next As RequestDelegate)
        _next = next
    End Sub

    Public Async Function InvokeAsync(context As HttpContext) As Task
        Dim apiKey As String = Nothing
        If Not context.Request.Headers.TryGetValue(ApiKeyHeader, apiKey) Then
            context.Response.StatusCode = 401
            Await context.Response.WriteAsync("API Key required")
            Return
        End If

        ' Validate API key (in production, check against database)
        Dim validApiKey As String = context.RequestServices.GetRequiredService(Of IConfiguration)()("ApiKey")
        If apiKey <> validApiKey Then
            context.Response.StatusCode = 403
            Await context.Response.WriteAsync("Invalid API Key")
            Return
        End If

        Await _next(context)
    End Function
End Class

' In Program.vb
app.UseMiddleware(Of 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 Professional 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 meinen 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;
}
Public Class Invoice
    Public Property InvoiceNumber As String
    Public Property [Date] As DateTime
    Public Property CustomerName As String
    Public Property CustomerAddress As String
    Public Property Items As List(Of InvoiceItem)
    Public Property Tax As Decimal
End Class

Public Class InvoiceItem
    Public Property Description As String
    Public Property Quantity As Integer
    Public Property UnitPrice As Decimal
    Public ReadOnly Property Total As Decimal
        Get
            Return Quantity * UnitPrice
        End Get
    End Property
End Class
$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 mit dem Namen 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>";
    }
}
Imports System
Imports System.Linq

Public Class InvoiceService
    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        _renderer.RenderingOptions.MarginTop = 10
        _renderer.RenderingOptions.MarginBottom = 10
        _renderer.RenderingOptions.PrintHtmlBackgrounds = True
    End Sub

    Public Function GenerateInvoice(invoice As Invoice) As Byte()
        Dim html = BuildInvoiceHtml(invoice)
        ' Add footer with page numbers
        _renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
            .MaxHeight = 15,
            .HtmlFragment = "<center><i>{page} of {total-pages}</i></center>",
            .DrawDividerLine = True
        }
        Dim pdf = _renderer.RenderHtmlAsPdf(html)
        Return pdf.BinaryData
    End Function

    Private Function BuildInvoiceHtml(invoice As Invoice) As String
        Dim subtotal = invoice.Items.Sum(Function(i) i.Total)
        Dim taxAmount = subtotal * (invoice.Tax / 100)
        Dim total = subtotal + taxAmount
        Dim itemsHtml = String.Join("", invoice.Items.Select(Function(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>"
    End Function
End Class
$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}");
        }
    }
}
Imports Microsoft.AspNetCore.Mvc

<ApiController>
<Route("api/[controller]")>
Public Class InvoiceController
    Inherits ControllerBase

    Private ReadOnly _invoiceService As InvoiceService

    Public Sub New(invoiceService As InvoiceService)
        _invoiceService = invoiceService
    End Sub

    <HttpPost("generate")>
    Public Function GenerateInvoice(<FromBody> invoice As Invoice) As IActionResult
        Try
            Dim pdfBytes = _invoiceService.GenerateInvoice(invoice)
            Dim fileName = $"Invoice_{invoice.InvoiceNumber}.pdf"
            Return File(pdfBytes, "application/pdf", fileName)
        Catch ex As Exception
            Return StatusCode(500, $"Error generating invoice: {ex.Message}")
        End Try
    End Function
End Class
$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 invoice document showing Invoice #INV-1023 dated 2025-08-22, with a single line item for 'Misc Object' totaling $495.00 including tax

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));
    }
}
' Middleware/ErrorHandlingMiddleware.vb
Public Class ErrorHandlingMiddleware
    Private ReadOnly _next As RequestDelegate
    Private ReadOnly _logger As ILogger(Of ErrorHandlingMiddleware)

    Public Sub New(ByVal [next] As RequestDelegate, ByVal logger As ILogger(Of ErrorHandlingMiddleware))
        _next = [next]
        _logger = logger
    End Sub

    Public Async Function InvokeAsync(ByVal context As HttpContext) As Task
        Try
            Await _next(context)
        Catch ex As Exception
            _logger.LogError(ex, "An error occurred processing request {Path}", context.Request.Path)
            Await HandleExceptionAsync(context, ex)
        End Try
    End Function

    Private Shared Async Function HandleExceptionAsync(ByVal context As HttpContext, ByVal ex As Exception) As Task
        context.Response.ContentType = "application/json"
        context.Response.StatusCode = If(TypeOf ex Is ArgumentNullException, 400, If(TypeOf ex Is UnauthorizedAccessException, 401, 500))
        Dim response = New With {
            .error = "An error occurred processing your request",
            .message = ex.Message,
            .statusCode = context.Response.StatusCode
        }
        Await context.Response.WriteAsync(JsonSerializer.Serialize(response))
    End Function
End Class
$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

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an