Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. API PDF .NET W Terminé
UTILISATION DE IRONPDF

Comment créer un service centralisé de génération de PDF avec ASP.NET Core et IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

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.

Pourquoi construire une API PDF dédiée ?

! Diagramme d'architecture montrant les applications clientes (web, bureau, mobile) envoyant du contenu HTML, des URL ou des données dynamiques à une couche API de contrôleur/service PDF, qui génère des documents PDF.

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 réside 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 ont besoin de fonctionnalités PDF.
  • Optimisation des performances : Il est plus facile de faire évoluer et d'optimiser un service dédié pour les fichiers PDF volumineux, les fichiers de plusieurs pages et les données dynamiques grâce aux opérations asynchrones et aux techniques de performance .
  • Indépendant du langage : Toute application cliente peut consommer l'API, quel que soit le langage de programmation.
  • Résultat homogène : Garantit que tous les PDF de votre organisation conservent une mise en page, un formatage et un contenu homogènes.

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.

Qu'est-ce qui fait d'IronPDF la bibliothèque PDF .NET complète ?

La page d'accueil d'IronPDF pour .NET présente des exemples de code C# pour la conversion de HTML en PDF, avec des fonctionnalités telles que le rendu HTML, l'enregistrement de fichiers et la commande d'installation NuGet.

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

Comment configurer votre projet d'API de document PDF ?

Commençons par créer un nouveau projet d'API Web ASP.NET Core et installer les packages nécessaires.

Quels sont les prérequis ?

  • .NET 6.0 SDK ou version ultérieure
  • Visual Studio 2022 ou Visual Studio Code
  • Utilisez Postman ou un outil de test d'API similaire pour tester votre API REST PDF.

Comment créer le projet ?

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 PdfApiService
dotnet new webapi -n PdfApiService
cd PdfApiService
SHELL

Comment installer IronPDF ?

Ensuite, ajoutez IronPDF à votre projet via NuGet :

dotnet add package IronPDF
dotnet add package IronPDF
SHELL

Ou, en utilisant la Console du Gestionnaire de Paquets NuGet dans Visual Studio :

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 d'IronPDF .

Quelle structure de projet dois-je utiliser ?

Un bon développement en C# nécessite de maintenir un dossier de projet propre et bien structuré. Par exemple :

! L'explorateur de solutions de Visual Studio affiche la structure des dossiers d'un projet de service d'API PDF .NET avec les répertoires Controllers, Models et Services.

Comment créer votre premier point d'extrémité PDF ?

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 :

Comment créer le service PDF ?

Commencez par ajouter ce qui suit à votre fichier IPdfService.cs :

public interface IPdfService
{
    byte[] GeneratePdfFromHtml(string htmlContent);
    byte[] GeneratePdfFromUrl(string url);
}
public interface IPdfService
{
    byte[] GeneratePdfFromHtml(string htmlContent);
    byte[] GeneratePdfFromUrl(string url);
}
$vbLabelText   $csharpLabel

Dans 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;
    }
}
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;
    }
}
$vbLabelText   $csharpLabel

Le PdfService gère la conversion du HTML en PDF. Utilisant ChromePdfRenderer d'IronPDF, cette classe configure les paramètres par défaut tels que les marges de page et le rendu de l'arrière-plan 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 .

Comment créer le contrôleur ?

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}");
        }
    }
}
// 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}");
        }
    }
}
$vbLabelText   $csharpLabel

Ensuite, 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.cs
public class HtmlRequest
{
    public string HtmlContent { get; set; }
    public string FileName { get; set; } = "document.pdf";
}
$vbLabelText   $csharpLabel

Cela configure un point de terminaison API qui convertit le HTML en un PDF téléchargeable. Lorsqu'une personne 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 sous forme de fichier téléchargeable. La requête utilise le modèle HtmlRequest , contenant le code HTML et un nom de fichier facultatif. Cela permet aux clients d'envoyer facilement du HTML et de recevoir un PDF impeccable.

Comment puis-je enregistrer mes services ?

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();
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();
$vbLabelText   $csharpLabel

Comment gérer différents types de réponse ?

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);
    }
}
[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);
    }
}
$vbLabelText   $csharpLabel

Cela ajoute un point de terminaison flexible pour la génération de PDF. Au lieu d'imposer des téléchargements, la méthode GeneratePdf permet aux clients de choisir comment ils reçoivent les résultats : par téléchargement, directement dans le navigateur ou encodés en Base64 pour une utilisation via 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 :

! Documentation Swagger UI montrant les points de terminaison PdfApiService avec trois méthodes POST pour les opérations PDF : html-to-pdf, generate et url-to-pdf, ainsi que les schémas de requête.

Comment mettre en œuvre des opérations PDF communes ?

Développons notre service pour gérer divers scénarios de génération de PDF :

Comment convertir des URL en 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; }
}
$vbLabelText   $csharpLabel

Ce 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 renvoie 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 :

À quoi ressemble le résultat ?

La page d'accueil du site web d'Apple Nouvelle-Zélande présente plusieurs sections de produits, notamment l'iPhone 16, le MacBook Air, l'Apple Watch et les AirPods, avec les boutons " En savoir plus " et " Acheter " – illustrant la conversion d'URL en PDF.

Comment ajouter des filigranes personnalisés ?

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;
}
$vbLabelText   $csharpLabel

Cette 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 .

À quoi ressemble le filigrane final ?

Document sécurisé portant le filigrane " CONFIDENTIEL " en diagonale sur une page blanche, avec l'identifiant du document : BA811648DCE1FF2AAA55E7CE indiqué en haut.

Comment ajouter des données dynamiques avec des modèles ?

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";
}
[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";
}
$vbLabelText   $csharpLabel

Pour 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 .

Comment optimiser les performances ?

Lorsque vous construisez une API PDF en production, la performance est cruciale. Voici des stratégies clés d'optimisation :

Pourquoi utiliser des opérations asynchrones ?

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 :

  • Téléchargement de pages HTML (RenderUrlAsPdf)
  • Récupération d'images, CSS ou polices via HTTP
  • Lecture/écriture de fichiers sur disque ou stockage cloud

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;
    });
}
public async Task<byte[]> GeneratePdfFromHtmlAsync(string htmlContent)
{
    return await Task.Run(() =>
    {
        var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
        return pdf.BinaryData;
    });
}
$vbLabelText   $csharpLabel

Pour les scénarios de génération de PDF en parallèle, explorez les techniques de multithreading et de traitement parallèle .

Quelles options de rendu dois-je configurer ? Configurez IronPDF pour des performances optimales : ```cs _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 ``` Pour des options de configuration de rendu complètes, y compris [les paramètres de la fenêtre d'affichage](https://ironpdf.com/how-to/viewport-zoom/) , [les formats de papier personnalisés](https://ironpdf.com/how-to/custom-paper-size/) et [l'orientation de la page](https://ironpdf.com/how-to/page-orientation-rotation/) , consultez la [documentation sur les options de rendu](https://ironpdf.com/how-to/rendering-options/) . ## Comment sécuriser votre API PDF ? La sécurité est essentielle pour toute API en production. Voici une approche simple de l'authentification par clé API : ```cs // 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()["ApiKey"]; if (apiKey != validApiKey) { context.Response.StatusCode = 403; await context.Response.WriteAsync("Invalid API Key"); return; } await _next(context); } } // In Program.cs app.UseMiddleware(); ``` Pour les scénarios d'authentification avancés, tenez compte des points suivants : * [Authentification JWT](https://learn.microsoft.com/en-us/aspnet/core/security/authentication/jwt) - Norme de l'industrie pour l'authentification des API * [OAuth 2.0](https://learn.microsoft.com/en-us/aspnet/core/security/authentication/oauth-providers) - Pour les intégrations tierces * [Intégration Azure AD](https://learn.microsoft.com/en-us/azure/active-directory/develop/) - Authentification d'entreprise * [Limitation des API](https://github.com/stefanprodan/AspNetCoreRateLimit) - Prévenir les abus et assurer une utilisation équitable * [En-têtes HTTP](https://ironpdf.com/how-to/http-request-header/) - Configuration personnalisée des en-têtes pour une sécurité renforcée Pour une sécurité spécifique aux fichiers PDF, mettez en œuvre [la protection par mot de passe](https://ironpdf.com/how-to/pdf-permissions-passwords/) , [les signatures numériques](https://ironpdf.com/how-to/signing/) et [le nettoyage des PDF](https://ironpdf.com/how-to/sanitize-pdf/) afin de supprimer tout contenu potentiellement malveillant. ## Comment créer une API de génération de factures concrète ? 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 professionnelles avec des données dynamiques.
Commencez avec IronPDF maintenant.
green arrow pointer
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 : ```cs 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 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; } ``` Ensuite, 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 : ```cs 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 = "
{page} of {total-pages}
", 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 => $@" {item.Description} {item.Quantity} ${item.UnitPrice:F2} ${item.Total:F2} ")); return $@"

Invoice #{invoice.InvoiceNumber}

Date: {invoice.Date:yyyy-MM-dd}

Bill To:

{invoice.CustomerName}
{invoice.CustomerAddress}

{itemsHtml}
Description Quantity Unit Price Total

Subtotal: ${subtotal:F2}

Tax ({invoice.Tax}%): ${taxAmount:F2}

Total: ${total:F2}

"; } } ``` Enfin, créez un nouveau contrôleur pour accéder aux factures et en créer à l'aide de l'API : ```cs [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}"); } } } ``` Pour des fonctionnalités de facturation avancées, pensez à ajouter [des codes-barres](https://ironpdf.com/examples/barcode-htmltopdf/) , [des codes QR](https://ironsoftware.com/csharp/qr/) , [des numéros de page](https://ironpdf.com/how-to/page-numbers/) et [des en-têtes/pieds de page personnalisés](https://ironpdf.com/how-to/headers-and-footers/) . Vous pouvez également mettre en œuvre [la conformité PDF/A](https://ironpdf.com/how-to/pdfa/) pour l'archivage à long terme ou l'intégrer aux [flux de travail de signature électronique](https://ironpdf.com/how-to/signing-pdf-with-hsm/) . #### À quoi ressemble la facture finale ? [Facture PDF n° INV-1023 datée du 22/08/2025, comportant une seule ligne " Objet divers " pour un montant total de 495,00 $ TTC.](/static-assets/pdf/blog/net-pdf-api/net-pdf-api-7.webp) ## Quelles sont les considérations à prendre en compte lors du déploiement de conteneurs ? 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 : ### Comment créer un Dockerfile de base ? ```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"] ``` Pour des guides de déploiement détaillés pour votre API PDF .NET, voir : * [Documentation sur Docker d'IronPDF](/get-started/ironpdf-docker/) - Guide complet de mise en conteneur * [Déploiement Azure d'IronPDF](/get-started/azure/) - Fonctions Azure et Service d'application * [Déploiement AWS d'IronPDF](/get-started/aws/) - Déploiement Lambda et EC2 * [Configuration Linux d'IronPDF](/get-started/linux/) - Configuration spécifique à Linux * [Exécution en tant que conteneur distant](https://ironpdf.com/get-started/ironpdfengine-docker/) - Conteneurisation du moteur IronPDF * [Moteur natif vs moteur distant](https://ironpdf.com/get-started/ironpdfengine/) - Options d'architecture de déploiement ## Quelles sont les meilleures pratiques en matière de gestion des erreurs ? Pour les programmes tolérants aux pannes, implémentez un gestionnaire d'erreurs global pour des réponses d'erreur cohérentes : ```cs // Middleware/ErrorHandlingMiddleware.cs public class ErrorHandlingMiddleware { private readonly RequestDelegate _next; private readonly ILogger _logger; public ErrorHandlingMiddleware(RequestDelegate next, ILogger 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)); } } ``` Pour des scénarios de dépannage spécifiques à IronPDF, veuillez vous référer à : [Guide de dépannage rapide](/troubleshooting/quick-ironpdf-troubleshooting/) * [Guide d'assistance technique](https://ironpdf.com/troubleshooting/engineering-support-for-ironpdf/) * [Configuration de journalisation personnalisée](https://ironpdf.com/how-to/custom-logging/) * [Prévention des fuites de mémoire](https://ironpdf.com/troubleshooting/memory-leak-in-ironpdf/) [Conseils d'optimisation des performances](https://ironpdf.com/troubleshooting/ironpdf-performance-assistance/) ## Prêt à créer votre API PDF .NET de production ? 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 simplifie la génération de PDF dans les projets d'API Web grâce [au rendu basé sur Chrome](https://ironpdf.com/how-to/pixel-perfect-html-to-pdf/) . * Modifiez facilement les PDF existants grâce aux [outils d'édition avancés](https://ironpdf.com/features/edit/) d'IronPDF. * Les principes de conception RESTful garantissent que votre API PDF est intuitive et facile à entretenir. * Une bonne gestion des erreurs et des mesures de sécurité sont essentielles pour la production. * L'optimisation des performances grâce [aux opérations asynchrones](https://ironpdf.com/how-to/async/) et [à la mise en cache](https://ironpdf.com/troubleshooting/initial-render-slow/) améliore l'évolutivité. * Prise en charge complète des applications de bureau et Web avec des solutions documentaires évolutives. IronPDF permet aux développeurs de créer des PDF, [d'enregistrer des fichiers PDF](https://ironpdf.com/how-to/export-save-pdf-csharp/) et de convertir efficacement du HTML, ce qui en fait l'API PDF essentielle pour les applications modernes du framework .NET. ### Quelles sont les prochaines étapes ? Prêt à mettre en œuvre IronPDF dans votre API PDF en production .NET ? Voici vos prochaines actions : 1. [**Commencez votre essai gratuit**](trial-license) - Testez IronPDF avec toutes les fonctionnalités dans votre environnement de développement. 2. **Explorez les fonctionnalités avancées** - Découvrez [les signatures numériques](/how-to/signing/) , [les formulaires PDF](/how-to/create-forms/) , [la conformité PDF/A](https://ironpdf.com/how-to/pdfa/) , [la gestion des métadonnées](https://ironpdf.com/how-to/metadata/) et d'autres [fonctionnalités PDF avancées](https://ironpdf.com/features/others/) . 3. **Évoluez en toute confiance** - Examinez [les options de licence](licensing) pour vos besoins d'API de production, y compris [les extensions](https://ironpdf.com/licensing/extensions/) et [les mises à niveau](https://ironpdf.com/licensing/upgrades/) . 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 !

Questions Fréquemment Posées

À quoi sert IronPDF dans les applications .NET ?

IronPDF est utilisé pour générer, manipuler et convertir des PDF au sein d'applications .NET, ce qui en fait un outil idéal pour créer des services PDF centralisés.

Comment IronPDF peut-il être intégré à ASP.NET Core ?

IronPDF peut être intégré à ASP.NET Core en installant le package NuGet IronPDF, ce qui permet de construire un service centralisé de génération de PDF.

Quelles sont les principales caractéristiques d'IronPDF pour la génération de PDF ?

Les principales fonctionnalités d'IronPDF comprennent la conversion de HTML en PDF, la fusion et la division de PDF, l'ajout d'en-têtes et de pieds de page, et l'extraction de texte et d'images.

IronPDF peut-il gérer des mises en page PDF complexes ?

Oui, IronPDF peut gérer des mises en page PDF complexes grâce à sa capacité à convertir du contenu HTML et CSS en documents PDF rendus avec précision.

Est-il possible de personnaliser la création de PDF avec IronPdf ?

Oui, IronPDF permet de personnaliser la création de PDF, notamment en définissant la taille des pages, les marges et en ajoutant des filigranes ou des annotations.

IronPDF prend-il en charge des fonctionnalités de sécurité PDF ?

IronPDF prend en charge les fonctions de sécurité PDF telles que la protection par mot de passe et le cryptage pour sécuriser les documents PDF générés.

Quels formats IronPDF peut-il convertir en PDF ?

IronPDF peut convertir divers formats en PDF, notamment HTML, URL et fichiers ASPX, ce qui le rend polyvalent pour différents cas d'utilisation.

Comment IronPDF gère-t-il la génération de PDF à grande échelle ?

IronPDF est optimisé pour les performances, ce qui lui permet de gérer efficacement les tâches de génération de PDF à grande échelle au sein des applications .NET.

IronPDF peut-il être utilisé dans des applications basées sur le cloud ?

Oui, IronPDF peut être utilisé dans des applications basées sur le cloud, prenant en charge le déploiement sur des plateformes telles qu'Azure et AWS pour des services PDF évolutifs.

Quelles sont les versions d'IronPDF for .NET prises en charge ?

IronPDF prend en charge plusieurs versions de .NET, notamment .NET Core et .NET Framework, ce qui garantit la compatibilité avec un large éventail de projets.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

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

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit