Inserir uma tabela em um documento de processamento de texto

Este tópico mostra como usar as classes no Open XML SDK for Office para inserir programaticamente uma tabela em um documento de processamento de texto.

Como obter um objeto WordprocessingDocument

Para abrir um documento existente, instancie a WordprocessingDocument classe conforme mostrado na instrução a seguir using . Na mesma instrução, abra o arquivo de processamento de texto no filepath especificado usando o Open método, com o parâmetro booleano definido como true para habilitar a edição do documento.

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

Com v3.0.0+, o Close() método foi removido em favor de confiar na instrução using. Ele garante que o Dispose() método seja chamado automaticamente quando a chave de fechamento for atingida. O bloco que segue a instrução using estabelece um escopo para o objeto que é criado ou nomeado na instrução using. Como a WordprocessingDocument classe no Open XML SDK salva e fecha automaticamente o objeto como parte de sua IDisposable implementação e porque Dispose() é chamada automaticamente quando você sai do bloco, você não precisa chamar Save() explicitamente ou Dispose() desde que use uma using instrução.

Estrutura de uma tabela

A estrutura básica do documento de um WordProcessingML documento consiste nos document elementos and body , seguidos por um ou mais elementos de nível de bloco, como p, que representa um parágrafo. Um parágrafo contém um ou mais r elementos. O r significa executar, que é uma região do texto com um conjunto comum de propriedades, como formatação. Uma execução contém um ou mais t elementos. O t elemento contém um intervalo de texto. O documento pode conter uma tabela como neste exemplo. Uma tabela é um conjunto de parágrafos (e outros conteúdos em nível de bloco) organizados em linhas e colunas. As tabelas são WordprocessingML definidas por meio do tbl elemento, que é análogo à tag de tabela HTML. Considere uma tabela vazia de uma célula (ou seja, uma tabela com uma linha, uma coluna) e bordas de 1 ponto em todos os lados. Esta tabela é representada pelo seguinte WordprocessingML segmento de marcação.

    <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 tabela especifica as propriedades de toda a tabela de 100% da largura da página usando o tblW elemento, um conjunto de bordas da tabela usando o tblBorders elemento, a grade da tabela, que define um conjunto de bordas verticais compartilhadas dentro da tabela usando o tblGrid elemento e uma única linha da tabela usando o tr elemento.

Como funciona o código de exemplo

No código de exemplo, depois de abrir o documento na using instrução, você cria um novo Table objeto. Em seguida, você cria um TableProperties objeto e especifica suas informações de borda. A TableProperties classe contém um construtor TableProperties() sobrecarregado que usa uma params matriz do tipo OpenXmlElement. O código usa esse construtor para instanciar um TableProperties objeto com BorderType objetos para cada borda, instanciando cada BorderType um e especificando seu valor usando inicializadores de objeto. Depois que ele tiver sido instanciado, acrescente o TableProperties objeto à tabela.

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

O código cria uma linha da tabela. Esta seção do código faz uso extensivo dos métodos sobrecarregados, que as classes derivadas herdam AppendOpenXmlElement . Os Append métodos fornecem uma maneira de anexar um único elemento ou anexar uma parte de uma árvore XML, ao final da lista de elementos filho em um determinado elemento pai. Em seguida, o código cria um TableCell objeto, que representa uma célula de tabela individual e especifica a propriedade width da célula da tabela usando um TableCellProperties objeto e o conteúdo da célula ("Olá, Mundo!") usando um Text objeto. No esquema de processamento de texto do Open XML, um elemento de parágrafo (<p\>) contém elementos de execução (<r\>) que, por sua vez, contêm elementos de texto (<t\>). Para inserir texto em uma célula de tabela usando a API, você deve criar um Paragraph objeto que contenha um Run objeto que contenha um objeto que contenha o Text texto que você deseja inserir na célula. Em seguida, você anexa o Paragraph objeto ao TableCell objeto. Isso cria a estrutura XML adequada para inserir texto em uma célula. Em seguida, TableCell é anexado ao 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);

O código cria então uma segunda célula da tabela. A seção final do código cria outra célula da tabela usando o construtor TableCell(String) sobrecarregado TableCell que usa a OuterXml propriedade de um objeto existente TableCell como seu único argumento. Depois de criar a segunda célula da tabela, o código acrescenta o TableCell ao TableRow, anexa o TableRow ao Table, e o Table ao 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 exemplo

O exemplo de código a seguir mostra como criar uma tabela, definir suas propriedades, inserir texto em uma célula da tabela, copiar uma célula e, em seguida, inserir a tabela em um documento de processamento de texto. Você pode invocar o método CreateTable usando a chamada a seguir.

string filePath = args[0];

CreateTable(filePath);

Depois de executar o programa, inspecione o arquivo para ver a tabela inserida.

A seguir está o código de exemplo completo em C# e em 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