Cargar y descargar archivos PDF en ASP.NET Core requiere manejar datos binarios, administrar acciones del controlador y, opcionalmente, procesar documentos del lado del servidor antes de almacenarlos o entregarlos. Con IronPDF , puede ir más allá del simple almacenamiento de archivos: aplica marcas de agua, genera archivos PDF desde HTML y devuelve los documentos procesados a los usuarios, todo dentro de su flujo de trabajo MVC. Esta guía le guía paso a paso para crear un flujo de trabajo completo de carga y descarga en C# con .NET 10.
Antes de escribir cualquier lógica de carga o descarga, agregue IronPDF a su proyecto usando el Administrador de paquetes NuGet o la CLI de .NET . Utilice Install-Package IronPdf en la consola del gestor de paquetes o ejecute los siguientes comandos de la CLI para crear un nuevo proyecto MVC y añadir todos los paquetes necesarios a la vez.
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.DesignUna vez instalado, IronPDF proporciona acceso a ChromePdfRenderer para generar PDF a partir de HTML, PdfDocument para cargar y manipular archivos existentes, y una serie de herramientas de edición que incluyen marcas de agua, sellos y firmas digitales. Puede consultar la página completa del paquete NuGet de IronPDF para ver el historial de versiones y las notas de compatibilidad.
Añada una constante de ruta de almacenamiento a Program.cs y registre su ApplicationDbContext con el contenedor de inyección de dependencias. La estructura de su proyecto incluirá un Controllers/PdfController.cs, un Models/PdfFileModel.cs y un Data/ApplicationDbContext.cs antes de escribir cualquier lógica específica de PDF.
La base de cualquier sistema de carga de PDF es una clase de modelo que se asigna a una tabla de base de datos. El siguiente registro de C# captura los campos esenciales: nombre de archivo, tipo de contenido, datos binarios sin procesar y una marca de tiempo de carga.
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 almacena el PDF como un objeto binario de gran tamaño (BLOB). Este enfoque mantiene los documentos contenidos dentro de la base de datos, lo que hace que las copias de seguridad sean más sencillas y las consultas más directas. Para escenarios de gran volumen o archivos grandes, considere almacenar solo la ruta del archivo en la base de datos y escribir el binario en un depósito de almacenamiento en la nube, como Azure Blob Storage o Amazon S3 .
Registre el modelo con EF Core añadiendo una propiedad DbSet<PdfFileModel> a su 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 ClassEjecute dotnet ef migrations add InitialCreate seguido de dotnet ef database update para crear el esquema. Entity Framework Core asigna automáticamente byte[] a una columna varbinary(max) en SQL Server o a una columna BLOB en SQLite, sin necesidad de SQL manual.
La acción del controlador que gestiona las cargas recibe un parámetro IFormFile de un formulario HTML utilizando enctype="multipart/form-data". La acción lee el flujo en un MemoryStream, lo convierte en una matriz de bytes y persiste el resultado a través de 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 ClassValide siempre el tipo de contenido antes de procesarlo. La comprobación de file.ContentType evita que los usuarios carguen accidentalmente contenido que no sea PDF. Para una mayor validación, lea los cuatro primeros bytes del flujo y compruebe el número mágico PDF (%PDF). También debe imponer un tamaño máximo de archivo -- normalmente 10 MB para flujos de trabajo de documentos generales -- comprobando file.Length antes de copiar el flujo.
El formulario HTML que desencadena esta acción necesita dos atributos: method="post" y enctype="multipart/form-data". Sin el tipo de codificación, los navegadores envían el nombre del archivo como texto simple en lugar del contenido binario. Añada un elemento <input type="file" name="file" accept=".pdf" /> y un botón de envío dentro de la etiqueta de formulario que apunta a /Pdf/Upload.
El procesamiento de archivos del lado del servidor antes de almacenarlos es uno de los usos más prácticos de las funciones de marca de agua de IronPDF . Puede sellar cada documento entrante con una etiqueta de "CONFIDENCIAL", un logotipo de la empresa o un aviso de "BORRADOR" antes de que los bytes lleguen a la base de datos.
[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 FunctionEl método ApplyWatermark de IronPDF acepta una cadena HTML, lo que significa que su marca de agua puede incluir cualquier HTML válido y CSS en línea: degradados, fuentes personalizadas, texto rotado o incluso iconos SVG incrustados. El parámetro rotation gira la marca de agua a lo largo de la diagonal de la página, mientras que opacity controla la transparencia de 0 (invisible) a 100 (totalmente opaca).
Además de las marcas de agua, el mismo objeto PdfDocument expone métodos para añadir encabezados y pies de página, estampar imágenes y editar campos de formulario existentes. Puede encadenar varios pasos de procesamiento antes de llamar a pdf.BinaryData para recuperar la matriz de bytes final.
Para devolver un PDF almacenado al navegador, recupere el registro por ID y devuelva un FileResult. El método de ayuda File de ASP.NET Core establece el encabezado Content-Type correcto y activa el diálogo de descarga del navegador con el nombre de archivo original.
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 FunctionLa acción Index recupera todos los registros de archivos almacenados y los pasa a una vista Razor. Una tabla HTML simple muestra el nombre del archivo, la fecha de carga y un ancla de descarga para cada registro.
<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 sobrecarga return File(bytes, contentType, fileName) establece tanto Content-Type: application/pdf como Content-Disposition: attachment; encabezados filename="...". Si desea que el navegador abra el PDF en línea en lugar de solicitar una descarga, utilice return File(bytes, contentType) sin el tercer argumento, omitiendo la instrucción Content-Disposition: attachment.
En el caso de implementaciones de gran tamaño, almacenar datos binarios sin procesar en la base de datos aumenta el tamaño de las filas y puede ralentizar las consultas. Una alternativa es escribir el archivo en un directorio del disco (o en un proveedor de nube) y almacenar sólo la ruta relativa en la base de datos. Sustituya FileData byte[] por FilePath string, escriba System.IO.File.WriteAllBytesAsync(path, bytes) durante la carga y lea System.IO.File.ReadAllBytesAsync(path) durante la descarga. Ambos caminos convergen en la misma llamada return File(...) en el controlador.
No está limitado a servir archivos previamente almacenados. La conversión de HTML a PDF de IronPDF le permite generar documentos dinámicamente a partir de datos en el momento de la solicitud, lo que resulta útil para facturas, informes, certificados y exportaciones de datos.
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 ClassChromePdfRenderer produce resultados con precisión de píxeles utilizando el mismo motor de renderizado Chromium que utiliza Google Chrome. Esto significa que cualquier CSS que pueda mostrar en un navegador (diseños de Flexbox, cuadrículas, fuentes personalizadas, gráficos SVG) se representa correctamente en el PDF generado. Puede establecer el tamaño del papel, los márgenes y la orientación a través de la propiedad RenderingOptions antes de llamar a RenderHtmlAsPdf.
Para documentos más complejos, pase una URL completa a RenderUrlAsPdf en lugar de una cadena HTML. IronPDF cargará la página en un navegador sin cabeza, ejecutará JavaScript, aplicará estilos y convertirá el DOM completamente renderizado a PDF. Revise la guía de conversión de HTML a PDF para conocer el conjunto completo de opciones de representación, incluidos encabezados, pies de página y tokens de numeración de páginas personalizados.
Además de las operaciones de un solo archivo, es posible que necesite combinar varios documentos cargados en uno. La función de fusión PDF de IronPDF acepta una lista de objetos PdfDocument y devuelve un único archivo fusionado.
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 FunctionLa operación inversa -- extraer un subconjunto de páginas -- utiliza CopyPages. Cargar un PdfDocument desde los bytes almacenados, llamar a source.CopyPages(startIndex, endIndex) con índices de página basados en cero, y devolver el PdfDocument.BinaryData resultante como un FileResult. Este patrón es útil para vistas previas de paginación, dividir informes de varias secciones o extraer una portada para generar miniaturas. También puede aplicar firmas digitales a la salida fusionada o dividida antes de entregarla a los usuarios.
Los archivos PDF grandes requieren una configuración adicional en el nivel de middleware ASP.NET Core . De forma predeterminada, el límite de tamaño del cuerpo de la solicitud se establece en aproximadamente 28 MB. Para subirlo, llame a builder.Services.Configure<FormOptions> para poner MultipartBodyLengthLimit y builder.WebHost.ConfigureKestrel para poner Limits.MaxRequestBodySize -- ambos a la cuenta de bytes deseada, como 50 * 1024 * 1024 para 50 MB -- en Program.cs antes de builder.Build().
Más allá de los límites de tamaño, aplique estas prácticas de seguridad a cada punto final de carga: valide el encabezado de tipo de contenido, inspeccione los primeros bytes del flujo en busca del número mágico %PDF, busque scripts incrustados mediante la API de inspección de documentos de IronPDF y almacene los archivos procesados fuera de la raíz web para que nunca se sirvan como contenido estático directamente. La documentación de seguridad de ASP.NET Core cubre técnicas de refuerzo adicionales, incluida la validación de tokens antifalsificación y la integración de escaneo de virus.
Cuando los archivos superan los 10 MB, la lectura de todo el flujo en un MemoryStream antes del procesamiento puede disparar el uso de memoria de forma significativa. Utilice IronPdf.PdfDocument.FromStream para cargar directamente desde el flujo de peticiones siempre que sea posible, o escriba en una ruta de archivo temporal y cargue desde el disco:
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)Este patrón mantiene bajas las asignaciones de montón y funciona bien con colas de procesamiento en segundo plano donde los archivos se procesan de forma asincrónica después de que ya se envió la respuesta HTTP. Explore la documentación de IronPDF para obtener patrones de procesamiento asincrónico adicionales.
Ahora tiene una base completa para cargar, procesar, almacenar y descargar archivos PDF en una aplicación ASP.NET Core MVC respaldada por IronPDF. Desde aquí, considere las siguientes instrucciones para ampliar el flujo de trabajo.
Amplíe las capacidades de procesamiento. IronPDF permite rellenar y leer campos de formularios PDF , extraer texto e imágenes con la API de extracción de texto PDF y convertir páginas PDF en imágenes para previsualizaciones en miniatura. Cada una de estas características se integra en el mismo patrón de controlador que se muestra arriba.
Añade firmas digitales. Firma digitalmente cada documento generado o subido con un certificado X.509 antes de almacenarlo. Los archivos PDF firmados contienen metadatos a prueba de manipulaciones que satisfacen muchos requisitos de cumplimiento.
Escala el almacenamiento a la nube. Sustituye la columna de la base de datos local byte[] por una referencia a Azure Blob Storage o Amazon S3. Suba los bytes procesados al almacenamiento en la nube después de la marca de agua y guarde solo el URI en la base de datos: esto reduce drásticamente el tamaño de las filas de la base de datos y permite la entrega de CDN.
Prueba gratis. Visita la página de la licencia de prueba de IronPDF para obtener una clave de evaluación de 30 días con acceso completo a todas las funciones. También puede explorar la descripción completa de las características de IronPDF para comprender el alcance total de las capacidades de PDF disponibles en su aplicación .NET , o consultar la página de precios y licencias cuando esté listo para la implementación de producción.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
