Estampado lento en PDFs muy grandes

Curtis Chau
Curtis Chau
Actualizado: 19 de octubre de 2026

Estampar cada página de un PDF muy grande en una sola pasada se vuelve progresivamente más lento a medida que avanza el trabajo. En el caso reportado de 20,000 páginas, el cuello de botella fue el método utilizado para dividir el documento, no la operación de estampado en sí.

El equipo de ingeniería rastreó la desaceleración en el caso de 20,000 páginas al método de división del documento en lugar de a la operación de estampado. El mecanismo detallado no ha sido confirmado de forma independiente a partir de las notas de los desarrolladores.

La solución es dividir recursivamente el PDF en fragmentos pequeños, estampar cada fragmento (opcionalmente en procesos de trabajo paralelos) y fusionar los resultados de nuevo en un solo archivo.

Solución

1. Divide recursivamente el PDF de origen

Recomendado: sigue dividiendo hasta que cada fragmento esté en o por debajo de una cantidad objetivo de páginas. Guarda cada fragmento en el disco para que la memoria se mantenga baja y los trabajadores puedan recoger archivos de forma independiente. El nombre del archivo almacena la primera página del fragmento, lo que mantiene los fragmentos en orden y admite estampados dependientes de la página más adelante.

using IronPdf;
using IronPdf.Editing;
static void SplitToFiles(PdfDocument doc, int startPage, int targetPages,
                         string outDir, List<string> files)
{
    if (doc.PageCount <= targetPages)
    {
        // File name carries the chunk's first page (1-based).
        string path = Path.Combine(outDir, $"chunk_{startPage:D6}.pdf");
        doc.SaveAs(path);
        files.Add(path);
        return;
    }
    int mid = doc.PageCount / 2;
    using (var left = doc.CopyPages(0, mid - 1))
        SplitToFiles(left, startPage, targetPages, outDir, files);
    using (var right = doc.CopyPages(mid, doc.PageCount - 1))
        SplitToFiles(right, startPage + mid, targetPages, outDir, files);
}
// Usage
var chunkFiles = new List<string>();
using (var source = PdfDocument.FromFile("input.pdf"))
    SplitToFiles(source, 1, 500, @"C:\temp\chunks", chunkFiles);
C#

El tamaño del fragmento de 500 es un punto de partida. Ajusta para tus documentos y hardware.

2. Estampa cada fragmento

Abre cada fragmento, aplica el sello y guarda el resultado en un nuevo archivo.

var stamper = new HtmlStamper("<div style='font-size:24px;color:red'>CONFIDENTIAL</div>")
{
    VerticalAlignment = VerticalAlignment.Middle,
    HorizontalAlignment = HorizontalAlignment.Center,
    Opacity = 50
};
var stampedFiles = new List<string>();
foreach (string file in chunkFiles)
{
    string outPath = file.Replace(".pdf", "_stamped.pdf");
    using (var chunk = PdfDocument.FromFile(file))
    {
        chunk.ApplyStamp(stamper);
        chunk.SaveAs(outPath);
    }
    stampedFiles.Add(outPath);
}
C#

3. Procesa fragmentos en paralelo

Opcional: da a cada proceso de trabajo su propia porción de la lista de fragmentos. El punto de referencia utilizó 8 procesos de trabajo en una máquina de 16 núcleos. Ajusta la cantidad de trabajadores para tu hardware.

// In each worker process: workerIndex = 0..workerCount-1
var mySlice = chunkFiles.Where((f, i) => i % workerCount == workerIndex);
C#

4. Fusiona los fragmentos estampados en orden

var parts = stampedFiles.OrderBy(f => f)
                        .Select(f => PdfDocument.FromFile(f))
                        .ToList();
using (var merged = PdfDocument.Merge(parts))
{
    merged.SaveAs("output.pdf");
}
parts.ForEach(p => p.Dispose());
C#

Elimina los archivos temporales de fragmentos una vez que hayas terminado.

5. Tiempos previstos

Resultados del punto de referencia de 20,000 páginas, como guía aproximada:

  • División: aproximadamente 6 minutos
  • Estampado y fusión, proceso único: aproximadamente 6 minutos
  • Estampado y fusión, 8 procesos: aproximadamente 1.5 minutos
  • Ejecución paralela total: aproximadamente 8 minutos

Dividir es el mayor costo. Si generas el PDF tú mismo, considera producirlo en fragmentos desde el principio y omitir la división.

6. Reutiliza el mismo patrón para otras operaciones a nivel de página

Dividir, procesar y fusionar funciona para cualquier operación que trate cada página de manera independiente. Buena adecuación:

  • Textos, imágenes, HTML y sellos de código de barras, y marcas de agua
  • Encabezados y pies de página HTML (ajusta FirstPageNumber para que la numeración se mantenga continua)
  • Censurar texto en todas las páginas
  • Buscar y reemplazar texto
  • Compresión de imágenes y aplanamiento de formularios
  • Fondos, primeros planos y rotación de páginas

Los sellos dependientes de la página, como los números Bates o las etiquetas de página, necesitan la página de inicio global de cada fragmento. Léela desde el nombre del archivo de fragmento:

int firstPage = int.Parse(Path.GetFileNameWithoutExtension(file).Split('_')[1]);
for (int i = 0; i < chunk.PageCount; i++)
{
    var bates = new TextStamper { Text = $"ABC{firstPage + i:D7}" };
    chunk.ApplyStamp(bates, i);
}
C#

El número de la primera página se analiza desde el nombre chunk_NNNNNN.pdf, luego cada página recibe un sello desplazado desde esa página de inicio global.

Solo dividir, no se necesita fusión:

  • Extraer texto para la indexación de búsqueda
  • Transformar páginas en imágenes ráster
  • Preparar páginas para OCR

Ejecuta esto después de fusionar, no por fragmento:

  • Firmas digitales (fusionar cambia el documento y rompe las firmas por fragmento)
  • Contraseñas, permisos y encriptación
  • Marcadores, esquemas y tablas de contenido
  • Metadatos del documento
  • Conversión a PDF/A o PDF/UA
Advertencia: Los fragmentos fusionados pueden repetir recursos compartidos, como fuentes. Compara el tamaño de salida con el original y comprime el archivo final si es necesario.

Casos de uso típicos:

  • Numeración Bates para conjuntos de descubrimiento legal
  • Marcas de agua de CONFIDENCIAL o BORRADOR en grandes archivos
  • Declaraciones o facturas por lotes con códigos de barras para clasificación postal
  • Censurar datos personales en registros exportados
  • Reducir archivos escaneados antes del almacenamiento a largo plazo

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.

Leer más

¿Listo para empezar?

Descargas de NuGet 22,198,312Versión:2026.11recién lanzado