Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Télécharger des fichiers PDF Asp .NET
UTILISATION DE IRONPDF

Comment télécharger et envoyer des fichiers PDF dans ASP.NET Core avec C#

Curtis Chau
Curtis Chau
Mis à jour:

Le chargement et le téléchargement de fichiers PDF dans ASP.NET Core nécessitent la gestion de données binaires, la gestion des actions du contrôleur et, éventuellement, le traitement des documents côté serveur avant leur stockage ou leur livraison. Avec IronPDF , vous pouvez aller au-delà du simple stockage de fichiers : ajoutez des filigranes, générez des PDF à partir de HTML et renvoyez les documents traités aux utilisateurs, le tout au sein de votre pipeline MVC existant. Ce guide vous accompagne pas à pas dans la création d'un flux de travail complet de téléchargement et d'envoi en C# avec .NET 10.

Comment installer IronPDF dans un projet ASP.NET Core ?

Avant d'écrire toute logique de téléchargement ou d'envoi, ajoutez IronPDF à votre projet à l'aide du gestionnaire de packages NuGet ou de l'interface de ligne de commande .NET . Utilisez Install-Package IronPdf dans la console du gestionnaire de paquets ou exécutez les commandes CLI ci-dessous pour créer un nouveau projet MVC et ajouter tous les paquets nécessaires en une seule fois.

dotnet new mvc -n PdfManager --framework net10.0
cd PdfManager
dotnet add package IronPdf
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design
dotnet new mvc -n PdfManager --framework net10.0
cd PdfManager
dotnet add package IronPdf
dotnet add package Microsoft.EntityFrameworkCore.Sqlite
dotnet add package Microsoft.EntityFrameworkCore.Design
SHELL

Une fois installé, IronPDF donne accès à ChromePdfRenderer pour générer des PDF à partir de HTML, PdfDocument pour charger et manipuler des fichiers existants, ainsi qu'à une gamme d'outils d'édition comprenant des filigranes, des tampons et des signatures numériques. Vous pouvez consulter la page complète du package NuGet IronPDF pour connaître l'historique des versions et les notes de compatibilité.

Configuration du projet

Ajoutez une constante de chemin de stockage à Program.cs et enregistrez votre ApplicationDbContext avec le conteneur d'injection de dépendances. La structure de votre projet comprendra un Controllers/PdfController.cs, un Models/PdfFileModel.cs, et un Data/ApplicationDbContext.cs avant que vous n'écriviez toute logique spécifique au PDF.

Comment créer un modèle de base de données pour le stockage de fichiers PDF ?

Tout système de téléchargement de PDF repose sur une classe modèle qui correspond à une table de base de données. L'enregistrement C# suivant capture les champs essentiels : nom du fichier, type de contenu, données binaires brutes et horodatage du téléchargement.

public class PdfFileModel
{
    public int Id { get; set; }
    public string FileName { get; set; } = string.Empty;
    public string ContentType { get; set; } = "application/pdf";
    public byte[] FileData { get; set; } = Array.Empty<byte>();
    public DateTime UploadedDate { get; set; } = DateTime.UtcNow;
}
public class PdfFileModel
{
    public int Id { get; set; }
    public string FileName { get; set; } = string.Empty;
    public string ContentType { get; set; } = "application/pdf";
    public byte[] FileData { get; set; } = Array.Empty<byte>();
    public DateTime UploadedDate { get; set; } = DateTime.UtcNow;
}
Public Class PdfFileModel
    Public Property Id As Integer
    Public Property FileName As String = String.Empty
    Public Property ContentType As String = "application/pdf"
    Public Property FileData As Byte() = Array.Empty(Of Byte)()
    Public Property UploadedDate As DateTime = DateTime.UtcNow
End Class
$vbLabelText   $csharpLabel

FileData stocke le PDF sous la forme d'un objet binaire de grande taille (BLOB). Cette approche permet de conserver les documents de manière autonome au sein de la base de données, ce qui simplifie les sauvegardes et facilite les requêtes. Pour les scénarios à volume élevé ou les fichiers volumineux, envisagez de ne stocker que le chemin du fichier dans la base de données et d'écrire le binaire dans un compartiment de stockage cloud tel qu'Azure Blob Storage ou Amazon S3 .

Configuration du noyau d'Entity Framework

Enregistrez le modèle avec EF Core en ajoutant une propriété DbSet<PdfFileModel> à votre ApplicationDbContext :

using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    public DbSet<PdfFileModel> PdfFiles { get; set; }
}
using Microsoft.EntityFrameworkCore;

public class ApplicationDbContext : DbContext
{
    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
        : base(options) { }

    public DbSet<PdfFileModel> PdfFiles { get; set; }
}
Imports Microsoft.EntityFrameworkCore

Public Class ApplicationDbContext
    Inherits DbContext

    Public Sub New(options As DbContextOptions(Of ApplicationDbContext))
        MyBase.New(options)
    End Sub

    Public Property PdfFiles As DbSet(Of PdfFileModel)
End Class
$vbLabelText   $csharpLabel

Exécutez dotnet ef migrations add InitialCreate suivi de dotnet ef database update pour créer le schéma. Entity Framework Core fait correspondre byte[]@ à une colonne varbinary(max)@ dans SQL Server ou à une colonne BLOB@ dans SQLite automatiquement - aucun SQL manuel n'est nécessaire.

Comment téléverser des fichiers PDF dans un contrôleur ASP.NET Core ?

L'action du contrôleur qui gère les téléchargements reçoit un paramètre IFormFile d'un formulaire HTML utilisant enctype="multipart/form-data". L'action lit le flux dans un MemoryStream, le convertit en tableau d'octets et persiste le résultat à travers Entity Framework Core.

using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

public class PdfController : Controller
{
    private readonly ApplicationDbContext _context;

    public PdfController(ApplicationDbContext context)
    {
        _context = context;
    }

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

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

        using var stream = new MemoryStream();
        await file.CopyToAsync(stream);

        var pdfFile = new PdfFileModel
        {
            FileName = Path.GetFileName(file.FileName),
            ContentType = file.ContentType,
            FileData = stream.ToArray(),
            UploadedDate = DateTime.UtcNow
        };

        _context.PdfFiles.Add(pdfFile);
        await _context.SaveChangesAsync();

        return RedirectToAction(nameof(Index));
    }

    public async Task<IActionResult> Index()
    {
        var files = await _context.PdfFiles
            .Select(f => new { f.Id, f.FileName, f.UploadedDate })
            .ToListAsync();
        return View(files);
    }
}
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

public class PdfController : Controller
{
    private readonly ApplicationDbContext _context;

    public PdfController(ApplicationDbContext context)
    {
        _context = context;
    }

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

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

        using var stream = new MemoryStream();
        await file.CopyToAsync(stream);

        var pdfFile = new PdfFileModel
        {
            FileName = Path.GetFileName(file.FileName),
            ContentType = file.ContentType,
            FileData = stream.ToArray(),
            UploadedDate = DateTime.UtcNow
        };

        _context.PdfFiles.Add(pdfFile);
        await _context.SaveChangesAsync();

        return RedirectToAction(nameof(Index));
    }

    public async Task<IActionResult> Index()
    {
        var files = await _context.PdfFiles
            .Select(f => new { f.Id, f.FileName, f.UploadedDate })
            .ToListAsync();
        return View(files);
    }
}
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.EntityFrameworkCore
Imports System.IO
Imports System.Threading.Tasks

Public Class PdfController
    Inherits Controller

    Private ReadOnly _context As ApplicationDbContext

    Public Sub New(context As ApplicationDbContext)
        _context = context
    End Sub

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

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

        Using stream As New MemoryStream()
            Await file.CopyToAsync(stream)

            Dim pdfFile As New PdfFileModel With {
                .FileName = Path.GetFileName(file.FileName),
                .ContentType = file.ContentType,
                .FileData = stream.ToArray(),
                .UploadedDate = DateTime.UtcNow
            }

            _context.PdfFiles.Add(pdfFile)
            Await _context.SaveChangesAsync()
        End Using

        Return RedirectToAction(NameOf(Index))
    End Function

    Public Async Function Index() As Task(Of IActionResult)
        Dim files = Await _context.PdfFiles _
            .Select(Function(f) New With {f.Id, f.FileName, f.UploadedDate}) _
            .ToListAsync()
        Return View(files)
    End Function
End Class
$vbLabelText   $csharpLabel

Validation des fichiers téléchargés

Toujours valider le type de contenu avant traitement. La vérification de file.ContentType permet d'éviter que les utilisateurs ne téléchargent accidentellement du contenu non PDF. Pour une meilleure validation, lisez les quatre premiers octets du flux et vérifiez le numéro magique PDF (%PDF). Vous devez également imposer une taille de fichier maximale - généralement 10 Mo pour les flux de documents généraux - en vérifiant file.Length avant de copier le flux.

Le formulaire HTML qui déclenche cette action a besoin de deux attributs : method="post" et enctype="multipart/form-data". Sans spécifier le type d'encodage, les navigateurs envoient le nom du fichier sous forme de texte brut plutôt que son contenu binaire. Ajoutez un élément <input type="file" name="file" accept=".pdf" /> et un bouton de soumission à l'intérieur de la balise de formulaire pointant vers /Pdf/Upload.

Comment charger et télécharger des fichiers PDF en ASP .NET C# avec IronPDF : Image 1 - Interface utilisateur montrant le PDF téléchargé

Comment ajouter un filigrane à un PDF téléchargé avant de l'enregistrer ?

Le traitement des fichiers côté serveur avant leur stockage est l'une des utilisations les plus pratiques des fonctionnalités de tatouage numérique d'IronPDF . Vous pouvez apposer sur chaque document entrant la mention " CONFIDENTIEL ", le logo de l'entreprise ou la mention " BROUILLON " avant même que les données n'atteignent la base de données.

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

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

    // Load the uploaded file into IronPDF
    var pdf = new IronPdf.PdfDocument(originalBytes);

    // Apply an HTML watermark centered on every page
    pdf.ApplyWatermark(
        "<h2 style='color:red;opacity:0.4'>CONFIDENTIAL</h2>",
        rotation: 45,
        opacity: 60,
        verticalAlignment: IronPdf.Editing.VerticalAlignment.Middle,
        horizontalAlignment: IronPdf.Editing.HorizontalAlignment.Center
    );

    var pdfFile = new PdfFileModel
    {
        FileName = Path.GetFileName(file.FileName),
        ContentType = "application/pdf",
        FileData = pdf.BinaryData,
        UploadedDate = DateTime.UtcNow
    };

    _context.PdfFiles.Add(pdfFile);
    await _context.SaveChangesAsync();

    return RedirectToAction(nameof(Index));
}
[HttpPost]
public async Task<IActionResult> UploadWithWatermark(IFormFile file)
{
    if (file is null || file.Length == 0)
        return BadRequest("No file selected.");

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

    // Load the uploaded file into IronPDF
    var pdf = new IronPdf.PdfDocument(originalBytes);

    // Apply an HTML watermark centered on every page
    pdf.ApplyWatermark(
        "<h2 style='color:red;opacity:0.4'>CONFIDENTIAL</h2>",
        rotation: 45,
        opacity: 60,
        verticalAlignment: IronPdf.Editing.VerticalAlignment.Middle,
        horizontalAlignment: IronPdf.Editing.HorizontalAlignment.Center
    );

    var pdfFile = new PdfFileModel
    {
        FileName = Path.GetFileName(file.FileName),
        ContentType = "application/pdf",
        FileData = pdf.BinaryData,
        UploadedDate = DateTime.UtcNow
    };

    _context.PdfFiles.Add(pdfFile);
    await _context.SaveChangesAsync();

    return RedirectToAction(nameof(Index));
}
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

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

    Using stream As New MemoryStream()
        Await file.CopyToAsync(stream)
        Dim originalBytes As Byte() = stream.ToArray()

        ' Load the uploaded file into IronPDF
        Dim pdf = New IronPdf.PdfDocument(originalBytes)

        ' Apply an HTML watermark centered on every page
        pdf.ApplyWatermark(
            "<h2 style='color:red;opacity:0.4'>CONFIDENTIAL</h2>",
            rotation:=45,
            opacity:=60,
            verticalAlignment:=IronPdf.Editing.VerticalAlignment.Middle,
            horizontalAlignment:=IronPdf.Editing.HorizontalAlignment.Center
        )

        Dim pdfFile As New PdfFileModel With {
            .FileName = Path.GetFileName(file.FileName),
            .ContentType = "application/pdf",
            .FileData = pdf.BinaryData,
            .UploadedDate = DateTime.UtcNow
        }

        _context.PdfFiles.Add(pdfFile)
        Await _context.SaveChangesAsync()

        Return RedirectToAction(NameOf(Index))
    End Using
End Function
$vbLabelText   $csharpLabel

Options de configuration du filigrane

La méthode ApplyWatermark d'IronPDF accepte une chaîne HTML, ce qui signifie que votre filigrane peut inclure n'importe quel HTML valide et CSS en ligne -- des dégradés, des polices personnalisées, du texte pivoté ou même des icônes SVG intégrées. Le paramètre rotation fait pivoter le filigrane sur la diagonale de la page, tandis que opacity contrôle la transparence de 0 (invisible) à 100 (totalement opaque).

Au-delà des filigranes, le même objet PdfDocument expose des méthodes pour ajouter des en-têtes et des pieds de page, estampiller des images, et éditer des champs de formulaire existants. Vous pouvez enchaîner plusieurs étapes de traitement avant d'appeler pdf.BinaryData pour récupérer le tableau d'octets final.

Comment charger et télécharger des fichiers PDF en ASP .NET C# avec IronPDF : Image 2 - PDF filigrané puis enregistré dans la base de données

Comment télécharger des fichiers PDF stockés dans la base de données ?

Pour renvoyer un PDF stocké au navigateur, récupérez l'enregistrement par ID et renvoyez un FileResult. La méthode d'aide File d'ASP.NET Core définit l'en-tête Content-Type correct et déclenche la boîte de dialogue de téléchargement du navigateur avec le nom de fichier d'origine.

public async Task<IActionResult> Download(int id)
{
    var pdfFile = await _context.PdfFiles.FindAsync(id);

    if (pdfFile is null)
        return NotFound();

    return File(pdfFile.FileData, pdfFile.ContentType, pdfFile.FileName);
}
public async Task<IActionResult> Download(int id)
{
    var pdfFile = await _context.PdfFiles.FindAsync(id);

    if (pdfFile is null)
        return NotFound();

    return File(pdfFile.FileData, pdfFile.ContentType, pdfFile.FileName);
}
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Async Function Download(id As Integer) As Task(Of IActionResult)
    Dim pdfFile = Await _context.PdfFiles.FindAsync(id)

    If pdfFile Is Nothing Then
        Return NotFound()
    End If

    Return File(pdfFile.FileData, pdfFile.ContentType, pdfFile.FileName)
End Function
$vbLabelText   $csharpLabel

Affichage d'une liste de téléchargements dans la vue

L'action Index récupère tous les enregistrements de fichiers stockés et les transmet à une vue Razor. Un simple tableau HTML affiche le nom du fichier, la date de mise en ligne et un lien de téléchargement pour chaque enregistrement.

<table class="content__data-table" data-content-table>
    <caption>Uploaded PDF Files</caption>
    <thead>
        <tr>
            <th>File Name</th>
            <th>Uploaded</th>
            <th>Action</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.FileName</td>
                <td>@item.UploadedDate.ToString("yyyy-MM-dd HH:mm")</td>
                <td><a href="/Pdf/Download/@item.Id">Download</a></td>
            </tr>
        }
    </tbody>
</table>
<table class="content__data-table" data-content-table>
    <caption>Uploaded PDF Files</caption>
    <thead>
        <tr>
            <th>File Name</th>
            <th>Uploaded</th>
            <th>Action</th>
        </tr>
    </thead>
    <tbody>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.FileName</td>
                <td>@item.UploadedDate.ToString("yyyy-MM-dd HH:mm")</td>
                <td><a href="/Pdf/Download/@item.Id">Download</a></td>
            </tr>
        }
    </tbody>
</table>
$vbLabelText   $csharpLabel

La surcharge return File(bytes, contentType, fileName) définit à la fois Content-Type: application/pdf et Content-Disposition : attachment ; nom_de_fichier=&quot;...&quot; en-têtes. Si vous souhaitez que le navigateur ouvre le PDF en ligne au lieu de demander un téléchargement, utilisezreturn File(bytes, contentType)sans le troisième argument -- cela omet l'instructionContent-Disposition: attachment`.

Comment charger et télécharger des fichiers PDF en ASP .NET C# avec IronPDF : Image 3 - Liste des fichiers PDF stockés

Le stockage de fichiers comme alternative

Pour les déploiements de grande envergure, le stockage de données binaires brutes dans la base de données augmente la taille des lignes et peut ralentir les requêtes. Une autre solution consiste à écrire le fichier dans un répertoire sur disque – ou chez un fournisseur de cloud – et à ne stocker que le chemin relatif dans la base de données. Remplacez FileData byte[] par FilePath string, écrivez System.IO.File.WriteAllBytesAsync(path, bytes) lors du téléchargement et lisez System.IO.File.ReadAllBytesAsync(path) lors de la réception. Les deux chemins convergent vers le même appel return File(...)@ dans le contrôleur.

Comment générer des documents PDF à la demande et les mettre à disposition pour téléchargement ?

Vous n'êtes pas limité à la diffusion de fichiers pré-enregistrés. La conversion HTML vers PDF d'IronPDF vous permet de générer des documents dynamiquement à partir de données au moment de la demande – utile pour les factures, les rapports, les certificats et les exportations de données.

public IActionResult GenerateInvoice(int orderId)
{
    // Build HTML content from your data model
    string html = $@"
        <html>
        <body style='font-family: Arial, sans-serif; padding: 40px;'>
            <h1>Invoice #{orderId}</h1>
            <p>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</p>
            <table border='1' cellpadding='8'>
                <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
                <tr><td>IronPDF License</td><td>1</td><td>$749</td></tr>
            </table>
        </body>
        </html>";

    var renderer = new IronPdf.ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);

    return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}
public IActionResult GenerateInvoice(int orderId)
{
    // Build HTML content from your data model
    string html = $@"
        <html>
        <body style='font-family: Arial, sans-serif; padding: 40px;'>
            <h1>Invoice #{orderId}</h1>
            <p>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</p>
            <table border='1' cellpadding='8'>
                <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
                <tr><td>IronPDF License</td><td>1</td><td>$749</td></tr>
            </table>
        </body>
        </html>";

    var renderer = new IronPdf.ChromePdfRenderer();
    using var pdf = renderer.RenderHtmlAsPdf(html);

    return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}
Imports System
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

Public Class InvoiceController
    Inherits Controller

    Public Function GenerateInvoice(orderId As Integer) As IActionResult
        ' Build HTML content from your data model
        Dim html As String = $"
            <html>
            <body style='font-family: Arial, sans-serif; padding: 40px;'>
                <h1>Invoice #{orderId}</h1>
                <p>Generated: {DateTime.UtcNow:yyyy-MM-dd HH:mm} UTC</p>
                <table border='1' cellpadding='8'>
                    <tr><th>Item</th><th>Qty</th><th>Price</th></tr>
                    <tr><td>IronPDF License</td><td>1</td><td>$749</td></tr>
                </table>
            </body>
            </html>"

        Dim renderer As New ChromePdfRenderer()
        Using pdf = renderer.RenderHtmlAsPdf(html)
            Return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Options de rendu pour les PDF à la demande

ChromePdfRenderer produit des résultats précis au pixel près en utilisant le même moteur de rendu Chromium que celui de Google Chrome. Cela signifie que tout CSS que vous pouvez afficher dans un navigateur (mises en page flexbox, grilles, polices personnalisées, graphiques SVG) s'affiche correctement dans le PDF généré. Vous pouvez définir la taille du papier, les marges et l'orientation par le biais de la propriété RenderingOptions avant d'appeler RenderHtmlAsPdf.

Pour les documents plus complexes, transmettez une URL complète à RenderUrlAsPdf au lieu d'une chaîne HTML. IronPDF chargera la page dans un navigateur sans interface graphique, exécutera JavaScript, appliquera les styles et convertira le DOM entièrement rendu en PDF. Consultez le guide de conversion HTML vers PDF pour connaître l'ensemble des options de rendu, y compris les en-têtes, les pieds de page et les jetons de numérotation de page personnalisés.

Comment charger et télécharger des fichiers PDF en ASP .NET C# avec IronPDF : Image 4 - Exemple de PDF généré

Comment fusionner plusieurs fichiers PDF dans ASP.NET Core?

Au-delà des opérations sur un seul fichier, vous pourriez avoir besoin de combiner plusieurs documents téléchargés en un seul. La fonction de fusion d'IronPDF PDF accepte une liste d'objets PdfDocument et renvoie un seul fichier fusionné.

public async Task<IActionResult> MergeAll()
{
    var allFiles = await _context.PdfFiles.ToListAsync();

    if (allFiles.Count < 2)
        return BadRequest("At least two files are required for merging.");

    var documents = allFiles
        .Select(f => new IronPdf.PdfDocument(f.FileData))
        .ToList();

    using var merged = IronPdf.PdfDocument.Merge(documents);

    return File(merged.BinaryData, "application/pdf", "merged.pdf");
}
public async Task<IActionResult> MergeAll()
{
    var allFiles = await _context.PdfFiles.ToListAsync();

    if (allFiles.Count < 2)
        return BadRequest("At least two files are required for merging.");

    var documents = allFiles
        .Select(f => new IronPdf.PdfDocument(f.FileData))
        .ToList();

    using var merged = IronPdf.PdfDocument.Merge(documents);

    return File(merged.BinaryData, "application/pdf", "merged.pdf");
}
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Async Function MergeAll() As Task(Of IActionResult)
    Dim allFiles = Await _context.PdfFiles.ToListAsync()

    If allFiles.Count < 2 Then
        Return BadRequest("At least two files are required for merging.")
    End If

    Dim documents = allFiles _
        .Select(Function(f) New IronPdf.PdfDocument(f.FileData)) _
        .ToList()

    Using merged = IronPdf.PdfDocument.Merge(documents)
        Return File(merged.BinaryData, "application/pdf", "merged.pdf")
    End Using
End Function
$vbLabelText   $csharpLabel

Séparer les pages d'un PDF

L'opération inverse - l'extraction d'un sous-ensemble de pages - utilise CopyPages. Chargez un PdfDocument à partir des octets stockés, appelez source.CopyPages(startIndex, endIndex) avec des indices de page basés sur zéro, et renvoyez le PdfDocument.BinaryData résultant sous la forme d'un FileResult. Ce modèle est utile pour les aperçus de pagination, la division des rapports à plusieurs sections ou l'extraction d'une page de couverture pour la génération de vignettes. Vous pouvez également appliquer des signatures numériques à la sortie fusionnée ou divisée avant de la diffuser aux utilisateurs.

Comment gérer en toute sécurité les téléchargements de fichiers volumineux ?

Les fichiers PDF volumineux nécessitent une configuration supplémentaire au niveau du middleware ASP.NET Core . Par défaut, la limite de taille du corps de la requête est fixée à environ 28 Mo. Pour l'augmenter, appelez builder.Services.Configure<FormOptions> pour définir MultipartBodyLengthLimit et builder.WebHost.ConfigureKestrel pour définir Limits.MaxRequestBodySize -- tous deux au nombre d'octets souhaité, comme 50 * 1024 * 1024 pour 50 MB -- dans @@--CODE-1308--@ avant builder.Build().

Au-delà des limites de taille, appliquez ces pratiques de sécurité à chaque point d'extrémité de téléchargement : validez l'en-tête de type de contenu, inspectez les premiers octets du flux à la recherche du nombre magique %PDF, recherchez les scripts intégrés à l'aide de l'API d'inspection de documents d'IronPDF et stockez les fichiers traités en dehors de la racine du site web afin qu'ils ne soient jamais servis directement en tant que contenu statique. La documentation de sécurité ASP.NET Core couvre des techniques de renforcement supplémentaires, notamment la validation des jetons anti-falsification et l'intégration de l'analyse antivirus.

Diffuser des fichiers volumineux en continu pour éviter la pression sur la mémoire

Lorsque les fichiers dépassent 10 Mo, la lecture de l'ensemble du flux dans un MemoryStream avant le traitement peut entraîner une augmentation significative de l'utilisation de la mémoire. Utilisez IronPdf.PdfDocument.FromStream pour charger directement à partir du flux de requêtes lorsque c'est possible, ou écrivez dans un chemin de fichier temporaire et chargez à partir du disque :

string tempPath = Path.GetTempFileName();
await using (var fs = System.IO.File.Create(tempPath))
{
    await file.CopyToAsync(fs);
}

using var pdf = new IronPdf.PdfDocument(tempPath);
// process...
System.IO.File.Delete(tempPath);
string tempPath = Path.GetTempFileName();
await using (var fs = System.IO.File.Create(tempPath))
{
    await file.CopyToAsync(fs);
}

using var pdf = new IronPdf.PdfDocument(tempPath);
// process...
System.IO.File.Delete(tempPath);
Imports System.IO
Imports IronPdf

Dim tempPath As String = Path.GetTempFileName()

Using fs As FileStream = System.IO.File.Create(tempPath)
    Await file.CopyToAsync(fs)
End Using

Using pdf As PdfDocument = New IronPdf.PdfDocument(tempPath)
    ' process...
End Using

System.IO.File.Delete(tempPath)
$vbLabelText   $csharpLabel

Ce modèle permet de limiter les allocations de mémoire et fonctionne bien avec les files d'attente de traitement en arrière-plan où les fichiers sont traités de manière asynchrone après l'envoi de la réponse HTTP. Consultez la documentation IronPDF pour découvrir d'autres modèles de traitement asynchrone.

Quelles sont vos prochaines étapes ?

Vous disposez désormais d'une base complète pour le chargement, le traitement, le stockage et le téléchargement de fichiers PDF dans une application ASP.NET Core MVC basée sur IronPDF. À partir de là, considérez les directions suivantes pour étendre le flux de travail.

Étendez les capacités de traitement. IronPDF prend en charge le remplissage et la lecture des champs de formulaires PDF , l'extraction de texte et d'images grâce à l' API d'extraction de texte PDF , et la conversion des pages PDF en images pour les aperçus miniatures. Chacune de ces fonctionnalités s'intègre dans le même modèle de contrôleur illustré ci-dessus.

Ajoutez des signatures numériques. Signez chaque document généré ou téléchargé avec une signature numérique utilisant un certificat X.509 avant de l'enregistrer. Les PDF signés contiennent des métadonnées inviolables qui satisfont à de nombreuses exigences de conformité.

<Remplacez la colonne locale de la base de données byte[] par une référence à Azure Blob Storage ou Amazon S3. Après le marquage numérique, téléchargez les octets traités sur le stockage cloud et ne conservez que l'URI dans la base de données ; cela réduit considérablement la taille des lignes de la base de données et permet la diffusion via CDN.

Démarrez un essai gratuit. Consultez la page de licence d'essai IronPDF pour obtenir une clé d'évaluation de 30 jours avec accès à toutes les fonctionnalités. Vous pouvez également consulter la présentation complète des fonctionnalités IronPDF pour comprendre l'ensemble des capacités PDF disponibles dans votre application .NET , ou consulter la page des tarifs et des licences lorsque vous serez prêt pour le déploiement en production.

Questions Fréquemment Posées

Comment puis-je télécharger des fichiers PDF dans une application ASP.NET Core MVC ?

Pour télécharger des fichiers PDF dans une application ASP.NET Core MVC, vous pouvez utiliser l'interface IFormFile pour capturer les données d'un fichier à partir d'un formulaire, puis les traiter côté serveur avant de les enregistrer, éventuellement avec l'aide d'IronPDF pour une manipulation plus poussée du PDF.

Quelle est la meilleure façon de télécharger des fichiers PDF en ASP.NET ?

La meilleure façon de télécharger des fichiers PDF en ASP.NET est d'utiliser l'action FileResult dans votre contrôleur. IronPDF peut aider à générer et à modifier les PDF côté serveur pour s'assurer qu'ils sont prêts à être téléchargés.

Puis-je stocker des fichiers PDF dans une base de données en utilisant ASP.NET ?

Oui, vous pouvez stocker des fichiers PDF dans une base de données à l'aide d'ASP.NET en convertissant le fichier en un tableau d'octets et en l'enregistrant en tant qu'objet binaire de grande taille (BLOB). IronPDF peut aider à traiter le PDF avant de le stocker.

Comment IronPDF aide-t-il à filigraner les PDF en ASP.NET ?

IronPDF offre une fonctionnalité permettant d'ajouter facilement des filigranes de texte ou d'image aux PDF, qui peuvent être intégrés à votre application ASP.NET pour modifier les documents avant leur téléchargement ou leur stockage.

Quels sont les avantages de l'utilisation d'EF Core pour le stockage des PDF ?

EF Core permet un mappage objet-relationnel efficace, ce qui facilite la gestion du stockage et de la récupération des PDF de manière structurée et évolutive au sein de votre application ASP.NET.

Est-il possible de manipuler du contenu PDF dans des applications ASP.NET ?

Oui, avec IronPDF, vous pouvez manipuler le contenu des PDF, notamment en modifiant le texte, les images et les métadonnées, ce qui peut être utile pour personnaliser les documents avant qu'ils ne soient servis aux utilisateurs.

Comment puis-je gérer les téléchargements de fichiers en toute sécurité en ASP.NET ?

Pour gérer les téléchargements de fichiers en toute sécurité en ASP.NET, vous devez valider les types de fichiers, limiter leur taille et les stocker dans des emplacements sécurisés. L'utilisation de bibliothèques telles qu'IronPDF peut également contribuer à garantir l'intégrité des fichiers PDF eux-mêmes.

Quels sont les défis courants liés à l'utilisation des PDF dans les applications web ?

Parmi les défis courants, citons la compatibilité des fichiers, la gestion de fichiers volumineux et le maintien de l'intégrité des documents. IronPDF aide à surmonter ces difficultés en fournissant des outils robustes pour la création et la manipulation de PDF.

Puis-je convertir différents types de fichiers en PDF en ASP.NET ?

Oui, IronPDF vous permet de convertir divers types de fichiers, tels que des fichiers HTML ou des fichiers images, en PDF de manière transparente au sein de votre application ASP.NET.

Quel est le rôle du modèle-vue-contrôleur (MVC) dans la gestion des PDF en ASP.NET ?

Le modèle MVC permet d'organiser le code pour gérer les PDF en séparant le traitement des données (modèle), l'interface utilisateur (vue) et la logique d'application (contrôleur), ce qui facilite la gestion et l'extension des fonctionnalités des 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