Lorsqu'ils travaillent avec des applications modernes, les développeurs .NET comme vous peuvent se retrouver à devoir créer un service centralisé de génération de PDF. Que vous génériez des factures, des rapports, des certificats ou des contrats, disposer d'une API PDF en .NET dédiée peut être bénéfique pour gérer efficacement les fichiers PDF. Alors, comment cela peut-il améliorer vos tâches de génération de PDF ? Il le fait en offrant cohérence, maintenabilité et évolutivité à travers vos applications de bureau et web. Jamais auparavant il n'a été aussi facile de gérer le contenu des documents, les pages PDF et les champs de formulaire PDF.
Dans ce tutoriel, vous apprendrez à construire une API PDF prête pour la production à l'aide d'ASP.NET Core et IronPDF, une puissante bibliothèque PDF en .NET. Nous allons créer des points d'extrémité RESTful capables de générer des PDF à partir de HTML, de fusionner des documents, d'ajouter des filigranes et de gérer divers scénarios de génération de PDF 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 :
Logique centralisée : toute la logique de génération de PDF est regroupée au même endroit, ce qui simplifie la maintenance et les mises à jour. Architecture de microservices : idéale pour les architectures orientées services où différentes applications nécessitent des fonctionnalités PDF.
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 bibliothèque PDF de choix 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. Elle est construite sur un moteur de rendu Chrome, ce qui garantit des conversions HTML en PDF pixel parfaites, souvent en quelques lignes de code. Elle fait tout cela tout en conservant tous les styles, l'exécution JavaScript et la réactivité.
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.
Tout d'abord, créons le projet dans lequel nous allons construire notre outil de génération de PDF.
dotnet new webapi -n PdfApiService
cd PdfApiServiceLa prochaine étape est d'ajouter IronPDF à votre projet via NuGet :
dotnet add package IronPdfOu, en utilisant la Console du Package Manager NuGet dans Visual Studio :
Un aspect essentiel du développement en C# est 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 :
En premier lieu, nous ajouterons ce qui suit à notre 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, nous ajouterons 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 le processus principal de conversion du HTML en PDF. Utilisant le ChromePdfRenderer d'IronPDF, cette classe est configurée avec des paramètres par défaut judicieux comme des marges de page et un rendu en arrière-plan pour produire un document final soigné.
Lorsque le contrôleur transmet du HTML brut, le service utilise IronPDF pour le rendre en un PDF de qualité professionnelle et renvoie le résultat sous forme de données binaires prêtes à être téléchargées. De plus, il peut également traiter des pages web entières en convertissant directement une URL en PDF.
Il est maintenant temps de créer le contrôleur pour notre API. Cela fournira un point d'extrémité API capable de générer des fichiers PDF à partir de HTML. Il pourra alors télécharger et enregistrer des documents PDF sur votre système pour un usage ultérieur ou pour le partage.
// 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 ClassPuis, dans le fichier HtmlRequest.cs, nous ajouterons 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 ClassDans le premier fichier, nous configurons un point d'extrémité API simple qui transforme le HTML en un PDF téléchargeable. Lorsqu'une quelqu'un envoie du contenu HTML à l'itinéraire api/pdf/html-to-pdf avec une simple requête POST, le PdfController transmet le travail de conversion en PDF à un service dédié.
Une fois le PDF créé, le contrôleur le renvoie à l'utilisateur sous forme de fichier prêt à être téléchargé. La requête elle-même est structurée à l'aide du modèle HtmlRequest, qui transporte à la fois le HTML brut et un nom de fichier facultatif pour le document final. En bref, cette configuration facilite l'envoi de HTML par les clients et la réception instantanée d'un PDF soigné en retour.
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 FunctionIci, nous avons ajouté un point d'extrémité de génération de PDF plus flexible au contrôleur. Au lieu de toujours forcer un téléchargement de fichier, la méthode GeneratePdf permet au client de choisir comment il souhaite que le résultat soit renvoyé. Cette option offre de la flexibilité, permettant d'afficher les PDF sous différents formats : en tant que fichier téléchargeable, directement dans le navigateur, ou encodés sous forme de chaîne Base64 pour une utilisation facile dans les APIs.
La demande est définie par le modèle PdfRequest, qui se base sur le HtmlRequest précédent et ajoute une option ResponseType. En bref, cela donne aux utilisateurs plus de contrôle sur la façon dont ils reçoivent leurs PDF, rendant l'API plus polyvalente et conviviale.
Maintenant, lorsque nous exécuterons notre programme, nous verrons cette sortie 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 d'extrémité permet aux clients d'envoyer une URL et de recevoir un PDF prêt à être téléchargé de cette page web. Lorsqu'une requête POST /api/pdf/url-to-pdf arrive, le contrôleur utilise _pdfService pour convertir l'URL fournie en octets PDF en arrière-plan, puis les renvoie sous forme de téléchargement de fichier. Si quelque chose se passe mal lors de la conversion, il répond gracieusement avec un message d'erreur clair.
Essayons d'utiliser l'URL "https://www.apple.com/nz" et testons la requête POST. Ci-dessous est le résultat que nous avons 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 FunctionIci, nous chargeons simplement un fichier local manuellement à des fins de test. Cependant, vous pouvez ajuster cela pour que votre API PDF génère un document PDF, puis applique un filigrane personnalisé facilement.
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 des scénarios de modèle plus 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.
Lorsque vous construisez une API PDF en production, la performance est cruciale. Voici des stratégies clés d'optimisation :
Lorsque vous construisez des projets impliquant l'utilisation d'opérations d'E/S, il est judicieux d'utiliser la programmation asynchrone. Ceci est particulièrement utile si votre contenu PDF provient de ressources externes comme :
Ces opérations peuvent alors bloquer un thread, mais l'utilisation de async empêche votre thread d'API de rester inactif.
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 FunctionConfigurez 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 timeoutnetLa 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 des scénarios d'authentification plus avancés, envisagez :
Construisons un point d'extrémité pratique de génération de factures qui démontre une mise en œuvre complète. Cet exemple montre comment une API PDF en .NET en production peut générer des factures professionnelles avec des données dynamiques.
D'abord, nous créerons un nouveau fichier dans notre dossier Models. Ici, j'ai appelé le mien Invoice.cs. Ensuite, ajoutez le code suivant à votre nouveau fichier.
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, nous devrons créer un nouveau fichier de service pour notre générateur de factures. Dans votre dossier Services, ajoutez le code suivant. Pour le mien, j'ai fait un nouveau fichier appelé InvoiceService.cs. Ce code gérera le style et la mise en page de notre fichier PDF de factures.
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, vous aurez besoin de créer un nouveau contrôleur pour accéder et créer une nouvelle facture à 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 Class
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"]The provided code is a Dockerfile written for building and running a .NET application, not C# code. Dockerfiles are not converted to VB.NET as they are not programming language code but configuration scripts for Docker. If you have C# code that needs conversion to VB.NET, please provide that code instead.Pour des guides de déploiement détaillés pour votre API PDF .NET, voir :
Pour un programme plus tolérant aux pannes, les meilleures pratiques consistent à mettre en œuvre un gestionnaire d'erreurs global pour des réponses d'erreur cohérentes, comme ci-dessous :
// Middleware/ErrorHandlingMiddleware.cs
public class ErrorHandlingMiddleware
{
private readonly RequestDelegate _next;
public ErrorHandlingMiddleware(RequestDelegate next)
{
_next = next;
}
public async Task InvokeAsync(HttpContext context)
{
try
{
await _next(context);
}
catch (Exception ex)
{
await HandleExceptionAsync(context, ex);
}
}
private static async Task HandleExceptionAsync(HttpContext context, Exception ex)
{
context.Response.ContentType = "application/json";
context.Response.StatusCode = 500;
var response = new
{
error = "An error occurred processing your request",
message = ex.Message
};
await context.Response.WriteAsync(JsonSerializer.Serialize(response));
}
}Imports System.Text.Json
Imports Microsoft.AspNetCore.Http
Imports System.Threading.Tasks
Public Class ErrorHandlingMiddleware
Private ReadOnly _next As RequestDelegate
Public Sub New(next As RequestDelegate)
_next = next
End Sub
Public Async Function InvokeAsync(context As HttpContext) As Task
Try
Await _next(context)
Catch ex As Exception
Await HandleExceptionAsync(context, ex)
End Try
End Function
Private Shared Async Function HandleExceptionAsync(context As HttpContext, ex As Exception) As Task
context.Response.ContentType = "application/json"
context.Response.StatusCode = 500
Dim response = New With {
.error = "An error occurred processing your request",
.message = ex.Message
}
Await context.Response.WriteAsync(JsonSerializer.Serialize(response))
End Function
End ClassPour des scénarios de dépannage spécifiques à IronPDF, référez-vous au guide de dépannage IronPDF.
Vous avez maintenant construit une API PDF .NET robuste à l'aide d'ASP.NET Core et IronPDF qui peut gérer 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 documents PDF, d'enregistrer des fichiers PDF et de convertir du HTML efficacement, en faisant l'API documentaire PDF essentielle pour les applications modernes .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 détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
