Cree objetos PdfDocument a partir de sus matrices de bytes y use PdfDocument.Merge() para combinarlos en un solo PDF sin guardarlo en disco. Este método gestiona automáticamente la compleja estructura del PDF, lo que le permite combinar documentos almacenados en bases de datos o recibidos de API sin necesidad de escribir archivos temporales.
Trabajar con archivos PDF almacenados como matrices de bytes es común en las aplicaciones C# modernas. Ya sea que esté recuperando documentos PDF de una base de datos, recibiéndolos de servicios web o procesándolos en la memoria, la capacidad de fusionar múltiples archivos PDF en uno sin guardarlos en el disco es esencial para los flujos de trabajo empresariales. IronPDF lo hace sencillo con una API intuitiva. En este artículo, aprenderá a fusionar matrices de bytes de PDF en C# y examinará diferentes enfoques, incluido el manejo de MemoryStream y patrones de bases de datos del mundo real.
Una matriz de bytes son datos binarios sin procesar que representan un archivo PDF en la memoria. Al trabajar con documentos PDF en C#, a menudo encontrará situaciones en las que los archivos existen como matrices de bytes en lugar de en el disco. Esto es particularmente común cuando se recuperan documentos de bases de datos donde los PDF se almacenan como columnas binarias o cuando se reciben documentos de API REST.
La funcionalidad MemoryStream en .NET , documentada en la referencia de Microsoft MemoryStream , hace que el manejo de estas matrices de bytes sea eficiente, especialmente cuando se combina con una gestión de memoria adecuada para documentos grandes. En lugar de escribir archivos temporales, puede cargar, procesar y guardar archivos PDF completamente en la memoria, lo que es más rápido, más limpio y evita problemas de permisos del sistema de archivos.
La simple concatenación de dos matrices de bytes PDF no funcionará. A diferencia de los archivos de texto simple, los archivos PDF tienen estructuras internas complejas con encabezados, tablas de referencias cruzadas y convenciones de formato específicas. La especificación PDF ISO 32000 define reglas complejas sobre la estructura del documento, incluidos metadatos, incrustación de fuentes y capas de cifrado. Unir los bytes directamente produce un archivo corrupto. Se necesita una biblioteca PDF adecuada para analizar esas matrices de bytes y combinarlas correctamente, preservando la integridad estructural.
IronPDF gestiona toda esta complejidad internamente. Puede fusionar documentos PDF con solo unas pocas líneas de código conservando las fuentes, las imágenes y el formato exactamente como aparecieron en los archivos de origen.
Este enfoque funciona bien cuando:
Al trabajar con Azure Blob Storage o servicios en la nube similares, la manipulación de matrices de bytes se vuelve esencial porque se descargan los bytes sin procesar, se los procesa y se carga el resultado, todo sin tocar el sistema de archivos.
Para comenzar, es necesario agregar el paquete NuGet IronPDF a su proyecto. El paquete está disponible en NuGet . Puede instalarlo utilizando la Consola del Administrador de paquetes o la CLI de .NET :
Para conocer las opciones de instalación detalladas, incluida la implementación de Docker o la configuración de Linux , consulte la guía de instalación avanzada . Si está implementando en un entorno mínimo, IronPDF Slim reduce significativamente el espacio de implementación.
Una vez instalado, agregue los siguientes espacios de nombres en la parte superior de su archivo C#:
using IronPdf;
using System.IO;
using System.Collections.Generic;Imports IronPdf
Imports System.IO
Imports System.Collections.GenericIronPDF es compatible con las plataformas Windows, macOS y Linux . Se integra con ASP.NET Core , Blazor, aplicaciones de consola y entornos de nube sin ninguna configuración adicional.
A continuación se muestra un ejemplo completo que demuestra cómo fusionar dos matrices de bytes PDF en un solo documento PDF:
// Simulate two PDF byte arrays (in practice, these come from a database or API)
byte[] pdfBytes1 = File.ReadAllBytes("document1.pdf");
byte[] pdfBytes2 = File.ReadAllBytes("document2.pdf");
// Create PdfDocument objects from byte arrays
var pdf1 = new PdfDocument(pdfBytes1);
var pdf2 = new PdfDocument(pdfBytes2);
// Merge the two PDF documents
PdfDocument combinedPdf = PdfDocument.Merge(pdf1, pdf2);
// Convert the combined PDF back to a byte array
byte[] mergedPdfBytes = combinedPdf.BinaryData;
// Optionally save the merged PDF to disk
File.WriteAllBytes("merged.pdf", mergedPdfBytes);Imports System.IO
' Simulate two PDF byte arrays (in practice, these come from a database or API)
Dim pdfBytes1 As Byte() = File.ReadAllBytes("document1.pdf")
Dim pdfBytes2 As Byte() = File.ReadAllBytes("document2.pdf")
' Create PdfDocument objects from byte arrays
Dim pdf1 As New PdfDocument(pdfBytes1)
Dim pdf2 As New PdfDocument(pdfBytes2)
' Merge the two PDF documents
Dim combinedPdf As PdfDocument = PdfDocument.Merge(pdf1, pdf2)
' Convert the combined PDF back to a byte array
Dim mergedPdfBytes As Byte() = combinedPdf.BinaryData
' Optionally save the merged PDF to disk
File.WriteAllBytes("merged.pdf", mergedPdfBytes)La clase PdfDocument acepta matrices de bytes sin procesar directamente en su constructor. Una vez que tenga dos instancias PdfDocument, PdfDocument.Merge() las combina en un solo documento. Luego, la propiedad BinaryData le brinda el resultado como una matriz de bytes, lista para almacenarse nuevamente en una base de datos o transmitirse a través de una API.
La API de PdfDocument proporciona una amplia funcionalidad más allá de la simple fusión, incluida la manipulación de páginas , la extracción de texto y el manejo de formularios . Una vez que tenga un documento fusionado, puede aplicar cualquiera de estas operaciones antes de extraer la matriz de bytes final.
El resultado es un único PDF que contiene todas las páginas de ambos documentos de origen en el orden en que se pasaron a Merge(). Se conservan la numeración de páginas, las fuentes, las imágenes y el contenido incrustado. El documento fusionado se comporta de forma idéntica a cualquier otro PDF: puedes paginarlo, anotarlo, firmarlo o comprimirlo utilizando los mismos métodos de IronPDF que aplicarías a cualquier documento.
Cuando pasa una matriz de bytes al constructor PdfDocument, IronPDF analiza los datos binarios y crea una representación en memoria de la estructura PDF. Luego, el método PdfDocument.Merge() combina varios documentos agregando páginas de cada fuente en secuencia, reconstruyendo la tabla de referencias cruzadas y resolviendo cualquier conflicto de nombres de fuentes o recursos entre los documentos.
Por eso no se pueden concatenar matrices de bytes: la tabla de referencias cruzadas del primer PDF apunta a desplazamientos dentro de ese archivo. Tras la concatenación, esos desplazamientos no son válidos porque el segundo archivo los ha desplazado. IronPDF reconstruye toda la estructura correctamente, dando como resultado un PDF válido y bien formado.
IronPDF proporciona una sobrecarga List para fusionar cualquier cantidad de documentos en una sola operación. Esto es más eficiente que encadenar múltiples fusiones de dos documentos:
// Load four PDFs as byte arrays
List<byte[]> pdfByteArrays = new List<byte[]>
{
File.ReadAllBytes("example1.pdf"),
File.ReadAllBytes("example2.pdf"),
File.ReadAllBytes("example3.pdf"),
File.ReadAllBytes("example4.pdf")
};
// Convert each byte array to a PdfDocument
List<PdfDocument> pdfsToMerge = new List<PdfDocument>();
for (int i = 0; i < pdfByteArrays.Count; i++)
{
pdfsToMerge.Add(new PdfDocument(pdfByteArrays[i]));
}
// Merge all documents in one call
PdfDocument combinedPdf = PdfDocument.Merge(pdfsToMerge);
byte[] finalPdfBytes = combinedPdf.BinaryData;
// Apply compression if the result is large
if (finalPdfBytes.Length > 1024 * 1024 * 10) // 10 MB
{
combinedPdf.CompressImages(90);
finalPdfBytes = combinedPdf.BinaryData;
}Imports System.IO
' Load four PDFs as byte arrays
Dim pdfByteArrays As New List(Of Byte()) From {
File.ReadAllBytes("example1.pdf"),
File.ReadAllBytes("example2.pdf"),
File.ReadAllBytes("example3.pdf"),
File.ReadAllBytes("example4.pdf")
}
' Convert each byte array to a PdfDocument
Dim pdfsToMerge As New List(Of PdfDocument)()
For i As Integer = 0 To pdfByteArrays.Count - 1
pdfsToMerge.Add(New PdfDocument(pdfByteArrays(i)))
Next
' Merge all documents in one call
Dim combinedPdf As PdfDocument = PdfDocument.Merge(pdfsToMerge)
Dim finalPdfBytes As Byte() = combinedPdf.BinaryData
' Apply compression if the result is large
If finalPdfBytes.Length > 1024 * 1024 * 10 Then ' 10 MB
combinedPdf.CompressImages(90)
finalPdfBytes = combinedPdf.BinaryData
End IfEste enfoque se adapta a cualquier número de documentos. Cada PDF se carga en un objeto PdfDocument, se agrega a una lista y luego se fusiona en una sola llamada. Para archivos de salida grandes, la compresión PDF reduce el tamaño final sin perder calidad significativa.
El enfoque MemoryStream le brinda más control al integrarse con otras bibliotecas .NET que trabajan con transmisiones en lugar de matrices de bytes. También es útil cuando ya tienes una transmisión disponible (por ejemplo, desde una respuesta HTTP o un SDK de almacenamiento de blobs):
using (var stream1 = new MemoryStream(pdfBytes1))
using (var stream2 = new MemoryStream(pdfBytes2))
{
var pdf1 = new PdfDocument(stream1);
var pdf2 = new PdfDocument(stream2);
var merged = PdfDocument.Merge(pdf1, pdf2);
// Add metadata to the merged document
merged.MetaData.Author = "Your Application";
merged.MetaData.Title = "Merged Document";
merged.MetaData.CreationDate = DateTime.Now;
byte[] result = merged.BinaryData;
}Imports System.IO
Using stream1 As New MemoryStream(pdfBytes1)
Using stream2 As New MemoryStream(pdfBytes2)
Dim pdf1 = New PdfDocument(stream1)
Dim pdf2 = New PdfDocument(stream2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
' Add metadata to the merged document
merged.MetaData.Author = "Your Application"
merged.MetaData.Title = "Merged Document"
merged.MetaData.CreationDate = DateTime.Now
Dim result As Byte() = merged.BinaryData
End Using
End UsingPuede enriquecer el documento fusionado configurando metadatos , agregando marcas de agua o aplicando firmas digitales antes de extraer los bytes finales. Para escenarios de cumplimiento, considere la conversión de PDF/A para archivo a largo plazo o la conformidad con PDF/UA para requisitos de accesibilidad.
El procesamiento basado en secuencias proporciona una mejor gestión de la memoria para archivos PDF más grandes y se integra perfectamente con los SDK de almacenamiento en la nube. Este enfoque es especialmente práctico para patrones asincrónicos en servicios de alto rendimiento.
Un patrón común en el mundo real implica obtener matrices de bytes de PDF de una base de datos SQL y combinarlas a pedido. A continuación se muestra un ejemplo listo para producción con manejo de errores:
public string MergePdfDocumentsFromDatabase(List<int> documentIds)
{
List<PdfDocument> documents = new List<PdfDocument>();
try
{
foreach (int id in documentIds)
{
// Fetch PDF byte array from database
byte[] pdfData = GetPdfFromDatabase(id); // Replace with your data access logic
if (pdfData == null || pdfData.Length == 0)
{
Console.WriteLine($"Warning: Document {id} is empty or not found");
continue;
}
documents.Add(new PdfDocument(pdfData));
}
if (documents.Count == 0)
{
return "Error: No valid documents found to merge";
}
// Merge all documents
PdfDocument mergedDocument = PdfDocument.Merge(documents);
// Add page numbers to the footer
mergedDocument.AddHtmlFooters(new HtmlHeaderFooter()
{
HtmlFragment = "<center>Page {page} of {total-pages}</center>",
DrawDividerLine = true
});
// Save back to the database
byte[] resultBytes = mergedDocument.BinaryData;
SaveMergedPdfToDatabase(resultBytes);
return "Document successfully combined and saved.";
}
catch (Exception ex)
{
Console.WriteLine($"Error merging PDFs: {ex.Message}");
return $"Merge failed: {ex.Message}";
}
}Imports System
Public Function MergePdfDocumentsFromDatabase(documentIds As List(Of Integer)) As String
Dim documents As New List(Of PdfDocument)()
Try
For Each id As Integer In documentIds
' Fetch PDF byte array from database
Dim pdfData As Byte() = GetPdfFromDatabase(id) ' Replace with your data access logic
If pdfData Is Nothing OrElse pdfData.Length = 0 Then
Console.WriteLine($"Warning: Document {id} is empty or not found")
Continue For
End If
documents.Add(New PdfDocument(pdfData))
Next
If documents.Count = 0 Then
Return "Error: No valid documents found to merge"
End If
' Merge all documents
Dim mergedDocument As PdfDocument = PdfDocument.Merge(documents)
' Add page numbers to the footer
mergedDocument.AddHtmlFooters(New HtmlHeaderFooter() With {
.HtmlFragment = "<center>Page {page} of {total-pages}</center>",
.DrawDividerLine = True
})
' Save back to the database
Dim resultBytes As Byte() = mergedDocument.BinaryData
SaveMergedPdfToDatabase(resultBytes)
Return "Document successfully combined and saved."
Catch ex As Exception
Console.WriteLine($"Error merging PDFs: {ex.Message}")
Return $"Merge failed: {ex.Message}"
End Try
End FunctionEste patrón maneja con elegancia los registros faltantes o nulos omitiéndolos y continuando con los documentos válidos. El resultado fusionado obtiene números de página agregados a través de encabezados y pies de página HTML antes de volver a escribirse en la base de datos. Para una navegación más avanzada, puede agregar marcadores para ayudar a los lectores a navegar por un documento combinado largo.
El patrón anterior funciona para facturas, informes, contratos o cualquier documento almacenado como columnas binarias. Ventajas clave:
Al crear flujos de trabajo de combinación de PDF, conviene tener cuidado con varios modos de error:
pdfData != null && pdfData.Length > 0 antes de construir un PdfDocument.PdfDocument después de fusionarlos.A continuación se muestra un patrón confiable con validación de entrada:
public bool TryMergePdfByteArrays(byte[] pdfBytes1, byte[] pdfBytes2, out byte[] mergedBytes)
{
mergedBytes = null;
try
{
if (pdfBytes1 == null || pdfBytes1.Length == 0)
throw new ArgumentException("First PDF byte array is null or empty");
if (pdfBytes2 == null || pdfBytes2.Length == 0)
throw new ArgumentException("Second PDF byte array is null or empty");
using var pdf1 = new PdfDocument(pdfBytes1);
using var pdf2 = new PdfDocument(pdfBytes2);
if (pdf1.PageCount == 0)
throw new InvalidOperationException("First PDF has no pages");
if (pdf2.PageCount == 0)
throw new InvalidOperationException("Second PDF has no pages");
var mergedPdf = PdfDocument.Merge(pdf1, pdf2);
mergedBytes = mergedPdf.BinaryData;
return true;
}
catch (Exception ex)
{
Console.WriteLine($"PDF merge failed: {ex.Message}");
return false;
}
}Imports System
Public Function TryMergePdfByteArrays(pdfBytes1 As Byte(), pdfBytes2 As Byte(), ByRef mergedBytes As Byte()) As Boolean
mergedBytes = Nothing
Try
If pdfBytes1 Is Nothing OrElse pdfBytes1.Length = 0 Then
Throw New ArgumentException("First PDF byte array is null or empty")
End If
If pdfBytes2 Is Nothing OrElse pdfBytes2.Length = 0 Then
Throw New ArgumentException("Second PDF byte array is null or empty")
End If
Using pdf1 As New PdfDocument(pdfBytes1)
Using pdf2 As New PdfDocument(pdfBytes2)
If pdf1.PageCount = 0 Then
Throw New InvalidOperationException("First PDF has no pages")
End If
If pdf2.PageCount = 0 Then
Throw New InvalidOperationException("Second PDF has no pages")
End If
Dim mergedPdf = PdfDocument.Merge(pdf1, pdf2)
mergedBytes = mergedPdf.BinaryData
Return True
End Using
End Using
Catch ex As Exception
Console.WriteLine($"PDF merge failed: {ex.Message}")
Return False
End Try
End FunctionLas declaraciones using garantizan que los objetos PdfDocument se eliminen correctamente, liberando recursos no administrados incluso si ocurre una excepción. El patrón TryXxx devuelve un indicador de éxito booleano en lugar de lanzar una excepción, lo que facilita la llamada desde un código de nivel superior que maneja varios documentos.
Varios hábitos reducen el riesgo de fallos de producción:
using para su eliminación : los documentos IronPDF contienen recursos nativos. Deshágase de ellos siempre, ya sea con declaraciones using o llamadas explícitas Dispose().| Acercarse | Mejor para | Uso de la memoria | Flexibilidad |
|---|---|---|---|
| Matriz de bytes directa (dos archivos) | Fusión simple de dos documentos | Bajo | Básico |
List<PdfDocument> overload | Fusión por lotes de muchos archivos | Medio | Alto |
| Constructor de MemoryStream | Integraciones basadas en stream | Bajo | Alto |
| Patrón de búsqueda de base de datos | Flujos de trabajo de documentos de producción | Medio | Muy alto |
IronPDF ofrece una prueba gratuita con todas las funciones para que pueda probar la fusión de PDF en su aplicación real antes de comprometerse con una licencia. La prueba incluye la API completa (combinar, dividir, convertir, anotar, firmar y más) sin restricciones de funciones durante la evaluación.
Para uso en producción, las opciones de licencia varían desde licencias para un solo desarrollador hasta licencias de sitio empresarial que cubren implementaciones ilimitadas. Las organizaciones que ejecutan flujos de trabajo de gran volumen pueden explorar las licencias OEM para escenarios redistribuibles.
Más allá de la fusión, IronPDF cubre todo el ciclo de vida del procesamiento de PDF: conversión de HTML a PDF , edición de PDF , creación y llenado de formularios , extracción de texto , firmas digitales y gestión de seguridad . Una vez que el flujo de trabajo de combinación funcione, estas funciones se integrarán sin dependencias adicionales.
Visita la página de tutoriales de IronPDF para explorar tutoriales completos para cada capacidad principal, o consulta la referencia de API para obtener documentación detallada sobre cada clase y método.
Instalar con NuGet
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.
