Dokumente einfügen und anhängen

Manchmal ist es erforderlich, mehrere Dokumente zu einem zu kombinieren. Sie können dies manuell tun oder die Aspose.Words Einfüge- oder Anhängefunktion verwenden.

Mit dem Einfügevorgang können Sie den Inhalt zuvor erstellter Dokumente in ein neues oder vorhandenes Dokument einfügen.

Mit der Anhängefunktion können Sie wiederum ein Dokument nur am Ende eines anderen Dokuments hinzufügen.

In diesem Artikel wird erläutert, wie Sie ein Dokument auf verschiedene Arten einfügen oder an ein anderes anhängen und die allgemeinen Eigenschaften beschreiben, die Sie beim Einfügen oder Anhängen von Dokumenten anwenden können.

Dokument einfügen

Wie oben erwähnt, wird in Aspose.Words ein Dokument als ein Baum von Knoten dargestellt, und der Vorgang des Einfügens eines Dokuments in ein anderes besteht darin, Knoten vom ersten Dokumentbaum in den zweiten zu kopieren.

Sie können Dokumente auf verschiedene Arten an verschiedenen Stellen einfügen. Sie können beispielsweise ein Dokument über einen Ersetzungsvorgang, ein Seriendruckfeld während eines Seriendruckvorgangs oder über ein Lesezeichen einfügen.

Sie können auch die InsertDocument -Methode verwenden, die dem Einfügen eines Dokuments in Microsoft Word ähnelt, um ein ganzes Dokument an der aktuellen Cursorposition ohne vorherigen Import einzufügen.

Das folgende Codebeispiel zeigt, wie Sie ein Dokument mit der Methode InsertDocument einfügen:

// 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 den folgenden Unterabschnitten werden die Optionen beschrieben, mit denen Sie ein Dokument in ein anderes einfügen können.

Dokument während des Such- und Ersetzungsvorgangs einfügen

Sie können Dokumente einfügen, während Sie Suchen- und Ersetzungsvorgänge ausführen. Beispielsweise kann ein Dokument Absätze mit dem Text [INTRODUCTION] und [CONCLUSION] enthalten. Im endgültigen Dokument müssen Sie diese Absätze jedoch durch den Inhalt ersetzen, der aus einem anderen externen Dokument stammt. Um dies zu erreichen, müssen Sie einen Handler für das Ersetzungsereignis erstellen.

Das folgende Codebeispiel zeigt, wie Sie einen Handler für das Ersetzungsereignis erstellen, um es später im Einfügevorgang zu verwenden:

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

Das folgende Codebeispiel zeigt, wie der Inhalt eines Dokuments während eines Such- und Ersetzungsvorgangs in ein anderes eingefügt wird:

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

Dokument während Mail Merge Vorgang {#insert-a-document-during-mail-merge-operation} einfügen

Sie können ein Dokument während eines mail merge-Vorgangs in ein Seriendruckfeld einfügen. Beispielsweise kann eine mail merge-Vorlage ein Seriendruckfeld wie [Zusammenfassung] enthalten. Im endgültigen Dokument müssen Sie jedoch Inhalte aus einem anderen externen Dokument in dieses Seriendruckfeld einfügen. Um dies zu erreichen, müssen Sie einen Handler für das Zusammenführungsereignis erstellen.

Das folgende Codebeispiel zeigt, wie Sie einen Handler für das Zusammenführungsereignis erstellen, um ihn später im Einfügevorgang zu verwenden:

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

Das folgende Codebeispiel zeigt, wie Sie mit dem erstellten Handler ein Dokument in das Seriendruckfeld einfügen:

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

Dokument als Lesezeichen einfügen

Sie können eine Textdatei in ein Dokument importieren und direkt nach einem Lesezeichen einfügen, das Sie im Dokument definiert haben. Erstellen Sie dazu einen Absatz mit Lesezeichen, in den das Dokument eingefügt werden soll.

Das folgende Codierungsbeispiel zeigt, wie Sie den Inhalt eines Dokuments in ein Lesezeichen in einem anderen Dokument einfügen:

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

Beachten Sie, dass das Lesezeichen nicht mehrere Absätze oder Texte einschließen sollte, die in Ihrem endgültigen Ergebnisdokument angezeigt werden sollen.

Anhängen eines Dokuments

Möglicherweise haben Sie einen Anwendungsfall, in dem Sie zusätzliche Seiten aus einem Dokument an das Ende eines vorhandenen Dokuments einfügen müssen. Dazu müssen Sie nur die Methode AppendDocument aufrufen, um ein Dokument am Ende eines anderen hinzuzufügen.

Beachten Sie, dass AppendChild eine Methode auf Knotenebene innerhalb eines Dokuments ist. Sie können beispielsweise einen Absatz erstellen, Formatierungseigenschaften festlegen und ihn dann mit der Methode AppendChild als untergeordnetes Element an den Textkörper anhängen.

Das folgende Codebeispiel zeigt, wie Sie ein Dokument an das Ende eines anderen Dokuments anhängen:

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

Knoten manuell importieren und einfügen

Aspose.Words ermöglicht das automatische Einfügen und Anhängen von Dokumenten ohne vorherige Importanforderungen. Wenn Sie jedoch einen bestimmten Knoten Ihres Dokuments einfügen oder anhängen müssen, z. B. einen Abschnitt oder einen Absatz, müssen Sie diesen Knoten zuerst manuell importieren.

Wenn Sie einen Abschnitt oder Absatz an einen anderen einfügen oder anhängen müssen, müssen Sie im Wesentlichen die Knoten des ersten Dokumentknotenbaums mit der Methode ImportNode in den zweiten importieren. Nach dem Importieren Ihrer Knoten müssen Sie die Methode InsertAfter / InsertBefore verwenden, um einen neuen Knoten nach / vor dem Referenzknoten einzufügen. Auf diese Weise können Sie den Einfügevorgang anpassen, indem Sie Knoten aus einem Dokument importieren und an bestimmten Positionen einfügen.

Sie können auch die Methode AppendChild verwenden, um einen neuen angegebenen Knoten am Ende der Liste der untergeordneten Knoten hinzuzufügen, z. B. wenn Sie Inhalte auf Absatzebene anstatt auf Abschnittsebene anhängen möchten.

Das folgende Codebeispiel zeigt, wie Knoten manuell importiert und nach einem bestimmten Knoten mit der Methode InsertAfter eingefügt werden:

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

Der Import erstellt einen neuen Knoten, der eine Kopie des ursprünglichen Knotens ist und zum Einfügen in das Zieldokument geeignet ist.

Inhalte werden abschnittsweise in das Zieldokument importiert, was bedeutet, dass Einstellungen wie Seiteneinrichtung und Kopf- oder Fußzeilen beim Import beibehalten werden. Es ist auch nützlich zu beachten, dass Sie beim Einfügen oder Anhängen eines Dokuments Formatierungseinstellungen definieren können, um festzulegen, wie zwei Dokumente zusammengefügt werden.

Allgemeine Eigenschaften für Dokumente einfügen und Anhängen

Sowohl InsertDocument als auch AppendDocument methoden akzeptieren ImportFormatMode und ImportFormatOptions als Eingabeparameter. Mit ImportFormatMode können Sie steuern, wie Dokumentformatierungen zusammengeführt werden, wenn Sie Inhalte aus einem Dokument in ein anderes importieren, indem Sie verschiedene Formatmodi wie UseDestinationStyles, KeepSourceFormatting und KeepDifferentStyles auswählen. Mit ImportFormatOptions können Sie verschiedene Importoptionen auswählen, z IgnoreHeaderFooter, IgnoreTextBoxes, KeepSourceNumbering, MergePastedLists, und SmartStyleBehavior.

Mit Aspose.Words können Sie die Visualisierung eines resultierenden Dokuments anpassen, wenn zwei Dokumente in einem Einfüge- oder Anhängevorgang mithilfe der Eigenschaften Section und PageSetup addiert werden. Die Eigenschaft PageSetup enthält alle Attribute eines Abschnitts, z. B.: SectionStart, RestartPageNumbering, PageStartingNumber, Orientation, und andere. Der häufigste Anwendungsfall besteht darin, die Eigenschaft SectionStart festzulegen, um zu definieren, ob der hinzugefügte Inhalt auf derselben Seite angezeigt oder in eine neue aufgeteilt wird.

Beachten Sie, dass die Eigenschaften Section und PageSetup nicht steuern, wie zwei Dokumente eingefügt / angehängt werden. Sie erlauben Ihnen nur, das Aussehen Ihres Ergebnisdokuments zu ändern.

Das folgende Codebeispiel zeigt, wie ein Dokument an ein anderes angehängt wird, während der Inhalt nicht auf zwei Seiten aufgeteilt wird:

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