Documenten invoegen en toevoegen

Soms is het nodig om meerdere documenten in één te combineren. U kunt dit handmatig doen of u kunt de functie Aspose.Words invoegen of toevoegen gebruiken.

Met de bewerking invoegen kunt u de inhoud van eerder gemaakte documenten invoegen in een nieuwe of bestaande.

Met de functie toevoegen kunt u een document alleen aan het einde van een ander document toevoegen.

In dit artikel wordt uitgelegd hoe u een document op verschillende manieren kunt invoegen of toevoegen aan een ander document en worden de algemene eigenschappen beschreven die u kunt toepassen tijdens het invoegen of toevoegen van documenten.

Een Document invoegen

Zoals hierboven vermeld, wordt in Aspose.Words een document weergegeven als een boom van knooppunten, en de operatie van het invoegen van een document in een ander is het kopiëren van knooppunten van de eerste documentboom naar de tweede.

U kunt documenten op verschillende locaties op verschillende manieren invoegen. U kunt bijvoorbeeld een document invoegen via een bewerking vervangen, een samenvoegveld tijdens een samenvoegbewerking of via een bladwijzer.

U kunt ook de methode InsertDocument gebruiken, die vergelijkbaar is met het invoegen van een document in Microsoft Word, om een heel document op de huidige cursorpositie in te voegen zonder eerder te importeren.

Het volgende codevoorbeeld laat zien hoe u een document invoegt met de methode 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");

In de volgende subsecties worden de opties beschreven waarin u het ene document in het andere kunt invoegen.

Een Document invoegen tijdens bewerking {#insert-a-document-during-find-and-replace-operation}zoeken en vervangen

U kunt documenten invoegen terwijl u bewerkingen zoeken en vervangen uitvoert. Een document kan bijvoorbeeld alinea ' s bevatten met de tekst [INTRODUCTION] en [CONCLUSION]. Maar in het einddocument moet u die alinea ' s vervangen door de inhoud die is verkregen uit een ander extern document. Om dat te bereiken, moet u een handler maken voor de replace-gebeurtenis.

Het volgende codevoorbeeld laat zien hoe u een handler voor de vervangingsgebeurtenis kunt maken om deze later in het invoegproces te gebruiken:

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

Het volgende codevoorbeeld laat zien hoe de inhoud van een document in een ander document wordt ingevoegd tijdens een bewerking zoeken en vervangen:

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

Een Document invoegen tijdens Mail Merge bewerking

U kunt een document invoegen in een samenvoegveld tijdens een bewerking van Mail Merge. Een Mail Merge - sjabloon kan bijvoorbeeld een samenvoegveld bevatten, zoals [samenvatting]. Maar in het einddocument moet u inhoud die is verkregen uit een ander extern document invoegen in dit samenvoegveld. Om dat te bereiken, moet u een handler maken voor de merge-gebeurtenis.

Het volgende codevoorbeeld laat zien hoe u een handler voor de samenvoegende gebeurtenis kunt maken om deze later in het invoegproces te gebruiken:

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

Het volgende codevoorbeeld laat zien hoe u een document invoegt in het samenvoegveld met behulp van de aangemaakte handler:

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

Een Document invoegen bij bladwijzer

U kunt een tekstbestand in een document importeren en direct na een bladwijzer invoegen die u in het document hebt gedefinieerd. Maak hiervoor een alinea met bladwijzers waarop u het document wilt invoegen.

Het volgende coderingsvoorbeeld laat zien hoe u de inhoud van een document invoegt in een bladwijzer in een ander 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");

Houd er rekening mee dat de bladwijzer niet meerdere alinea ' s of tekst mag bevatten waarvan u wilt dat deze in het uiteindelijke resulterende document worden weergegeven.

Een Document toevoegen

Mogelijk hebt u een use case waarbij u extra pagina ' s van een document moet toevoegen aan het einde van een bestaand document. Hiervoor hoeft u alleen de methode AppendDocument aan te roepen om een document aan het einde van een ander document toe te voegen.

Merk op dat AppendChild een methode op knoopniveau is in een document. U kunt bijvoorbeeld een alinea maken, opmaakeigenschappen instellen en deze vervolgens als een kind aan de hoofdtekst toevoegen met de methode AppendChild.

Het volgende codevoorbeeld laat zien hoe u een document aan het einde van een ander document toevoegt:

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

Knooppunten handmatig {#import-and-insert-nodes-manually}importeren en invoegen

Met Aspose.Words kunt u documenten automatisch invoegen en toevoegen zonder voorafgaande importvereisten. Als u echter een specifiek knooppunt van uw document wilt invoegen of toevoegen, zoals een sectie of een alinea, moet u dit knooppunt eerst handmatig importeren.

Wanneer u een sectie of alinea moet invoegen of toevoegen aan een andere, moet u in wezen de knooppunten van de eerste documentknoopboom importeren in de tweede met behulp van de methode ImportNode. Na het importeren van uw knooppunten, moet u de methode InsertAfter/InsertBefore gebruiken om een nieuw knooppunt na/voor het referentieknooppunt in te voegen. Hiermee kunt u het invoegproces aanpassen door knooppunten uit een document te importeren en op bepaalde posities in te voegen.

U kunt ook de methode AppendChild gebruiken om een nieuw opgegeven knooppunt aan het einde van de lijst met onderliggende knooppunten toe te voegen, bijvoorbeeld als u inhoud op alineaniveau wilt toevoegen in plaats van op sectieniveau.

Het volgende codevoorbeeld laat zien hoe u knooppunten handmatig kunt importeren en invoegen na een specifiek knooppunt met behulp van de methode 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.");
    }
}

Bij het importeren wordt een nieuw knooppunt gemaakt dat een kopie is van het oorspronkelijke knooppunt en geschikt is voor invoeging in het doeldocument.

Inhoud wordt sectie voor sectie geïmporteerd in het doeldocument, wat betekent dat instellingen, zoals Pagina-instellingen en kop-of voetteksten, behouden blijven tijdens het importeren. Het is ook handig op te merken dat u opmaakinstellingen kunt definiëren wanneer u een document invoegt of toevoegt om aan te geven hoe twee documenten worden samengevoegd.

Gemeenschappelijke eigenschappen voor documenten invoegen en toevoegen

Zowel InsertDocument als AppendDocument methoden accepteren ImportFormatMode en ImportFormatOptions als invoerparameters. Met ImportFormatMode kunt u bepalen hoe documentopmaak wordt samengevoegd wanneer u inhoud van het ene document naar het andere importeert door verschillende opmaakmodi te selecteren, zoals UseDestinationStyles, KeepSourceFormatting en KeepDifferentStyles. Met ImportFormatOptions kunt u verschillende importopties selecteren, zoals IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, en SmartStyleBehavior.

Met Aspose.Words kunt u de visualisatie van een resulterende document aanpassen wanneer twee documenten bij elkaar worden opgeteld in een bewerking invoegen of toevoegen met behulp van de eigenschappen Section en PageSetup. De eigenschap PageSetup bevat alle attributen van een sectie zoals SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, en anderen. Het meest voorkomende gebruik is om de eigenschap SectionStart in te stellen om te bepalen of de toegevoegde inhoud op dezelfde pagina verschijnt of in een nieuwe wordt gesplitst.

Merk op dat de eigenschappen Section en PageSetup niet bepalen hoe twee documenten aan elkaar worden toegevoegd. Hiermee kunt u alleen het uiterlijk van uw resultaatdocument wijzigen.

Het volgende codevoorbeeld laat zien hoe u het ene document aan het andere kunt toevoegen terwijl de inhoud niet over twee pagina ' s wordt gesplitst:

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