Inserați și adăugați documente

Uneori este necesar să combinați mai multe documente într-unul singur. Puteți face acest lucru manual sau puteți utiliza Aspose.Words inserare sau Adăugare caracteristică.

Operația insert vă permite să inserați conținutul documentelor create anterior într-unul nou sau existent.

La rândul său, caracteristica Adăugare vă permite să adăugați un document numai la sfârșitul altui document.

Acest articol explică modul de inserare sau adăugare a unui document la altul în moduri diferite și descrie proprietățile comune pe care le puteți aplica în timp ce inserați sau adăugați documente.

Inserarea unui Document

După cum sa menționat mai sus, în Aspose.Words un document este reprezentat ca un arbore de noduri, iar operația de inserare a unui document în altul este copierea nodurilor din primul arbore de documente în al doilea.

Puteți insera documente într-o varietate de locații în moduri diferite. De exemplu, puteți insera un document printr-o operație de înlocuire, un câmp de îmbinare în timpul unei operații de îmbinare sau printr-un marcaj.

De asemenea, puteți utiliza metoda InsertDocument, care este similară cu inserarea unui document în Microsoft Word, pentru a insera un document întreg în poziția curentă a cursorului fără importuri anterioare.

Următorul exemplu de cod arată cum să inserați un document folosind metoda InsertDocument:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto srcDoc = MakeObject<Document>(MyDir + u"Document source.docx");
auto dstDoc = MakeObject<Document>(MyDir + u"Northwind traders.docx");
auto builder = MakeObject<DocumentBuilder>(dstDoc);
builder->MoveToDocumentEnd();
builder->InsertBreak(BreakType::PageBreak);
builder->InsertDocument(srcDoc, ImportFormatMode::KeepSourceFormatting);
builder->get_Document()->Save(ArtifactsDir + u"JoinAndAppendDocuments.InsertDocument.docx");

Următoarele subsecțiuni descriu opțiunile în timpul cărora puteți insera un document în altul.

Introduceți un Document în timpul operației Găsire și înlocuire

Puteți insera documente în timp ce efectuați operațiuni de găsire și înlocuire. De exemplu, un document poate conține paragrafe cu textul [INTRODUCTION] și [CONCLUSION]. Dar în documentul final, trebuie să înlocuiți acele paragrafe cu conținutul obținut dintr-un alt document extern. Pentru a realiza acest lucru, va trebui să creați un handler pentru evenimentul replace.

Următorul exemplu de cod arată cum să creați un handler pentru evenimentul de înlocuire pentru a-l utiliza mai târziu în procesul de inserare:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
class InsertDocumentAtReplaceHandler : public IReplacingCallback
{
private:
ReplaceAction Replacing(SharedPtr<ReplacingArgs> args) override
{
auto subDoc = MakeObject<Document>(MyDir + u"Document insertion 2.docx");
// Insert a document after the paragraph, containing the match text.
auto para = System::ExplicitCast<Paragraph>(args->get_MatchNode()->get_ParentNode());
InsertDocument(para, subDoc);
// Remove the paragraph with the match text.
para->Remove();
return ReplaceAction::Skip;
}
};

Următorul exemplu de cod arată modul în care introduceți conținutul unui document în altul în timpul unei operații de găsire și înlocuire:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto mainDoc = MakeObject<Document>(MyDir + u"Document insertion 1.docx");
// Set find and replace options.
auto options = MakeObject<FindReplaceOptions>();
options->set_Direction(FindReplaceDirection::Backward);
options->set_ReplacingCallback(MakeObject<CloneAndCombineDocuments::InsertDocumentAtReplaceHandler>());
// Call the replace method.
mainDoc->get_Range()->Replace(MakeObject<System::Text::RegularExpressions::Regex>(u"\\[MY_DOCUMENT\\]"), u"", options);
mainDoc->Save(ArtifactsDir + u"CloneAndCombineDocuments.InsertDocumentAtReplace.docx");

Introduceți un Document în timpul operației Mail Merge

Puteți insera un document într-un câmp de îmbinare în timpul unei operații mail merge. De exemplu, un șablon Mail Merge poate conține un câmp de îmbinare, cum ar fi [rezumat]. Dar în documentul final, trebuie să inserați conținut obținut dintr-un alt document extern în acest câmp de îmbinare. Pentru a realiza acest lucru, va trebui să creați un handler pentru evenimentul de îmbinare.

Următorul exemplu de cod arată cum să creați un handler pentru evenimentul de fuziune pentru a-l utiliza mai târziu în procesul de inserare:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
class InsertDocumentAtMailMergeHandler : public IFieldMergingCallback
{
private:
void FieldMerging(SharedPtr<FieldMergingArgs> args) override
{
if (args->get_DocumentFieldName() == u"Document_1")
{
// Use document builder to navigate to the merge field with the specified name.
auto builder = MakeObject<DocumentBuilder>(args->get_Document());
builder->MoveToMergeField(args->get_DocumentFieldName());
// The name of the document to load and insert is stored in the field value.
auto subDoc = MakeObject<Document>(System::ObjectExt::Unbox<String>(args->get_FieldValue()));
InsertDocument(builder->get_CurrentParagraph(), subDoc);
// The paragraph that contained the merge field might be empty now, and you probably want to delete it.
if (!builder->get_CurrentParagraph()->get_HasChildNodes())
{
builder->get_CurrentParagraph()->Remove();
}
// Indicate to the mail merge engine that we have inserted what we wanted.
args->set_Text(nullptr);
}
}
void ImageFieldMerging(SharedPtr<ImageFieldMergingArgs> args) override
{
ASPOSE_UNUSED(args);
// Do nothing.
}
};

Următorul exemplu de cod arată cum să inserați un document în câmpul de îmbinare utilizând handler-ul creat:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto mainDoc = MakeObject<Document>(MyDir + u"Document insertion 1.docx");
mainDoc->get_MailMerge()->set_FieldMergingCallback(MakeObject<CloneAndCombineDocuments::InsertDocumentAtMailMergeHandler>());
// The main document has a merge field in it called "Document_1".
// The corresponding data for this field contains a fully qualified path to the document.
// That should be inserted to this field.
mainDoc->get_MailMerge()->Execute(MakeArray<String>({u"Document_1"}),
MakeArray<SharedPtr<System::Object>>({System::ObjectExt::Box<String>(MyDir + u"Document insertion 2.docx")}));
mainDoc->Save(ArtifactsDir + u"CloneAndCombineDocuments.InsertDocumentAtMailMerge.doc");

Introduceți un Document la marcaj

Puteți importa un fișier text într-un document și îl puteți insera imediat după un marcaj pe care l-ați definit în document. Pentru a face acest lucru, creați un paragraf marcat în care doriți să fie inserat documentul.

Următorul exemplu de codificare arată cum să inserați conținutul unui document într - un marcaj dintr-un alt document:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto mainDoc = MakeObject<Document>(MyDir + u"Document insertion 1.docx");
auto subDoc = MakeObject<Document>(MyDir + u"Document insertion 2.docx");
SharedPtr<Bookmark> bookmark = mainDoc->get_Range()->get_Bookmarks()->idx_get(u"insertionPlace");
InsertDocument(bookmark->get_BookmarkStart()->get_ParentNode(), subDoc);
mainDoc->Save(ArtifactsDir + u"CloneAndCombineDocuments.InsertDocumentAtBookmark.docx");

Adăugați un Document

Este posibil să aveți un caz de utilizare în care trebuie să includeți pagini suplimentare dintr-un document până la sfârșitul unui document existent. Pentru a face acest lucru, trebuie doar să apelați metoda AppendDocument pentru a adăuga un document la sfârșitul altuia.

Următorul exemplu de cod arată cum să adăugați un document la sfârșitul unui alt document:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto dstDoc = MakeObject<Document>();
dstDoc->get_FirstSection()->get_Body()->AppendParagraph(u"Destination document text. ");
auto srcDoc = MakeObject<Document>();
srcDoc->get_FirstSection()->get_Body()->AppendParagraph(u"Source document text. ");
// Append the source document to the destination document.
// Pass format mode to retain the original formatting of the source document when importing it.
dstDoc->AppendDocument(srcDoc, ImportFormatMode::KeepSourceFormatting);
dstDoc->Save(ArtifactsDir + u"JoinAndAppendDocuments.KeepSourceFormatting.docx");

Importați și inserați manual nodurile

Aspose.Words vă permite să inserați și să adăugați documente automat fără cerințe anterioare de import. Cu toate acestea, dacă trebuie să inserați sau să adăugați un anumit nod al documentului dvs., cum ar fi o secțiune sau un paragraf, atunci mai întâi trebuie să importați manual acest nod.

Când trebuie să inserați sau să adăugați o secțiune sau un paragraf la altul, trebuie în esență să importați nodurile primului arbore de noduri de document în cel de-al doilea folosind metoda ImportNode. După importarea nodurilor, trebuie să utilizați metoda InsertAfter / InsertBefore pentru a insera un nou nod după / înainte de nodul de referință. Acest lucru vă permite să personalizați procesul de inserare importând noduri dintr-un document și inserându-l în poziții date.

De asemenea, puteți utiliza metoda AppendChild pentru a adăuga un nou nod specificat la sfârșitul listei de noduri copil, de exemplu, dacă doriți să adăugați conținut la nivel de paragraf în loc de la nivel de secțiune.

Următorul exemplu de cod arată cum să importați manual noduri și să le inserați după un anumit nod folosind metoda InsertAfter:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
/// <summary>
/// Inserts content of the external document after the specified node.
/// Section breaks and section formatting of the inserted document are ignored.
/// </summary>
/// <param name="insertionDestination">Node in the destination document after which the content
/// Should be inserted. This node should be a block level node (paragraph or table).</param>
/// <param name="docToInsert">The document to insert.</param>
static void InsertDocument(SharedPtr<Node> insertionDestination, SharedPtr<Document> docToInsert)
{
if (insertionDestination->get_NodeType() == NodeType::Paragraph || insertionDestination->get_NodeType() == NodeType::Table)
{
SharedPtr<CompositeNode> destinationParent = insertionDestination->get_ParentNode();
auto importer = MakeObject<NodeImporter>(docToInsert, insertionDestination->get_Document(), ImportFormatMode::KeepSourceFormatting);
// Loop through all block-level nodes in the section's body,
// then clone and insert every node that is not the last empty paragraph of a section.
for (const auto& srcSection : System::IterateOver(docToInsert->get_Sections()->LINQ_OfType<SharedPtr<Section>>()))
{
for (const auto& srcNode : System::IterateOver(srcSection->get_Body()))
{
if (srcNode->get_NodeType() == NodeType::Paragraph)
{
auto para = System::ExplicitCast<Paragraph>(srcNode);
if (para->get_IsEndOfSection() && !para->get_HasChildNodes())
{
continue;
}
}
SharedPtr<Node> newNode = importer->ImportNode(srcNode, true);
destinationParent->InsertAfter(newNode, insertionDestination);
insertionDestination = newNode;
}
}
}
else
{
throw System::ArgumentException(u"The destination node should be either a paragraph or table.");
}
}

Conținutul este importat în documentul de destinație secțiune cu secțiune, ceea ce înseamnă că setările, cum ar fi configurarea paginii și anteturile sau subsolurile, sunt păstrate în timpul importului. De asemenea, este util să rețineți că puteți defini setările de formatare atunci când inserați sau adăugați un document pentru a specifica modul în care două documente sunt unite.

Proprietăți comune pentru Inserare și Adăugare documente

Ambele InsertDocument și AppendDocument metodele acceptă ImportFormatMode și ImportFormatOptions ca parametri de intrare. ImportFormatMode Vă permite să controlați modul în care formatarea documentului este îmbinată atunci când importați conținut dintr-un document în altul selectând diferite moduri de format, cum ar fi UseDestinationStyles, KeepSourceFormatting și KeepDifferentStyles. ImportFormatOptions Vă permite să selectați diferite opțiuni de import, cum ar fi IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, și SmartStyleBehavior.

Aspose.Words vă permite să ajustați vizualizarea unui document rezultat atunci când două documente sunt adăugate împreună într-o operație de inserare sau Adăugare utilizând proprietățile Section și PageSetup. Proprietatea PageSetup conține toate atributele unei secțiuni, cum ar fi SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, și altele. Cel mai frecvent caz de utilizare este să setați proprietatea SectionStart pentru a defini dacă conținutul adăugat va apărea pe aceeași pagină sau va fi împărțit într-unul nou.

Următorul exemplu de cod arată cum să adăugați un document la altul, păstrând în același timp conținutul să nu se împartă pe două pagini:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto srcDoc = MakeObject<Document>(MyDir + u"Document source.docx");
auto dstDoc = MakeObject<Document>(MyDir + u"Northwind traders.docx");
// Set the source document to continue straight after the end of the destination document.
srcDoc->get_FirstSection()->get_PageSetup()->set_SectionStart(SectionStart::Continuous);
// Restart the page numbering on the start of the source document.
srcDoc->get_FirstSection()->get_PageSetup()->set_RestartPageNumbering(true);
srcDoc->get_FirstSection()->get_PageSetup()->set_PageStartingNumber(1);
// To ensure this does not happen when the source document has different page setup settings, make sure the
// settings are identical between the last section of the destination document.
// If there are further continuous sections that follow on in the source document,
// this will need to be repeated for those sections.
srcDoc->get_FirstSection()->get_PageSetup()->set_PageWidth(dstDoc->get_LastSection()->get_PageSetup()->get_PageWidth());
srcDoc->get_FirstSection()->get_PageSetup()->set_PageHeight(dstDoc->get_LastSection()->get_PageSetup()->get_PageHeight());
srcDoc->get_FirstSection()->get_PageSetup()->set_Orientation(dstDoc->get_LastSection()->get_PageSetup()->get_Orientation());
// Iterate through all sections in the source document.
for (const auto& para : System::IterateOver<Paragraph>(srcDoc->GetChildNodes(NodeType::Paragraph, true)))
{
para->get_ParagraphFormat()->set_KeepWithNext(true);
}
dstDoc->AppendDocument(srcDoc, ImportFormatMode::KeepSourceFormatting);
dstDoc->Save(ArtifactsDir + u"JoinAndAppendDocuments.DifferentPageSetup.docx");