💡 Exemplo completo em funcionamento disponível no GitHub:
one-line-document-merge-and-split-dotnet

Onde os trabalhos de documentos de back‑office realmente residem

Um back‑office financeiro encerra o mês grampeando uma página de capa ao PDF do extrato do mês anterior. Uma equipe de contratos anexa uma emenda assinada ao contrato original antes que ele vá para o arquivo. Um assistente de operações de vendas extrai dois slides de um deck de sessenta slides porque um stakeholder só precisava da página de preços. Um funcionário de registros remove uma página que nunca deveria ter sido enviada, pouco antes de o arquivo deixar o prédio.

Nenhum desses é um projeto de mesclagem. Cada um é um arquivo e uma operação, feita da mesma forma toda vez que o trabalho é executado, geralmente por alguém que não tem interesse em aprender uma API de documentos de uso geral apenas para chegar lá.

GroupDocs.Merger.LowCode é um pacote .NET que transforma um desses trabalhos — uma junção, uma divisão ou a remoção de página — em uma única chamada ao construtor, distinguindo‑se da classe de uso geral Merger que esses trabalhos nunca precisam. Cada um de seus sete produtos recebe sua fonte e suas opções no construtor, em C#, e executa apenas uma vez que Save é chamado, com a mesma forma independentemente de o trabalho ser um PDF, um documento Word ou um deck PowerPoint.

Por que correções genéricas não funcionam aqui

Equipes que enfrentam um desses trabalhos geralmente tentam uma das três coisas antes de recorrer a um pacote focado:

  • Fazer manualmente em um editor de desktop: funciona para um documento, impossível de agendar, e ninguém aprova um passo manual rodando às 2 h da manhã.
  • Escrever um script pontual contra APIs de arquivos brutas: funciona até aparecer o próximo formato de entrada, e o script cresce até se tornar exatamente o cliente de uso geral que se pretendia evitar.
  • Usar a classe completa Merger para uma única chamada: correto, mas adiciona uma superfície de API maior do que uma operação jamais precisaria.

GroupDocs.Merger.LowCode existe exatamente para preencher essa última lacuna: uma chamada por operação, nada mais para aprender antes.


A Solução: GroupDocs.Merger.LowCode para Pipelines de Back‑Office

GroupDocs.Merger.LowCode agrupa sete produtos de propósito único por trás daquela forma “construtor‑então‑Save”. JoinPdf e JoinDocx anexam um documento a outro; JoinPptx faz o mesmo para decks; SplitPdf, SplitDocx e SplitPptx extraem páginas ou slides escolhidos para arquivos próprios; RemovePagesPdf remove páginas sem tocar na fonte. Cada um dos sete aceita sua fonte como caminho ou fluxo e verifica essa fonte, além de cada arquivo fornecido, contra seu próprio formato antes de escrever qualquer coisa, de modo que um pipeline nunca precise adivinhar por que a saída saiu errada.

Para seguir a implementação abaixo, você precisará de:

  • .NET 6.0 ou superior (o projeto deste exemplo tem alvo net8.0)
  • O pacote NuGet separado GroupDocs.Merger.LowCode
  • Uma licença temporária, se quiser ver a saída sem os limites de avaliação descritos adiante
dotnet add package GroupDocs.Merger.LowCode

O pacote está disponível separadamente no NuGet
https://www.nuget.org/packages/GroupDocs.Merger.LowCode/ a partir da biblioteca principal GroupDocs.Merger.


Implementando o Passo de Trabalho Reporting‑Pack Passo a Passo

Aqui está a forma que cada um dos sete produtos segue, demonstrada com a junção que anexa uma página de capa a um PDF mensal.

Passo 1: Apontar o Produto para sua Fonte

O construtor de JoinPdf recebe o documento fonte, todos os arquivos a anexar e uma instância de JoinOptions; nada é executado ainda.

var join = new JoinPdf("report.pdf", new[] { "appendix.pdf" }, new JoinOptions());

Passo 2: Decidir Onde o Resultado Vai

Save(outputPath) é onde o trabalho realmente grava. Um caminho relativo é resolvido em relação ao diretório de trabalho atual do processo, e Save cria a pasta de saída caso ela ainda não exista, de modo que um pipeline que grava em uma nova pasta mensal a cada execução não precise de um passo separado para provisioná‑la.

string outputPath = "output/monthly/report-with-appendix.pdf";

Por que isso importa para um trabalho não supervisionado:

  • Um caminho que você controla: construa o caminho de saída a partir de configuração ou de um parâmetro do trabalho, nunca diretamente de entrada não validada; Save lança ArgumentNullException se o caminho for nulo ou vazio.
  • A pasta que ele cria: um trabalho agendado que grava em um novo destino a cada execução não carrega um passo “garantir que o diretório exista” próprio.

Passo 3: Executar e Capturar o Resultado

Chamar Save executa a junção imediatamente; não há um passo separado de “construir‑então‑executar”.

join.Save(outputPath);
var sizeInBytes = new FileInfo(outputPath).Length;

Na nossa própria execução contra os arquivos de exemplo, essa chamada juntou um report.pdf de 2 páginas ao appendix.pdf de 2 páginas, resultando em um report-with-appendix.pdf de 4 páginas e 257 987 bytes.

Passo 4: Alimentar o Resultado de Volta ao Pipeline

O tamanho do arquivo lido logo após Save costuma ser tudo o que um agendador precisa antes de marcar o trabalho como concluído, ou antes de compará‑lo a um tamanho mínimo para decidir se a saída é confiável o suficiente para prosseguir.

if (sizeInBytes == 0)
{
    throw new InvalidOperationException("Join produced an empty file.");
}

O GroupDocs.Merger.LowCode aceita um Stream em vez de um caminho de arquivo?

Sim, na entrada. Cada um dos sete produtos aceita sua fonte como fluxo na mesma posição do construtor onde um caminho de arquivo seria usado, útil quando a entrada do trabalho vem de armazenamento de blobs ou de uma fila em vez de disco local. Save ainda grava o resultado em um caminho de saída string de qualquer forma; o streaming da própria saída permanece na classe completa Merger.


Fluxo Real: Rejeitando um Arquivo antes que Chegue ao Arquivo

Uma equipe de contratos que anexa emendas a acordos assinados não pode arriscar aceitar qualquer arquivo que chegue à caixa de entrada; uma emenda .docx colocada ao lado de uma junção PDF geraria uma entrada de arquivo corrompida. JoinPdf verifica a fonte e cada arquivo a ser anexado contra o formato PDF antes de escrever qualquer coisa, e lança FileTypeNotSupportedException no momento em que um deles não corresponde.

try
{
    new JoinPdf("report.pdf", new[] { "contract.docx" }, new JoinOptions())
        .Save("output/mixed.pdf");
}
catch (FileTypeNotSupportedException exception)
{
    Console.WriteLine(exception.Message);
}

Na execução de exemplo, onde os caminhos são construídos a partir da pasta resources, a mensagem foi: Input format does not match the expected format 'PDF'; the joined file 'resources\contract.docx' is 'Microsoft Word Open XML Document (.docx)'.

O trabalho acima nunca grava output/mixed.pdf quando a exceção é capturada, de modo que um pipeline de contratos pode encaminhar essa mensagem diretamente para o alerta ou fila de tickets que já utiliza, em vez de descobrir uma entrada de arquivo ruim dias depois.


Outros Cenários de Back‑Office Onde esse Padrão se Aplica

Uma vez que a junção acima esteja funcionando, a mesma forma “construtor‑então‑Save” cobre vários trabalhos que um back‑office executa em agenda:

  • Cortar uma página antes que o documento deixe o prédio: RemovePagesPdf elimina as páginas escolhidas e grava um novo arquivo sem tocar na fonte, de modo que o original permanece disponível para auditoria após o envio da cópia recortada. Na nossa execução, remover a página 2 de report.pdf gerou um report-without-page-2.pdf de 1 página e 86 647 bytes, enquanto report.pdf permaneceu inalterado.
  • Dividir um deck para um stakeholder: SplitPptx extrai os slides solicitados para arquivos próprios, nomeados por um token {0} no padrão de saída ou, na ausência dele, por um número de parte acrescentado na mesma pasta, seguindo o mesmo padrão que SplitPdf usa para dividir páginas PDF.
  • Mesclar documentos Word em vez de PDFs: JoinDocx segue exatamente a forma “construtor‑então‑Save” como JoinPdf, colocando o documento anexado após a última página da fonte.

Sem licença, cada um desses processos roda em modo de avaliação. Na nossa execução sem licença, os PDFs e documentos Word resultantes foram reduzidos a 3 páginas cada, embora todos os seis arquivos de exemplo ainda fossem produzidos; aplique uma licença com License.Set antes que qualquer um desses processos seja executado de forma não supervisionada em produção.


Começando no Seu Pipeline de Back‑Office

Você tem um padrão de mesclagem de documentos de baixo código funcionando de ponta a ponta, além da prova de que a verificação de formato ocorre em cada chamada. Aqui está o que fazer a seguir:

  • Ver o panorama completo: o guia de casos de uso acompanha cada uma das seis operações do exemplo, método a método, com um FAQ completo.
  • Aprofundar quando o trabalho crescer: a API completa do GroupDocs.Merger cobre mais terreno do que esse padrão precisa no momento em que um pipeline ultrapassa uma única operação.
  • Explorar o código: o exemplo completo no GitHub inclui todos os arquivos de entrada usados acima.
  • Instalar: a página de instalação detalha o pacote separado e os frameworks de destino suportados.
  • Remover os limites de avaliação: obtenha uma licença temporária antes de executar qualquer coisa em produção.
  • Dúvidas: o fórum de suporte é onde a equipe responde a perguntas de implementação.

Recursos