💡 Ejemplo completo funcionando disponible en GitHub: one-line-document-merge-and-split-dotnet

Dónde viven realmente los trabajos de documentos de back‑office

Una oficina financiera de back‑office cierra el mes engrampando una página de portada al PDF del estado de cuenta del mes anterior. Un equipo de contratos agrega una enmienda firmada al acuerdo original antes de archivarlo. Un asistente de ventas‑ops extrae dos diapositivas de una presentación de sesenta diapositivas porque un interesado solo necesitaba la página de precios. Un archivista elimina una página que nunca debió enviarse, justo antes de que el archivo salga del edificio.

Ninguno de estos es un proyecto de fusión. Cada uno es un archivo y una operación, realizados de la misma manera cada vez que se ejecuta un trabajo, generalmente por alguien que no tiene interés en aprender una API de documentos de propósito general solo para lograrlo.

GroupDocs.Merger.LowCode es un paquete .NET que convierte uno de esos trabajos —una unión, una división o una eliminación de página— en una única llamada al constructor, separándose de la clase de propósito general Merger que esos trabajos nunca necesitan. Cada uno de sus siete productos toma su origen y sus opciones en el constructor, en C#, y se ejecuta solo cuando se llama a Save, con la misma forma sea que el trabajo sea un PDF, un documento Word o una presentación PowerPoint.

Por qué las soluciones genéricas no sirven aquí

Los equipos que enfrentan uno de estos trabajos suelen intentar una de tres cosas antes de recurrir a un paquete enfocado:

  • Hacerlo manualmente en un editor de escritorio: está bien para un documento, imposible de programar, y nadie aprueba un paso manual que se ejecuta a las 2 a.m.
  • Escribir un script puntual contra APIs de archivos crudos: funciona hasta que aparece el siguiente formato de entrada, y el script se convierte en el cliente de propósito general que se pretendía evitar.
  • Utilizar la clase completa Merger para una sola llamada: correcto, pero añade una superficie de API más amplia de la que una operación necesita.

GroupDocs.Merger.LowCode existe precisamente para ese último vacío: una llamada por operación, nada más que aprender primero.


La solución: GroupDocs.Merger.LowCode para canalizaciones de back‑office

GroupDocs.Merger.LowCode empaqueta siete productos de un solo propósito detrás de esa forma de constructor‑luego‑Save. JoinPdf y JoinDocx añaden un documento a otro; JoinPptx hace lo mismo con presentaciones; SplitPdf, SplitDocx y SplitPptx extraen páginas o diapositivas elegidas en archivos propios; RemovePagesPdf elimina páginas sin tocar el origen. Cada uno de los siete acepta su origen como ruta o flujo y verifica ese origen, más cada archivo que se le pasa, contra su propio formato antes de escribir nada, de modo que una canalización nunca tenga que adivinar por qué una salida salió mal.

Para seguir la implementación a continuación, necesitarás:

  • .NET 6.0 o posterior (el proyecto de este ejemplo tiene como objetivo net8.0)
  • El paquete NuGet separado GroupDocs.Merger.LowCode
  • Una licencia temporal, si deseas ver la salida sin los límites de evaluación descritos más adelante
dotnet add package GroupDocs.Merger.LowCode

El paquete vive por separado en NuGet del principal GroupDocs.Merger library.


Implementando el paso del trabajo Reporting‑Pack paso a paso

Esta es la forma que sigue cada uno de los siete productos, ilustrada con la unión que agrega una portada a un PDF mensual.

Paso 1: Apuntar el producto a su origen

El constructor de JoinPdf recibe el documento origen, cada archivo a añadir y una instancia de JoinOptions; aún no se ejecuta nada.

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

Paso 2: Decidir dónde va el resultado

Save(outputPath) es donde el trabajo realmente se compromete. Una ruta relativa se resuelve contra el directorio de trabajo actual del proceso, y Save crea la carpeta de salida si aún no existe, por lo que una canalización que escribe en una nueva carpeta mensual en cada ejecución no necesita un paso separado para provisionarla.

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

Por qué esto importa para un trabajo desatendido:

  • Una ruta que controlas: construye la ruta de salida a partir de la configuración o de un parámetro del trabajo, nunca directamente de una entrada no validada; Save lanza ArgumentNullException si la ruta es nula o vacía.
  • La carpeta que crea: un trabajo programado que escribe en un nuevo destino en cada ejecución no lleva un paso separado de “asegurar que el directorio exista”.

Paso 3: Ejecutarlo y capturar lo que devuelve

Llamar a Save ejecuta la unión inmediatamente; no hay un paso separado de compilación‑luego‑ejecución.

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

En nuestra propia ejecución contra los archivos del ejemplo, esa llamada unió un report.pdf de 2 páginas con un appendix.pdf de 2 páginas en un report-with-appendix.pdf de 4 páginas y 257 987 bytes.

Paso 4: Alimentar el resultado de nuevo a la canalización

El tamaño del archivo leído justo después de Save suele ser todo lo que un programador necesita antes de marcar el trabajo como completado, o antes de compararlo con un tamaño mínimo para decidir si la salida es lo suficientemente confiable como para continuar.

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

¿GroupDocs.Merger.LowCode acepta un flujo en lugar de una ruta de archivo?

Sí, en el lado de entrada. Cada uno de los siete productos acepta su origen como flujo en la misma posición del constructor donde iría una ruta de archivo, lo que resulta útil cuando la entrada del trabajo proviene de almacenamiento de blobs o de una cola en lugar de disco local. Save sigue escribiendo su resultado en una cadena de ruta de salida de cualquier manera; el streaming de la salida misma permanece en la clase completa Merger.


Flujo de trabajo real: rechazar un archivo antes de que llegue al archivo

Un equipo de contratos que agrega enmiendas a acuerdos firmados no puede arriesgarse a aceptar cualquier archivo que llegue a la bandeja de entrada; una enmienda .docx mal archivada junto a una unión PDF produciría una entrada de archivo dañada. JoinPdf verifica el origen y cada archivo que se añade contra el formato PDF antes de escribir nada, y lanza FileTypeNotSupportedException en el momento en que uno de ellos no coincide.

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

En la ejecución de ejemplo, donde las rutas se construyen a partir de su carpeta resources, el mensaje fue: Input format does not match the expected format 'PDF'; the joined file 'resources\contract.docx' is 'Microsoft Word Open XML Document (.docx)'.

El trabajo anterior nunca escribe output/mixed.pdf cuando se dispara la captura, por lo que una canalización de contratos puede dirigir ese mensaje directamente al alerta o cola de tickets que ya utiliza, en lugar de descubrir una entrada de archivo dañada días después.


Otros escenarios de back‑office donde este patrón encaja

Una vez que la unión anterior funciona, la misma forma de constructor‑luego‑Save cubre varios trabajos que una oficina de back‑office ejecuta según un programa:

  • Recortar una página antes de que el documento salga del edificio: RemovePagesPdf elimina las páginas elegidas y escribe un nuevo archivo sin tocar el origen, de modo que el original permanece disponible para auditoría después de que la copia recortada se envíe. En nuestra propia ejecución, eliminar la página 2 de report.pdf produjo un report-without-page-2.pdf de 1 página y 86 647 bytes, y report.pdf quedó sin cambios.
  • Dividir una presentación para un interesado: SplitPptx extrae las diapositivas solicitadas en archivos propios, nombrados mediante un token {0} en el patrón de salida o, sin él, con un número de parte añadido en la misma carpeta, el mismo patrón que usa SplitPdf para dividir páginas PDF.
  • Fusionar documentos Word en lugar de PDFs: JoinDocx sigue la forma exacta de constructor‑luego‑Save que tiene JoinPdf, colocando el documento añadido después de la última página del origen.

Sin una licencia, cada uno de estos se ejecuta en modo de evaluación. En nuestra propia ejecución sin licencia, los PDFs y Word resultantes se redujeron a 3 páginas cada uno, aunque los seis archivos de ejemplo se generaron; aplica una licencia con License.Set antes de que cualquiera de estos se ejecute de forma desatendida en producción.


Comenzando en tu canalización de back‑office

Tienes un patrón de fusión de documentos de bajo código funcionando de extremo a extremo, además de la prueba de que la verificación de formato detrás de él se ejecuta en cada llamada. Aquí tienes a dónde ir a partir de ahora:

  • Ver el panorama completo: la guía complementaria use-case guide recorre cada una de las seis operaciones del ejemplo método a método, con una FAQ completa.
  • Profundizar una vez que el trabajo crezca: la full GroupDocs.Merger API cubre más terreno del que este patrón necesita en el momento en que una canalización supera una sola operación.
  • Explorar el código: el complete sample on GitHub incluye todos los archivos de entrada usados arriba.
  • Instalarlo: la installation page cubre el paquete separado y sus frameworks objetivo compatibles.
  • Eliminar los límites de evaluación: obtén una temporary license antes de ejecutar cualquiera de esto en producción.
  • Preguntas: el support forum es donde el equipo responde preguntas de implementación.

Recursos