Carimbagem lenta em PDFs muito grandes

Curtis Chau
Curtis Chau
Atualizado: 19 de outubro de 2026

Carimbar cada página de um PDF muito grande em uma única passagem fica progressivamente mais lento à medida que o trabalho avança. No caso relatado de 20.000 páginas, o gargalo foi o método usado para dividir o documento, não a operação de carimbagem em si.

A engenharia rastreou a desaceleração no caso de 20.000 páginas ao método de divisão do documento, em vez da operação de carimbagem. O mecanismo detalhado não foi confirmado independentemente a partir das notas do desenvolvedor.

A correção é dividir o PDF recursivamente em pequenos pedaços, carimbar cada pedaço (opcionalmente em processos de trabalho paralelos) e mesclar os resultados de volta em um único arquivo.

Solução

1. Divida o PDF de origem recursivamente

Recomendado: continue dividindo até que cada pedaço esteja em ou abaixo de um número alvo de páginas. Salve cada pedaço no disco para que a memória permaneça baixa e os trabalhadores possam pegar arquivos de forma independente. O nome do arquivo armazena a primeira página do pedaço, o que mantém os pedaços em ordem e suporta carimbos dependentes de página posteriormente.

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#

O tamanho do pedaço de 500 é um ponto de partida. Ajuste isso para seus documentos e hardware.

2. Carimbe cada pedaço

Abra cada pedaço, aplique o carimbo e salve o resultado em um novo arquivo.

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. Processe pedaços em paralelo

Opcional: dê a cada processo de trabalho sua própria parte da lista de pedaços. A referência usou 8 processos de trabalho em uma máquina de 16 núcleos. Ajuste a quantidade de trabalhadores para o seu hardware.

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

4. Mescle os pedaços carimbados em ordem

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#

Exclua os arquivos temporários de pedaços quando terminar.

5. Tempos esperados

Resultados da referência de 20.000 páginas, como um guia aproximado:

  • Divisão: cerca de 6 minutos
  • Carimbagem e mesclagem, processo único: cerca de 6 minutos
  • Carimbagem e mesclagem, 8 processos: cerca de 1,5 minutos
  • Execução paralela total: cerca de 8 minutos

A divisão é o maior custo. Se você gerar o PDF por conta própria, considere produzi-lo em pedaços desde o início e pular a divisão.

6. Reutilize o mesmo padrão para outras operações em nível de página

Dividir, processar e mesclar funciona para qualquer operação que trate cada página de forma independente. Bom ajuste:

  • Carimbos e marcas d'água de texto, imagem, HTML e código de barras
  • Cabeçalhos e rodapés em HTML (defina FirstPageNumber para que a numeração permaneça contínua)
  • Redação de texto em todas as páginas
  • Localizar e substituir texto
  • Compressão de imagem e achatamento de formulário
  • Fundos, frentes e rotação de página

Carimbos dependentes de página, como números Bates ou rótulos de página, precisam da página inicial global de cada pedaço. Leia isso do nome do arquivo do pedaço:

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#

O número da primeira página é analisado a partir do nome chunk_NNNNNN.pdf, então cada página recebe uma compensação de carimbo a partir desse início global.

Somente divisão, sem necessidade de mesclagem:

  • Extração de texto para indexação de busca
  • Rasterização de páginas para imagens
  • Preparação de páginas para OCR

Execute esses após a mesclagem, não por pedaço:

  • Assinaturas digitais (a mesclagem altera o documento e quebra assinaturas por pedaço)
  • Senhas, permissões e criptografia
  • Marcadores, esboços e tabelas de conteúdos
  • Metadados do documento
  • Conversão para PDF/A ou PDF/UA
Aviso: Os pedaços mesclados podem repetir recursos compartilhados, como fontes. Compare o tamanho de saída com o original e comprima o arquivo final, se necessário.

Casos de uso típicos:

  • Numeração Bates para conjuntos de descoberta legal
  • Marcas d'água CONFIDENCIAL ou RASCUNHO em grandes arquivos
  • Extratos em lote ou faturas com códigos de barras para classificação de correspondência
  • Redação de dados pessoais em registros exportados
  • Encolhendo arquivos escaneados antes do armazenamento a longo prazo

Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.

Leia Mais

Pronto para começar?

Downloads no NuGet 22,198,312Versão:2026.11recém-lançado