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

Créer une API PDF .NET avec IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

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.

Pourquoi construire une API PDF dédiée ?

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 en un seul endroit, facilitant la maintenance et les mises à jour.
  • Architecture microservices : Parfait pour les architectures orientées services où différentes applications ont besoin de capacités PDF.
  • Optimisation des performances : Plus facile de dimensionner et d'optimiser un service dédié pour les fichiers PDF volumineux, les pages multiples et les données dynamiques.
  • Indépendant de la langue : Toute application cliente peut consommer l'API quel que soit le langage de programmation.
  • Sortie cohérente : Assure que tous les documents PDF de votre organisation conservent une mise en page cohérente, une mise en forme de paragraphe et un contenu 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 : La bibliothèque PDF complète en .NET

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 :

  • Rendu basé sur Chrome : Utilise le moteur de rendu de Google Chrome pour convertir les documents PDF à partir du contenu HTML avec précision, avec un support complet pour les images intégrées et autres ressources web.
  • Rich Feature Set: Supports the editing of new and existing documents with digital signatures, PDF forms, annotations, encryption, compression, and more
  • Créer des documents PDF sécurisés : Gérer du contenu PDF sensible avec cryptage, signatures numériques, et protection des documents.
  • Multiple Input Formats: Use HTML, URLs, images, and Office documents to create PDF documents
  • Manipulation avancée : Fusionner des pages PDF, diviser des documents, appliquer des filigranes, créer des formulaires PDF interactifs, et manipuler des fichiers PDF par programmation.
  • Cross-Platform Support: Works on Windows, Linux, macOS, Docker, and cloud platforms
  • Performances optimisées : Opérations Async, gestion efficace de la mémoire, et rendu rapide.

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.

Prérequis

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

Création du projet

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 PdfApiService

Installer IronPDF

La prochaine étape est d'ajouter IronPDF à votre projet via NuGet :

dotnet add package IronPdf

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

Install-Package IronPdf

Structure du projet

Un aspect essentiel du développement en C# est de maintenir un dossier de projet propre et bien structuré. Par exemple :

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 :

Création du service PDF

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
{
    byte[] GeneratePdfFromHtml(string htmlContent);
    byte[] GeneratePdfFromUrl(string url);
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Dans 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;
    }
}
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;
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Création du contrôleur

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}");
        }
    }
}
// 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}");
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Puis, 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.cs
public class HtmlRequest
{
    public string HtmlContent { get; set; }
    public string FileName { get; set; } = "document.pdf";
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Enregistrement des 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();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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);
     }
 }
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Comment créer une API PDF .NET à l'aide d'IronPDF : Figure 4 - Swagger UI

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 :

Conversion d'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; }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Sortie

Comment créer une API PDF .NET à l'aide d'IronPDF : Figure 5 - Sortie PDF URL

Ajout de 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;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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

Sortie de filigrane

Comment créer une API PDF .NET à l'aide d'IronPDF : Figure 6 - Sortie de filigrane de l'exemple de code ci-dessus

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";
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Pour des scénarios de modèle plus avancés avec Razor, Handlebars, ou d'autres moteurs, consultez la documentation HTML vers PDF d'IronPDF. You can also explore CSHTML to PDF conversion for MVC applications and Razor to PDF for Blazor applications.

Comment optimiser les performances ?

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

Opérations asynchrones

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 :

  • 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 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;
    });
}
public async Task<byte[]> GeneratePdfFromHtmlAsync(string htmlContent)
{
    return await Task.Run(() => 
    {
        var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
        return pdf.BinaryData;
    });
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Options de rendu

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 timeout
_renderer.RenderingOptions.EnableJavaScript = false; // If JS not needed
_renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
_renderer.RenderingOptions.RenderDelay = 0; // Remove if no JS
_renderer.RenderingOptions.Timeout = 30; // Set reasonable timeout
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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 :

// Middleware/ApiKeyMiddleware.cs
public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private const string ApiKeyHeader = "X-API-Key";
    public ApiKeyMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        if (!context.Request.Headers.TryGetValue(ApiKeyHeader, out var apiKey))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("API Key required");
            return;
        }
        // Validate API key (in production, check against database)
        var validApiKey = context.RequestServices
            .GetRequiredService<IConfiguration>()["ApiKey"];
        if (apiKey != validApiKey)
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Invalid API Key");
            return;
        }
        await _next(context);
    }
}
// In Program.cs
app.UseMiddleware<ApiKeyMiddleware>();
// Middleware/ApiKeyMiddleware.cs
public class ApiKeyMiddleware
{
    private readonly RequestDelegate _next;
    private const string ApiKeyHeader = "X-API-Key";
    public ApiKeyMiddleware(RequestDelegate next)
    {
        _next = next;
    }
    public async Task InvokeAsync(HttpContext context)
    {
        if (!context.Request.Headers.TryGetValue(ApiKeyHeader, out var apiKey))
        {
            context.Response.StatusCode = 401;
            await context.Response.WriteAsync("API Key required");
            return;
        }
        // Validate API key (in production, check against database)
        var validApiKey = context.RequestServices
            .GetRequiredService<IConfiguration>()["ApiKey"];
        if (apiKey != validApiKey)
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Invalid API Key");
            return;
        }
        await _next(context);
    }
}
// In Program.cs
app.UseMiddleware<ApiKeyMiddleware>();
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Pour des scénarios d'authentification plus avancés, envisagez :

Real-World Exemple : Invoice Generation API

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.

Commencez avec IronPDF maintenant.
green arrow pointer

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 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;
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ensuite, 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>";
    }
}
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>";
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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}");
        }
    }
}
[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}");
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Sortie de facture

Comment créer une API PDF .NET à l'aide d'IronPDF : Figure 7 - Sortie de facture PDF

Considérations sur le déploiement en conteneur

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 :

Dockerfile de base

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"]
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"]
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Pour des guides de déploiement détaillés pour votre API PDF .NET, voir :

Meilleures pratiques de gestion des erreurs

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));
    }
}
// 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));
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Pour des scénarios de dépannage spécifiques à IronPDF, référez-vous au guide de dépannage IronPDF.

Conclusion

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 rend la génération de PDF dans les projets d'API Web simple grâce à son rendu basé sur Chrome
  • Vous pouvez facilement ajuster votre API Web pour éditer des documents PDF existants avec les outils avancés d'édition d'IronPDF
  • Les principes de conception RESTful garantissent que votre API PDF est intuitive et maintenable
  • Une gestion correcte des erreurs et des mesures de sécurité sont essentielles pour la production
  • L'optimisation des performances par des opérations asynchrones et la mise en cache améliorent la scalabilité
  • Vous aurez un support pour les applications de bureau et web avec des solutions documentaires scalables

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.

Prochaines étapes

Prêt à mettre en œuvre IronPDF dans votre API PDF en production .NET ? Voici vos prochaines actions :

  1. Commencez votre essai gratuit - Testez IronPDF avec toutes ses fonctionnalités dans votre environnement de développement
  2. Explore advanced features - Check out digital signatures, PDF forms, and other advanced PDF features
  3. Montez en puissance avec confiance - Consultez les options de licence pour vos besoins d'API en production

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

Qu'est-ce qu'une API PDF .NET?

Une API PDF .NET est une bibliothèque qui permet aux développeurs de créer, éditer et extraire du contenu PDF dans des applications .NET. Elle simplifie les tâches complexes liées aux PDF et assure une gestion efficace des fichiers PDF.

Comment une API PDF .NET peut-elle bénéficier à mon application?

Une API PDF .NET peut améliorer votre application en apportant cohérence, maintenabilité et évolutivité dans la gestion des fichiers PDF, tels que la génération de factures, de rapports, de certificats ou de contrats.

Quels sont les cas d'utilisation courants pour une API PDF .NET?

Les cas d'utilisation courants pour une API PDF .NET incluent la génération de factures, la création de rapports, la production de certificats et la gestion des contrats dans des applications de bureau et web.

Comment IronPDF simplifie-t-il les tâches de génération de PDF?

IronPDF simplifie les tâches de génération de PDF en offrant une bibliothèque robuste qui permet une gestion facile du contenu des documents, des pages PDF et des champs de formulaire, facilitant ainsi la maintenance et l'évolutivité des applications.

IronPDF peut-il gérer les champs de formulaire PDF?

Oui, IronPDF peut gérer efficacement les champs de formulaire PDF, permettant aux développeurs de créer, remplir et extraire des données de formulaires au sein des documents PDF.

IronPDF est-il adapté aux applications de bureau et web?

Absolument, IronPDF est conçu pour fonctionner de manière transparente à la fois sur les applications de bureau et web, offrant une solution cohérente et évolutive pour la gestion des PDF.

Qu'est-ce qui rend IronPDF un choix fiable pour les développeurs .NET?

IronPDF est un choix fiable pour les développeurs .NET en raison de sa facilité d'utilisation, de ses fonctionnalités complètes et de sa capacité à rationaliser les tâches liées aux PDF, ce qui améliore la productivité et les performances des applications.

IronPDF prend-il en charge les capacités d'extraction de PDF?

Oui, IronPDF prend en charge les capacités d'extraction de PDF, vous permettant d'extraire du texte, des images et d'autres données des documents PDF de manière efficace.

Comment IronPDF améliore-t-il l'évolutivité dans la gestion des PDF?

IronPDF améliore l'évolutivité en fournissant un service centralisé de génération de PDF qui peut répondre à des demandes croissantes sans sacrifier les performances, ce qui le rend idéal pour les applications en croissance.

Quel type de support IronPDF offre-t-il pour les applications .NET?

IronPDF offre un support étendu pour les applications .NET, y compris une documentation détaillée, des exemples de code et une équipe de support réactive pour aider les développeurs à intégrer des fonctionnalités PDF.

IronPDF est-il entièrement compatible avec .NET 10 ?

Oui, IronPDF est entièrement compatible avec .NET 10. Il prend en charge toutes les améliorations de performances, de langage et d'exécution introduites par .NET 10 et fonctionne immédiatement dans les projets .NET 10, tout comme avec les versions précédentes telles que .NET 6, 7, 8 et 9.

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. Démarrer l'essai gratuit