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 clase WordprocessingDocument como se muestra en la siguiente instrucción using. En la misma instrucción, abra el archivo de procesamiento de texto en la ruta del archivo especificado mediante el método Open, con el parámetro booleano establecido en true para habilitar la edición del documento.
using (WordprocessingDocument doc =
WordprocessingDocument.Open(filepath, true))
{
// Insert other code here.
}
La instrucción using proporciona una alternativa recomendada a la típica secuencia .Create, .Save, .Close. Garantiza que se llamará automáticamente al método Dispose (un método interno que Open XML SDK usa para limpiar recursos) cuando se llegue a la llave de cierre. El bloque que sigue a la instrucción using establece un ámbito para el objeto que se crea o se denomina en la instrucción using, en este caso doc. Dado que la clase WordprocessingDocument del SDK de Open XML guarda y cierra automáticamente el objeto como parte de su implementación System.IDisposable y, como Dispose se llama automáticamente al salir del bloque, no es necesario llamar explícitamente a Save y Close─siempre que use.
Estructura de una tabla
La estructura de documento básica de un documento WordProcessingML contiene los elementos document y body, seguidos de uno o varios elementos a nivel de bloque, como p, que representa un párrafo. Un párrafo contiene uno o varios elementos r. La r representa a run (segmento), que es una región de texto con un conjunto de propiedades comunes, como el formato. Un segmento contiene uno o varios elementos t. El elemento t 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 mediante el elemento tbl, 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 segmento de marcado WordprocessingML .
<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>
En esta tabla se indican las propiedades para toda la tabla: ancho de página de 100% mediante el elemento tblW, un conjunto de bordes de tabla mediante el elemento tblBorders, la cuadrícula de tabla que define un conjunto de bordes verticales compartidos dentro de la tabla mediante el elemento tblGrid y una única fila de tabla mediante el elemento tr.
Funcionamiento del código de ejemplo
En el código de ejemplo, después de abrir el documento en la instrucción using , se crea un nuevo objeto Table . A continuación, cree un objeto TableProperties y especifique su información de borde. La clase TableProperties contiene un constructor sobrecargado TableProperties() que toma una matriz de parámetros de tipo OpenXmlElement. El código usa este constructor para crear una instancia de un objeto TableProperties con objetos BorderType para cada borde, creando una instancia de cada BorderType y especificando su valor mediante inicializadores de objeto. Una vez que se crea la instancia, agregue el objeto TableProperties 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 Append[]) sobrecargados, que las clases derivadas de OpenXmlElement heredan. Los métodos Append proporcionan un modo de anexar un solo elemento o de anexar una parte de un árbol XML al final de la lista de elementos secundarios de un elemento principal dado. A continuación, el código crea un objeto TableCell , que representa una celda de tabla individual, y especifica la propiedad width de la celda table mediante un objeto TableCellProperties y el contenido de la celda ("Hello, World!") mediante un objeto Text . 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 la tabla usando la API, se debe crear un objeto Paragraph que contiene un objeto Run, que a su vez contiene un objeto Text con el texto que desea insertar en la celda. A continuación, anexe el objeto Paragraph al objeto TableCell. Esto crea la estructura XML apropiada para insertar texto en una celda. A continuación, TableCell se anexa al objeto TableRow .
// 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("Hello, World!"))));
// 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 TableCell sobrecargado TableCell(String) que toma la propiedad OuterXml de un objeto TableCell existente como su único argumento. Después de crear la segunda celda de tabla, el código anexa TableCell a TableRow, anexa TableRow a TableRow y Table al objeto Document.
// 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);
// Append the table to the document.
doc.MainDocumentPart.Document.Body.Append(table);
// Save changes to the MainDocumentPart.
doc.MainDocumentPart.Document.Save();
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 siguiente llamada.
string fileName = @"C:\Users\Public\Documents\Word10.docx";
CreateTable(fileName);
Después de ejecutar el programa, inspeccione el archivo "Word10.docx" 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;
CreateTable(args[0]);
// 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 2007 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);
}
}