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.
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 packages, ou exécutez les commandes CLI ci-dessous pour générer un nouveau projet MVC et ajouter tous les packages requis 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.DesignUne fois installé, IronPDF offre un accès à ChromePdfRenderer pour générer des PDFs à partir de HTML, PdfDocument pour charger et manipuler des fichiers existants, et une gamme d'outils d'édition incluant filigranes, tampons et 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é.
Ajouter une constante de chemin de stockage à Program.cs et enregistrer 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.
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 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 ClassFileData stocke le PDF comme un objet binaire volumineux (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 .
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; }
}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 ClassExécutez dotnet ef migrations add InitialCreate suivi de dotnet ef database update pour créer le schéma. Entity Framework Core mappe byte[] à une colonne varbinary(max) dans SQL Server ou à une colonne BLOB dans SQLite automatiquement -- aucune SQL manuelle n'est requise.
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 un tableau d'octets, et conserve le résultat via 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);
}
}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 ClassToujours valider le type de contenu avant traitement. Vérifier file.ContentType évite aux utilisateurs de télécharger accidentellement du contenu non PDF. Pour une validation plus rigoureuse, lisez les quatre premiers octets du flux et vérifiez le nombre magique du PDF (%PDF). Vous devez également imposer une taille de fichier maximale -- typiquement 10 Mo pour les flux de travail 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 formulaire pointant vers /Pdf/Upload.
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));
}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 FunctionLa méthode ApplyWatermark d'IronPDF accepte une chaîne HTML, ce qui signifie que votre filigrane peut inclure du HTML valide et du CSS en ligne -- dégradés, polices personnalisées, texte rotatif, ou même des icônes SVG intégrées. Le paramètre rotation fait pivoter le filigrane à travers la diagonale de la page, tandis que opacity contrôle la transparence de 0 (invisible) à 100 (entièrement opaque).
Au-delà des filigranes, le même objet PdfDocument expose des méthodes pour ajouter des en-têtes et pieds de page, appliquer 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.
Pour servir un PDF stocké au navigateur, récupérez l'enregistrement par identifiant et renvoyez un FileResult. La méthode d'assistance File d'ASP.NET Core configure le bon en-tête Content-Type et déclenche le 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);
}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 FunctionL'action Index récupère tous les enregistrements de fichiers stockés et les passe à 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>netLa surcharge return File(bytes, contentType, fileName) définit à la fois Content-Type: application/pdf et Content-Disposition: attachment; nom_de_fichier="..." en-têtes. Si vous souhaitez que le navigateur ouvre le PDF en ligne au lieu de demander un téléchargement, utilisez return File(bytes, contentType)sans le troisième argument -- cela omet l'instructionContent-Disposition: attachment`.
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 du téléchargement. Les deux chemins convergent sur le même appel return File(...) dans le contrôleur.
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>$999</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");
}ChromePdfRenderer produit une sortie précise en pixels en utilisant le même moteur de rendu Chromium qui alimente 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 via la propriété RenderingOptions avant d'appeler RenderHtmlAsPdf.
Pour des 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.
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 capacité de fusion PDF d'IronPDF 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");
}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 FunctionL'opération inverse -- extraire 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 de base zéro, et renvoyez le PdfDocument.BinaryData résultant sous 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.
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 -- les deux à votre compte d'octets souhaité, comme 50 * 1024 * 1024 pour 50 Mo -- dans Program.cs avant builder.Build().
Au-delà des limites de taille, appliquez ces pratiques de sécurité à chaque point de terminaison de téléchargement : validez l'en-tête de type de contenu, inspectez les premiers octets du flux pour le nombre magique %PDF, recherchez des scripts intégrés en utilisant l'API d'inspection de documents IronPDF, et stockez les fichiers traités en dehors de la racine web pour qu'ils ne soient jamais servis comme contenu statique directement. 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.
Lorsque les fichiers dépassent 10 Mo, la lecture de tout le 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 depuis le flux de requête lorsque c'est possible, ou écrivez à un chemin de fichier temporaire et chargez depuis le 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);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)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.
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é.
Évoluez le stockage vers le cloud. Remplacez la colonne de base de données locale 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.
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 et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
