💡 Volledig werkend voorbeeld beschikbaar op GitHub:
one-line-document-merge-and-split-dotnet

Waar back‑office‑documenttaken daadwerkelijk plaatsvinden

Een financiële back‑office sluit de maand af door een voorblad aan de PDF‑verklaring van de vorige maand te nieten. Een contractenteam voegt een ondertekende amendement toe aan de oorspronkelijke overeenkomst voordat deze naar het archief gaat. Een sales‑ops assistent haalt twee dia’s uit een zestig‑dia‑presentatie omdat één belanghebbende alleen de prijspagina nodig had. Een archiefmedewerker verwijdert een pagina die nooit verzonden had mogen worden, vlak voordat het bestand het gebouw verlaat.

Geen van deze zijn samenvoegprojecten. Elk is één bestand en één bewerking, telkens op dezelfde manier uitgevoerd wanneer een taak draait, meestal door iemand die geen interesse heeft om een algemene document‑API te leren alleen om daar te komen.

GroupDocs.Merger.LowCode is een .NET‑pakket dat één dergelijke taak – een samenvoeging, een splitsing of een paginaverwijdering – omzet in één constructor‑aanroep, los van de algemene Merger‑klasse die die taken nooit nodig hebben. Elk van de zeven producten neemt zijn bron en zijn opties mee in de constructor, in C#, en wordt pas uitgevoerd wanneer Save wordt aangeroepen, dezelfde structuur ongeacht of de taak een PDF, een Word‑document of een PowerPoint‑presentatie betreft.

Waarom generieke oplossingen hier niet volstaan

Teams die met een van deze taken te maken hebben, proberen meestal één van de drie dingen voordat ze een gespecialiseerd pakket gebruiken:

  • Handmatig doen in een desktop‑editor: prima voor één document, onmogelijk te plannen, en niemand keurt een handmatige stap goed die om 2 uur ’s nachts draait.
  • Een eenmalig script schrijven tegen ruwe bestands‑API’s: werkt tot het volgende invoerformaat verschijnt, en het script groeit uit tot precies de algemene client die men probeerde te vermijden.
  • De volledige Merger‑klasse gebruiken voor één aanroep: correct, maar het voegt een bredere API‑oppervlakte toe dan één bewerking ooit nodig heeft.

GroupDocs.Merger.LowCode bestaat precies voor dat laatste gat: één aanroep per bewerking, niets anders om eerst te leren.


De oplossing: GroupDocs.Merger.LowCode voor back‑office‑pijplijnen

GroupDocs.Merger.LowCode verpakt zeven enkelvoudige producten achter die één constructor‑dan‑Save‑structuur. JoinPdf en JoinDocx voegen een document toe aan een ander; JoinPptx doet hetzelfde voor presentaties; SplitPdf, SplitDocx en SplitPptx halen gekozen pagina’s of dia’s naar eigen bestanden; RemovePagesPdf verwijdert pagina’s zonder de bron aan te raken. Elk van de zeven accepteert zijn bron als een pad of een stream en controleert die bron, plus elk bestand dat wordt meegegeven, tegen zijn eigen formaat voordat er iets wordt weggeschreven, zodat een pijplijn nooit hoeft te raden waarom een output fout is.

Om de onderstaande implementatie te volgen, heb je nodig:

  • .NET 6.0 of later (dit voorbeeldproject richt zich op net8.0)
  • Het aparte GroupDocs.Merger.LowCode NuGet‑pakket
  • Een tijdelijke licentie, als je de output wilt zien zonder de evaluatielimieten die verderop worden beschreven
dotnet add package GroupDocs.Merger.LowCode

Het pakket staat apart op NuGet van de hoofd‑GroupDocs.Merger‑bibliotheek.


Implementatie van de Reporting‑Pack‑taak stap voor stap

Dit is de structuur die elk van de zeven producten volgt, uitgelegd met de samenvoeging die een voorblad toevoegt aan een maandelijkse PDF.

Stap 1: Richt het product op de bron

De constructor van JoinPdf neemt het bron‑document, elk toe te voegen bestand, en een JoinOptions‑instantie; er gebeurt nog niets.

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

Stap 2: Bepaal waar het resultaat naartoe gaat

Save(outputPath) is waar de taak daadwerkelijk wordt weggeschreven. Een relatief pad wordt ten opzichte van de huidige werkmap van het proces opgelost, en Save maakt de output‑map aan als deze nog niet bestaat, zodat een pijplijn die elke run in een nieuwe maandmap schrijft geen aparte stap nodig heeft om die map te voorzien.

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

Waarom dit belangrijk is voor een onbeheerde taak:

  • Een pad dat je beheert: bouw het output‑pad op basis van configuratie of een taakparameter, nooit rechtstreeks uit niet‑gevalideerde invoer; Save gooit een ArgumentNullException bij een null‑ of leeg pad.
  • De map die het aanmaakt: een geplande taak die elke run naar een nieuwe bestemming schrijft, heeft geen aparte stap nodig om “directory bestaat” te garanderen.

Stap 3: Voer uit en vang op wat terugkomt

Het aanroepen van Save voert de samenvoeging direct uit; er is geen aparte build‑dan‑execute stap.

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

In onze eigen uitvoering met de voorbeeldbestanden, voegde die aanroep een 2‑pagina‑report.pdf samen met een 2‑pagina‑appendix.pdf tot een 4‑pagina, 257987‑byte report-with-appendix.pdf.

Stap 4: Voer het resultaat terug in de pijplijn

De bestandsgrootte die direct na Save wordt gelezen, is meestal alles wat een planner nodig heeft voordat de taak als voltooid wordt gemarkeerd, of voordat deze wordt vergeleken met een minimumgrootte om te bepalen of de output betrouwbaar genoeg is om door te gaan.

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

Accepteert GroupDocs.Merger.LowCode een stream in plaats van een bestandspad?

Ja, aan de invoerkant. Elk van de zeven producten accepteert zijn bron als een stream op dezelfde constructor‑positie waar een bestandspad zou staan, handig wanneer de invoer van een taak afkomstig is van blob‑opslag of een wachtrij in plaats van van een lokale schijf. Save schrijft nog steeds het resultaat naar een output‑pad‑string, hoe dan ook; het streamen van de output zelf blijft in de volledige Merger‑klasse.


Werkelijke workflow: een bestand afwijzen voordat het het archief bereikt

Een contractenteam dat amendementen toevoegt aan ondertekende overeenkomsten kan zich niet veroorloven om welk bestand dan ook uit de inbox te accepteren; een .docx‑amendement dat naast een PDF‑samenvoeging wordt geplaatst, zou anders een defect archiefitem opleveren. JoinPdf controleert de bron en elk toe te voegen bestand op het PDF‑formaat voordat er iets wordt weggeschreven, en gooit een FileTypeNotSupportedException zodra een van hen niet overeenkomt.

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

In de voorbeeldrun, waar de paden worden opgebouwd vanuit de resources‑map, luidde het bericht: Input format does not match the expected format 'PDF'; the joined file 'resources\contract.docx' is 'Microsoft Word Open XML Document (.docx)'.

De bovenstaande taak schrijft output/mixed.pdf nooit wanneer de catch wordt geactiveerd, zodat een contract‑pijplijn dat bericht direct kan doorsturen naar welke waarschuwing of ticket‑wachtrij dan ook die al wordt gebruikt, in plaats van dagen later een slecht archiefitem te ontdekken.


Andere back‑office‑scenario’s waar dit patroon past

Zodra de bovenstaande samenvoeging werkt, dekt dezelfde constructor‑dan‑Save‑structuur verschillende taken die een back‑office volgens een schema uitvoert:

  • Een pagina bijsnijden voordat een document het gebouw verlaat: RemovePagesPdf verwijdert de gekozen pagina’s en schrijft een nieuw bestand zonder de bron aan te raken, zodat het origineel beschikbaar blijft voor audit nadat de bijgesneden kopie is verzonden. In onze eigen run produceerde het verwijderen van pagina 2 uit report.pdf een 1‑pagina, 86647‑byte report-without-page-2.pdf, en report.pdf zelf bleef ongewijzigd.
  • Een presentatie splitsen voor één belanghebbende: SplitPptx haalt de gevraagde dia’s op in eigen bestanden, benoemd met een {0}‑token in het output‑patroon of, zonder token, met een toegevoegd deelnummer in dezelfde map, hetzelfde patroon dat SplitPdf gebruikt om PDF‑pagina’s te splitsen.
  • Word‑documenten samenvoegen in plaats van PDF’s: JoinDocx volgt exact de constructor‑dan‑Save‑structuur van JoinPdf, waarbij het toegevoegde document na de laatste pagina van de bron wordt geplaatst.

Zonder licentie draait elk van deze in evaluatiemodus. In onze eigen niet‑gelicentieerde run werden de samengevoegde PDF‑ en Word‑outputs teruggebracht tot 3 pagina’s elk, hoewel alle zes voorbeeld‑outputs nog steeds werden geproduceerd; pas een licentie toe met License.Set voordat een van deze onbemand in productie draait.


Aan de slag in jouw back‑office‑pijplijn

Je hebt één low‑code document‑samenvoegpatroon dat van begin tot eind werkt, plus bewijs dat de formaatcontrole erachter bij elke aanroep wordt uitgevoerd. Hier kun je verder gaan:

  • Zie het volledige plaatje: de bijbehorende use‑case‑gids loopt elke van de zes bewerkingen van het voorbeeld stap voor stap door, met een volledige FAQ.
  • Ga dieper zodra een taak groeit: de volledige GroupDocs.Merger API biedt meer functionaliteit dan dit patroon nodig heeft zodra een pijplijn meer dan één bewerking vereist.
  • Bekijk de code: de volledige voorbeeld op GitHub bevat elk invoerbestand dat hierboven is gebruikt.
  • Installeer het: de installatiepagina behandelt het aparte pakket en de ondersteunde doel‑frameworks.
  • Verwijder de evaluatielimieten: haal een tijdelijke licentie voordat je dit in productie draait.
  • Vragen: het supportforum is waar het team implementatievragen beantwoordt.

Bronnen