Construir uma tabela a partir de um DataTable

Contents
[ ]

Freqüentemente, seu aplicativo extrai dados de um banco de dados e os armazena na forma de DataTable. Você pode inserir facilmente esses dados em seu documento como uma nova tabela e aplicar rapidamente a formatação a toda a tabela.

Usando Aspose.Words, você pode recuperar facilmente dados de um banco de dados e armazená-los como uma tabela:

  1. Crie um novo objeto DocumentBuilder em seu Document.
  2. Inicie uma nova tabela usando DocumentBuilder.
  3. Se quisermos inserir os nomes de cada uma das colunas de nosso DataTable como uma linha de cabeçalho, itere cada coluna de dados e escreva os nomes das colunas em uma linha da tabela.
  4. Itere cada DataRow no DataTable:
    1. Itere cada objeto no DataRow.
    2. Insira o objeto no documento usando DocumentBuilder. O método utilizado depende do tipo de objeto que está sendo inserido, por exemplo, DocumentBuilder.Writeln para texto e DocumentBuilder.InsertImage para uma matriz de bytes que representa uma imagem.
    3. Ao final do processamento do DataRow finalize também a linha que está sendo criada pelo DocumentBuilder utilizando DocumentBuilder.EndRow.
  5. Depois que todas as linhas do DataTable forem processadas, finalize a tabela chamando DocumentBuilder.EndTable.
  6. Finalmente podemos definir o estilo de tabela desejado usando uma das propriedades de tabela apropriadas, como Table.StyleIdentifier, para aplicar automaticamente a formatação a toda a tabela.

O método ImportTableFromDataTable aceita um objeto DocumentBuilder, o DataTable contendo os dados e um sinalizador que especifica se o cabeçalho da coluna do DataTable está incluído no topo da tabela. Este método cria uma tabela a partir desses parâmetros usando a posição e a formatação atuais do construtor. Fornece um método para importar dados do DataTable e inseri-los em uma nova tabela usando o DocumentBuilder.

Os seguintes dados em nosso DataTable são usados neste exemplo:

how-to-build-a-table-from-a-datatable-aspose-words-net

O exemplo de código a seguir mostra como executar o algoritmo acima em Aspose.Words:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
/// <summary>
/// Imports the content from the specified DataTable into a new Aspose.Words Table object.
/// The table is inserted at the document builder's current position and using the current builder's formatting if any is defined.
/// </summary>
public Table ImportTableFromDataTable(DocumentBuilder builder, DataTable dataTable,
bool importColumnHeadings)
{
Table table = builder.StartTable();
// Check if the columns' names from the data source are to be included in a header row.
if (importColumnHeadings)
{
// Store the original values of these properties before changing them.
bool boldValue = builder.Font.Bold;
ParagraphAlignment paragraphAlignmentValue = builder.ParagraphFormat.Alignment;
// Format the heading row with the appropriate properties.
builder.Font.Bold = true;
builder.ParagraphFormat.Alignment = ParagraphAlignment.Center;
// Create a new row and insert the name of each column into the first row of the table.
foreach (DataColumn column in dataTable.Columns)
{
builder.InsertCell();
builder.Writeln(column.ColumnName);
}
builder.EndRow();
// Restore the original formatting.
builder.Font.Bold = boldValue;
builder.ParagraphFormat.Alignment = paragraphAlignmentValue;
}
foreach (DataRow dataRow in dataTable.Rows)
{
foreach (object item in dataRow.ItemArray)
{
// Insert a new cell for each object.
builder.InsertCell();
switch (item.GetType().Name)
{
case "DateTime":
// Define a custom format for dates and times.
DateTime dateTime = (DateTime) item;
builder.Write(dateTime.ToString("MMMM d, yyyy"));
break;
default:
// By default any other item will be inserted as text.
builder.Write(item.ToString());
break;
}
}
// After we insert all the data from the current record, we can end the table row.
builder.EndRow();
}
// We have finished inserting all the data from the DataTable, we can end the table.
builder.EndTable();
return table;
}

O método pode então ser facilmente chamado usando seu DocumentBuilder e dados.

O exemplo de código a seguir mostra como importar os dados de um DataTable e inseri-los em uma nova tabela no documento:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
Document doc = new Document();
// We can position where we want the table to be inserted and specify any extra formatting to the table.
DocumentBuilder builder = new DocumentBuilder(doc);
// We want to rotate the page landscape as we expect a wide table.
doc.FirstSection.PageSetup.Orientation = Orientation.Landscape;
DataSet ds = new DataSet();
ds.ReadXml(MyDir + "List of people.xml");
// Retrieve the data from our data source, which is stored as a DataTable.
DataTable dataTable = ds.Tables[0];
// Build a table in the document from the data contained in the DataTable.
Table table = ImportTableFromDataTable(builder, dataTable, true);
// We can apply a table style as a very quick way to apply formatting to the entire table.
table.StyleIdentifier = StyleIdentifier.MediumList2Accent1;
table.StyleOptions = TableStyleOptions.FirstRow | TableStyleOptions.RowBands | TableStyleOptions.LastColumn;
// For our table, we want to remove the heading for the image column.
table.FirstRow.LastCell.RemoveAllChildren();
doc.Save(ArtifactsDir + "WorkingWithTables.BuildTableFromDataTable.docx");