Freigeben über

Einfügen einer Tabelle in ein Textverarbeitungsdokument

In diesem Thema wird gezeigt, wie Sie die Klassen im Open XML SDK für Office verwenden, um eine Tabelle programmgesteuert in ein Textverarbeitungsdokument einzufügen.

Abrufen eines WordprocessingDocument-Objekts

Um ein vorhandenes Dokument zu öffnen, instanziieren Sie die WordprocessingDocument -Klasse wie in der folgenden using Anweisung gezeigt. Öffnen Sie in derselben Anweisung die Textverarbeitungsdatei am angegebenen Dateipfad, indem Sie die Open -Methode verwenden, wobei der boolesche Parameter auf true festgelegt ist, um die Bearbeitung des Dokuments zu ermöglichen.

using (WordprocessingDocument doc = WordprocessingDocument.Open(fileName, true))

Mit v3.0.0 und höher wurde die Close() -Methode entfernt, um sich auf die using-Anweisung zu verlassen. Dadurch wird sichergestellt, dass die Dispose() -Methode automatisch aufgerufen wird, wenn die schließende Klammer erreicht ist. Der Block, der auf die using-Anweisung folgt, richtet einen Bereich für das Objekt ein, das in der using-Anweisung erstellt oder benannt wird. Da die WordprocessingDocument -Klasse im Open XML SDK das Objekt als Teil der IDisposable Implementierung automatisch speichert und schließt und da Dispose() automatisch aufgerufen wird, wenn Sie den Block beenden, müssen Sie oder Dispose() nicht explizit aufrufenSave(), solange Sie eine using -Anweisung verwenden.

Struktur einer Tabelle

Die grundlegende Dokumentstruktur eines WordProcessingML Dokuments besteht aus den document Elementen und body gefolgt von einem oder mehreren Elementen auf Blockebene, z p. B. , die einen Absatz darstellen. Ein Absatz enthält mindestens ein r Element. Das r steht für "run" (Lauf), wobei es sich um einen Textbereich mit gemeinsamen Eigenschaften, z. B. Formatierung, handelt. Eine Ausführung enthält mindestens ein t Element. Das t -Element enthält einen Textbereich. Das Dokument kann eine Tabelle wie in diesem Beispiel enthalten. Eine Tabelle besteht aus einer Reihe von Absätzen (und anderen Inhalten auf Blockebene), die in Zeilen und Spalten angeordnet sind. Tabellen in WordprocessingML werden über das tbl -Element definiert, das analog zum HTML-Tabellentag ist. Stellen Sie sich eine leere Tabelle mit einer Zelle (d. h. eine Tabelle mit einer Zeile, einer Spalte) und 1 Punktrahmen auf allen Seiten vor. Diese Tabelle wird durch das folgende WordprocessingML Markupsegment dargestellt.

    <w:tbl>
      <w:tblPr>
        <w:tblW w:w="5000" w:type="pct"/>
        <w:tblBorders>
          <w:top w:val="single" w:sz="4" w:space="0" w:color="auto"/>
          <w:left w:val="single" w:sz="4" w:space="0" w:color="auto"/>
          <w:bottom w:val="single" w:sz="4" w:space="0" w:color="auto"/>
          <w:right w:val="single" w:sz="4" w:space="0" w:color="auto"/>
        </w:tblBorders>
      </w:tblPr>
      <w:tblGrid>
        <w:gridCol w:w="10296"/>
      </w:tblGrid>
      <w:tr>
        <w:tc>
          <w:tcPr>
            <w:tcW w:w="0" w:type="auto"/>
          </w:tcPr>
          <w:p/>
        </w:tc>
      </w:tr>
    </w:tbl>

Diese Tabelle gibt tabellenweite Eigenschaften von 100 % der Seitenbreite mithilfe tblW des -Elements an, eine Reihe von Tabellenrahmen, die das tblBorders -Element verwenden, das Tabellenraster, das eine Reihe von freigegebenen vertikalen Kanten innerhalb der Tabelle mit dem tblGrid -Element definiert, und eine einzelne Tabellenzeile mit dem tr -Element.

Funktionsweise des Beispielcodes

Nachdem Sie das Dokument in der using -Anweisung geöffnet haben, erstellen Sie im Beispielcode ein neues Table -Objekt. Anschließend erstellen Sie ein TableProperties -Objekt und geben dessen Rahmeninformationen an. Die TableProperties -Klasse enthält einen überladenen Konstruktor TableProperties() , der ein params Array vom Typ OpenXmlElementakzeptiert. Der Code verwendet diesen Konstruktor, um ein TableProperties Objekt mit BorderType Objekten für jeden Rahmen zu instanziieren, wobei jedes BorderType instanziiert und sein Wert mithilfe von Objektinitialisierern angegeben wird. Fügen Sie das Objekt nach der TableProperties Instanziierung an die Tabelle an.

// Create an empty table.
Table table = new Table();

// Create a TableProperties object and specify its border information.
TableProperties tblProp = new TableProperties(
    new TableBorders(
        new TopBorder()
        {
            Val =
            new EnumValue<BorderValues>(BorderValues.Dashed),
            Size = 24
        },
        new BottomBorder()
        {
            Val =
            new EnumValue<BorderValues>(BorderValues.Dashed),
            Size = 24
        },
        new LeftBorder()
        {
            Val =
            new EnumValue<BorderValues>(BorderValues.Dashed),
            Size = 24
        },
        new RightBorder()
        {
            Val =
            new EnumValue<BorderValues>(BorderValues.Dashed),
            Size = 24
        },
        new InsideHorizontalBorder()
        {
            Val =
            new EnumValue<BorderValues>(BorderValues.Dashed),
            Size = 24
        },
        new InsideVerticalBorder()
        {
            Val =
            new EnumValue<BorderValues>(BorderValues.Dashed),
            Size = 24
        }
    )
);

// Append the TableProperties object to the empty table.
table.AppendChild<TableProperties>(tblProp);

Vom Code wird eine Tabellenzeile erstellt. In diesem Abschnitt des Codes werden die überladenen Append Methoden umfassend verwendet, von denen abgeleitete OpenXmlElement Klassen erben. Die Append Methoden bieten eine Möglichkeit, entweder ein einzelnes Element oder einen Teil einer XML-Struktur an das Ende der Liste der untergeordneten Elemente unter einem bestimmten übergeordneten Element anzufügen. Als Nächstes erstellt der Code ein TableCell -Objekt, das eine einzelne Tabellenzelle darstellt, und gibt die Width-Eigenschaft der Tabellenzelle mithilfe eines TableCellProperties -Objekts und den Zellinhalt ("Hello, World!") mithilfe eines Text -Objekts an. Im Open XML Wordprocessing-Schema enthält ein Absatzelement (<p\>) ausführungselemente (<r\>), die wiederum Textelemente (<t\>) enthalten. Zum Einfügen von Text in eine Tabellenzelle mithilfe der API müssen Sie ein Paragraph -Objekt erstellen, das ein Run -Objekt enthält, das ein Text -Objekt enthält, das den Text enthält, den Sie in die Zelle einfügen möchten. Anschließend fügen Sie das Paragraph -Objekt an das TableCell -Objekt an. Dadurch wird die ordnungsgemäße XML-Struktur zum Einfügen von Text in eine Zelle erstellt. Der TableCell wird dann an das TableRow -Objekt angefügt.

// Create a row.
TableRow tr = new TableRow();

// Create a cell.
TableCell tc1 = new TableCell();

// Specify the width property of the table cell.
tc1.Append(new TableCellProperties(
    new TableCellWidth() { Type = TableWidthUnitValues.Dxa, Width = "2400" }));

// Specify the table cell content.
tc1.Append(new Paragraph(new Run(new Text("some text"))));

// Append the table cell to the table row.
tr.Append(tc1);

Der Code erstellt dann eine zweite Tabellenzelle. Im letzten Codeabschnitt wird eine weitere Tabellenzelle mit dem überladenen TableCell Konstruktor TableCell(String) erstellt, der die OuterXml -Eigenschaft eines vorhandenen TableCell Objekts als einziges Argument verwendet. Nach dem Erstellen der zweiten Tabellenzelle fügt der Code die TableCell an , TableRowfügt den TableRow an und Tableden Table an das Document -Objekt an.

// Create a second table cell by copying the OuterXml value of the first table cell.
TableCell tc2 = new TableCell(tc1.OuterXml);

// Append the table cell to the table row.
tr.Append(tc2);

// Append the table row to the table.
table.Append(tr);

if (doc.MainDocumentPart is null || doc.MainDocumentPart.Document.Body is null)
{
    throw new ArgumentNullException("MainDocumentPart and/or Body is null.");
}

// Append the table to the document.
doc.MainDocumentPart.Document.Body.Append(table);

Beispielcode

Das folgende Codebeispiel veranschaulicht Folgendes: das Erstellen einer Tabelle, das Festlegen ihrer Eigenschaften, das Einfügen von Text in eine Zelle in der Tabelle, das Kopieren einer Zelle und schließlich das Einfügen der Tabelle in ein Textverarbeitungsdokument. Sie können die -Methode CreateTable mithilfe des folgenden Aufrufs aufrufen.

string filePath = args[0];

CreateTable(filePath);

Nachdem Sie das Programm ausgeführt haben, überprüfen Sie die Datei, um die eingefügte Tabelle anzuzeigen.

Nachstehend ist der vollständige Beispielcode in C# und Visual Basic aufgeführt.

using DocumentFormat.OpenXml;
using DocumentFormat.OpenXml.Packaging;
using DocumentFormat.OpenXml.Wordprocessing;
using System;


// Insert a table into a word processing document.
static void CreateTable(string fileName)
{
    // Use the file name and path passed in as an argument 
    // to open an existing Word document.

    using (WordprocessingDocument doc = WordprocessingDocument.Open(fileName, true))
    {
        // Create an empty table.
        Table table = new Table();

        // Create a TableProperties object and specify its border information.
        TableProperties tblProp = new TableProperties(
            new TableBorders(
                new TopBorder()
                {
                    Val =
                    new EnumValue<BorderValues>(BorderValues.Dashed),
                    Size = 24
                },
                new BottomBorder()
                {
                    Val =
                    new EnumValue<BorderValues>(BorderValues.Dashed),
                    Size = 24
                },
                new LeftBorder()
                {
                    Val =
                    new EnumValue<BorderValues>(BorderValues.Dashed),
                    Size = 24
                },
                new RightBorder()
                {
                    Val =
                    new EnumValue<BorderValues>(BorderValues.Dashed),
                    Size = 24
                },
                new InsideHorizontalBorder()
                {
                    Val =
                    new EnumValue<BorderValues>(BorderValues.Dashed),
                    Size = 24
                },
                new InsideVerticalBorder()
                {
                    Val =
                    new EnumValue<BorderValues>(BorderValues.Dashed),
                    Size = 24
                }
            )
        );

        // Append the TableProperties object to the empty table.
        table.AppendChild<TableProperties>(tblProp);

        // Create a row.
        TableRow tr = new TableRow();

        // Create a cell.
        TableCell tc1 = new TableCell();

        // Specify the width property of the table cell.
        tc1.Append(new TableCellProperties(
            new TableCellWidth() { Type = TableWidthUnitValues.Dxa, Width = "2400" }));

        // Specify the table cell content.
        tc1.Append(new Paragraph(new Run(new Text("some text"))));

        // Append the table cell to the table row.
        tr.Append(tc1);

        // Create a second table cell by copying the OuterXml value of the first table cell.
        TableCell tc2 = new TableCell(tc1.OuterXml);

        // Append the table cell to the table row.
        tr.Append(tc2);

        // Append the table row to the table.
        table.Append(tr);

        if (doc.MainDocumentPart is null || doc.MainDocumentPart.Document.Body is null)
        {
            throw new ArgumentNullException("MainDocumentPart and/or Body is null.");
        }

        // Append the table to the document.
        doc.MainDocumentPart.Document.Body.Append(table);
    }
}