Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. Modelo de exportação do Excel em C#
USANDO O IRONXL

Como exportar um modelo em C#

Jordi Bardia
Jordi Bardia
Atualizado:

Trabalhar com modelos do Microsoft Excel simplifica a geração de relatórios preservando a formatação, fórmulas e layouts enquanto preenche os dados dinamicamente. Este tutorial demonstra como exportar dados de forma eficiente para modelos de planilha Excel existentes usando o IronXL, eliminando a necessidade de dependências do Microsoft Office ou do Excel Interop. O exemplo a seguir mostra como escrever dados em modelos de Excel e criar saídas de planilhas profissionais. Suponha que você esteja procurando uma forma de exportar C# para um modelo Excel existente sem o Microsoft Office instalado. Nesse caso, esta biblioteca Excel fornece uma solução limpa, de alto desempenho, com recursos mais avançados que permitem inserir dados de várias fontes, incluindo objetos de dataset.

Além dos livros de trabalho do Excel, o IronXL integra-se bem com outros formatos de troca de dados, como arquivos XML, permitindo que os desenvolvedores importem dados, exportem ou transformem dados estruturados entre sistemas com facilidade. Seja para escrever dados no Excel a partir de um banco de dados ou arquivos do sistema, esta biblioteca suporta integração perfeita com aplicações .NET.

Como Exportar Template em C#: Figura 1

Por que Usar Modelos do Excel para Exportação de Dados?

Os modelos do Excel oferecem vantagens significativas sobre a criação de planilhas do zero. Os modelos mantêm formatação profissional, fórmulas complexas, regras de formatação condicional e estruturas de dados validadas. As organizações costumam ter modelos padronizados para faturas, relatórios e painéis que devem manter seu design enquanto incorporam dados dinâmicos de bancos de dados, APIs ou objetos de coleção, como uma tabela de dados. Ao aplicar a formatação condicional e a formatação de células ao seu arquivo de saída, os modelos garantem consistência em todos os documentos gerados no formato xlsx.

Ao preencher modelos existentes programaticamente, os desenvolvedores economizam inúmeras horas de trabalho de formatação e garantem consistência em todos os documentos gerados. IronXL torna esse processo perfeito, suportando vários formatos do Excel, incluindo templates XLSX, arquivo XLS, XLSM, e XLTX sem necessitar da instalação do Office. O código-fonte para essas operações é direto e fácil de implementar em qualquer pasta de projeto.

Como Exportar Template em C#: Figura 2

Configurando o IronXL para Operações com Modelos

Comece instalando o IronXL através do Gerenciador de Pacotes NuGet. Abra seu Console do Gerenciador de Pacotes e execute o seguinte comando:

Install-Package IronXl.Excel

Como Exportar Template em C#: Figura 3

Após a instalação, adicione o namespace necessário ao seu arquivo C#:

using IronXL;
using IronXL;
$vbLabelText   $csharpLabel

IronXL opera de forma independente, sem necessitar de instalação do Microsoft Office, tornando-o ideal para ambientes de servidor e aplicações multiplataforma, incluindo contêineres Docker e plataformas em nuvem. Para instruções detalhadas de configuração e informações adicionais, visite o guia de introdução do IronXL. A biblioteca suporta .NET Framework, .NET Core, e .NET 5+ em ambientes Windows, Linux e macOS, tornando-a perfeita para aplicações .NET.

Como Exportar Template em C#: Figura 4 - Funcionalidades

Carregando e Preenchendo Modelos do Excel

Carregar um modelo existente é simples com o método WorkBook.Load() do IronXL. O exemplo a seguir mostra como abrir um modelo e preenchê-lo com dados, tratando a primeira linha como cabeçalhos e gerenciando nomes de colunas de forma eficaz:

// Load the existing Excel template for data import
WorkBook workbook = WorkBook.Load("ReportTemplate.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Populate specific worksheet cells with data
sheet["B2"].Value = "Q4 2024 Sales Report";
sheet["C4"].StringValue = DateTime.Now.ToString("MMMM dd, yyyy");
sheet["C6"].DecimalValue = 125000.50m;
sheet["C7"].DecimalValue = 98500.75m;
sheet["C8"].Formula = "=C6-C7"; // Profit calculation
// Populate a range with array data
decimal[] monthlyData = { 10500, 12300, 15600, 11200 };
for (int i = 0; i < monthlyData.Length; i++)
{
    sheet[$"E{10 + i}"].DecimalValue = monthlyData[i];
}
// Save the populated template
workbook.SaveAs("Q4_Sales_Report.xlsx");
// Load the existing Excel template for data import
WorkBook workbook = WorkBook.Load("ReportTemplate.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Populate specific worksheet cells with data
sheet["B2"].Value = "Q4 2024 Sales Report";
sheet["C4"].StringValue = DateTime.Now.ToString("MMMM dd, yyyy");
sheet["C6"].DecimalValue = 125000.50m;
sheet["C7"].DecimalValue = 98500.75m;
sheet["C8"].Formula = "=C6-C7"; // Profit calculation
// Populate a range with array data
decimal[] monthlyData = { 10500, 12300, 15600, 11200 };
for (int i = 0; i < monthlyData.Length; i++)
{
    sheet[$"E{10 + i}"].DecimalValue = monthlyData[i];
}
// Save the populated template
workbook.SaveAs("Q4_Sales_Report.xlsx");
$vbLabelText   $csharpLabel

Este código carrega um modelo pré-desenhado, mantém todas as formatações existentes e preenche células específicas com novos dados. A propriedade DecimalValue garante que os dados numéricos mantenham a formatação adequada. As células de fórmula recalculam automaticamente quando dados adjacentes mudam, preservando a lógica computacional do modelo. Saiba mais sobre como trabalhar com fórmulas do Excel no IronXL.

Entrada

Como Exportar Template em C#: Figura 5 - Amostra de Entrada do Template

Saída

Como Exportar Template em C#: Figura 6 - Carregar Saída do Template do Excel

Trabalhando com Espaços Reservados de Modelos

Muitos modelos usam marcadores de texto reservados que precisam ser substituídos por dados reais. IronXL lida eficientemente com este cenário por meio de iteração de células e substituição de texto. Quando você precisa escrever dados em modelos do Excel e inserir conteúdo dinâmico, essa abordagem oferece flexibilidade máxima:

// Load template with placeholders
WorkBook workbook = WorkBook.Load("InvoiceTemplate.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Find and replace placeholder text in cells
foreach (var cell in sheet["A1:H50"])
{
    if (cell.Text.Contains("{{CustomerName}}"))
        cell.Value = cell.Text.Replace("{{CustomerName}}", "Acme Corporation");
    if (cell.Text.Contains("{{InvoiceDate}}"))
        cell.Value = cell.Text.Replace("{{InvoiceDate}}", DateTime.Now.ToShortDateString());
    if (cell.Text.Contains("{{InvoiceNumber}}"))
        cell.Value = cell.Text.Replace("{{InvoiceNumber}}", "INV-2024-001");
}
// Populate line items dynamically
var items = new[] {
    new { Description = "Software License", Qty = 5, Price = 299.99 },
    new { Description = "Support Package", Qty = 1, Price = 999.99 }
};
int startRow = 15;
foreach (var item in items)
{
    sheet[$"B{startRow}"].Value = item.Description;
    sheet[$"E{startRow}"].IntValue = item.Qty;
    sheet[$"F{startRow}"].DoubleValue = item.Price;
    sheet[$"G{startRow}"].Formula = $"=E{startRow}*F{startRow}";
    startRow++;
}
workbook.SaveAs("GeneratedInvoice.xlsx");
// Load template with placeholders
WorkBook workbook = WorkBook.Load("InvoiceTemplate.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Find and replace placeholder text in cells
foreach (var cell in sheet["A1:H50"])
{
    if (cell.Text.Contains("{{CustomerName}}"))
        cell.Value = cell.Text.Replace("{{CustomerName}}", "Acme Corporation");
    if (cell.Text.Contains("{{InvoiceDate}}"))
        cell.Value = cell.Text.Replace("{{InvoiceDate}}", DateTime.Now.ToShortDateString());
    if (cell.Text.Contains("{{InvoiceNumber}}"))
        cell.Value = cell.Text.Replace("{{InvoiceNumber}}", "INV-2024-001");
}
// Populate line items dynamically
var items = new[] {
    new { Description = "Software License", Qty = 5, Price = 299.99 },
    new { Description = "Support Package", Qty = 1, Price = 999.99 }
};
int startRow = 15;
foreach (var item in items)
{
    sheet[$"B{startRow}"].Value = item.Description;
    sheet[$"E{startRow}"].IntValue = item.Qty;
    sheet[$"F{startRow}"].DoubleValue = item.Price;
    sheet[$"G{startRow}"].Formula = $"=E{startRow}*F{startRow}";
    startRow++;
}
workbook.SaveAs("GeneratedInvoice.xlsx");
$vbLabelText   $csharpLabel

Esta abordagem procura marcadores de espaço reservado dentro de um intervalo especificado e os substitui por valores reais. A formatação do modelo, incluindo fontes, cores e bordas, permanece intacta durante todo o processo. Para cenários mais avançados, explore as opções de formatação de células do IronXL para modificar a formatação dinamicamente quando necessário.

Exemplo de Implementação no Mundo Real

Aqui está um exemplo completo gerando um relatório de vendas mensal a partir de um modelo de Excel existente com células pré-formatadas. Este código demonstra como lidar com eventos de remetente de objeto e escrever relatórios abrangentes. Ao trabalhar com dados de um banco de dados do sistema ou coleções em memória, você pode exportar dados para excel usando uma nova tabela de dados ou conjunto de dados existente para preencher modelos de forma eficiente:

public void GenerateMonthlyReport(string templatePath, Dictionary<string, decimal> salesData)
{
    // Load the existing template file
    WorkBook workbook = WorkBook.Load(templatePath);
    WorkSheet sheet = workbook.GetWorkSheet("Monthly Report");
    // Set report header information
    sheet["B2"].Value = $"Sales Report - {DateTime.Now:MMMM yyyy}";
    sheet["B3"].Value = $"Generated: {DateTime.Now:g}";
    // Populate sales data starting from row 6
    int currentRow = 6;
    decimal totalSales = 0;
    foreach (var sale in salesData)
    {
        sheet[$"B{currentRow}"].Value = sale.Key;  // Product name
        sheet[$"C{currentRow}"].DecimalValue = sale.Value;  // Sales amount
        sheet[$"D{currentRow}"].Formula = $"=C{currentRow}/C${salesData.Count + 6}*100"; // Percentage formula
        totalSales += sale.Value;
        currentRow++;
    }
    // Update total row with sum
    sheet[$"C{currentRow}"].DecimalValue = totalSales;
    sheet[$"C{currentRow}"].Style.Font.Bold = true;
    // Save with timestamp
    string outputPath = $"Reports/Monthly_Report_{DateTime.Now:yyyyMMdd}.xlsx";
    workbook.SaveAs(outputPath);
}
public void GenerateMonthlyReport(string templatePath, Dictionary<string, decimal> salesData)
{
    // Load the existing template file
    WorkBook workbook = WorkBook.Load(templatePath);
    WorkSheet sheet = workbook.GetWorkSheet("Monthly Report");
    // Set report header information
    sheet["B2"].Value = $"Sales Report - {DateTime.Now:MMMM yyyy}";
    sheet["B3"].Value = $"Generated: {DateTime.Now:g}";
    // Populate sales data starting from row 6
    int currentRow = 6;
    decimal totalSales = 0;
    foreach (var sale in salesData)
    {
        sheet[$"B{currentRow}"].Value = sale.Key;  // Product name
        sheet[$"C{currentRow}"].DecimalValue = sale.Value;  // Sales amount
        sheet[$"D{currentRow}"].Formula = $"=C{currentRow}/C${salesData.Count + 6}*100"; // Percentage formula
        totalSales += sale.Value;
        currentRow++;
    }
    // Update total row with sum
    sheet[$"C{currentRow}"].DecimalValue = totalSales;
    sheet[$"C{currentRow}"].Style.Font.Bold = true;
    // Save with timestamp
    string outputPath = $"Reports/Monthly_Report_{DateTime.Now:yyyyMMdd}.xlsx";
    workbook.SaveAs(outputPath);
}
$vbLabelText   $csharpLabel

Este método aceita dados de vendas e preenche um modelo padronizado, calculando automaticamente porcentagens e totais enquanto preserva a aparência profissional do modelo. Os gráficos existentes e a formatação condicional no modelo são atualizados automaticamente com base nos novos dados. Nota: Ao transferir dados para excel a partir de objetos DataTable ou coleções de conjunto de dados, preserve os nomes das colunas e trate a primeira linha como cabeçalhos.

A abordagem de exemplo a seguir funciona perfeitamente, independentemente de você precisar escrever dados de dicionários, inserir valores de consultas de banco de dados, ou exportar dados para Excel de várias fontes do sistema. Apenas salve o arquivo de saída na sua pasta designada para fácil acesso. Para mais informações sobre como trabalhar com DataTables, veja a documentação de importação de DataTable e exemplos de código-fonte.

Entrada

Como Exportar Template em C#: Figura 7 - Entrada do Template do Excel

Saída

Como Exportar Template em C#: Figura 8 - Saída do Relatório Mensal

Solução de problemas comuns

Ao trabalhar com modelos, assegure-se de que os caminhos dos arquivos estão corretos e que os modelos não estão bloqueados por outros processos. Para modelos protegidos por senha, use WorkBook.Load("template.xlsx", "password"). Se as fórmulas não estiverem atualizando, chame sheet.Calculate() após preencher os dados. Para grandes conjuntos de dados, considere usar workbook.SaveAs() com opções de streaming para otimizar o uso de memória. Verifique a documentação de solução de problemas para informações adicionais e soluções ao trabalhar com arquivos no formato xlsx em diferentes ambientes do sistema.

Conclusão

IronXL simplifica o preenchimento de modelos Excel em C#, preservando a formatação complexa enquanto injeta dados dinâmicos de várias fontes, incluindo objetos de conjunto de dados e conexões de banco de dados. Essa abordagem reduz significativamente o tempo de desenvolvimento e mantém a consistência do documento nos fluxos de trabalho de relatórios da sua organização. Quer você precise escrever dados no excel, inserir novas linhas ou aplicar formatação de células ao seu arquivo de saída, o IronXL fornece as ferramentas necessárias para automação profissional de excel em aplicativos .NET.

Pronto para otimizar seus relatórios Excel? Inicie seu teste gratuito do IronXL para testar o preenchimento de modelos em seu projeto, ou explore mais tutoriais de automação de Excel para aprimorar seu fluxo de trabalho. Para implantação em produção, veja opções de licenciamento que atendam às suas necessidades.

Como Exportar Template em C#: Figura 9 - Licenciamento

Perguntas frequentes

Qual a vantagem de usar o IronXL para exportar dados para um modelo do Excel?

O IronXL permite exportar dados para um modelo do Excel existente sem a necessidade do Microsoft Office ou do Excel Interop, preservando a formatação, as fórmulas e os layouts de forma eficiente.

Posso exportar dados de um objeto de conjunto de dados para um modelo do Excel usando o IronXL?

Sim, o IronXL suporta a exportação de dados de várias fontes, incluindo objetos de conjunto de dados, para modelos do Excel, mantendo a estrutura existente do modelo.

É necessário o Microsoft Office para usar o IronXL para operações com o Excel?

Não, o IronXL opera independentemente do Microsoft Office, fornecendo uma solução limpa e de alto desempenho para trabalhar com modelos do Excel em C#.

Como o IronXL lida com a formatação ao exportar dados para modelos do Excel?

O IronXL preserva a formatação, as fórmulas e o layout existentes dos seus modelos do Excel, garantindo que seus dados sejam exportados perfeitamente para a estrutura desejada.

Que tipo de arquivos Excel o IronXL pode gerar?

O IronXL pode criar planilhas do Excel com aparência profissional, escrevendo dados em modelos e mantendo a integridade da formatação e estrutura originais.

O IronXL suporta o preenchimento dinâmico de dados em modelos do Excel?

Sim, o IronXL suporta o preenchimento dinâmico de dados, permitindo que você preencha modelos do Excel de forma eficiente com dados de várias fontes, mantendo a integridade do modelo.

O IronXL consegue lidar com modelos complexos do Excel com fórmulas?

O IronXL é capaz de lidar com modelos complexos do Excel que incluem fórmulas, garantindo que as fórmulas permaneçam intactas e funcionais após a exportação dos dados.

O que torna o IronXL uma solução de alto desempenho para exportar dados para o Excel?

A capacidade do IronXL de funcionar independentemente do Microsoft Office e seus recursos avançados para lidar com diversas fontes de dados o tornam uma solução de alto desempenho para exportar dados para o Excel.

É possível exportar dados para um modelo de planilha do Excel usando C# sem dependências externas?

Sim, o IronXL permite exportar dados para um modelo de planilha do Excel usando C#, sem depender de softwares externos como o Microsoft Office.

Como o IronXL simplifica o processo de geração de relatórios no Excel?

O IronXL simplifica a geração de relatórios, permitindo que os usuários exportem dados diretamente para modelos do Excel, preservando a formatação e o layout originais e eliminando a necessidade de ajustes manuais.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me