Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Cargar Descargar Archivos PDF Asp .NET
USANDO IRONPDF

Cómo subir y descargar archivos PDF en ASP.NET Core con C#

Curtis Chau
Curtis Chau
Actualizado:

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.

¿Cómo instalar IronPDF en un proyecto ASP.NET Core ?

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

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

Configuración del proyecto

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.

¿Cómo se crea un modelo de base de datos para el almacenamiento 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 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 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 .

Configuración de Entity Framework Core

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

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

¿Cómo cargar archivos PDF en un controlador ASP.NET Core ?

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);
    }
}
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

Validación de archivos cargados

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

Cómo cargar y descargar archivos PDF en ASP .NET C# con IronPDF: Imagen 1 - UI mostrando el PDF subido

¿Cómo agregar una marca de agua a un PDF cargado antes de guardarlo?

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));
}
[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

Opciones de configuración de marca de agua

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

Cómo cargar y descargar archivos PDF en ASP .NET C# con IronPDF: Imagen 2 - PDF con marca de agua y luego guardado en la base de datos

¿Cómo descargar archivos PDF almacenados en la base de datos?

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);
}
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

Visualización de una lista de descargas en la vista

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

Cómo cargar y descargar archivos PDF en ASP .NET C# con IronPDF: Imagen 3 - Lista de archivos PDF almacenados

Almacenamiento del sistema de archivos como alternativa

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.

¿Cómo generar documentos PDF a pedido y ofrecerlos para su descarga?

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");
}
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

Opciones de renderizado para archivos PDF a pedido

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

Cómo cargar y descargar archivos PDF en ASP .NET C# con IronPDF: Imagen 4 - PDF de ejemplo generado

¿Cómo fusionar varios archivos PDF en ASP.NET Core?

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");
}
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

Cómo dividir páginas de un PDF

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

¿Cómo gestionar de forma segura la carga de archivos grandes?

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.

Transmisión de archivos grandes para evitar la presión de la memoria

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

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.

¿Cuales son tus próximos pasos?

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.

Preguntas Frecuentes

¿Cómo puedo cargar archivos PDF en una aplicación ASP.NET Core MVC?

Para cargar archivos PDF en una aplicación ASP.NET Core MVC, puede utilizar la interfaz IFormFile para capturar los datos del archivo desde un formulario y, a continuación, procesarlos del lado del servidor antes de guardarlos, posiblemente con la ayuda de IronPDF para una manipulación posterior del PDF.

¿Cuál es la mejor manera de descargar archivos PDF en ASP.NET?

La mejor manera de descargar archivos PDF en ASP.NET es utilizar la acción FileResult en su controlador. IronPDF puede ayudarle a generar y modificar archivos PDF en el servidor para garantizar que estén listos para su descarga.

¿Puedo almacenar archivos PDF en una base de datos utilizando ASP.NET?

Sí, puede almacenar archivos PDF en una base de datos mediante ASP.NET convirtiendo el archivo en una matriz de bytes y guardándolo como un objeto binario de gran tamaño (BLOB). IronPDF puede ayudar a procesar el PDF antes de almacenarlo.

¿Cómo ayuda IronPDF a poner marcas de agua a los PDF en ASP.NET?

IronPDF ofrece funciones para añadir fácilmente marcas de agua de texto o imagen a los PDF, que pueden integrarse en su aplicación ASP.NET para modificar los documentos antes de descargarlos o almacenarlos.

¿Cuáles son las ventajas de utilizar EF Core para el almacenamiento de PDF?

EF Core permite una asignación objeto-relacional eficaz, lo que facilita la gestión del almacenamiento y la recuperación de archivos PDF de forma estructurada y escalable dentro de su aplicación ASP.NET.

¿Es posible manipular contenido PDF en aplicaciones ASP.NET?

Sí, con IronPDF se puede manipular el contenido de PDF, incluida la edición de texto, imágenes y metadatos, lo que puede ser útil para personalizar documentos antes de que se sirvan a los usuarios.

¿Cómo puedo gestionar la carga de archivos de forma segura en ASP.NET?

Para gestionar las cargas de archivos de forma segura en ASP.NET, debe validar los tipos de archivos, limitar su tamaño y almacenarlos en ubicaciones seguras. El uso de bibliotecas como IronPDF también puede ayudar a garantizar la integridad de los propios archivos PDF.

¿Cuáles son los retos más comunes cuando se trabaja con PDF en aplicaciones web?

Entre los retos comunes se incluyen garantizar la compatibilidad de archivos, gestionar archivos de gran tamaño y mantener la integridad de los documentos. IronPDF ayuda a superarlos proporcionando herramientas sólidas para la creación y manipulación de PDF.

¿Puedo convertir diferentes tipos de archivos a PDF en ASP.NET?

Sí, IronPDF le permite convertir varios tipos de archivos, como archivos HTML o de imagen, en archivos PDF sin problemas dentro de su aplicación ASP.NET.

¿Cuál es el papel del Modelo-Vista-Controlador (MVC) en la gestión de archivos PDF en ASP.NET?

El patrón MVC ayuda a organizar el código para manejar PDF separando la gestión de datos (Modelo), la interfaz de usuario (Vista) y la lógica de aplicación (Controlador), lo que facilita la gestión y la ampliación de las funcionalidades de PDF.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

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

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame