UTILISATION DE IRONPDF

Comment imprimer des fichiers PDF par programmation en ASP.NET

Mis à jour:9 mars 2026

Récupérer un fichier PDF à partir d'une base de données dans ASP.NET utilisant C# nécessite trois étapes : interroger la table de la base de données pour la colonne BLOB binaire, charger les octets dans un objet PdfDocument en utilisant IronPDF, et renvoyer les octets au navigateur via une réponse Contenu du fichierResult ou File(). IronPDF gère le rendu, le filigrane et les fonctions de sécurité afin que vous puissiez vous concentrer sur la logique d'accès aux données.

Comment installer IronPDF pour ASP.NET?

Avant d'écrire le moindre code de récupération de PDF, ajoutez IronPDF à votre projet via le gestionnaire de packages NuGet :

Install-Package IronPdf

Après l'installation, définissez votre clé de licence dans Program.cs ou appsettings.json avant d'appeler toute méthode IronPDF :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

$vbLabelText $csharpLabel

IronPDF prend en charge .NET 10 , .NET 8, .NET 6 et .NET Framework 4.6.2+. Il fonctionne sous Windows, Linux et macOS sans nécessiter de dépendances supplémentaires ni d'installation de navigateur sans interface graphique. Une licence d'essai gratuite est disponible pour évaluation.

Comment configurer une table de base de données SQL Server ?

L'approche la plus courante est de stocker les fichiers PDF sous forme de données binaires dans une colonne VARBINAIRE(MAX) de SQL Server. Cela permet de conserver le document et ses métadonnées dans un seul tableau, simplifie la sauvegarde et évite la gestion des chemins d'accès au système de fichiers.

Utilisez le script SQL suivant pour créer la table de stockage :

// SQL Server table definition (run this in SSMS or via EF migrations)
// CREATE TABLE PdfDocuments (
//     Identifiant IDENTITÉ INT(1,1) PRIMARY KEY,
//     Nom de fichier NVARCHAR(255) NOT NULL,
//     Contenu du fichier VARBINAIRE(MAX) NOT NULL,
//     Téléchargé à DATETIME2 DEFAULT GETUTCDATE()
// );

// SQL Server table definition (run this in SSMS or via EF migrations)
// CREATE TABLE PdfDocuments (
//     Identifiant IDENTITÉ INT(1,1) PRIMARY KEY,
//     Nom de fichier NVARCHAR(255) NOT NULL,
//     Contenu du fichier VARBINAIRE(MAX) NOT NULL,
//     Téléchargé à DATETIME2 DEFAULT GETUTCDATE()
// );

' SQL Server table definition (run this in SSMS or via EF migrations)
' CREATE TABLE PdfDocuments (
'     Identifiant INT IDENTITY(1,1) PRIMARY KEY,
'     [Nom de fichier] NVARCHAR(255) NOT NULL,
'     [Contenu du fichier] VARBINARY(MAX) NOT NULL,
'     [Téléchargé à] DATETIME2 DEFAULT GETUTCDATE()
' )

$vbLabelText $csharpLabel

Une fois que la table existe, configurez la chaîne de connexion dans appsettings.json :

// appsettings.json snippet (not C# -- shown as reference)
// "ConnectionStrings": {
//   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
// }

// appsettings.json snippet (not C# -- shown as reference)
// "ConnectionStrings": {
//   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
// }

' appsettings.json snippet (not VB.NET -- shown as reference)
' "ConnectionStrings": {
'   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
' }

$vbLabelText $csharpLabel

Enregistrez la chaîne de connexion via l'injection de dépendance dans Program.cs :

using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddSingleton<IConfiguration>(builder.Configuration);

IronPdf.License.LicenseKey = builder.Configuration["IronPdf:LicenseKey"];

var app = builder.Build();
app.MapControllers();
app.Run();

using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddSingleton<IConfiguration>(builder.Configuration);

IronPdf.License.LicenseKey = builder.Configuration["IronPdf:LicenseKey"];

var app = builder.Build();
app.MapControllers();
app.Run();

Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
builder.Services.AddSingleton(Of IConfiguration)(builder.Configuration)

IronPdf.License.LicenseKey = builder.Configuration("IronPdf:LicenseKey")

Dim app = builder.Build()
app.MapControllers()
app.Run()

$vbLabelText $csharpLabel

Comment récupérer un fichier PDF depuis SQL Server dans ASP.NET Core?

Le schéma de récupération suit trois étapes : ouvrir une connexion, exécuter une requête SELECT avec paramètres, et lire la colonne binaire dans un byte[]. IronPDF charge ensuite ce tableau dans un objet PdfDocument pour un traitement optionnel avant de le diffuser au client.

Création du contrôleur d'API

Créez un contrôleur qui expose des points de terminaison GET pour l'affichage en ligne et le téléchargement de fichiers :

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.SqlClient;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly string _connectionString;

    public PdfController(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection")
            ?? throw new InvalidOperationException("Connection string not found.");
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetPdf(int id)
    {
        byte[] pdfBytes = await RetrievePdfBytesAsync(id);
        if (pdfBytes is null || pdfBytes.Length == 0)
            return NotFound("PDF document not found.");

        // Load into IronPDF for validation or optional modification
        using var pdfDocument = new PdfDocument(pdfBytes);

        // Inline display -- browser opens PDF viewer
        Response.Headers.Append("Content-Disposition", "inline; filename=\"document.pdf\"");
        return File(pdfDocument.BinaryData, "application/pdf");
    }

    private async Task<byte[]> RetrievePdfBytesAsync(int documentIdentifiant)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

        const string query = "SELECT Contenu du fichier FROM PdfDocuments WHERE Identifiant = @Identifiant";
        await using var command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Identifiant", documentIdentifiant);

        var result = await command.ExecuteScalarAsync();
        return result as byte[] ?? Array.Empty<byte>();
    }
}

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.SqlClient;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly string _connectionString;

    public PdfController(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection")
            ?? throw new InvalidOperationException("Connection string not found.");
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetPdf(int id)
    {
        byte[] pdfBytes = await RetrievePdfBytesAsync(id);
        if (pdfBytes is null || pdfBytes.Length == 0)
            return NotFound("PDF document not found.");

        // Load into IronPDF for validation or optional modification
        using var pdfDocument = new PdfDocument(pdfBytes);

        // Inline display -- browser opens PDF viewer
        Response.Headers.Append("Content-Disposition", "inline; filename=\"document.pdf\"");
        return File(pdfDocument.BinaryData, "application/pdf");
    }

    private async Task<byte[]> RetrievePdfBytesAsync(int documentIdentifiant)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

        const string query = "SELECT Contenu du fichier FROM PdfDocuments WHERE Identifiant = @Identifiant";
        await using var command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Identifiant", documentIdentifiant);

        var result = await command.ExecuteScalarAsync();
        return result as byte[] ?? Array.Empty<byte>();
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Data.SqlClient

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _connectionString As String

    Public Sub New(configuration As IConfiguration)
        _connectionString = configuration.GetConnectionString("DefaultConnection")
        If _connectionString Is Nothing Then
            Throw New InvalidOperationException("Connection string not found.")
        End If
    End Sub

    <HttpGet("{id}")>
    Public Async Function GetPdf(id As Integer) As Task(Of IActionResult)
        Dim pdfBytes As Byte() = Await RetrievePdfBytesAsync(id)
        If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
            Return NotFound("PDF document not found.")
        End If

        ' Load into IronPDF for validation or optional modification
        Using pdfDocument As New PdfDocument(pdfBytes)
            ' Inline display -- browser opens PDF viewer
            Response.Headers.Append("Content-Disposition", "inline; filename=""document.pdf""")
            Return File(pdfDocument.BinaryData, "application/pdf")
        End Using
    End Function

    Private Async Function RetrievePdfBytesAsync(documentIdentifiant As Integer) As Task(Of Byte())
        Await Using connection As New SqlConnection(_connectionString)
            Await connection.OpenAsync()

            Const query As String = "SELECT Contenu du fichier FROM PdfDocuments WHERE Identifiant = @Identifiant"
            Await Using command As New SqlCommand(query, connection)
                command.Parameters.AddWithValue("@Identifiant", documentIdentifiant)

                Dim result = Await command.ExecuteScalarAsync()
                Return If(TryCast(result, Byte()), Array.Empty(Of Byte)())
            End Using
        End Using
    End Function
End Class

$vbLabelText $csharpLabel

Ce contrôleur utilise des requêtes paramétrées pour prévenir l'injection SQL et await using pour bien libérer SqlConnection et SqlCommand. La classe PdfDocument valide le tableau d'octets et expose la propriété BinaryData pour le streaming.

Retour d'un fichier nommé pour téléchargement

Lorsque les utilisateurs ont besoin d'enregistrer le document plutôt que de le voir en ligne, définissez l'en-tête Content-Disposition à attachment et passez le nom du fichier original :

[HttpGet("download/{id}")]
public async Task<IActionResult> DownloadPdf(int id)
{
    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string query = "SELECT Nom de fichier, Contenu du fichier FROM PdfDocuments WHERE Identifiant = @Identifiant";
    await using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Identifiant", documentIdentifiant);

    await using var reader = await command.ExecuteReaderAsync();
    if (!await reader.ReadAsync())
        return NotFound("Document not found.");

    var fileName = reader.GetString(reader.GetOrdinal("Nom de fichier"));
    var pdfBytes = (byte[])reader["Contenu du fichier"];

    using var pdfDocument = new PdfDocument(pdfBytes);
    return File(pdfDocument.BinaryData, "application/pdf", fileName);
}

[HttpGet("download/{id}")]
public async Task<IActionResult> DownloadPdf(int id)
{
    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string query = "SELECT Nom de fichier, Contenu du fichier FROM PdfDocuments WHERE Identifiant = @Identifiant";
    await using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Identifiant", documentIdentifiant);

    await using var reader = await command.ExecuteReaderAsync();
    if (!await reader.ReadAsync())
        return NotFound("Document not found.");

    var fileName = reader.GetString(reader.GetOrdinal("Nom de fichier"));
    var pdfBytes = (byte[])reader["Contenu du fichier"];

    using var pdfDocument = new PdfDocument(pdfBytes);
    return File(pdfDocument.BinaryData, "application/pdf", fileName);
}

Imports System.Data.SqlClient
Imports Microsoft.AspNetCore.Mvc

<HttpGet("download/{id}")>
Public Async Function DownloadPdf(id As Integer) As Task(Of IActionResult)
    Await Using connection As New SqlConnection(_connectionString)
        Await connection.OpenAsync()

        Const query As String = "SELECT Nom de fichier, Contenu du fichier FROM PdfDocuments WHERE Identifiant = @Identifiant"
        Await Using command As New SqlCommand(query, connection)
            command.Parameters.AddWithValue("@Identifiant", id)

            Await Using reader As SqlDataReader = Await command.ExecuteReaderAsync()
                If Not Await reader.ReadAsync() Then
                    Return NotFound("Document not found.")
                End If

                Dim fileName As String = reader.GetString(reader.GetOrdinal("Nom de fichier"))
                Dim pdfBytes As Byte() = CType(reader("Contenu du fichier"), Byte())

                Using pdfDocument As New PdfDocument(pdfBytes)
                    Return File(pdfDocument.BinaryData, "application/pdf", fileName)
                End Using
            End Using
        End Using
    End Using
End Function

$vbLabelText $csharpLabel

Passer fileName comme troisième argument à File() définit automatiquement l'en-tête Content-Disposition à attachment. ASP.NET Core gère correctement l'encodage des noms de fichiers contenant des espaces.

Comment ajouter un filigrane à un PDF récupéré ?

L'une des opérations de post-récupération les plus pratiques consiste à apposer un filigrane sur chaque page avant de diffuser le document. Ceci est utile pour les rapports confidentiels, les documents de travail ou tout fichier nécessitant un marquage de sécurité visible.

Appliquer un filigrane HTML avec IronPDF

L'API de filigrane d'IronPDF accepte n'importe quelle chaîne HTML, ce qui signifie que vous pouvez styliser le texte du filigrane à l'aide de CSS en ligne. Réglez l'opacité à un niveau suffisamment bas pour que le contenu sous-jacent reste lisible :

[HttpGet("watermarked/{id}")]
public async Task<IActionResult> GetWatermarkedPdf(int id)
{
    byte[] pdfBytes = await RetrievePdfBytesAsync(id);
    if (pdfBytes is null || pdfBytes.Length == 0)
        return NotFound("PDF document not found.");

    using var pdfDocument = new PdfDocument(pdfBytes);

    // HTML watermark applied to every page
    string watermarkHtml = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>";
    pdfDocument.ApplyWatermark(
        watermarkHtml,
        rotation: 30,
        verticalAlignment: VerticalAlignment.Middle,
        horizontalAlignment: HorizontalAlignment.Center
    );

    return File(pdfDocument.BinaryData, "application/pdf");
}

[HttpGet("watermarked/{id}")]
public async Task<IActionResult> GetWatermarkedPdf(int id)
{
    byte[] pdfBytes = await RetrievePdfBytesAsync(id);
    if (pdfBytes is null || pdfBytes.Length == 0)
        return NotFound("PDF document not found.");

    using var pdfDocument = new PdfDocument(pdfBytes);

    // HTML watermark applied to every page
    string watermarkHtml = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>";
    pdfDocument.ApplyWatermark(
        watermarkHtml,
        rotation: 30,
        verticalAlignment: VerticalAlignment.Middle,
        horizontalAlignment: HorizontalAlignment.Center
    );

    return File(pdfDocument.BinaryData, "application/pdf");
}

Imports Microsoft.AspNetCore.Mvc

<HttpGet("watermarked/{id}")>
Public Async Function GetWatermarkedPdf(id As Integer) As Task(Of IActionResult)
    Dim pdfBytes As Byte() = Await RetrievePdfBytesAsync(id)
    If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
        Return NotFound("PDF document not found.")
    End If

    Using pdfDocument As New PdfDocument(pdfBytes)
        ' HTML watermark applied to every page
        Dim watermarkHtml As String = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>"
        pdfDocument.ApplyWatermark(
            watermarkHtml,
            rotation:=30,
            verticalAlignment:=VerticalAlignment.Middle,
            horizontalAlignment:=HorizontalAlignment.Center
        )

        Return File(pdfDocument.BinaryData, "application/pdf")
    End Using
End Function

$vbLabelText $csharpLabel

La méthode ApplyWatermark accepte le HTML et le CSS standard, vous permettant de contrôler pleinement la police, la couleur, l'opacité et la position. Le filigrane est automatiquement appliqué à toutes les pages du document. Pour des fonctionnalités supplémentaires de manipulation de fichiers PDF , notamment l'ajout d'images, d'en-têtes et de pieds de page, ou la fusion de plusieurs documents, consultez la documentation IronPDF .

Comment stocker les fichiers PDF téléchargés dans SQL Server ?

Pour effectuer l'aller-retour, il faut un point de terminaison de téléchargement qui lit les fichiers de formulaire entrants et les écrit dans la base de données. Associé aux points de terminaison de récupération ci-dessus, cela forme un système complet de gestion de documents :

[HttpPost("upload")]
public async Task<IActionResult> UploadPdf(IFormFile file)
{
    if (file is null || file.Length == 0)
        return BadRequest("No file uploaded.");

    if (!file.Type de contenu.Equals("application/pdf", StringComparison.OrdinalIgnoreCase))
        return BadRequest("Only PDF files are accepted.");

    using var memoryStream = new MemoryStream();
    await file.CopyToAsync(memoryStream);
    byte[] pdfBytes = memoryStream.ToArray();

    // Validate using IronPDF before storage
    using var pdfDocument = new PdfDocument(pdfBytes);

    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string insertQuery = @"
        INSERT INTO PdfDocuments (Nom de fichier, Contenu du fichier)
        VALUES (@Nom de fichier, @Contenu du fichier);
        SELECT SCOPE_IDENTITY();";

    await using var command = new SqlCommand(insertQuery, connection);
    command.Parameters.AddWithValue("@Nom de fichier", file.Nom de fichier);
    command.Parameters.AddWithValue("@Contenu du fichier", pdfDocument.BinaryData);

    var newIdentifiant = Convert.ToInt32(await command.ExecuteScalarAsync());
    return Ok(new { id = newIdentifiant, fileName = file.Nom de fichier });
}

[HttpPost("upload")]
public async Task<IActionResult> UploadPdf(IFormFile file)
{
    if (file is null || file.Length == 0)
        return BadRequest("No file uploaded.");

    if (!file.Type de contenu.Equals("application/pdf", StringComparison.OrdinalIgnoreCase))
        return BadRequest("Only PDF files are accepted.");

    using var memoryStream = new MemoryStream();
    await file.CopyToAsync(memoryStream);
    byte[] pdfBytes = memoryStream.ToArray();

    // Validate using IronPDF before storage
    using var pdfDocument = new PdfDocument(pdfBytes);

    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string insertQuery = @"
        INSERT INTO PdfDocuments (Nom de fichier, Contenu du fichier)
        VALUES (@Nom de fichier, @Contenu du fichier);
        SELECT SCOPE_IDENTITY();";

    await using var command = new SqlCommand(insertQuery, connection);
    command.Parameters.AddWithValue("@Nom de fichier", file.Nom de fichier);
    command.Parameters.AddWithValue("@Contenu du fichier", pdfDocument.BinaryData);

    var newIdentifiant = Convert.ToInt32(await command.ExecuteScalarAsync());
    return Ok(new { id = newIdentifiant, fileName = file.Nom de fichier });
}

Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Data.SqlClient
Imports IronPdf

<HttpPost("upload")>
Public Async Function UploadPdf(file As IFormFile) As Task(Of IActionResult)
    If file Is Nothing OrElse file.Length = 0 Then
        Return BadRequest("No file uploaded.")
    End If

    If Not file.ContentType.Equals("application/pdf", StringComparison.OrdinalIgnoreCase) Then
        Return BadRequest("Only PDF files are accepted.")
    End If

    Using memoryStream As New MemoryStream()
        Await file.CopyToAsync(memoryStream)
        Dim pdfBytes As Byte() = memoryStream.ToArray()

        ' Validate using IronPDF before storage
        Using pdfDocument As New PdfDocument(pdfBytes)

            Await Using connection As New SqlConnection(_connectionString)
                Await connection.OpenAsync()

                Const insertQuery As String = "
                    INSERT INTO PdfDocuments (FileName, FileContent)
                    VALUES (@FileName, @FileContent);
                    SELECT SCOPE_IDENTITY();"

                Await Using command As New SqlCommand(insertQuery, connection)
                    command.Parameters.AddWithValue("@FileName", file.FileName)
                    command.Parameters.AddWithValue("@FileContent", pdfDocument.BinaryData)

                    Dim newId As Integer = Convert.ToInt32(Await command.ExecuteScalarAsync())
                    Return Ok(New With {.id = newId, .fileName = file.FileName})
                End Using
            End Using
        End Using
    End Using
End Function

$vbLabelText $csharpLabel

Utiliser PdfDocument pour valider avant le stockage garantit que seuls les fichiers PDF analysables et bien formés entrent dans la base de données. Si le tableau d'octets est corrompu ou tronqué, IronPDF lance une exception que vous pouvez intercepter et renvoyer sous forme de réponse 400 Bad Request.

Quels sont les principaux types de tables et de colonnes pour le stockage PDF ?

Le schéma que vous utilisez influe sur les performances des requêtes et l'efficacité du stockage. Le tableau ci-dessous présente la configuration de colonnes recommandée pour SQL Server :

Schéma SQL Server recommandé pour le stockage BLOB PDF
Colonne	Type de données	Objectif
Identifiant	IDENTITÉ INT	Clé primaire, auto-incrémentée
Nom de fichier	NVARCHAR(255)	Nom de fichier d'origine pour les en-têtes de téléchargement
Contenu du fichier	VARBINAIRE(MAX)	Données binaires PDF brutes (BLOB)
Type de contenu	NVARCHAR(100)	Type MIME, par exemple, application/pdf
Taille du fichier (octets)	BIGINT	Taille stockée pour la gestion des quotas
Téléchargé à	DATETIME2	Horodatage UTC pour l'audit
Téléchargé par	NVARCHAR(100)	Identifiantentité de l'utilisateur pour le contrôle d'accès

Pour les systèmes à grande échelle nécessitant le streaming de fichiers SQL Server, Microsoft présente la fonctionnalité FILESTREAM comme une alternative permettant de stocker de gros BLOB sur le système de fichiers tout en restant interrogeable via T-SQL. Cependant, pour la plupart des applications ASP.NET servant des documents jusqu'à quelques centaines de mégaoctets, le stockage VARBINAIRE(MAX) en ligne fonctionne bien et simplifie le déploiement.

Comment gérez-vous les erreurs et optimisez-vous les performances ?

Pour une récupération fiable des fichiers PDF en production, il est nécessaire de gérer les erreurs à chaque niveau : base de données, IronPDF et réponse HTTP. Le tableau ci-dessous résume les principales pratiques :

Gestion des erreurs et modèles de performance pour la récupération de fichiers PDF
Préoccupation	Recommandation	Raison
Élimination des connexions	`await using` des instructions	Empêche l'épuisement du pool de connexions
Destruction de documents PDF	`using` des instructions	Libère rapidement la mémoire non gérée
Injection SQL	Requêtes paramétrées uniquement	Empêche les entrées malveillantes de modifier les requêtes
validation du type de fichier	Vérifiez le type MIME et les octets magiques	Bloque les chargements non PDF avant le stockage
Gestion des fichiers volumineux	Réponse du flux avec `FileStreamResult`	Évite de charger l'intégralité du fichier dans la mémoire du serveur
Mise en cache	Utilisez `IMemoryCache` ou `IDistributedCache`	Réduit les allers-retours répétés vers la base de données
opérations asynchrones	`async` / `await` tout au long	Maintient les threads libres pendant les attentes disque et réseau.

Pour la gestion des chaînes de connexion, stockez la valeur dans appsettings.json et ne la codez jamais en dur dans les fichiers source. Utilisez la gestion des secrets intégrée d' ASP.NET Core lors du développement local, et Azure Key Vault ou AWS Secrets Manager en production. Ne jamais consigner les chaînes de connexion ou les clés de licence dans un système de contrôle de version.

Lors de la diffusion de fichiers PDF volumineux, envisagez de renvoyer un FileStreamResult soutenu par un MemoryStream plutôt que de charger tout le tableau d'octets en mémoire. Pour les documents très volumineux (plus de 100 Mo), l' API FILESTREAM de SQL Server permet la diffusion par blocs directement depuis le système de fichiers.

Mise en cache des documents fréquemment consultés

Si certains fichiers PDF sont demandés à plusieurs reprises -- par exemple, un document de conditions générales ou un catalogue de produits -- mettre en cache le tableau d'octets dans IMemoryCache évite les allers-retours répétés à la base de données. Enregistrez IMemoryCache dans Program.cs avec builder.Services.AddMemoryCache(), puis injectez-le dans le contrôleur et vérifiez le cache avant d'interroger la base de données. Définissez une date d'expiration absolue qui corresponde à la fréquence de mise à jour prévue des documents. Lorsqu'un document est mis à jour, supprimez l'entrée mise en cache par clé afin que la requête suivante récupère la nouvelle version.

Pour les scénarios distribués -- tels qu'un déploiement équilibré avec plusieurs instances de serveur -- remplacez IMemoryCache par IDistributedCache soutenu par Redis ou SQL Server. Les abstractions de cache distribué d' ASP.NET Core permettent de conserver un code de contrôleur quasiment identique ; seule l'enregistrement dans Program.cs change.

Comment déployer la récupération de PDF avec IronPDF sur plusieurs plateformes ?

IronPDF fonctionne sous Linux, Windows et macOS sans nécessiter d'installation séparée de Chromium ni aucune modification de configuration. Le même package NuGet cible toutes les plateformes, votre contrôleur PDF fonctionne donc de manière identique, que vous le déployiez sur :

Serveur Windows avec IIS
Conteneurs Ubuntu sur Docker ou Kubernetes
Azure App Service (Linux ou Windows)
AWS Elastic Beanstalk

Déploiement sur Docker et Linux

Pour les déploiements Docker, ajoutez les dépendances IronPDF à votre Dockerfile. La documentation Linux IronPDF fournit les paquets apt exacts requis pour les images de base Debian et Alpine. Un Dockerfile multi-étapes classique installe les dépendances du système d'exploitation lors de la création de l'image d'exécution, puis y copie l'application ASP.NET publiée. Pour Azure, le guide de déploiement Azure détaille la configuration d'App Service, notamment les paramètres de mémoire et de processeur nécessaires au rendu PDF à grande échelle.

Comme IronPDF intègre son propre moteur de rendu basé sur Chromium, vous n'avez pas besoin d'installer un navigateur séparé sur le serveur. Cela simplifie considérablement la configuration des conteneurs Linux par rapport aux solutions qui nécessitent un navigateur système. L'équipe IronPDF effectue des tests sur les images de base Linux les plus courantes à chaque version, vous pouvez donc être sûr qu'un conteneur Alpine ou Debian fonctionnera immédiatement.

Utilisation d'Entity Framework Core au lieu d' .NET

IronPDF s'intègre également à Entity Framework Core comme alternative à .NET brut. Si votre projet utilise déjà EF Core, vous pouvez mapper la colonne Contenu du fichier à une propriété byte[] sur une classe de modèle et laisser EF gérer la génération de requêtes. Cette approche réduit considérablement le code répétitif et facilite l'ajout de fonctionnalités de filtrage, de pagination et d'audit via le fournisseur LINQ d'EF.

En contrepartie, EF Core charge l'intégralité du BLOB en mémoire dans le cadre du graphe d'entités. Pour les fichiers PDF très volumineux, envisagez d'utiliser ADO.NET brut ou la méthode FromSql d'EF Core avec une projection qui sélectionne uniquement la colonne de tableau d'octets plutôt que l'entité complète.

Quelles sont vos prochaines étapes ?

Récupérer les fichiers PDF d'une base de données SQL Server dans ASP.NET Core en utilisant C# et IronPDF suit un schéma clair : interroger la colonne BLOB avec un SELECT paramétré, charger les octets dans un PdfDocument, et retourner les données binaires avec le bon en-tête Content-Disposition. IronPDF permet en plus de valider, d'ajouter un filigrane, de fusionner ou de sécuriser des documents avant qu'ils ne quittent votre serveur.

Pour aller plus loin avec les fonctionnalités de gestion de documents d'IronPDF, consultez ces ressources :

IronPDF : Génération de PDF à partir de HTML -- générez des PDF dynamiquement et stockez-les directement dans votre base de données
IronPDF Fusionner et diviser des PDF -- combiner les documents récupérés en une seule réponse
Sécurité et autorisations IronPDF : ajoutez une protection par mot de passe avant de diffuser des documents sensibles.
Tutoriel IronPDF : convertir le contenu HTML en PDF pour l'archivage
IronPDF PDF Stamping -- appliquer des tampons de texte et d'image aux fichiers récupérés
Licences IronPDF : consultez les différents niveaux de licence pour le développement, la préproduction et la production.

Commencez par une licence d'essai gratuite IronPDF pour tester toutes les fonctionnalités sans restriction. L'essai produit des résultats marqués d'un filigrane ; Supprimez le filigrane en appliquant une clé de licence payante. La documentation de référence API complète et des exemples de code sont disponibles sur le site web IronPDF pour chaque méthode utilisée dans cet article.

Si votre projet utilise déjà Entity Framework Core, le guide d'intégration IronPDF avec EF Core explique comment remplacer le code .NET brut par des modèles d'entités tout en conservant le même pipeline de traitement IronPDF . Pour les équipes travaillant avec .NET 10 et les dernières fonctionnalités ASP.NET Core , les mêmes modèles décrits ici fonctionnent sans modification : IronPDF est compatible avec toutes les versions LTS et STS de .NET .

Consultez la page des tarifs IronPDF pour trouver le niveau de licence adapté à votre déploiement. Une seule licence de développeur couvre le développement et les tests locaux ; Des licences de redistribution sont disponibles pour les produits SaaS et les déploiements sur site avec plusieurs serveurs.

Questions Fréquemment Posées

Qu'est-ce que IronPDF ?

IronPDF est une bibliothèque .NET qui permet aux développeurs de créer, de modifier et d'extraire du contenu de fichiers PDF dans des applications C#.

Comment puis-je récupérer un fichier PDF à partir d'une base de données en utilisant ASP.NET ?

Pour récupérer un fichier PDF à partir d'une base de données en ASP.NET, vous pouvez utiliser le code C# pour interroger la base de données et lire les données PDF dans un tableau d'octets. Ce tableau d'octets peut ensuite être utilisé avec IronPDF pour rendre ou manipuler le PDF selon les besoins.

Pourquoi devrais-je utiliser IronPDF pour gérer les PDF dans mon application ASP.NET ?

IronPDF offre un large éventail de fonctionnalités pour gérer les PDFs, y compris la génération de PDF, la conversion à partir de HTML, et la manipulation. Il s'intègre à ASP.NET et fournit une API facile à utiliser pour travailler avec des PDFs.

Quelles sont les conditions préalables à l'utilisation d'IronPDF for .NET ?

Pour utiliser IronPDF en ASP.NET, vous devez disposer d'un environnement de développement .NET, tel que Visual Studio, et inclure la bibliothèque IronPDF dans votre projet via le Package Manager NuGet.

IronPDF peut-il être utilisé pour modifier des fichiers PDF existants ?

Oui, IronPDF peut être utilisé pour modifier des fichiers PDF existants. Il permet des modifications telles que l'ajout de texte ou d'images, la fusion de documents, etc.

Est-il possible de convertir HTML en PDF avec IronPDF ?

Oui, IronPDF peut convertir du contenu HTML directement au format PDF, ce qui permet de générer facilement des PDF à partir de pages web ou d'autres contenus HTML.

Comment gérer les fonctions de sécurité des PDF à l'aide d'IronPDF ?

IronPDF prend en charge diverses fonctions de sécurité pour les PDF, notamment la protection par mot de passe et la définition de permissions pour contrôler l'accès aux documents et leur modification.

Quels types de bases de données sont compatibles avec IronPDF pour la récupération de PDF ?

IronPDF peut fonctionner avec n'importe quelle base de données capable de stocker des données binaires, comme SQL Server, MySQL ou PostgreSQL, pour récupérer et manipuler des fichiers PDF.

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

Mise en avant du client :

Projecteur sur les Développeurs:

Webinaires:

Essai gratuit de 30 jours

Comment imprimer des fichiers PDF par programmation en ASP.NET

Comment installer IronPDF pour ASP.NET?

Comment configurer une table de base de données SQL Server ?

Comment récupérer un fichier PDF depuis SQL Server dans ASP.NET Core?

Création du contrôleur d'API

Retour d'un fichier nommé pour téléchargement

Comment ajouter un filigrane à un PDF récupéré ?

Appliquer un filigrane HTML avec IronPDF

Comment stocker les fichiers PDF téléchargés dans SQL Server ?

Quels sont les principaux types de tables et de colonnes pour le stockage PDF ?

Comment gérez-vous les erreurs et optimisez-vous les performances ?

Mise en cache des documents fréquemment consultés

Comment déployer la récupération de PDF avec IronPDF sur plusieurs plateformes ?

Déploiement sur Docker et Linux

Utilisation d'Entity Framework Core au lieu d' .NET

Quelles sont vos prochaines étapes ?

Questions Fréquemment Posées

Qu'est-ce que IronPDF ?

Comment puis-je récupérer un fichier PDF à partir d'une base de données en utilisant ASP.NET ?

Pourquoi devrais-je utiliser IronPDF pour gérer les PDF dans mon application ASP.NET ?

Quelles sont les conditions préalables à l'utilisation d'IronPDF for .NET ?

IronPDF peut-il être utilisé pour modifier des fichiers PDF existants ?

Est-il possible de convertir HTML en PDF avec IronPDF ?

Comment gérer les fonctions de sécurité des PDF à l'aide d'IronPDF ?

Quels types de bases de données sont compatibles avec IronPDF pour la récupération de PDF ?

Votre clé de licence a été livrée dans votre boîte de réception

Votre demande de démo est en cours.

Équipe de soutien Iron

Essai gratuit de 30 jours

Comment imprimer des fichiers PDF par programmation en ASP.NET

Comment installer IronPDF pour ASP.NET?

Comment configurer une table de base de données SQL Server ?

Comment récupérer un fichier PDF depuis SQL Server dans ASP.NET Core?

Création du contrôleur d'API

Retour d'un fichier nommé pour téléchargement

Comment ajouter un filigrane à un PDF récupéré ?

Appliquer un filigrane HTML avec IronPDF

Comment stocker les fichiers PDF téléchargés dans SQL Server ?

Quels sont les principaux types de tables et de colonnes pour le stockage PDF ?

Comment gérez-vous les erreurs et optimisez-vous les performances ?

Mise en cache des documents fréquemment consultés

Comment déployer la récupération de PDF avec IronPDF sur plusieurs plateformes ?

Déploiement sur Docker et Linux

Utilisation d'Entity Framework Core au lieu d' .NET

Quelles sont vos prochaines étapes ?

Questions Fréquemment Posées

Qu'est-ce que IronPDF ?

Comment puis-je récupérer un fichier PDF à partir d'une base de données en utilisant ASP.NET ?

Pourquoi devrais-je utiliser IronPDF pour gérer les PDF dans mon application ASP.NET ?

Quelles sont les conditions préalables à l'utilisation d'IronPDF for .NET ?

IronPDF peut-il être utilisé pour modifier des fichiers PDF existants ?

Est-il possible de convertir HTML en PDF avec IronPDF ?

Comment gérer les fonctions de sécurité des PDF à l'aide d'IronPDF ?

Quels types de bases de données sont compatibles avec IronPDF pour la récupération de PDF ?

Articles connexes

Générer des relevés de compte mensuels au format PDF

Tutoriel C# PDFWriter pour les développeurs .NET 10

Visualiseur PDF pour ASP.NET : Comment afficher des PDF dans .NET 10

Étape suivante : Commencer l'essai gratuit de 30 jours

Thank You

Étape suivante : Commencer l'essai gratuit de 30 jours

Vous voulez déployer IronSuite sur un projet en direct GRATUITEMENT ?

Qu'est-ce qui est inclus ?

Votre clé de licence a été livrée dans votre boîte de réception

Votre demande de démo est en cours.

De confiance par des millions d'ingénieurs dans le monde entier

Équipe de soutien Iron