Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Recuperar un archivo PDF de una base de datos Apr .NET
USANDO IRONPDF

Cómo recuperar archivos PDF de una base de datos en ASP.NET usando C#

Curtis Chau
Curtis Chau
Actualizado:

Recuperar un archivo PDF de una base de datos en ASP.NET usando C# requiere tres pasos: consultar la tabla de la base de datos por la columna BLOB binaria, cargar los bytes en un objeto PdfDocument usando IronPDF, y devolver los bytes al navegador a través de una respuesta Contenido del archivoResult o File(). IronPDF se encarga de las funciones de renderizado, marca de agua y seguridad para que usted pueda concentrarse en la lógica de acceso a los datos.

¿Cómo instalar IronPDF para ASP.NET?

Antes de escribir cualquier código de recuperación de PDF, agregue IronPDF a su proyecto a través del Administrador de paquetes NuGet :

Install-Package IronPdf
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Después de la instalación, configure su clave de licencia en Program.cs o appsettings.json antes de llamar a cualquier método de IronPDF:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

IronPDF es compatible con .NET 10 , .NET 8, .NET 6 y .NET Framework 4.6.2+. Funciona en Windows, Linux y macOS sin necesidad de dependencias adicionales ni instalaciones de navegadores sin interfaz gráfica. Está disponible una licencia de prueba gratuita para evaluación.

¿Cómo se configura la tabla de base de datos de SQL Server?

El enfoque más común es almacenar archivos PDF como datos binarios en una columna VARBINARY(MAX) de SQL Server. Esto mantiene el documento y sus metadatos juntos en una sola tabla, simplifica la copia de seguridad y evita la administración de rutas del sistema de archivos.

Utilice el siguiente script SQL para crear la tabla de almacenamiento:

// SQL Server table definition (run this in SSMS or via EF migrations)
// CREATE TABLE PdfDocuments (
//     Id INT IDENTITY(1,1) PRIMARY KEY,
//     FileName NVARCHAR(255) NOT NULL,
//     FileContent VARBINARY(MAX) NOT NULL,
//     UploadedAt DATETIME2 DEFAULT GETUTCDATE()
// );
// SQL Server table definition (run this in SSMS or via EF migrations)
// CREATE TABLE PdfDocuments (
//     Id INT IDENTITY(1,1) PRIMARY KEY,
//     FileName NVARCHAR(255) NOT NULL,
//     FileContent VARBINARY(MAX) NOT NULL,
//     UploadedAt DATETIME2 DEFAULT GETUTCDATE()
// );
$vbLabelText   $csharpLabel

Una vez que la tabla exista, configure la cadena de conexión en appsettings.json:

// appsettings.json snippet (not C# -- shown as reference)
// "ConnectionStrings": {
//   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
// }
// appsettings.json snippet (not C# -- shown as reference)
// "ConnectionStrings": {
//   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
// }
' appsettings.json snippet (not VB.NET -- shown as reference)
' "ConnectionStrings": {
'   "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
' }
$vbLabelText   $csharpLabel

Registre la cadena de conexión mediante inyección de dependencias en Program.cs:

using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddSingleton<IConfiguration>(builder.Configuration);

IronPdf.License.LicenseKey = builder.Configuration["IronPdf:LicenseKey"];

var app = builder.Build();
app.MapControllers();
app.Run();
using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllers();
builder.Services.AddSingleton<IConfiguration>(builder.Configuration);

IronPdf.License.LicenseKey = builder.Configuration["IronPdf:LicenseKey"];

var app = builder.Build();
app.MapControllers();
app.Run();
Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllers()
builder.Services.AddSingleton(Of IConfiguration)(builder.Configuration)

IronPdf.License.LicenseKey = builder.Configuration("IronPdf:LicenseKey")

Dim app = builder.Build()
app.MapControllers()
app.Run()
$vbLabelText   $csharpLabel

¿Cómo recuperar un PDF de SQL Server en ASP.NET Core?

El patrón de recuperación sigue tres pasos: abrir una conexión, ejecutar una consulta SELECT parametrizada y leer la columna binaria en un byte[]. IronPDF luego carga esa matriz en un objeto PdfDocument para procesamiento opcional antes de enviarlo al cliente.

Construyendo el controlador de API

Cree un controlador que exponga puntos finales GET tanto para la visualización en línea como para la descarga de archivos:

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.SqlClient;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly string _connectionString;

    public PdfController(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection")
            ?? throw new InvalidOperationException("Connection string not found.");
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetPdf(int id)
    {
        byte[] pdfBytes = await RetrievePdfBytesAsync(id);
        if (pdfBytes is null || pdfBytes.Length == 0)
            return NotFound("PDF document not found.");

        // Load into IronPDF for validation or optional modification
        using var pdfDocument = new PdfDocument(pdfBytes);

        // Inline display -- browser opens PDF viewer
        Response.Headers.Append("Content-Disposition", "inline; filename=\"document.pdf\"");
        return File(pdfDocument.BinaryData, "application/pdf");
    }

    private async Task<byte[]> RetrievePdfBytesAsync(int documentId)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

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

        var result = await command.ExecuteScalarAsync();
        return result as byte[] ?? Array.Empty<byte>();
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Data.SqlClient;

[ApiController]
[Route("api/[controller]")]
public class PdfController : ControllerBase
{
    private readonly string _connectionString;

    public PdfController(IConfiguration configuration)
    {
        _connectionString = configuration.GetConnectionString("DefaultConnection")
            ?? throw new InvalidOperationException("Connection string not found.");
    }

    [HttpGet("{id}")]
    public async Task<IActionResult> GetPdf(int id)
    {
        byte[] pdfBytes = await RetrievePdfBytesAsync(id);
        if (pdfBytes is null || pdfBytes.Length == 0)
            return NotFound("PDF document not found.");

        // Load into IronPDF for validation or optional modification
        using var pdfDocument = new PdfDocument(pdfBytes);

        // Inline display -- browser opens PDF viewer
        Response.Headers.Append("Content-Disposition", "inline; filename=\"document.pdf\"");
        return File(pdfDocument.BinaryData, "application/pdf");
    }

    private async Task<byte[]> RetrievePdfBytesAsync(int documentId)
    {
        await using var connection = new SqlConnection(_connectionString);
        await connection.OpenAsync();

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

        var result = await command.ExecuteScalarAsync();
        return result as byte[] ?? Array.Empty<byte>();
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Data.SqlClient

<ApiController>
<Route("api/[controller]")>
Public Class PdfController
    Inherits ControllerBase

    Private ReadOnly _connectionString As String

    Public Sub New(configuration As IConfiguration)
        _connectionString = configuration.GetConnectionString("DefaultConnection")
        If _connectionString Is Nothing Then
            Throw New InvalidOperationException("Connection string not found.")
        End If
    End Sub

    <HttpGet("{id}")>
    Public Async Function GetPdf(id As Integer) As Task(Of IActionResult)
        Dim pdfBytes As Byte() = Await RetrievePdfBytesAsync(id)
        If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
            Return NotFound("PDF document not found.")
        End If

        ' Load into IronPDF for validation or optional modification
        Using pdfDocument As New PdfDocument(pdfBytes)
            ' Inline display -- browser opens PDF viewer
            Response.Headers.Append("Content-Disposition", "inline; filename=""document.pdf""")
            Return File(pdfDocument.BinaryData, "application/pdf")
        End Using
    End Function

    Private Async Function RetrievePdfBytesAsync(documentId As Integer) As Task(Of Byte())
        Await Using connection As New SqlConnection(_connectionString)
            Await connection.OpenAsync()

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

                Dim result = Await command.ExecuteScalarAsync()
                Return If(TryCast(result, Byte()), Array.Empty(Of Byte)())
            End Using
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Este controlador usa consultas parametrizadas para prevenir la inyección SQL y await using para desechar SqlConnection y SqlCommand correctamente. La clase PdfDocument valida la matriz de bytes y expone la propiedad BinaryData para transmisión.

Devolución de un archivo con nombre para su descarga

Cuando los usuarios necesitan guardar el documento en lugar de verlo en línea, configure el encabezado Content-Disposition a attachment y pase el nombre de archivo original:

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

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

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

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

    using var pdfDocument = new PdfDocument(pdfBytes);
    return File(pdfDocument.BinaryData, "application/pdf", fileName);
}
[HttpGet("download/{id}")]
public async Task<IActionResult> DownloadPdf(int id)
{
    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

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

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

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

    using var pdfDocument = new PdfDocument(pdfBytes);
    return File(pdfDocument.BinaryData, "application/pdf", fileName);
}
Imports System.Data.SqlClient
Imports Microsoft.AspNetCore.Mvc

<HttpGet("download/{id}")>
Public Async Function DownloadPdf(id As Integer) As Task(Of IActionResult)
    Await Using connection As New SqlConnection(_connectionString)
        Await connection.OpenAsync()

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

            Await Using reader As SqlDataReader = Await command.ExecuteReaderAsync()
                If Not Await reader.ReadAsync() Then
                    Return NotFound("Document not found.")
                End If

                Dim fileName As String = reader.GetString(reader.GetOrdinal("FileName"))
                Dim pdfBytes As Byte() = CType(reader("FileContent"), Byte())

                Using pdfDocument As New PdfDocument(pdfBytes)
                    Return File(pdfDocument.BinaryData, "application/pdf", fileName)
                End Using
            End Using
        End Using
    End Using
End Function
$vbLabelText   $csharpLabel

Pasar fileName como tercer argumento a File() establece automáticamente el encabezado Content-Disposition a attachment. ASP.NET Core maneja la correcta comilla de nombres de archivos que contienen espacios.

¿Cómo agregar una marca de agua a un PDF recuperado?

Una de las operaciones posteriores a la recuperación más prácticas es estampar una marca de agua en cada página antes de entregar el documento. Esto es útil para informes confidenciales, borradores de documentos o cualquier archivo que necesite una marca de seguridad visible.

Cómo aplicar una marca de agua HTML con IronPDF

La API de marca de agua de IronPDF acepta cualquier cadena HTML, lo que significa que puedes diseñar el texto de la marca de agua usando CSS en línea. Establezca la opacidad lo suficientemente baja para que el contenido subyacente permanezca legible:

[HttpGet("watermarked/{id}")]
public async Task<IActionResult> GetWatermarkedPdf(int id)
{
    byte[] pdfBytes = await RetrievePdfBytesAsync(id);
    if (pdfBytes is null || pdfBytes.Length == 0)
        return NotFound("PDF document not found.");

    using var pdfDocument = new PdfDocument(pdfBytes);

    // HTML watermark applied to every page
    string watermarkHtml = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>";
    pdfDocument.ApplyWatermark(
        watermarkHtml,
        rotation: 30,
        verticalAlignment: VerticalAlignment.Middle,
        horizontalAlignment: HorizontalAlignment.Center
    );

    return File(pdfDocument.BinaryData, "application/pdf");
}
[HttpGet("watermarked/{id}")]
public async Task<IActionResult> GetWatermarkedPdf(int id)
{
    byte[] pdfBytes = await RetrievePdfBytesAsync(id);
    if (pdfBytes is null || pdfBytes.Length == 0)
        return NotFound("PDF document not found.");

    using var pdfDocument = new PdfDocument(pdfBytes);

    // HTML watermark applied to every page
    string watermarkHtml = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>";
    pdfDocument.ApplyWatermark(
        watermarkHtml,
        rotation: 30,
        verticalAlignment: VerticalAlignment.Middle,
        horizontalAlignment: HorizontalAlignment.Center
    );

    return File(pdfDocument.BinaryData, "application/pdf");
}
Imports Microsoft.AspNetCore.Mvc

<HttpGet("watermarked/{id}")>
Public Async Function GetWatermarkedPdf(id As Integer) As Task(Of IActionResult)
    Dim pdfBytes As Byte() = Await RetrievePdfBytesAsync(id)
    If pdfBytes Is Nothing OrElse pdfBytes.Length = 0 Then
        Return NotFound("PDF document not found.")
    End If

    Using pdfDocument As New PdfDocument(pdfBytes)
        ' HTML watermark applied to every page
        Dim watermarkHtml As String = "<h2 style='color:red; opacity:0.4; font-family:Arial;'>CONFIDENTIAL</h2>"
        pdfDocument.ApplyWatermark(
            watermarkHtml,
            rotation:=30,
            verticalAlignment:=VerticalAlignment.Middle,
            horizontalAlignment:=HorizontalAlignment.Center
        )

        Return File(pdfDocument.BinaryData, "application/pdf")
    End Using
End Function
$vbLabelText   $csharpLabel

El método ApplyWatermark acepta HTML y CSS estándar, por lo que tienes control total sobre la fuente, el color, la opacidad y la posición. La marca de agua se aplica automáticamente a todas las páginas del documento. Para características adicionales de manipulación de PDF, incluyendo estampar imágenes, agregar encabezados y pies de página, o fusionar múltiples documentos, consulte la documentación de IronPDF.

¿Cómo almacenar archivos PDF cargados nuevamente en SQL Server?

Para completar el viaje de ida y vuelta se requiere un punto final de carga que lea los archivos de formulario entrantes y los escriba en la base de datos. Esto se combina con los puntos finales de recuperación anteriores para formar un sistema completo de gestión de documentos:

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

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

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

    // Validate using IronPDF before storage
    using var pdfDocument = new PdfDocument(pdfBytes);

    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string insertQuery = @"
        INSERT INTO PdfDocuments (FileName, FileContent)
        VALUES (@FileName, @FileContent);
        SELECT SCOPE_IDENTITY();";

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

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

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

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

    // Validate using IronPDF before storage
    using var pdfDocument = new PdfDocument(pdfBytes);

    await using var connection = new SqlConnection(_connectionString);
    await connection.OpenAsync();

    const string insertQuery = @"
        INSERT INTO PdfDocuments (FileName, FileContent)
        VALUES (@FileName, @FileContent);
        SELECT SCOPE_IDENTITY();";

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

    var newId = Convert.ToInt32(await command.ExecuteScalarAsync());
    return Ok(new { id = newId, fileName = file.FileName });
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Http
Imports Microsoft.AspNetCore.Mvc
Imports System.Data.SqlClient
Imports IronPdf

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

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

    Using memoryStream As New MemoryStream()
        Await file.CopyToAsync(memoryStream)
        Dim pdfBytes As Byte() = memoryStream.ToArray()

        ' Validate using IronPDF before storage
        Using pdfDocument As New PdfDocument(pdfBytes)

            Await Using connection As New SqlConnection(_connectionString)
                Await connection.OpenAsync()

                Const insertQuery As String = "
                    INSERT INTO PdfDocuments (FileName, FileContent)
                    VALUES (@FileName, @FileContent);
                    SELECT SCOPE_IDENTITY();"

                Await Using command As New SqlCommand(insertQuery, connection)
                    command.Parameters.AddWithValue("@FileName", file.FileName)
                    command.Parameters.AddWithValue("@FileContent", pdfDocument.BinaryData)

                    Dim newId As Integer = Convert.ToInt32(Await command.ExecuteScalarAsync())
                    Return Ok(New With {.id = newId, .fileName = file.FileName})
                End Using
            End Using
        End Using
    End Using
End Function
$vbLabelText   $csharpLabel

Usar PdfDocument para validar antes del almacenamiento asegura que solo archivos PDF analizables y bien formados ingresen a la base de datos. Si la matriz de bytes está dañada o truncada, IronPDF lanza una excepción que puede capturar y devolver como una respuesta 400 Bad Request.

¿Cuáles son las tablas y tipos de columnas clave para el almacenamiento de PDF?

El esquema que utilice afectará el rendimiento de la consulta y la eficiencia del almacenamiento. La siguiente tabla muestra la configuración de columnas recomendada para SQL Server:

Esquema de SQL Server recomendado para el almacenamiento de BLOB PDF
Columna Tipo de datos Objetivo
Id INT IDENTITY Clave principal, incremento automático
FileName NVARCHAR(255) Nombre de archivo original para los encabezados de descarga
FileContent VARBINARY(MAX) Datos binarios PDF sin procesar (BLOB)
ContentType NVARCHAR(100) Tipo MIME, p. ej., application/pdf
FileSizeBytes BIGINT Tamaño almacenado para la gestión de cuotas
UploadedAt DATETIME2 Marca de tiempo UTC para auditoría
UploadedBy NVARCHAR(100) Identificador de entidad de usuario para control de acceso

Para sistemas de gran escala donde se necesita la transmisión de archivos de SQL Server, Microsoft documenta la función FILESTREAM como una alternativa que almacena BLOB grandes en el sistema de archivos y al mismo tiempo permite realizar consultas a través de T-SQL. Sin embargo, para la mayoría de las aplicaciones ASP.NET que sirven documentos de hasta unos cientos de megabytes, el almacenamiento en fila VARBINARY(MAX) funciona bien y simplifica el despliegue.

¿Cómo gestionar los errores y optimizar el rendimiento?

La recuperación confiable de PDF en producción requiere manejo de errores en cada capa: base de datos, IronPDF y respuesta HTTP. La siguiente tabla resume las prácticas clave:

Manejo de errores y patrones de rendimiento para la recuperación de PDF
Inquietud Recomendación Razón
Eliminación de la conexión `await using` declaraciones Previene el agotamiento del grupo de conexiones
Eliminación de documentos PDF `using` declaraciones Libera rápidamente la memoria no administrada
Inyección SQL Solo consultas parametrizadas Evita que entradas maliciosas alteren las consultas
Validación del tipo de archivo Comprobar el tipo MIME y los bytes mágicos Bloquea cargas que no sean PDF antes del almacenamiento
Manejo de archivos grandes Respuesta de transmisión con `FileStreamResult` Evita cargar el archivo completo en la memoria del servidor
Caché Utilice `IMemoryCache` o `IDistributedCache` Reduce los viajes repetidos de ida y vuelta a la base de datos
Operaciones asincrónicas `async` / `await` durante todo el proceso Mantiene los subprocesos libres durante las esperas de disco y red

Para la gestión de cadenas de conexión, almacene el valor en appsettings.json y nunca lo codifique directamente en los archivos fuente. Utilice la administración de secretos integrada de ASP.NET Core durante el desarrollo local y Azure Key Vault o AWS Secrets Manager en producción. Nunca envíe cadenas de conexión ni claves de licencia al control de código fuente.

Al servir archivos PDF grandes, considere devolver un FileStreamResult respaldado por un MemoryStream en lugar de cargar toda la matriz de bytes en la memoria. Para documentos muy grandes (más de 100 MB), la API FILESTREAM de SQL Server permite la transmisión fragmentada directamente desde el sistema de archivos.

Almacenamiento en caché de documentos de acceso frecuente

Si ciertos archivos PDF se solicitan repetidamente -- por ejemplo, un documento de términos y condiciones o un catálogo de productos -- almacenar en caché la matriz de bytes en IMemoryCache evita repetidos viajes de ida y vuelta al base de datos. Registre IMemoryCache en Program.cs con builder.Services.AddMemoryCache(), luego inyectelo en el controlador y verifique la caché antes de consultar la base de datos. Establezca una fecha de caducidad absoluta que coincida con la frecuencia de actualización esperada de los documentos. Cuando se actualiza un documento, elimina la entrada almacenada en caché por clave para que la próxima solicitud obtenga la nueva versión.

Para escenarios distribuidos -- como un despliegue equilibrado con múltiples instancias de servidor -- reemplace IMemoryCache con IDistributedCache respaldado por Redis o SQL Server. Las abstracciones de caché distribuida de ASP.NET Core mantienen el código del controlador casi idéntico; solo cambia el registro en Program.cs.

¿Cómo implementar la recuperación de PDF en varias plataformas con IronPDF?

IronPDF funciona en Linux, Windows y macOS sin necesidad de una instalación independiente de Chromium ni de ningún cambio de configuración. El mismo paquete NuGet está dirigido a todas las plataformas, por lo que su controlador de PDF funciona de manera idéntica independientemente de si implementa en:

  • Servidor Windows con IIS
  • Contenedores de Ubuntu en Docker o Kubernetes
  • Servicio de aplicaciones de Azure (Linux o Windows)
  • AWS Elastic Beanstalk

Implementación en Docker y Linux

Para implementaciones de Docker, agregue las dependencias de IronPDF a su Dockerfile. La documentación de IronPDF para Linux proporciona los paquetes apt exactos necesarios para las imágenes base de Debian y Alpine. Un Dockerfile típico de varias etapas instala las dependencias del sistema operativo en la etapa de imagen en tiempo de ejecución y luego copia la aplicación ASP.NET publicada. Al usar Azure, la guía de implementación de Azure cubre la configuración de App Service, incluyendo la configuración de memoria y CPU que permite la representación de PDF a escala.

Dado que IronPDF incluye su propio motor de renderizado basado en Chromium, no es necesario instalar un navegador independiente en el servidor. Esto simplifica considerablemente las configuraciones de contenedores Linux en comparación con las soluciones que requieren un navegador a nivel de sistema. El equipo de IronPDF realiza pruebas con las imágenes base de Linux más comunes en cada lanzamiento, por lo que puede confiar en que un contenedor Alpine o Debian funcionará de inmediato.

Uso de Entity Framework Core en lugar de ADO .NET

IronPDF también se integra con Entity Framework Core como alternativa al formato ADO .NET sin formato. Si su proyecto ya usa EF Core, puede mapear la columna Contenido del archivo a una propiedad byte[] en una clase modelo y dejar que EF maneje la generación de la consulta. Este enfoque reduce significativamente el código repetitivo y facilita la incorporación de filtrado, paginación y comportamiento de auditoría a través del proveedor LINQ de EF.

La desventaja es que EF Core carga el BLOB completo en la memoria como parte del gráfico de entidades. Para archivos PDF muy grandes, considere usar ADO.NET en crudo o el método FromSql de EF Core con una proyección que seleccione solo la columna de matriz de bytes en lugar de la entidad completa.

¿Cuales son tus próximos pasos?

Recuperar archivos PDF de una base de datos SQL Server en ASP.NET Core usando C# e IronPDF sigue un patrón claro: consultar la columna BLOB con un SELECT parametrizado, cargar los bytes en un PdfDocument, y devolver los datos binarios con el encabezado Content-Disposition correcto. IronPDF agrega la capacidad de validar, marcar con marca de agua, fusionar o proteger documentos antes de que salgan de su servidor.

Para profundizar en las capacidades de gestión de documentos de IronPDF, explore estos recursos:

Comience con una licencia de prueba gratuita de IronPDF para probar todas las funciones sin restricciones. La versión de prueba produce una salida con marca de agua; Eliminar la marca de agua aplicando una clave de licencia paga. La documentación de referencia completa de la API y ejemplos de código están disponibles en el sitio web de IronPDF para cada método utilizado en este artículo.

Si su proyecto ya utiliza Entity Framework Core, la guía de integración de IronPDF con EF Core muestra cómo reemplazar ADO .NET sin procesar con modelos de entidad, manteniendo la misma canalización de procesamiento de IronPDF . Para los equipos que trabajan con .NET 10 y las últimas características de ASP.NET Core , los mismos patrones descritos aquí funcionan sin modificaciones: IronPDF es compatible con todas las versiones activas de .NET LTS y STS.

Revise la página de precios de IronPDF para encontrar el nivel de licencia adecuado para su implementación. Una única licencia de desarrollador cubre el desarrollo y las pruebas locales; Las licencias de redistribución están disponibles para productos SaaS e implementaciones locales con múltiples servidores.

Preguntas Frecuentes

¿Qué es IronPDF?

IronPDF es una biblioteca .NET que permite a los desarrolladores crear, editar y extraer contenido de archivos PDF en aplicaciones C#.

¿Cómo puedo recuperar un archivo PDF de una base de datos utilizando ASP.NET?

Para recuperar un archivo PDF de una base de datos en ASP.NET, puede utilizar código C# para consultar la base de datos y leer los datos del PDF en una matriz de bytes. A continuación, esta matriz de bytes se puede utilizar con IronPDF para representar o manipular el PDF según sea necesario.

¿Por qué debería utilizar IronPDF para gestionar archivos PDF en mi aplicación ASP.NET?

IronPDF ofrece un amplio conjunto de características para manejar PDFs, incluyendo la generación de PDFs, conversión desde HTML y manipulación. Se integra con ASP.NET y proporciona una API fácil de usar para trabajar con PDFs.

¿Cuáles son los requisitos previos para utilizar IronPDF en ASP.NET?

Para utilizar IronPDF en ASP.NET, debe tener configurado un entorno de desarrollo .NET, como Visual Studio, e incluir la biblioteca IronPDF en su proyecto a través del gestor de paquetes NuGet.

¿Se puede utilizar IronPDF para editar archivos PDF existentes?

Sí, IronPDF puede utilizarse para editar archivos PDF existentes. Permite modificaciones como añadir texto o imágenes, fusionar documentos, etc.

¿Es posible convertir HTML a PDF con IronPDF?

Sí, IronPDF puede convertir contenido HTML directamente a formato PDF, lo que facilita la generación de PDF a partir de páginas web u otro contenido HTML.

¿Cómo se gestionan las funciones de seguridad de PDF con IronPDF?

IronPDF es compatible con varias funciones de seguridad para PDF, incluida la protección mediante contraseña y el establecimiento de permisos para controlar el acceso y la edición de documentos.

¿Qué tipos de bases de datos son compatibles con IronPDF para la recuperación de PDF?

IronPDF puede trabajar con cualquier base de datos que pueda almacenar datos binarios, como SQL Server, MySQL o PostgreSQL, para recuperar y manipular archivos 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