Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Récupérer un fichier PDF à partir d'une base de données Apr .NET
UTILISATION DE IRONPDF

Comment récupérer des fichiers PDF à partir d'une base de données dans ASP.NET en utilisant C#

Curtis Chau
Curtis Chau
Mis à jour:

La récupération d'un fichier PDF à partir d'une base de données dans ASP.NET en utilisant C# nécessite trois étapes : interroger la table de base de données pour la colonne BLOB binaire, charger les octets dans un objet PdfDocument à l'aide IronPDF et renvoyer les octets au navigateur via une réponse FileContentResult 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
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Après l'installation, définissez votre clé de licence dans Program.cs ou appsettings.json avant d'appeler une 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 consiste à stocker les fichiers PDF sous forme de données binaires dans une colonne SQL Server VARBINARY(MAX). 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 (
//     Id INT IDENTITY(1,1) PRIMARY KEY,
//     FileName NVARCHAR(255) NOT NULL,
//     FileContent VARBINARY(MAX) NOT NULL,
//     UploadedAt DATETIME2 DEFAULT GETUTCDATE()
// );
// SQL Server table definition (run this in SSMS or via EF migrations)
// CREATE TABLE PdfDocuments (
//     Id INT IDENTITY(1,1) PRIMARY KEY,
//     FileName NVARCHAR(255) NOT NULL,
//     FileContent VARBINARY(MAX) NOT NULL,
//     UploadedAt DATETIME2 DEFAULT GETUTCDATE()
// );
$vbLabelText   $csharpLabel

Une fois la table créée, 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épendances 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 modèle de récupération suit trois étapes : ouvrir une connexion, exécuter une requête SELECT paramétrée 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 documentId)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

        const string query = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id";
        await using var command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Id", documentId);

        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 documentId)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

        const string query = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id";
        await using var command = new SqlCommand(query, connection);
        command.Parameters.AddWithValue("@Id", documentId);

        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(documentId As Integer) As Task(Of Byte())
        Await Using connection As New SqlConnection(_connectionString)
            Await connection.OpenAsync()

            Const query As String = "SELECT FileContent FROM PdfDocuments WHERE Id = @Id"
            Await Using command As New SqlCommand(query, connection)
                command.Parameters.AddWithValue("@Id", documentId)

                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 empêcher l'injection SQL et await using pour se débarrasser correctement de 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 doivent enregistrer le document plutôt que de le visualiser en ligne, définissez l'en-tête Content-Disposition sur attachment et transmettez le nom de fichier d'origine :

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

    const string query = "SELECT FileName, FileContent FROM PdfDocuments WHERE Id = @Id";
    await using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Id", documentId);

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

    var fileName = reader.GetString(reader.GetOrdinal("FileName"));
    var pdfBytes = (byte[])reader["FileContent"];

    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 FileName, FileContent FROM PdfDocuments WHERE Id = @Id";
    await using var command = new SqlCommand(query, connection);
    command.Parameters.AddWithValue("@Id", documentId);

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

    var fileName = reader.GetString(reader.GetOrdinal("FileName"));
    var pdfBytes = (byte[])reader["FileContent"];

    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 FileName, FileContent FROM PdfDocuments WHERE Id = @Id"
        Await Using command As New SqlCommand(query, connection)
            command.Parameters.AddWithValue("@Id", 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("FileName"))
                Dim pdfBytes As Byte() = CType(reader("FileContent"), 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 sur 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 avez donc un contrôle total sur 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.ContentType.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 (FileName, FileContent)
        VALUES (@FileName, @FileContent);
        SELECT SCOPE_IDENTITY();";

    await using var command = new SqlCommand(insertQuery, connection);
    command.Parameters.AddWithValue("@FileName", file.FileName);
    command.Parameters.AddWithValue("@FileContent", pdfDocument.BinaryData);

    var newId = Convert.ToInt32(await command.ExecuteScalarAsync());
    return Ok(new { id = newId, fileName = file.FileName });
}
[HttpPost("upload")]
public async Task<IActionResult> UploadPdf(IFormFile file)
{
    if (file is null || file.Length == 0)
        return BadRequest("No file uploaded.");

    if (!file.ContentType.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 (FileName, FileContent)
        VALUES (@FileName, @FileContent);
        SELECT SCOPE_IDENTITY();";

    await using var command = new SqlCommand(insertQuery, connection);
    command.Parameters.AddWithValue("@FileName", file.FileName);
    command.Parameters.AddWithValue("@FileContent", pdfDocument.BinaryData);

    var newId = Convert.ToInt32(await command.ExecuteScalarAsync());
    return Ok(new { id = newId, fileName = file.FileName });
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
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

L'utilisation de 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 lève 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
Id INT IDENTITY Clé primaire, auto-incrémentée
FileName NVARCHAR(255) Nom de fichier d'origine pour les en-têtes de téléchargement
FileContent VARBINARY(MAX) Données binaires PDF brutes (BLOB)
ContentType NVARCHAR(100) Type MIME, par exemple, application/pdf
FileSizeBytes BIGINT Taille stockée pour la gestion des quotas
UploadedAt DATETIME2 Horodatage UTC pour l'audit
UploadedBy NVARCHAR(100) Identifiant 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 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 de la chaîne de connexion, stockez la valeur dans appsettings.json et ne la codez jamais en dur dans les fichiers sources. 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 l'intégralité du 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 -- la mise en cache du tableau d'octets dans IMemoryCache évite les allers-retours répétés avec 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 à charge équilibrée avec plusieurs instances de serveur -- remplacez IMemoryCache par IDistributedCache pris en charge 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'inscription 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 FileContent à une propriété byte[] sur une classe de modèle et laisser EF gérer la génération de la requête. 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 la méthode brute ADO .NET ou EF Core FromSql avec une projection qui sélectionne uniquement la colonne du tableau d'octets plutôt que l'entité complète.

Quelles sont vos prochaines étapes ?

La récupération de fichiers PDF à partir d'une base de données SQL Server dans ASP.NET Core en utilisant C# et IronPDF suit un modèle clair : interroger la colonne BLOB avec un SELECT paramétré, charger les octets dans un PdfDocument et renvoyer les données binaires avec l'en-tête Content-Disposition correct. 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 :

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

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi