Compartir a través de

Insertar una tabla en un documento de procesamiento de texto

En este tema se muestra cómo usar las clases del SDK de Open XML para Office para insertar mediante programación una tabla en un documento de procesamiento de texto.

Obtención de un objeto WordprocessingDocument

Para abrir un documento existente, cree una instancia de la WordprocessingDocument clase como se muestra en la instrucción siguiente using . En la misma instrucción, abra el archivo de procesamiento de texto en la ruta de archivo especificada mediante el Open método , con el parámetro booleano establecido true en para habilitar la edición del documento.

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

Con v3.0.0+ el Close() método se ha quitado en favor de confiar en la instrucción using. Garantiza que se llama automáticamente al Dispose() método cuando se alcanza la llave de cierre. El bloque que sigue a la instrucción using establece un ámbito para el objeto que se crea o se nombra en la instrucción using. Dado que la WordprocessingDocument clase del SDK de Open XML guarda y cierra automáticamente el objeto como parte de su IDisposable implementación y, dado Dispose() que se llama automáticamente al salir del bloque, no es necesario llamar Save() explícitamente o siempre que Dispose() use una using instrucción.

Estructura de una tabla

La estructura básica de un WordProcessingML documento consta de los document elementos y body , seguidos de uno o varios elementos de nivel de bloque, como p, que representa un párrafo. Un párrafo contiene uno o varios r elementos. La r representa a run (segmento), que es una región de texto con un conjunto de propiedades comunes, como el formato. Una ejecución contiene uno o varios t elementos. El t elemento contiene un intervalo de texto. El documento puede contener una tabla como en este ejemplo. Una tabla es un conjunto de párrafos (y otro contenido a nivel de bloque) organizados en filas y columnas. Las tablas de WordprocessingML se definen a través del tbl elemento , que es análogo a la etiqueta de tabla HTML. Considere la posibilidad de una tabla vacía de una celda (es decir, una tabla con una fila, una columna) y bordes de 1 punto en todos los lados. Esta tabla se representa mediante el siguiente WordprocessingML segmento de marcado.

    <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>

Esta tabla especifica las propiedades de toda la tabla del 100 % del ancho de página mediante el tblW elemento , un conjunto de bordes de tabla con el tblBorders elemento , la cuadrícula de tabla, que define un conjunto de bordes verticales compartidos dentro de la tabla mediante el tblGrid elemento y una sola fila de tabla con el tr elemento .

Funcionamiento del código de ejemplo

En el código de ejemplo, después de abrir el documento en la using instrucción , se crea un nuevo Table objeto . A continuación, cree un TableProperties objeto y especifique su información de borde. La TableProperties clase contiene un constructor TableProperties() sobrecargado que toma una params matriz de tipo OpenXmlElement. El código usa este constructor para crear una instancia de un TableProperties objeto con BorderType objetos para cada borde, creando una instancia de cada uno BorderType y especificando su valor mediante inicializadores de objeto. Después de crear una instancia de ella, anexe el TableProperties objeto a la tabla.

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

El código crea una fila en la tabla. Esta sección del código hace un uso extensivo de los métodos sobrecargados Append , que las clases derivadas de OpenXmlElement heredan. Los Append métodos proporcionan una manera de anexar un solo elemento o anexar una parte de un árbol XML al final de la lista de elementos secundarios en un elemento primario determinado. A continuación, el código crea un TableCell objeto, que representa una celda de tabla individual, y especifica la propiedad width de la celda table mediante un TableCellProperties objeto y el contenido de la celda ("Hello, World!") mediante un Text objeto . En el esquema Wordprocessing de Open XML, un elemento de párrafo (<p\>) contiene elementos de ejecución (<r\>) que, a su vez, contienen elementos de texto (<t\>). Para insertar texto dentro de una celda de tabla mediante la API, debe crear un Paragraph objeto que contenga un RunText objeto que contenga el texto que desea insertar en la celda. A continuación, anexe el Paragraph objeto al TableCell objeto . Esto crea la estructura XML apropiada para insertar texto en una celda. TableCell A continuación, se anexa al TableRow objeto .

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

A continuación, el código crea una segunda celda de tabla. La sección final del código crea otra celda de tabla mediante el constructor sobrecargado TableCell que toma la OuterXml propiedad de un objeto existente TableCell como su único TableCell(String) argumento. Después de crear la segunda celda de tabla, el código anexa TableCell a TableRow, anexa al TableTableRow objeto y Table al Document objeto .

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

Código de ejemplo

En el siguiente ejemplo de código se muestra cómo crear una tabla, establecer sus propiedades, insertar texto en una celda de la tabla, copiar una celda y, a continuación, insertar la tabla en un documento de procesamiento de texto. Puede invocar el método CreateTable mediante la llamada siguiente.

string filePath = args[0];

CreateTable(filePath);

Después de ejecutar el programa, inspeccione el archivo para ver la tabla insertada.

A continuación se incluye el código de ejemplo completo en C# y Visual Basic.

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);
    }
}
  • Last updated on