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.
Antes de escribir cualquier código de recuperación de PDF, agregue IronPDF a su proyecto a través del Administrador de paquetes NuGet :
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 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.
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()
// );netUna 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 VB.NET -- shown as reference)
' "ConnectionStrings": {
' "DefaultConnection": "Server=localhost;Database=PdfStorage;Integrated Security=True;"
' }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();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()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.
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>();
}
}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 ClassEste 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.
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);
}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 FunctionPasar 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.
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.
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");
}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 FunctionEl 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.
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 });
}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 FunctionUsar 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.
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:
| 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.
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:
| 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.
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.
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:
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.
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.
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.
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.
