Gerenciar arquivos CSV é um requisito fundamental em aplicativos modernos C#, desde gerar relatórios de negócios até exportar registros de banco de dados. Embora o .NET forneça capacidades básicas de escrita de arquivo, lidar com arquivos CSV de forma eficiente, especialmente ao lidar com caracteres especiais, múltiplos tipos de dados e grandes conjuntos de dados, exigiria uma solução mais robusta. IronXL simplifica todo esse processo ao fornecer uma API abrangente que lida com operações CSV, como C# salvar em CSV, juntamente com total compatibilidade com Excel.
Este tutorial demonstra como aproveitar os recursos poderosos do IronXL para criar, salvar e gerenciar arquivos CSV em suas aplicações C#. Você aprenderá técnicas práticas para lidar com várias fontes de dados, desde coleções simples até DataTables complexas, tudo mantendo o código limpo e de fácil manutenção.
Antes de mergulhar nas operações CSV, você precisará instalar o IronXL em seu projeto. A biblioteca é compatível com .NET Framework 4.6.2+ e .NET Core 2+, tornando-a compatível com aplicativos legados e modernos. O IronXL também oferece excelente suporte multiplataforma, operando sem problemas em ambientes Windows, Linux e macOS.
Abra o Visual Studio, vá para o Console do Gerenciador de Pacotes e digite o seguinte comando:
Ou via .NET CLI
Uma vez instalado, adicione o namespace IronXL ao seu arquivo C# para acessar todos os recursos de gerenciamento de CSV, como gravar dados:
using IronXL;Imports IronXLEsta configuração simples dá acesso imediato a capacidades poderosas de manipulação de planilhas. Ao contrário de abordagens tradicionais que requerem Excel Interop ou lógica complexa de análise CSV, o IronXL fornece uma API intuitiva que lida com as complexidades nos bastidores. A biblioteca opera de forma independente sem exigir a instalação do Microsoft Office, tornando-a ideal para implantações em servidores e aplicativos conteinerizados.
Se ocorreu um erro ao instalar ou inicializar a biblioteca, garanta que seu projeto tem como alvo uma versão .NET suportada e que todas as dependências estão corretamente restauradas.
Criar ou escrever arquivos CSV do zero com IronXL segue um padrão intuitivo. Você começa criando uma planilha, adiciona todos os dados às células e depois salva em formato CSV. Essa abordagem proporciona muito mais controle do que os métodos básicos de concatenação de strings.
Antes de mergulhar na lógica principal de criação de CSV, aqui está uma definição de modelo simples usando uma estrutura de classe pública estudante. Este modelo representa dados estruturados que podemos exportar para CSV posteriormente.
// Define a Student class to model your data
public class Student
{
public string? Name { get; set; }
public int Age { get; set; }
public string? Grade { get; set; }
}Public Class Student
Public Property Name As String
Public Property Age As Integer
Public Property Grade As String
End ClassVocê pode preencher uma lista de objetos de estudantes e depois usar o IronXL para exportá-los eficientemente para um arquivo CSV. Este exemplo mostra como mapear propriedades de classe para células da planilha:
using System;
using System.Collections.Generic;
using IronXL;
class Program
{
static void Main(string[] args)
{
// Create sample data using the student class
List<Student> students = new List<Student>()
{
new Student { Name = "Alice Johnson", Age = 20, Grade = "A" },
new Student { Name = "Brian Smith", Age = 22, Grade = "B+" },
new Student { Name = "Chloe Brown", Age = 19, Grade = "A-" },
new Student { Name = "David Clark", Age = 21, Grade = "B" }
};
// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Students");
// Add headers
sheet["A1"].Value = "Name";
sheet["B1"].Value = "Age";
sheet["C1"].Value = "Grade";
// Add student data to the worksheet
for (int i = 0; i < students.Count; i++)
{
sheet[$"A{i + 2}"].Value = students[i].Name;
sheet[$"B{i + 2}"].IntValue = students[i].Age;
sheet[$"C{i + 2}"].Value = students[i].Grade;
}
// Save as CSV file
workbook.SaveAsCsv("students.csv");
Console.WriteLine("students.csv file has been created successfully!");
}
}Imports System
Imports System.Collections.Generic
Imports IronXL
Class Program
Shared Sub Main(ByVal args As String())
' Create sample data using the student class
Dim students As New List(Of Student)() From {
New Student With {.Name = "Alice Johnson", .Age = 20, .Grade = "A"},
New Student With {.Name = "Brian Smith", .Age = 22, .Grade = "B+"},
New Student With {.Name = "Chloe Brown", .Age = 19, .Grade = "A-"},
New Student With {.Name = "David Clark", .Age = 21, .Grade = "B"}
}
' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Students")
' Add headers
sheet("A1").Value = "Name"
sheet("B1").Value = "Age"
sheet("C1").Value = "Grade"
' Add student data to the worksheet
For i As Integer = 0 To students.Count - 1
sheet($"A{i + 2}").Value = students(i).Name
sheet($"B{i + 2}").IntValue = students(i).Age
sheet($"C{i + 2}").Value = students(i).Grade
Next
' Save as CSV file
workbook.SaveAsCsv("students.csv")
Console.WriteLine("students.csv file has been created successfully!")
End Sub
End Class
Class Student
Public Property Name As String
Public Property Age As Integer
Public Property Grade As String
End ClassExplicação:
WorkBook e WorkSheet do IronXL são usadas para criar uma planilha estruturada na memória.SaveAsCsv().
Esse padrão é escalável; assim você pode facilmente adaptá-lo para conjuntos de dados maiores ou integrá-lo a um aplicativo que recupere dados de estudantes de um banco de dados ou API.
Por exemplo, se ocorrer um erro ao escrever no arquivo (p. ex., arquivo bloqueado ou caminho inválido), você pode lidar com isso graciosamente:
try
{
workbook.SaveAsCsv("students.csv");
}
catch (Exception ex)
{
Console.WriteLine($"Error occurred while saving CSV: {ex.Message}");
}Try
workbook.SaveAsCsv("students.csv")
Catch ex As Exception
Console.WriteLine($"Error occurred while saving CSV: {ex.Message}")
End TryIsso garante que seu aplicativo permaneça robusto e informativo mesmo quando surgem problemas de E/S de arquivo.
O seguinte é o código de exemplo para criar um arquivo CSV básico.
static void Main(string[] args)
{
// Create a new workbook
var writer = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = writer.CreateWorkSheet("Sales Data");
// Add headers
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Quantity";
sheet["C1"].Value = "Price";
sheet["D1"].Value = "Total";
// Add data rows
sheet["A2"].Value = "Widget A";
sheet["B2"].IntValue = 100;
sheet["C2"].DecimalValue = 29.99m;
sheet["D2"].Formula = "=B2*C2";
sheet["A3"].Value = "Widget B";
sheet["B3"].IntValue = 50;
sheet["C3"].DecimalValue = 49.99m;
sheet["D3"].Formula = "=B3*C3";
// Save as new CSV file
writer.SaveAsCsv("sales_report.csv");
}netEste código cria um workbook estruturado com cabeçalhos e dados, em seguida, exporta-o para o formato CSV. O método WorkBook.Create() inicializa uma nova planilha na memória. Cada célula pode conter diferentes tipos de dados, como strings, inteiros, decimais e até mesmo fórmulas. Quando você chama SaveAsCsv(), o IronXL lida automaticamente com a conversão, escapando corretamente quaisquer caracteres especiais e mantendo a integridade dos dados.
A beleza dessa abordagem está em sua flexibilidade. Você pode manipular os dados como uma planilha antes de exportar, aplicando fórmulas, formatação ou regras de validação. O IronXL avalia fórmulas automaticamente durante o processo de exportação, garantindo que seu CSV contenha os valores calculados em vez do texto da fórmula.
Para requisitos de delimitador personalizado, o IronXL permite que você especifique alternativas ao padrão de vírgula:
// Save with semicolon delimiter for European locale compatibility
workbook.SaveAsCsv("sales_report.csv", ";");net// Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");' Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", vbTab)Essa flexibilidade garante a compatibilidade com várias configurações regionais e requisitos de aplicativo. A biblioteca lida automaticamente com problemas de codificação, garantindo a representação adequada de caracteres em diferentes sistemas e locais.
DataTables são onipresentes em aplicações .NET para armazenar dados tabulares de bancos de dados ou lógica de negócios. O IronXL fornece conversão tranquila de DataTable para CSV, preservando nomes de colunas e tipos de dados durante todo o processo.
// Create a sample DataTable (simulating database results) to store data
DataTable customerOrders = new DataTable("CustomerOrders");
customerOrders.Columns.Add("OrderID", typeof(int));
customerOrders.Columns.Add("CustomerName", typeof(string));
customerOrders.Columns.Add("OrderDate", typeof(DateTime));
customerOrders.Columns.Add("Amount", typeof(decimal));
// Add sample data
customerOrders.Rows.Add(1001, "Acme Corp", new DateTime(2024, 1, 15), 1250.50m);
customerOrders.Rows.Add(1002, "TechStart Inc", new DateTime(2024, 1, 16), 3500.00m);
customerOrders.Rows.Add(1003, "Global Systems", new DateTime(2024, 1, 17), 875.25m);
// Convert DataTable to CSV using IronXL
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Orders");
// Add headers from DataTable columns
for (int i = 0; i < customerOrders.Columns.Count; i++)
{
sheet.SetCellValue(0, i, customerOrders.Columns[i].ColumnName);
}
// Add data rows
for (int row = 0; row < customerOrders.Rows.Count; row++)
{
for (int col = 0; col < customerOrders.Columns.Count; col++)
{
sheet.SetCellValue(row + 1, col, customerOrders.Rows[row][col]);
}
}
// Export to CSV
workbook.SaveAsCsv("customer_orders.csv");Imports System
Imports System.Data
Imports IronXL
' Create a sample DataTable (simulating database results) to store data
Dim customerOrders As New DataTable("CustomerOrders")
customerOrders.Columns.Add("OrderID", GetType(Integer))
customerOrders.Columns.Add("CustomerName", GetType(String))
customerOrders.Columns.Add("OrderDate", GetType(DateTime))
customerOrders.Columns.Add("Amount", GetType(Decimal))
' Add sample data
customerOrders.Rows.Add(1001, "Acme Corp", New DateTime(2024, 1, 15), 1250.5D)
customerOrders.Rows.Add(1002, "TechStart Inc", New DateTime(2024, 1, 16), 3500.0D)
customerOrders.Rows.Add(1003, "Global Systems", New DateTime(2024, 1, 17), 875.25D)
' Convert DataTable to CSV using IronXL
Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Orders")
' Add headers from DataTable columns
For i As Integer = 0 To customerOrders.Columns.Count - 1
sheet.SetCellValue(0, i, customerOrders.Columns(i).ColumnName)
Next
' Add data rows
For row As Integer = 0 To customerOrders.Rows.Count - 1
For col As Integer = 0 To customerOrders.Columns.Count - 1
sheet.SetCellValue(row + 1, col, customerOrders.Rows(row)(col))
Next
Next
' Export to CSV
workbook.SaveAsCsv("customer_orders.csv")Este exemplo demonstra um cenário do mundo real onde dados de pedidos de um banco de dados precisam ser exportados para fins de relatórios ou integração. O código itera através da estrutura do DataTable, preservando cabeçalhos de coluna e dados de linha. O IronXL lida adequadamente com a conversão de diferentes tipos de dados, garantindo que datas, decimais e strings sejam formatados corretamente no arquivo CSV resultante.
Para cenários mais complexos que envolvem múltiplas tabelas relacionadas ou transformações de dados avançadas, você pode aproveitar as capacidades de referência de células e fórmulas do IronXL:
// Add summary row with formulas
int lastRow = customerOrders.Rows.Count + 1;
sheet[$"A{lastRow + 1}"].Value = "Total:";
sheet[$"D{lastRow + 1}"].Formula = $"=SUM(D2:D{lastRow})";
// Calculate and save
workbook.SaveAsCsv("customer_orders_with_total.csv");' Add summary row with formulas
Dim lastRow As Integer = customerOrders.Rows.Count + 1
sheet($"A{lastRow + 1}").Value = "Total:"
sheet($"D{lastRow + 1}").Formula = $"=SUM(D2:D{lastRow})"
' Calculate and save
workbook.SaveAsCsv("customer_orders_with_total.csv")Essa abordagem oferece muito mais controle do que os métodos tradicionais de exportação de DataTable. Você pode adicionar campos calculados, aplicar lógica de formatação condicional ou reorganizar colunas antes da exportação final. A documentação do IronXL fornece exemplos abrangentes para cenários avançados de manipulação de DataTable.
Uma das características mais fortes do IronXL é sua capacidade de trabalhar perfeitamente com arquivos Excel existentes, convertendo-os para o formato CSV enquanto preserva a integridade dos dados. Isto é particularmente útil ao integrar com sistemas que produzem relatórios em Excel, mas requerem CSV para processamento a jusante.
// Load an existing Excel file
WorkBook existingWorkbook = WorkBook.Load("Budget.xlsx");
// Access the first worksheet
WorkSheet sheet = existingWorkbook.WorkSheets[0];
// Save as CSV - single sheet
sheet.SaveAsCsv("Budget.csv");
// Or save entire workbook (creates multiple CSV files for multiple sheets)
existingWorkbook.SaveAsCsv("BudgetReport.csv");' Load an existing Excel file
Dim existingWorkbook As WorkBook = WorkBook.Load("Budget.xlsx")
' Access the first worksheet
Dim sheet As WorkSheet = existingWorkbook.WorkSheets(0)
' Save as CSV - single sheet
sheet.SaveAsCsv("Budget.csv")
' Or save entire workbook (creates multiple CSV files for multiple sheets)
existingWorkbook.SaveAsCsv("BudgetReport.csv")Ao carregar arquivos Excel, o IronXL preserva todos os valores das células, incluindo aqueles calculados por fórmulas. A biblioteca avalia fórmulas do Excel durante o processo de conversão, garantindo que seu CSV contenha os valores calculados de fato. Isso elimina o problema comum de texto de fórmula aparecendo em exportações CSV.
Para workbooks contendo múltiplas planilhas, o IronXL lida com cada planilha de forma inteligente:
// Process multiple sheets
WorkBook multiSheetWorkbook = WorkBook.Load("annual_data.xlsx");
foreach (WorkSheet sheet in multiSheetWorkbook.WorkSheets)
{
string fileName = $"export_{sheet.Name}.csv";
sheet.SaveAsCsv(fileName);
Console.WriteLine($"Exported {sheet.Name} to {fileName}");
}Imports System
' Process multiple sheets
Dim multiSheetWorkbook As WorkBook = WorkBook.Load("annual_data.xlsx")
For Each sheet As WorkSheet In multiSheetWorkbook.WorkSheets
Dim fileName As String = $"export_{sheet.Name}.csv"
sheet.SaveAsCsv(fileName)
Console.WriteLine($"Exported {sheet.Name} to {fileName}")
NextEste código itera por todas as planilhas em um arquivo Excel, criando arquivos CSV separados para cada planilha. Os nomes das planilhas são preservados no nome do arquivo, facilitando a identificação da origem de cada arquivo CSV. O IronXL suporta vários formatos do Excel, incluindo XLSX, XLS, XLSM e XLTX, fornecendo ampla compatibilidade com diferentes versões do Excel e casos de uso. Saiba mais sobre converter entre formatos na documentação.
Além da criação básica de CSV, o IronXL oferece recursos sofisticados para lidar com cenários complexos que costumam surgir em ambientes de produção. Essas capacidades o diferenciam das abordagens simples de escrita de arquivos.
Ao lidar com caracteres especiais, o IronXL trata automaticamente do escaping e codificação:
WorkBook workbook = WorkBook.Create();
WorkSheet sheet = workbook.CreateWorkSheet("Data");
// Data with special characters
sheet["A1"].Value = "Company \"ABC\", Inc."; // Quotes
sheet["B1"].Value = "Line 1\nLine 2"; // Newlines
sheet["C1"].Value = "Price: €50,00"; // Unicode characters
workbook.SaveAsCsv("special_chars.csv");Dim workbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Data")
' Data with special characters
sheet("A1").Value = "Company ""ABC"", Inc." ' Quotes
sheet("B1").Value = "Line 1" & vbLf & "Line 2" ' Newlines
sheet("C1").Value = "Price: €50,00" ' Unicode characters
workbook.SaveAsCsv("special_chars.csv")O IronXL escapa corretamente aspas, lida com conteúdo multi-linha e preserva caracteres Unicode. Este manejo automático evita erros comuns de parsing de CSV que ocorrem com abordagens de manipulação de strings manuais.
Para cenários de processamento em lote, você pode lidar com eficácia com múltiplos arquivos:
string[] sourceFiles = Directory.GetFiles("input_folder", "*.xlsx");
foreach (string file in sourceFiles)
{
WorkBook wb = WorkBook.Load(file);
var csv = Path.ChangeExtension(file, ".csv");
wb.SaveAsCsv(csv);
}Imports System.IO
Dim sourceFiles As String() = Directory.GetFiles("input_folder", "*.xlsx")
For Each file As String In sourceFiles
Dim wb As WorkBook = WorkBook.Load(file)
Dim csv = Path.ChangeExtension(file, ".csv")
wb.SaveAsCsv(csv)
NextA eficiência da memória torna-se crucial ao processar grandes conjuntos de dados. O IronXL otimiza o uso de memória internamente, mas você pode melhorar ainda mais o desempenho processando dados em blocos e descartando corretamente os recursos:
WorkBook largeWorkbook = WorkBook.Create();
WorkSheet sheet = largeWorkbook.CreateWorkSheet("LargeData");
// Process in batches
const int batchSize = 1000;
for (int batch = 0; batch < 10; batch++)
{
for (int row = 0; row < batchSize; row++)
{
int actualRow = (batch * batchSize) + row;
sheet.SetCellValue(actualRow, 0, $"Row {actualRow}");
// Add more data...
sheet.SetCellValue(actualRow, 1, DateTime.Now);
sheet.SetCellValue(actualRow, 2, $"Batch {batch + 1}");
}
}
largeWorkbook.SaveAsCsv("large_dataset.csv");Dim largeWorkbook As WorkBook = WorkBook.Create()
Dim sheet As WorkSheet = largeWorkbook.CreateWorkSheet("LargeData")
' Process in batches
Const batchSize As Integer = 1000
For batch As Integer = 0 To 9
For row As Integer = 0 To batchSize - 1
Dim actualRow As Integer = (batch * batchSize) + row
sheet.SetCellValue(actualRow, 0, $"Row {actualRow}")
' Add more data...
sheet.SetCellValue(actualRow, 1, DateTime.Now)
sheet.SetCellValue(actualRow, 2, $"Batch {batch + 1}")
Next
Next
largeWorkbook.SaveAsCsv("large_dataset.csv")
O IronXL transforma o gerenciamento de arquivos CSV em C# de uma tarefa tediosa em um processo direto. Ao fornecer uma API unificada para operações tanto de CSV quanto de Excel, elimina a necessidade de várias bibliotecas ou lógica de análise complexa. O tratamento automático da biblioteca para caracteres especiais, tipos de dados e problemas de codificação garante exportação de dados confiável entre diferentes sistemas e locais.
Quer você esteja construindo sistemas de relatório, pipelines de integração de dados ou funcionalidades de exportação simples, o IronXL oferece as ferramentas necessárias para um gerenciamento eficiente de CSV. Sua compatibilidade com arquivos Excel existentes e estruturas de DataTable facilita a integração em aplicativos existentes sem uma grande refatoração. Uma vez que seus arquivos CSV são gerados, você pode abri-los diretamente no Excel ou inspecionar seu formato bruto usando qualquer editor de texto para validação rápida ou solução de problemas.
Pronto para otimizar suas operações de CSV? Comece com um teste gratuito ou explore a documentação completa da API para descobrir recursos mais avançados. Para implantações em produção, o licenciamento começa em $999 e inclui suporte profissional e atualizações.
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.
