Créez une API PDF .NET prête pour la production en utilisant ASP.NET Core et IronPDF pour centraliser la logique de génération de PDF, permettant une création de documents cohérente dans toutes vos applications grâce à des points de terminaison RESTful pour la conversion HTML vers PDF, la fusion, le filigrane et le traitement dynamique des modèles.
Lorsqu'ils travaillent avec des applications modernes, les développeurs .NET ont souvent besoin de créer un service centralisé de génération de PDF. Qu'il s'agisse de factures, de rapports, de certificats ou de contrats, une API PDF .NET dédiée optimise votre flux de travail. En quoi cela est-il utile ? Cela assure la cohérence, la maintenabilité et l'évolutivité de vos applications de bureau et web. La gestion du contenu des documents, des pages PDF et des champs de formulaires PDF devient simple.
Dans ce tutoriel, vous apprendrez à construire une API PDF prête pour la production en utilisant ASP.NET Core et IronPDF, une puissante bibliothèque PDF .NET. Nous créerons des points de terminaison RESTful qui généreront des PDF à partir de HTML, fusionneront des documents , ajouteront des filigranes et géreront divers scénarios PDF concrets dans votre API Web.
Avant de plonger dans le code, comprenons pourquoi la création d'une API PDF dédiée a du sens :
Prêt à commencer la construction ? Téléchargez l'essai gratuit d'IronPDF et suivez ce tutoriel pour créer des fichiers PDF par programmation dans vos projets .NET Framework.
IronPDF se distingue comme la première bibliothèque PDF pour les développeurs .NET, offrant un ensemble complet de fonctionnalités qui rendent la génération de PDF dans les projets d'API Web simple et fiable. Conçu sur un moteur de rendu Chrome , il garantit des conversions HTML vers PDF au pixel près en seulement quelques lignes de code, tout en conservant le style, l'exécution JavaScript et les mises en page réactives .
Principales capacités qui font d'IronPDF un choix idéal pour le développement d'API PDF en .NET :
Commençons par créer un nouveau projet d'API Web ASP.NET Core et installer les packages nécessaires.
Commençons par créer le projet sur lequel nous développerons notre outil de génération de PDF.
dotnet new webapi -n PdfApiService
cd PdfApiServiceEnsuite, ajoutez IronPDF à votre projet via NuGet:
> dotnet add package IronPdf
Ou, en utilisant la Console du Package Manager NuGet dans Visual Studio :
PM > Install-Package IronPdf
Pour les options d'installation avancées, y compris les packages spécifiques à la plateforme , la configuration Docker ou les configurations Linux , consultez la documentation d'installation IronPDF .
Un bon développement en C# nécessite de maintenir un dossier de projet propre et bien structuré. Par exemple :
Construisons un point d'extrémité simple qui convertit le HTML en format PDF. D'abord, créez l'interface de service et sa mise en œuvre :
Tout d'abord, ajoutez ce qui suit à votre fichier IPdfService.cs :
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 InterfaceDans le fichier PdfService.cs, ajoutez ceci :
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 ClassLe PdfService gère la conversion du HTML en PDF. En utilisant le ChromePdfRenderer d'IronPDF, cette classe configure par défaut des options comme les marges de page et le rendu de fond pour des résultats professionnels. Pour des configurations de rendu avancées, explorez les options de rendu d'IronPDF .
Lorsque le contrôleur transmet du code HTML brut, le service le convertit en un PDF de haute qualité et renvoie les données binaires pour téléchargement. Il convertit également des pages Web entières directement en PDF grâce à la conversion d'URL en PDF .
Créez maintenant le contrôleur de votre API. Ce dispositif offre un point d'accès qui génère des fichiers PDF à partir de HTML et vous permet de télécharger et d'enregistrer des documents PDF sur votre système.
// 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 ClassEnsuite, dans le fichier HtmlRequest.cs, ajoutez ceci :
// 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 ClassCela configure un point de terminaison API qui convertit le HTML en un PDF téléchargeable. Lorsque quelqu'un envoie du HTML à api/pdf/html-to-pdf, le PdfController délègue la conversion au service.
Une fois créé, le contrôleur renvoie le PDF comme un fichier téléchargeable. La requête utilise le modèle HtmlRequest, contenant le HTML et un nom de fichier optionnel. Cela permet aux clients d'envoyer facilement du HTML et de recevoir un PDF impeccable.
Mettez à jour votre Program.cs pour enregistrer le service PDF :
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()Votre API doit prendre en charge différentes manières de retourner les PDF selon les besoins des clients :
[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 FunctionCela ajoute un point de terminaison flexible pour la génération de PDF. Au lieu de forcer les téléchargements, la méthode GeneratePdf permet aux clients de choisir comment ils reçoivent les résultats : en tant que téléchargement, en ligne dans le navigateur ou encodé en Base64 pour l'utilisation de l'API.
Le modèle PdfRequest étend HtmlRequest avec une option ResponseType. Cela permet aux utilisateurs de contrôler la distribution des PDF, ce qui rend l'API plus polyvalente. Pour la gestion des PDF en mémoire sans accès au système de fichiers, consultez la documentation relative aux flux mémoire d'IronPDF .
Lorsque nous exécuterons notre programme, nous verrons ce résultat sur Swagger :
Développons notre service pour gérer divers scénarios de génération de 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; }
}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 ClassCe point de terminaison convertit les URL en fichiers PDF téléchargeables. Lorsqu'une requête POST atteint /api/pdf/url-to-pdf, le contrôleur utilise _pdfService pour convertir l'URL en octets PDF en arrière-plan, puis les retourne pour téléchargement. En cas d'échec de la conversion, un message d'erreur clair est affiché. Pour les sites web nécessitant une authentification, consultez la documentation de connexion d'IronPDF .
Essayons d'utiliser l'URL "https://www.apple.com/nz "et testez la requête POST. Voici le résultat obtenu :
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 FunctionCette fonction charge manuellement un fichier local à des fins de test. Vous pouvez configurer cela pour que votre API PDF génère un PDF, puis applique facilement des filigranes personnalisés. Pour les options de filigrane avancées, y compris les filigranes d'image et le positionnement personnalisé, consultez le guide de filigrane .
Pour les applications du monde réel, vous devrez souvent générer des PDF à partir de modèles avec des données dynamiques :
[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 ClassPour les scénarios de modèles avancés avec Razor, Handlebars ou d'autres moteurs, consultez la documentation HTML vers PDF d'IronPDF . Vous pouvez également explorer la conversion CSHTML en PDF pour les applications MVC et Razor au PDF pour les applications Blazor. Pour le rendu Razor sans interface graphique, consultez le guide CSHTML sans interface graphique .
Lorsque vous construisez une API PDF en production, la performance est cruciale. Voici des stratégies clés d'optimisation :
Utilisez la programmation asynchrone lorsque vos projets impliquent des opérations d'entrée/sortie. Cela s'avère particulièrement utile lorsque votre contenu PDF provient de ressources externes telles que :
RenderUrlAsPdf)Ces opérations peuvent bloquer les threads, mais l'asynchronisme empêche les threads de l'API de rester inactifs. Pour des modèles complets de génération de PDF asynchrones, consultez le guide de génération de PDF asynchrones .
Exemple :
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 FunctionPour les scénarios de génération de PDF en parallèle, explorez les techniques de multithreading et de traitement parallèle .
Configurez IronPDF pour des performances optimales :
_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 timeoutnetPour des options de configuration de rendu complètes, y compris les paramètres de la fenêtre d'affichage , les formats de papier personnalisés et l'orientation de la page , consultez la documentation sur les options de rendu .
La sécurité est essentielle pour toute API en production. Voici une approche simple de l'authentification par clé API :
// 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)()Pour les scénarios d'authentification avancés, tenez compte des points suivants :
Pour une sécurité spécifique aux fichiers PDF, mettez en œuvre la protection par mot de passe , les signatures numériques et le nettoyage des PDF afin de supprimer tout contenu potentiellement malveillant.
Créons un point de terminaison pratique de génération de factures illustrant une implémentation complète. Cet exemple montre comment une API PDF .NET de production génère des factures Professional avec des données dynamiques.
Commencez par créer un nouveau fichier dans votre dossier Modèles. Ici, j'ai appelé le mien Invoice.cs. Ajoutez ensuite le code suivant :
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 ClassEnsuite, créez un nouveau fichier de service pour le générateur de factures. Dans votre dossier Services, ajoutez le code suivant. J'ai créé un fichier appelé InvoiceService.cs. Ce code gère le style et la mise en page de votre facture PDF :
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>";
}
}Enfin, créez un nouveau contrôleur pour accéder aux factures et en créer à l'aide de l'API :
[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 ClassPour des fonctionnalités de facturation avancées, pensez à ajouter des codes-barres , des codes QR , des numéros de page et des en-têtes/pieds de page personnalisés . Vous pouvez également mettre en œuvre la conformité PDF/A pour l'archivage à long terme ou l'intégrer aux flux de travail de signature électronique .
Bien que ce tutoriel soit axé sur le développement local, voici un aperçu concis de la mise en conteneur de votre API PDF :
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"]Pour des guides de déploiement détaillés pour votre API PDF .NET, voir :
Pour les programmes tolérants aux pannes, implémentez un gestionnaire d'erreurs global pour des réponses d'erreur cohérentes :
// 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 ClassPour des scénarios de dépannage spécifiques à IronPDF , veuillez vous référer à : Guide de dépannage rapide
Vous avez maintenant construit une API PDF .NET robuste utilisant ASP.NET Core et IronPDF qui gère divers scénarios de génération de documents. Cette API REST fournit une base solide pour les opérations PDF centralisées dans vos applications.
Points à retenir :
IronPDF permet aux développeurs de créer des PDF, d'enregistrer des fichiers PDF et de convertir efficacement du HTML, ce qui en fait l'API PDF essentielle pour les applications modernes du .NET Framework .
Prêt à mettre en œuvre IronPDF dans votre API PDF en production .NET ? Voici vos prochaines actions :
Créez votre API PDF .NET dès aujourd'hui et rationalisez la génération de documents à travers tout votre écosystème d'applications avec 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 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
