Exportar um DataSet ou DataTable para Excel em C# oferece uma maneira confiável de transformar dados estruturados em memória em arquivos de planilhas profissionais -- sem depender do Microsoft Office instalado na máquina de destino. Quer você recupere registros de um banco de dados SQL, construa um DataSet programaticamente ou trabalhe com um DataGrid existente, IronXL lida com todo o fluxo através de uma API limpa e orientada a código. Este guia percorre todos os cenários principais -- desde a exportação de uma tabela única até livros com múltiplas folhas e resultados de consultas de banco de dados ao vivo -- usando instruções de C# de nível superior e .NET 10.
Instale o IronXL uma vez, escreva algumas linhas de código, e seus dados estarão em um arquivo XLSX sem uma única dependência do Office. As seções abaixo cobrem instalação, padrões principais, formatação avançada e integração de banco de dados de uma forma que você pode copiar e colar diretamente em seus próprios projetos.
Antes de escrever qualquer código de exportação, adicione o IronXL ao seu projeto através do Gerenciador de Pacotes NuGet. Abra um terminal na raiz do seu projeto e execute o comando CLI do .NET, ou use o Console do Gerenciador de Pacotes no Visual Studio com o comando Install-Package:
Ou no Console do Gerenciador de Pacotes do Visual Studio:
Após a instalação, adicione uma instrução using de nível superior para importar o namespace IronXL:
using IronXL;
using System.Data;Imports IronXL
Imports System.DataIronXL é direcionado a .NET 8, .NET 9, e .NET 10, bem como versões mais antigas do .NET Framework (4.6.2+). Nenhuma instalação do Office é necessária em qualquer máquina -- servidor, desktop ou nuvem. Uma vez que o pacote está instalado, você pode criar, ler e escrever arquivos XLSX, XLS, e CSV inteiramente em código gerenciado.
Para obter opções detalhadas de instalação, consulte o guia de instalação do IronXL e a página do pacote NuGet para o histórico de versões.
O cenário mais comum é exportar um DataTable para uma única planilha. As classes WorkBook e WorkSheet do IronXL mapeiam naturalmente para o modelo de objeto do Excel. Você cria um livro, adiciona uma planilha, e então itera pelas colunas e linhas do DataTable.
O exemplo a seguir cria um DataTable de Funcionários em memória e o escreve para EmployeeData.xlsx:
using IronXL;
using System.Data;
// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");
// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
// Write data rows starting at row 1
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
worksheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
}
}
workbook.SaveAs("EmployeeData.xlsx");Imports IronXL
Imports System.Data
' Build an in-memory DataTable
Dim dt As New DataTable("Employees")
dt.Columns.Add("ID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Rows.Add(1, "John Smith", "Engineering")
dt.Rows.Add(2, "Sarah Jones", "Marketing")
dt.Rows.Add(3, "Mike Wilson", "Sales")
' Create a workbook and a named worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Write column headers in row 0
For col As Integer = 0 To dt.Columns.Count - 1
worksheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
' Write data rows starting at row 1
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
worksheet.SetCellValue(row + 1, col, dt.Rows(row)(col).ToString())
Next
Next
workbook.SaveAs("EmployeeData.xlsx")
SetCellValue aceita int, double, string e bool -- então você obtém tipos de células Excel nativas sem necessidade de casting extra. O padrão de loop funciona para tabelas de qualquer tamanho porque o IronXL escreve diretamente na memória e salva no disco apenas quando SaveAs é chamado, mantendo o processo eficiente mesmo para milhares de linhas.
Para uma visão mais ampla das técnicas de leitura e escrita, o tutorial de C# do IronXL cobre toda a gama de operações de arquivo ao lado deste padrão de exportação.
Quando um DataSet contém várias tabelas relacionadas -- como Produtos e Pedidos -- você pode mapear cada DataTable para sua própria planilha dentro de um livro. Isso permite que os destinatários vejam todos os dados relacionados em um único arquivo sem precisar abrir múltiplos documentos.
O loop abaixo itera ds.Tables e cria uma planilha por tabela:
using IronXL;
using System.Data;
// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");
DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);
DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);
// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
foreach (DataTable table in ds.Tables)
{
WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);
// Write headers
for (int col = 0; col < table.Columns.Count; col++)
{
sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
}
// Write rows
for (int row = 0; row < table.Rows.Count; row++)
{
for (int col = 0; col < table.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
}
}
}
workbook.SaveAs("CompanyReport.xlsx");Imports IronXL
Imports System.Data
' Build a DataSet with two related tables
Dim ds As New DataSet("CompanyData")
Dim dtProducts As New DataTable("Products")
dtProducts.Columns.Add("ProductID", GetType(Integer))
dtProducts.Columns.Add("ProductName", GetType(String))
dtProducts.Columns.Add("Price", GetType(Decimal))
dtProducts.Rows.Add(101, "Widget A", 29.99D)
dtProducts.Rows.Add(102, "Widget B", 49.99D)
ds.Tables.Add(dtProducts)
Dim dtOrders As New DataTable("Orders")
dtOrders.Columns.Add("OrderID", GetType(Integer))
dtOrders.Columns.Add("Customer", GetType(String))
dtOrders.Columns.Add("Total", GetType(Decimal))
dtOrders.Rows.Add(1001, "Acme Corp", 599.90D)
dtOrders.Rows.Add(1002, "Tech Inc", 299.95D)
ds.Tables.Add(dtOrders)
' Create one workbook and iterate each DataTable
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
For Each table As DataTable In ds.Tables
Dim sheet As WorkSheet = workbook.CreateWorkSheet(table.TableName)
' Write headers
For col As Integer = 0 To table.Columns.Count - 1
sheet.SetCellValue(0, col, table.Columns(col).ColumnName)
Next
' Write rows
For row As Integer = 0 To table.Rows.Count - 1
For col As Integer = 0 To table.Columns.Count - 1
sheet.SetCellValue(row + 1, col, table.Rows(row)(col).ToString())
Next
Next
Next
workbook.SaveAs("CompanyReport.xlsx")
Cada planilha é nomeada de acordo com o DataTable de origem, tornando a navegação no Excel direta. Porque WorkBook.Create aloca o livro em memória, você pode continuar adicionando planilhas no loop sem reabrir o arquivo -- o IronXL constrói toda a estrutura XLSX antes de escrever no disco.
A documentação do IronXL WorkBook lista todos os métodos disponíveis no objeto WorkBook, incluindo reordenamento de planilhas, proteção com senha e salvamento em formatos diferentes de XLSX.
Exportações de dados simples são funcionais, mas adicionar cabeçalhos em negrito e larguras de coluna torna a saída imediatamente utilizável em um contexto empresarial. O IronXL expõe a formatação de células e intervalos através do objeto Style anexado a qualquer intervalo @@--CODE-34@@.
O trecho abaixo aplica formatação de fonte em negrito à linha de cabeçalho e ajusta automaticamente o tamanho das colunas após a escrita dos dados:
using IronXL;
using System.Data;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));
dt.Rows.Add("Nãorth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East", 87000m, 93000m, 99000m, 108000m);
dt.Rows.Add("West", 145000m, 152000m, 161000m, 174000m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
sheet["A1:E1"].Style.Font.Bold = true;
sheet["A1:E1"].Style.Font.Height = 12;
}
// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
}
}
workbook.SaveAs("SalesReport.xlsx");Imports IronXL
Imports System.Data
Dim dt As New DataTable("Sales")
dt.Columns.Add("Region", GetType(String))
dt.Columns.Add("Q1", GetType(Decimal))
dt.Columns.Add("Q2", GetType(Decimal))
dt.Columns.Add("Q3", GetType(Decimal))
dt.Columns.Add("Q4", GetType(Decimal))
dt.Rows.Add("Nãorth", 120000D, 135000D, 142000D, 158000D)
dt.Rows.Add("South", 98000D, 104000D, 112000D, 121000D)
dt.Rows.Add("East", 87000D, 93000D, 99000D, 108000D)
dt.Rows.Add("West", 145000D, 152000D, 161000D, 174000D)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")
' Write and style headers
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
sheet("A1:E1").Style.Font.Bold = True
sheet("A1:E1").Style.Font.Height = 12
Next
' Write data rows
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
sheet.SetCellValue(row + 1, col, dt.Rows(row)(col))
Next
Next
workbook.SaveAs("SalesReport.xlsx")A propriedade Style.Font.Bold aplica-se a todo o intervalo de cabeçalho em uma única declaração. O IronXL também suporta cores de fundo (Style.BackgroundColor), estilos de borda (Style.Border), formatos de número (Style.NumberFormat.FormatCode) e alinhamento horizontal (Style.HorizontalAlignment). Para obter um guia completo de formatação, consulte o guia de formatação de células do IronXL .
Conectar-se a um banco de dados SQL e exportar os resultados diretamente para o Excel abrange um grande caso de uso do mundo real -- relatórios agendados, instantâneos de dados e exportações administrativas. A abordagem preenche um DataSet usando SqlDataAdapter, depois mapeia o DataTable resultante para uma planilha do IronXL.
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";
// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
adapter.Fill(ds, "Customers");
}
DataTable dt = ds.Tables["Customers"]!;
// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");
// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;
// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
object cellValue = dt.Rows[row][col];
worksheet.SetCellValue(row + 1, col,
cellValue == DBNull.Value ? "" : cellValue.ToString()!);
}
}
workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Server=localhost;Database=SalesDB;Integrated Security=True;"
Dim query As String = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers"
' Fill DataSet from SQL query
Dim ds As New DataSet()
Using connection As New SqlConnection(connectionString)
Dim adapter As New SqlDataAdapter(query, connection)
adapter.Fill(ds, "Customers")
End Using
Dim dt As DataTable = ds.Tables("Customers")
' Create workbook and export
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("CustomerData")
' Bold header row
For col As Integer = 0 To dt.Columns.Count - 1
worksheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
worksheet("A1:D1").Style.Font.Bold = True
' Write rows, handling DBNull values safely
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
Dim cellValue As Object = dt.Rows(row)(col)
worksheet.SetCellValue(row + 1, col, If(cellValue Is DBNull.Value, "", cellValue.ToString()))
Next
Next
workbook.SaveAs("CustomerExport.xlsx")
Console.WriteLine("Export complete.")O guardião nulo (valorDaCelula == DBNull.Value ? "" : cellValue.ToString()) prevents exceptions when the database returns valores NULL` -- uma ocorrência comum com colunas opcionais. A formatação em negrito na linha de cabeçalho permite que os destinatários do relatório distingam imediatamente os cabeçalhos dos dados.
Para mais padrões em torno da leitura de dados de volta do Excel para objetos C#, o tutorial de exportação IronXL DataTable mostra como reverter este fluxo de trabalho.
Antes de escolher uma biblioteca, é útil entender como as principais opções se comparam nas áreas que mais importam para cenários de exportação de DataSet.
| Abordagem | Escritório necessário | Suporte a XLSX | API de Estilização | Multi-Planilha | Performance (grandes volumes de dados) |
|---|---|---|---|---|---|
| IronXL | Não | Sim | Completo | Sim | Alto |
| Interoperabilidade com o Microsoft Office | Sim | Sim | Completo | Sim | Baixo |
| EPPlus | Não | Sim | Parcial | Sim | Alto |
| XML fechado | Não | Sim | Parcial | Sim | Médio |
| CSV (manual) | Não | Não | Nãone | Não | Muito alta |
O Interoperabilidade com o Microsoft Office só funciona em máquinas Windows com o Office instalado, o que o descarta para implantações em servidores e funções na nuvem. IronXL, EPPlus e XML fechado todos suportam geração do lado do servidor -- o principal diferencial é a amplitude da API de estilização e o modelo de licenciamento. O licenciamento do IronXL inclui uso comercial e cobre todas as estruturas de destino .NET a partir de um único pacote.
Para benchmarks de terceiros e comparações, a documentação da Microsoft sobre formatos de arquivos Excel e a página do projeto EPPlus proporcionam contexto adicional para fazer a escolha certa para o seu projeto.
Ao exportar DataTables com dezenas de milhares de linhas, manter o uso de memória previsível é importante. O padrão abaixo transmite dados de um IDataReader em vez de carregar o conjunto de resultados completo em um DataTable primeiro. Isso evita o custo duplo de memória de manter tanto o buffer do leitor quanto o DataTable simultaneamente.
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");
using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();
using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();
// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
sheet.SetCellValue(0, col, reader.GetName(col));
}
// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
for (int col = 0; col < reader.FieldCount; col++)
{
sheet.SetCellValue(excelRow, col,
reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
}
excelRow++;
}
workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Server=localhost;Database=InventoryDB;Integrated Security=True;"
Dim query As String = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products"
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Inventory")
Using conn As New SqlConnection(connectionString)
conn.Open()
Using cmd As New SqlCommand(query, conn)
Using reader As SqlDataReader = cmd.ExecuteReader()
' Write schema-derived headers
For col As Integer = 0 To reader.FieldCount - 1
sheet.SetCellValue(0, col, reader.GetName(col))
Next
' Stream rows directly into IronXL without buffering a DataTable
Dim excelRow As Integer = 1
While reader.Read()
For col As Integer = 0 To reader.FieldCount - 1
sheet.SetCellValue(excelRow, col, If(reader.IsDBNull(col), "", reader.GetValue(col).ToString()))
Next
excelRow += 1
End While
workbook.SaveAs("InventoryExport.xlsx")
Console.WriteLine($"Exported {excelRow - 1} rows.")
End Using
End Using
End UsingEste padrão é recomendado quando o conjunto de resultados pode exceder 50.000 linhas ou quando executado em um serviço com memória limitada. A documentação de desempenho do IronXL aborda opções adicionais de ajuste de memória e taxa de transferência para exportações de alto volume.
Para exportações que excedem 500.000 linhas onde a memória é extremamente limitada, considere dividir a saída em várias pastas de trabalho ou exportar para o formato CSV:
using IronXL;
// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");Imports IronXL
' IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv")O CSV perde formatação e suporte a múltiplas planilhas, mas permanece válido para processamentos ETL a jusante que consomem dados delimitados brutos.
O IronXL suporta a gravação em caminho de arquivo, MemoryStream, e byte[] -- o que é importante para aplicativos ASP.NET que retornam o Excel como resposta de download.
using IronXL;
using System.IO;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");
// Save to file path
workbook.SaveAs("Report.xlsx");
// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");
// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller actionImports IronXL
Imports System.IO
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")
sheet.SetCellValue(0, 0, "Generated Report")
' Save to file path
workbook.SaveAs("Report.xlsx")
' Save as XLS (legacy format)
workbook.SaveAs("Report.xls")
' Save to MemoryStream for HTTP response
Using ms As New MemoryStream()
workbook.SaveAs(ms)
Dim fileBytes As Byte() = ms.ToArray()
' fileBytes can be returned from an ASP.NET controller action
End UsingPara ASP.NET Core, retorne File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx") da sua ação do controlador para acionar um download no navegador. O guia IronXL ASP.NET Excel mostra o padrão completo de integração de controladores.
Para bibliotecas Excel alternativas para .NET, o Open XML SDK é a base de código aberto sobre a qual muitas bibliotecas são construídas.
O IronXL salva nos seguintes formatos sem dependências adicionais:
Alterne formatos mudando a extensão do arquivo no caminho SaveAs ou usando o método sobrecarregado que aceita um valor enum ExcelFileFormat.
Após a exportação, você pode ler o arquivo de volta com IronXL para verificar a contagem de linhas, verificar valores ou executar assertivas automatizadas em um projeto de teste:
using IronXL;
WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];
// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");
// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;
Console.WriteLine($"Header: {header}, First row: {firstEmployee}");Imports IronXL
Dim loaded As WorkBook = WorkBook.Load("EmployeeData.xlsx")
Dim sheet As WorkSheet = loaded.WorkSheets(0)
' Verify row count (header row + data rows)
Dim totalRows As Integer = sheet.Rows.Count()
Console.WriteLine($"Rows in file: {totalRows}")
' Spot-check specific cell values
Dim header As String = sheet("A1").StringValue
Dim firstEmployee As String = sheet("A2").StringValue
Console.WriteLine($"Header: {header}, First row: {firstEmployee}")Este padrão de verificação é particularmente útil em suítes de teste de integração onde a correção da exportação deve ser confirmada antes de enviar arquivos para sistemas externos. O tutorial de leitura do IronXL mostra toda a gama de operações de leitura disponíveis após carregar um arquivo.
Para mais leitura sobre padrões de DataSet e DataTable no .NET, a documentação da Microsoft sobre DataSet cobre o modelo de objeto ADO.NET em profundidade.
Agora você tem padrões funcionais para cada cenário principal de exportação de DataSet para Excel em C# -- desde uma única DataTable até livros com várias planilhas, exportações baseadas em banco de dados, cabeçalhos formatados e transmissão de dados em grande escala. Aqui está como dar o próximo passo com base no seu objetivo:
Com base nos padrões abordados aqui, você pode incorporar automação de tarefas agendadas, endpoints de download de ASP.NET Core e pipelines de saída em múltiplos formatos inteiramente em C# gerenciado -- sem Office, sem COM, sem dependências de tempo de execução além do pacote NuGet.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronXL faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
A API do Excel que você precisa, sem as complicações do Office Interop.
