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.
Bevor wir in den Code eintauchen, lassen Sie uns verstehen, warum die Erstellung einer dedizierten PDF-API sinnvoll ist:
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 ist die führende PDF-Bibliothek für .NET-Entwickler und bietet eine umfassende Reihe von Funktionen, die die PDF-Erzeugung in Web-API-Projekten einfach und zuverlässig machen. Es basiert auf einer Chrome-Rendering-Engine und gewährleistet pixelgenaue HTML-zu-PDF-Konvertierungen mit nur wenigen Codezeilen, wobei sämtliche Stile, die JavaScript Ausführung und responsive Layouts erhalten bleiben.
Schlüsselfähigkeiten, die IronPDF ideal für die .NET PDF-API-Entwicklung machen:
Beginnen wir mit der Erstellung eines neuen ASP.NET Core Web API-Projekts und der Installation der erforderlichen Pakete.
Als Erstes erstellen wir das Projekt, in dem wir unser PDF-Generierungstool entwickeln werden.
dotnet new webapi -n PdfApiService
cd PdfApiServiceFügen Sie als Nächstes IronPDF über NuGet zu Ihrem Projekt hinzu:
> dotnet add package IronPdf
Oder mit der NuGet-Paket-Manager-Konsole in Visual Studio:
PM > Install-Package IronPdf
Erweiterte Installationsoptionen, einschließlich plattformspezifischer Pakete , Docker-Setup oder Linux-Konfigurationen , finden Sie in der IronPDF Installationsdokumentation .
Eine gute C#-Entwicklung erfordert die Pflege eines sauberen und gut strukturierten Projektordners. Zum Beispiel:
Lassen Sie uns einen einfachen Endpunkt erstellen, der HTML in PDF-Format konvertiert. Zuerst erstellen Sie die Service-Schnittstelle und -Implementierung:
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
Function GeneratePdfFromHtml(htmlContent As String) As Byte()
Function GeneratePdfFromUrl(url As String) As Byte()
End InterfaceFü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;
}
}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 ClassDer 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.
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}");
}
}
}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 ClassFü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.vb
Public Class HtmlRequest
Public Property HtmlContent As String
Public Property FileName As String = "document.pdf"
End ClassHiermit 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.
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();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()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);
}
}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 FunctionDies 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:
Lassen Sie uns unseren Service erweitern, um verschiedene PDF-Generierungsszenarien zu behandeln:
[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 ClassDieser 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:
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 FunctionHiermit 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 .
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";
}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 ClassFü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 .
Beim Aufbau einer Produktions-PDF-API ist Leistung entscheidend. Hier sind die wichtigen Optimierungsstrategien:
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:
RenderUrlAsPdf)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;
});
}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 FunctionFür Szenarien der parallelen PDF-Generierung sollten Multithreading- und Parallelverarbeitungstechniken untersucht werden.
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 timeoutnetAusführliche Informationen zu den Rendering-Konfigurationsoptionen, einschließlich Ansichtsfenstereinstellungen , benutzerdefinierten Papierformaten und Seitenausrichtung , finden Sie in der Dokumentation zu den Rendering-Optionen .
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>();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)()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.
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.
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 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 ClassAls 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>";
}
}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 ClassErstellen 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}");
}
}
}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 ClassFü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.
Obwohl sich dieses Tutorial auf lokale Entwicklung konzentriert, hier eine kurze Übersicht über die Containerisierung Ihrer PDF-API:
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:
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.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 ClassSpezifische Szenarien zur Fehlerbehebung bei IronPDF finden Sie hier:
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:
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.
Bereit, IronPDF in Ihrer produktiven .NET PDF-API zu implementieren? Dies sind Ihre nächsten Aktionen:
Erstellen Sie noch heute Ihre .NET PDF-API und optimieren Sie die Dokumentenerstellung in Ihrem gesamten Anwendungsökosystem mit IronPDF!
Curtis Chau holds a Bachelor’s degree in Computer Science (Carleton University) and specializes in front-end development with expertise in Node.js, TypeScript, JavaScript, and React. Passionate about crafting intuitive and aesthetically pleasing user interfaces, Curtis enjoys working with modern frameworks and creating well-structured, visually appealing manuals.
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
