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

.NET PDF API un tutoriel pour les développeurs .NET

Curtis Chau
Curtis Chau
Publié:

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

Lorsqu'ils travaillent avec des applications modernes, les développeurs .NET peuvent être amenés à créer un service centralisé de génération de PDF. Qu'il s'agisse de générer des factures, des rapports, des certificats ou des contrats, disposer d'une API PDF .NET dédiée peut s'avérer utile pour gérer efficacement les fichiers PDF. Alors, comment cela peut-il améliorer vos tâches de génération de PDF ? Pour ce faire, elle assure la cohérence, la maintenabilité et l'évolutivité de vos applications bureautiques 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 en utilisant ASP.NET Core et IronPDF, une puissante bibliothèque PDF .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 ?

.NET PDF API un tutoriel pour les développeurs .NET : Image 1 - Diagramme d'architecture de l'API 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 des PDF est centralisée, ce qui facilite la maintenance et les mises à jour.
  • Architecture de microservices : Parfait pour les architectures orientées services où différentes applications ont besoin de fonctionnalités PDF.
  • Optimisation des performances : Il est plus facile d'adapter et d'optimiser un service dédié aux fichiers PDF volumineux, aux pages multiples et aux données dynamiques.
  • Agnostique du point de vue linguistique : Toute application client peut utiliser l'API quel que soit le langage de programmation.
  • Un résultat cohérent : Assure la cohérence de la mise en page, du formatage des paragraphes et du contenu des documents PDF dans l'ensemble de votre organisation.

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

.NET PDF API un tutoriel pour les développeurs .NET : Image 2 - Image 2 sur 7 liées à .NET PDF API un tutoriel pour les développeurs .NET

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. Il est construit sur un moteur de rendu Chrome, qui assure des conversions HTML-to-PDF parfaites au pixel près, souvent en quelques lignes de code seulement. 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 : Exploite le moteur de rendu de Google Chrome pour convertir avec précision des documents PDF à partir de contenus HTML, avec une prise en charge complète des images intégrées et autres ressources web.
  • Riche ensemble de fonctionnalités : Prend en charge l'édition de documents nouveaux et existants avec signatures numériques, formulaires PDF, annotations, cryptage, compression, et bien plus encore.
  • Créez des documents PDF sécurisés : Gérez les contenus PDF sensibles grâce au cryptage, aux signatures numériques et à la protection des documents.
  • Formats d'entrée multiples : Utilisez du HTML, des URL, des images, et des documents bureautiques pour créer des documents PDF.
  • Manipulation avancée : Fusionner des pages PDF, diviser des documents, appliquer des filigranes, créer des formulaires PDF interactifs et manipuler des fichiers PDF de manière programmatique.
  • Compatibilité multiplateforme : fonctionne sous Windows, Linux , macOS, Docker et les plateformes cloud.
  • Optimisation des performances : Opérations asynchrones, 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
dotnet new webapi -n PdfApiService
cd PdfApiService
SHELL

Installer IronPDF

La prochaine étape est d'ajouter 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

Structure du projet

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

.NET PDF API un tutoriel pour les développeurs .NET : Image 3 - Structure du dossier du projet

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

Tout d'abord, 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 de HTML en PDF. Utilisant le ChromePdfRenderer d'IronPDF, cette classe est configurée avec des paramètres par défaut judicieux tels que les marges de page et le rendu de l'arrière-plan afin de 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

Ensuite, 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. Lorsque quelqu'un envoie un contenu HTML à la route 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 remet à l'utilisateur sous la forme d'un fichier prêt à être téléchargé. La demande elle-même est structurée à l'aide du modèle HtmlRequest, qui contient à la fois le code 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 le téléchargement d'un fichier, la méthode GeneratePdf permet au client de choisir la manière dont 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 s'appuie sur le modèle HtmlRequest 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.

.NET PDF API un tutoriel pour les développeurs .NET : Image 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 donnée en octets PDF en arrière-plan, puis les renvoie sous la forme d'un fichier à télécharger. 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

.NET PDF API un tutoriel pour les développeurs .NET : Image 5 - URL PDF output

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

.NET PDF API un tutoriel pour les développeurs .NET : Image 6 - Sortie du filigrane à partir 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. Vous pouvez également explorer la conversion CSHTML en PDF pour les applications MVC et Razor au PDF pour les applications Blazor.

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 :

Exemple du monde réel : API de génération de facture

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 la mienne, j'ai créé 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
        {

```cs
public IActionResult GeneratePDF(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
        {

```cs
public IActionResult GeneratePDF(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

.NET PDF API un tutoriel pour les développeurs .NET : Image 7 - Sortie d'une 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"]

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 simplifie la génération de PDF dans les projets d'API Web grâce à son rendu basé sur Chrome.
  • Vous pouvez facilement ajuster votre API Web pour éditer des documents PDF existants avec les outils d'édition avancés 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 et à la mise en cache améliore l'évolutivité.
  • Vous aurez à prendre en charge des applications de bureau et des applications web avec des solutions documentaires évolutives.

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 les fonctionnalités dans votre environnement de développement.

  2. Explorer les fonctionnalités avancées - Découvrez signatures numériques, formulaires PDF, et d'autres fonctionnalités PDF avancées.

  3. Scale with confidence - Passez en revue les options de licence pour vos besoins en API de 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

À 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