Compartilhar via

Inserir uma tabela em um documento de processamento de texto

  • Artigo

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

Como obter um objeto WordprocessingDocument

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

    using (WordprocessingDocument doc =
           WordprocessingDocument.Open(filepath, true)) 
    { 
       // Insert other code here. 
    }

A instrução de uso fornece uma alternativa recomendada ao típico . Criar. Salvar. Fechar sequência. Ela garante que o método Dispose (método interno usado pelo SDK do Open XML para limpar recursos) seja chamado automaticamente quando a chave de fechamento for atingida. O bloco que segue a instrução de uso estabelece um escopo para o objeto que é criado ou nomeado na instrução de uso, nesse caso, doc. Como a classe WordprocessingDocument no SDK Open XML salva e fecha automaticamente o objeto como parte de sua implementação System.IDisposable e, como o Dispose é chamado automaticamente quando você sai do bloco, você não precisa chamar explicitamente Salvar e Fechar─desde que você use o uso.

Estrutura de uma tabela

A estrutura básica do documento de um documento WordProcessingML consiste nos elementos do documento e do corpo , 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 elementos r . O r significa run, que é uma região de texto com um conjunto comum de propriedades, como a formatação. Uma execução contém um ou mais elementos t . O elemento t 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 de nível de bloco) organizados em linhas e colunas. Tabelas no WordprocessingML são definidas por meio do elemento tbl , que é análogo à marca de tabela HTML. Considere uma tabela de uma célula vazia (ou seja, uma tabela com uma linha, uma coluna) e bordas de 1 ponto em todos os lados. Esta tabela é representada pelo seguinte segmento de marcação 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>

Esta tabela especifica propriedades em toda a tabela de 100% da largura da página usando o elemento tblW , um conjunto de bordas de tabela usando o elemento tblBorders , a grade da tabela, que define um conjunto de bordas verticais compartilhadas dentro da tabela usando o elemento tblGrid e uma única linha de tabela usando o elemento tr .

Como funciona o código de exemplo

No código de exemplo, depois de abrir o documento na instrução usando , você criará um novo objeto Table . Em seguida, você cria um objeto TableProperties e especifica suas informações de borda. A classe TableProperties contém um construtor sobrecarregado TableProperties() que usa uma matriz de params do tipo OpenXmlElement. O código usa esse construtor para instanciar um objeto TableProperties com objetos BorderType para cada borda, instanciando cada BorderType e especificando seu valor usando inicializadores de objeto. Depois de instanciado, anexe o objeto TableProperties à 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 de tabela. Esta seção do código faz uso extensivo dos métodos append[]) sobrecarregados, que as classes derivadas de OpenXmlElement herdam. Os métodos Append fornecem uma maneira de acrescentar um único elemento ou acrescentar 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 objeto TableCell , que representa uma célula de tabela individual, e especifica a propriedade de largura da célula de tabela usando um objeto TableCellProperties e o conteúdo da célula ("Olá, Mundo!") usando um objeto Text . No esquema Open XML Wordprocessing, 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 objeto Paragraph que contém um objeto Run que contém um objeto Text que contém o texto que você deseja inserir na célula. Em seguida, você acrescenta o objeto Parágrafo ao objeto TableCell . Isso cria a estrutura XML adequada para inserir texto em uma célula. Em seguida, o TableCell é acrescentado ao 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);

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

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

    string fileName = @"C:\Users\Public\Documents\Word10.docx";
    CreateTable(fileName);

Depois de executar o programa, inspecione o arquivo "Word10.docx" 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;

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