Voeg Dokumente in en Voeg By

Soms is dit nodig om verskeie dokumente in een te kombineer. Jy kan dit met die hand doen of jy kan Aspose.Words invoeg of voeg funksie by.

Die invoegbewerking laat jou toe om die inhoud van voorheen geskepte dokumente in’n nuwe of bestaande een in te voeg.

Op sy beurt kan die append-funksie u slegs’n dokument aan die einde van’n ander dokument byvoeg.

Hierdie artikel verduidelik hoe om’n dokument op verskillende maniere by’n ander een in te voeg of by te voeg en beskryf die algemene eienskappe wat u kan toepas terwyl u dokumente invoeg of byvoeg.

Voeg’n Dokument in

Soos hierbo genoem, word’n dokument in Aspose.Words voorgestel as’n boom van nodusse, en die operasie om een dokument in’n ander in te voeg, is om nodusse van die eerste dokumentboom na die tweede te kopieer.

U kan dokumente op verskillende plekke op verskillende maniere invoeg. U kan byvoorbeeld’n dokument invoeg deur’n vervangingsbewerking, ‘n samesmeltingsveld tydens’n samesmeltingsbewerking of via’n boekmerk.

Jy kan ook die InsertDocument metode gebruik, wat soortgelyk is aan die invoeging van’n dokument in Microsoft Word, om’n hele dokument by die huidige wyserposisie in te voeg sonder enige vorige invoer.

Die volgende kode voorbeeld toon hoe om’n dokument in te voeg met behulp van die InsertDocument metode:

// 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");

Die volgende onderafdelings beskryf die opsies waartydens jy een dokument in’n ander kan invoeg.

Voeg’n Dokument in Tydens Soek En Vervang Operasie

U kan dokumente invoeg terwyl u bewerkings vind en vervang. Byvoorbeeld, ‘n dokument kan paragrawe bevat met die teks [INTRODUCTION] en [CONCLUSION]. Maar in die finale dokument moet jy daardie paragrawe vervang met die inhoud wat van’n ander eksterne dokument verkry is. Om dit te bereik, sal jy’n hanteerder vir die vervangingsgeleentheid moet skep.

Die volgende kode voorbeeld toon hoe om’n hanteerder vir die vervanging gebeurtenis te skep om dit later in die invoeging proses te gebruik:

// 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;
    }
};

Die volgende kode voorbeeld toon hoe voeg inhoud van een dokument in’n ander tydens’n vind en vervang operasie:

// 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");

Voeg’n Dokument in Tydens Mail Merge Operasie

U kan’n dokument in’n samesmeltingsveld plaas tydens’n Mail Merge - bewerking. Byvoorbeeld, ‘n Mail Merge sjabloon kan’n samesmelting veld soos [Opsomming] bevat. Maar in die finale dokument moet jy inhoud wat van’n ander eksterne dokument verkry is, in hierdie samesmeltingsveld invoeg. Om dit te bereik, sal jy’n hanteerder vir die samesmeltingsgeleentheid moet skep.

Die volgende kode voorbeeld toon hoe om’n hanteerder vir die samesmelting gebeurtenis te skep om dit later in die invoeging proses te gebruik:

// 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.
    }
};

Die volgende kode voorbeeld toon hoe om’n dokument in die merge veld te voeg met behulp van die geskep handelaar:

// 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");

Voeg’n Dokument By Boekmerk in

U kan’n tekslêer in’n dokument invoer en dit direk na’n boekmerk wat u in die dokument gedefinieer het, invoeg. Om dit te doen, skep’n boekmerk paragraaf waar jy wil hê die dokument moet ingevoeg word.

Die volgende kodering voorbeeld toon hoe om die inhoud van een dokument in’n boekmerk in’n ander dokument in te voeg:

// 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");

Let daarop dat die boekmerk nie veelvuldige paragrawe of teks moet insluit wat jy wil hê hulle moet in jou finale gevolglike dokument verskyn nie.

Voeg’n Dokument by

U het moontlik’n gebruiksgeval waar u addisionele bladsye van’n dokument tot aan die einde van’n bestaande dokument moet insluit. Om dit te doen, moet jy net die AppendDocument metode noem om’n dokument aan die einde van’n ander een by te voeg.

Let daarop dat AppendChild is’n knoop vlak metode binne’n dokument. U kan byvoorbeeld’n paragraaf skep, formateringseienskappe stel en dit dan as kind by die liggaam voeg deur die AppendChild - metode te gebruik.

Die volgende kode voorbeeld toon hoe om’n dokument aan die einde van’n ander dokument te voeg:

// 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");

Invoer En Voeg Nodes Handmatig

Aspose.Words laat jou toe om dokumente outomaties in te voeg en by te voeg sonder enige vorige invoervereistes. As jy egter’n spesifieke nodus van jou dokument, soos’n afdeling of’n paragraaf, moet invoeg of byvoeg, moet jy eers hierdie nodus handmatig invoer.

Wanneer jy een afdeling of paragraaf by’n ander moet voeg of byvoeg, moet jy in wese die nodusse van die eerste dokumentknoopboom in die tweede een invoer deur die ImportNode - metode te gebruik. Na die invoer van jou nodes, moet jy die InsertAfter/InsertBefore metode gebruik om’n nuwe node na/voor die verwysing node in te voeg. Dit laat jou toe om die invoeging proses aan te pas deur die invoer van nodes van’n dokument en die invoeging van dit by gegewe posisies.

U kan ook die AppendChild - metode gebruik om’n nuwe gespesifiseerde nodus aan die einde van die lys van kindknope by te voeg, byvoorbeeld as u inhoud op die paragraafvlak wil byvoeg in plaas van op die afdelingvlak.

Die volgende kode voorbeeld toon hoe om handmatig invoer nodes en voeg hulle na’n spesifieke node met behulp van die InsertAfter metode:

// 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.");
    }
}

Die invoer skep’n nuwe knoop wat’n kopie van die oorspronklike knoop is en geskik is vir invoeging in die bestemming dokument.

Inhoud word in die bestemming dokument afdeling vir afdeling ingevoer, wat beteken dat instellings, soos bladsy opstel en koptekste of voetskrifte, tydens invoer bewaar word. Dit is ook nuttig om daarop te let dat jy formatering instellings kan definieer wanneer jy’n dokument invoeg of byvoeg om te spesifiseer hoe twee dokumente saamgevoeg word.

Algemene Eienskappe vir Voeg Dokumente in en Voeg By

Beide InsertDocument en AppendDocument metodes aanvaar ImportFormatMode en ImportFormatOptions as insetparameters. Die ImportFormatMode laat jou toe om te beheer hoe dokument formatering saamgesmelt word wanneer jy inhoud van een dokument in’n ander invoer deur verskillende formaatmodusse soos UseDestinationStyles, KeepSourceFormatting en KeepDifferentStyles te kies. Met die ImportFormatOptions kan u verskillende invoeropsies kies, soos IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, en SmartStyleBehavior.

Aspose.Words laat jou toe om die visualisering van’n gevolglike dokument aan te pas wanneer twee dokumente saamgevoeg word in’n insetsel of byvoeging deur die Section en PageSetup eienskappe te gebruik. Die PageSetup eienskap bevat al die eienskappe van’n afdeling soos SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, en ander. Die mees algemene gebruik geval is om die SectionStart eienskap te stel om te definieer of die bygevoeg inhoud sal verskyn op dieselfde bladsy of verdeel in’n nuwe een.

Let daarop dat die Section en PageSetup eienskappe nie beheer hoe twee dokumente saam ingevoeg/aangeheg word nie. Hulle laat jou net toe om die voorkoms van jou resultaatdokument te verander.

Die volgende kode voorbeeld toon hoe om een dokument by’n ander te voeg terwyl die inhoud van die verdeling oor twee bladsye:

// 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");