💡 Esempio completo funzionante disponibile su GitHub: one-line-document-merge-and-split-dotnet
Dove i lavori di documenti del back‑office si trovano realmente
Un back‑office finanziario chiude il mese cucendo una pagina di copertina al PDF dell’estratto conto del mese precedente. Un team contratti aggiunge un emendamento firmato all’accordo originale prima che venga archiviato. Un assistente delle operazioni di vendita estrae due diapositive da una presentazione di sessanta diapositive perché un stakeholder aveva bisogno solo della pagina dei prezzi. Un impiegato degli archivi rimuove una pagina che non avrebbe mai dovuto essere spedita, proprio prima che il file lasci l’edificio.
Nessuno di questi è un progetto di fusione. Ognuno è un singolo file e una singola operazione, eseguita allo stesso modo ogni volta che il lavoro viene avviato, di solito da qualcuno che non ha interesse a imparare un’API di documenti generica solo per arrivare a quel risultato.
GroupDocs.Merger.LowCode è un pacchetto .NET che trasforma un lavoro di questo tipo, un’unione, una divisione o una rimozione di pagina, in una singola chiamata al costruttore, distinguendosi dalla classe Merger generica di cui questi lavori non hanno mai bisogno. Ognuno dei suoi sette prodotti accetta la sorgente e le opzioni nel costruttore, in C#, e viene eseguito solo quando viene chiamato Save, con la stessa struttura sia che il lavoro sia un PDF, un documento Word o una presentazione PowerPoint.
Perché le soluzioni generiche non bastano qui
I team che si trovano di fronte a uno di questi lavori di solito provano una delle tre cose prima di ricorrere a un pacchetto specifico:
- Farlo manualmente in un editor desktop: va bene per un documento, impossibile da programmare, e nessuno approva un passaggio manuale eseguito alle 2 del mattino.
- Scrivere uno script ad hoc contro le API di file grezze: funziona finché non appare il prossimo formato di input, e lo script si trasforma esattamente nel client generico che si voleva evitare.
- Utilizzare la classe completa
Mergerper una singola chiamata: corretto, ma aggiunge una superficie API più ampia di quella mai necessaria per una singola operazione.
GroupDocs.Merger.LowCode esiste proprio per colmare quest’ultimo divario: una chiamata per operazione, nulla di più da imparare prima.
La soluzione: GroupDocs.Merger.LowCode per i flussi di lavoro del back‑office
GroupDocs.Merger.LowCode raggruppa sette prodotti a scopo unico dietro quella struttura costruttore‑poi‑Save. JoinPdf e JoinDocx aggiungono un documento a un altro; JoinPptx fa lo stesso per le presentazioni; SplitPdf, SplitDocx e SplitPptx estraggono le pagine o le diapositive scelte in file separati; RemovePagesPdf rimuove pagine senza toccare la sorgente. Ognuno dei sette accetta la sorgente come percorso o stream e verifica quella sorgente, più ogni file fornito, rispetto al proprio formato prima di scrivere, così un flusso di lavoro non deve mai indovinare perché un output sia errato.
Per seguire l’implementazione qui sotto, avrai bisogno di:
- .NET 6.0 o successivo (il progetto di questo esempio mira a net8.0)
- Il pacchetto
GroupDocs.Merger.LowCodeNuGet separato - Una licenza temporanea, se vuoi vedere l’output senza i limiti di valutazione descritti più avanti
dotnet add package GroupDocs.Merger.LowCode
Il pacchetto è disponibile separatamente su NuGet rispetto alla libreria principale GroupDocs.Merger.
Implementare il lavoro Reporting-Pack passo per passo
Ecco la struttura che ciascuno dei sette prodotti segue, illustrata con l’unione che aggiunge una pagina di copertina a un PDF mensile.
Passo 1: Puntare il prodotto alla sua sorgente
Il costruttore di JoinPdf accetta il documento sorgente, ogni file da aggiungere e un’istanza di JoinOptions; nulla viene eseguito ancora.
var join = new JoinPdf("report.pdf", new[] { "appendix.pdf" }, new JoinOptions());
Passo 2: Decidere dove va il risultato
Save(outputPath) è il punto in cui il lavoro viene effettivamente salvato. Un percorso relativo viene risolto rispetto alla directory di lavoro corrente del processo, e Save crea la cartella di output se non esiste già, così un flusso di lavoro che scrive in una nuova cartella mensile ad ogni esecuzione non ha bisogno di un passaggio separato per crearla.
string outputPath = "output/monthly/report-with-appendix.pdf";
Perché questo è importante per un lavoro non supervisionato:
- Un percorso che controlli: costruisci il percorso di output dalla configurazione o da un parametro del lavoro, mai direttamente da input non validato;
SavelanciaArgumentNullExceptionsu un percorso nullo o vuoto. - La cartella che crea: un lavoro pianificato che scrive in una nuova destinazione ad ogni esecuzione non richiede un passaggio separato “assicura che la directory esista”.
Passo 3: Eseguire e catturare il risultato
Chiamare Save esegue immediatamente l’unione; non c’è un passaggio separato di costruzione‑poi‑esecuzione.
join.Save(outputPath);
var sizeInBytes = new FileInfo(outputPath).Length;
Nel nostro test con i file di esempio, quella chiamata ha unito un report.pdf di 2 pagine con un appendix.pdf di 2 pagine, creando un report-with-appendix.pdf di 4 pagine e 257987 byte.
Passo 4: Reintrodurre il risultato nel flusso di lavoro
La dimensione del file letta subito dopo Save è di solito tutto ciò di cui un scheduler ha bisogno prima di segnare il lavoro completato, o prima di confrontarla con una dimensione minima per decidere se l’output è sufficientemente affidabile per procedere.
if (sizeInBytes == 0)
{
throw new InvalidOperationException("Join produced an empty file.");
}
GroupDocs.Merger.LowCode accetta uno stream invece di un percorso file?
Sì, sul lato input. Ognuno dei sette prodotti accetta la sua sorgente come stream nella stessa posizione del costruttore dove andrebbe un percorso file, utile quando l’input di un lavoro proviene da storage blob o da una coda invece che dal disco locale. Save scrive comunque il risultato in una stringa di percorso di output; lo streaming dell’output rimane nella classe completa Merger.
Flusso di lavoro reale: rifiutare un file prima che arrivi all’archivio
Un team contratti che aggiunge emendamenti a accordi firmati non può rischiare di accettare qualsiasi file arrivi nella casella di posta; un emendamento .docx inserito accanto a un’unione PDF produrrebbe altrimenti una voce di archivio corrotta. JoinPdf verifica la sorgente e ogni file aggiunto rispetto al formato PDF prima di scrivere, e solleva FileTypeNotSupportedException non appena uno di essi non corrisponde.
try
{
new JoinPdf("report.pdf", new[] { "contract.docx" }, new JoinOptions())
.Save("output/mixed.pdf");
}
catch (FileTypeNotSupportedException exception)
{
Console.WriteLine(exception.Message);
}
Nell’esecuzione di esempio, dove i percorsi sono costruiti dalla cartella resources, il messaggio era: Input format does not match the expected format 'PDF'; the joined file 'resources\contract.docx' is 'Microsoft Word Open XML Document (.docx)'.
Il lavoro sopra non scrive mai output/mixed.pdf quando il catch scatta, così un flusso di lavoro contratti può instradare quel messaggio direttamente nella qualsiasi coda di avvisi o ticket già in uso, invece di scoprire una voce di archivio errata giorni dopo.
Altri scenari di back‑office in cui questo modello è adatto
Una volta che l’unione sopra funziona, la stessa struttura costruttore‑poi‑Save copre diversi lavori che un back‑office esegue su base programmata:
- Ritagliare una pagina prima che un documento lasci l’edificio:
RemovePagesPdfrimuove le pagine scelte e scrive un nuovo file senza toccare la sorgente, così l’originale rimane disponibile per l’audit dopo che la copia ritagliata è stata spedita. Nel nostro test, rimuovendo la pagina 2 dareport.pdfè stato prodotto unreport-without-page-2.pdfdi 1 pagina e 86647 byte, ereport.pdfè rimasto invariato. - Dividere una presentazione per un singolo stakeholder:
SplitPptxestrae le diapositive richieste in file separati, denominati con un token{0}nel modello di output o, in sua assenza, con un numero di parte aggiunto nella stessa cartella, lo stesso modello cheSplitPdfutilizza per dividere le pagine PDF. - Unire documenti Word invece di PDF:
JoinDocxsegue esattamente la struttura costruttore‑poi‑SavediJoinPdf, inserendo il documento aggiunto dopo l’ultima pagina della sorgente.
Senza licenza, ognuno di questi gira in modalità valutazione. Nel nostro test non licenziato, gli output PDF e Word uniti sono stati ridotti a 3 pagine ciascuno, sebbene tutti e sei gli output di esempio siano stati comunque prodotti; applica una licenza con License.Set prima che questi vengano eseguiti in modo non supervisionato in produzione.
Iniziare nel tuo flusso di lavoro back‑office
Hai un modello di fusione di documenti low‑code che funziona end‑to‑end, più la prova che il controllo del formato dietro di esso viene eseguito ad ogni chiamata. Ecco dove andare da qui:
- Vedi il quadro completo: la guida casi d’uso di accompagnamento illustra ciascuna delle sei operazioni dell’esempio metodo per metodo, con una FAQ completa.
- Approfondisci una volta che un lavoro cresce: l’API completa di GroupDocs.Merger copre più ambiti di quanto questo modello richieda nel momento in cui un flusso di lavoro supera una singola operazione.
- Sfoglia il codice: il campione completo su GitHub include tutti i file di input usati sopra.
- Installa: la pagina di installazione copre il pacchetto separato e i framework di destinazione supportati.
- Rimuovi i limiti di valutazione: ottieni una licenza temporanea prima di eseguire tutto questo in produzione.
- Domande: il forum di supporto è dove il team risponde alle domande di implementazione.