Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. Salvar dados em CSV em C#
USANDO O IRONXL

Como salvar dados em CSV em C# com IronXL

Jordi Bardia
Jordi Bardia
Atualizado:

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 manipula operações CSV, como salvar em CSV em C#, juntamente com a compatibilidade total 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.

Como Salvar Dados em CSV no C# com IronXL: Imagem 1 - IronXL

Começando com IronXL

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.

Como Salvar Dados em CSV no C# com IronXL: Imagem 2 - Multiplataforma

Abra o Visual Studio, vá para o Console do Gerenciador de Pacotes e digite o seguinte comando:

Install-Package IronXL.Excel

Como Salvar Dados em CSV no C# com IronXL: Imagem 3 - Instalação

Ou via .NET CLI:

dotnet add package IronXL.Excel
dotnet add package IronXL.Excel
SHELL

Uma vez instalado, adicione o namespace do IronXL ao seu arquivo C# para acessar todos os recursos de gerenciamento de CSV, como escrever dados:

using IronXL;
using IronXL;
Imports IronXL
$vbLabelText   $csharpLabel

Esta 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.

Como Salvar e Escrever Dados em Novos Arquivos CSV?

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 string firstname, public string lastname
    public int Age { get; set; }
    public string? Grade { get; set; }
}
// Define a Student class to model your data
public class Student
{
    public string? Name { get; set; } // public string firstname, public string lastname
    public int Age { get; set; }
    public string? Grade { get; set; }
}
Option Strict On



Public Class Student
    Public Property Name As String
    Public Property Age As Integer
    Public Property Grade As String
End Class
$vbLabelText   $csharpLabel

Você 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!");
    }
}
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 Class
$vbLabelText   $csharpLabel

Explicação:

  1. A classe pública student define o esquema para seu modelo de dados.
  2. Uma lista de objetos student é criada com dados de exemplo.
  3. As APIs WorkBook e WorkSheet do IronXL são usadas para criar uma planilha estruturada na memória.
  4. Cabeçalhos são adicionados manualmente para garantir a legibilidade na saída do CSV.
  5. Os dados dos estudantes são escritos linha por linha na planilha.
  6. Finalmente, os dados são salvos como um arquivo CSV usando SaveAsCsv().

Saída

Como Salvar Dados em CSV no C# com IronXL: Figura 4 - Saída do Console

Como Salvar Dados em CSV no C# com IronXL: Figura 5 - Saída do Excel

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 (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 Try
$vbLabelText   $csharpLabel

Isso 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");
}
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");
}
$vbLabelText   $csharpLabel

Este 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 qualquer caractere especial 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.

Saída

Como Salvar Dados em CSV no C# com IronXL: Figura 6 - Saída CSV

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", ";");
// Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");
// Save with semicolon delimiter for European locale compatibility
workbook.SaveAsCsv("sales_report.csv", ";");
// Save with tab delimiter
workbook.SaveAsCsv("sales_report.tsv", "\t");
$vbLabelText   $csharpLabel

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.

Como Salvar Dados em CSV no C# com IronXL: Figura 7 - Funcionalidades

Como Exportar DataTable para CSV?

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");
// 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")
$vbLabelText   $csharpLabel

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.

Saída

Como Salvar Dados em CSV no C# com IronXL: Figura 8 - Saída DataTable para CSV

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
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")
$vbLabelText   $csharpLabel

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.

Como Converter Arquivos Excel para CSV?

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
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")
$vbLabelText   $csharpLabel

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.

Entrada

Como Salvar Dados em CSV no C# com IronXL: Figura 9 - Exemplo de Entrada

Saída

Como Salvar Dados em CSV no C# com IronXL: Figura 10 - Saída de Excel para 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}");
}
// 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}")
Next
$vbLabelText   $csharpLabel

Este 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.

Técnicas Avançadas de Gerenciamento de CSV

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");
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")
$vbLabelText   $csharpLabel

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.

Saída

Como Salvar Dados em CSV no C# com IronXL: Figura 11 - Saída com Caracteres Especiais

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);
}
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)
Next
$vbLabelText   $csharpLabel

A 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");
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")
$vbLabelText   $csharpLabel

Saída

Como Salvar Dados em CSV no C# com IronXL: Figura 12 - Saída de Grande Conjunto de Dados

Conclusão

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 uma licença de teste gratuita que inclui suporte profissional e atualizações.

Como Salvar Dados em CSV no C# com IronXL: Figura 13 - Licenciamento

Perguntas frequentes

Qual a vantagem de usar o IronXL para salvar dados em CSV em C#?

A IronXL oferece uma API abrangente que simplifica o processamento de arquivos CSV, incluindo o salvamento de dados em CSV, além de oferecer total compatibilidade com o Excel, facilitando o gerenciamento de caracteres especiais, múltiplos tipos de dados e grandes conjuntos de dados.

Como o IronXL lida com caracteres especiais em arquivos CSV?

O IronXL gerencia com eficiência caracteres especiais em arquivos CSV, fornecendo recursos robustos de análise e gravação, garantindo a integridade dos dados durante as operações com os arquivos.

O IronXL consegue gerenciar grandes conjuntos de dados ao salvar em CSV?

Sim, o IronXL foi projetado para lidar com grandes conjuntos de dados de forma eficiente, oferecendo uma abordagem otimizada para salvar dados em arquivos CSV sem comprometer a velocidade ou a confiabilidade.

O IronXL suporta múltiplos tipos de dados para operações com CSV?

O IronXL suporta vários tipos de dados, permitindo que os desenvolvedores exportem conjuntos de dados complexos para o formato CSV sem problemas de compatibilidade.

O IronXL é compatível com o Excel ao lidar com arquivos CSV?

O IronXL oferece total compatibilidade com o Excel, o que significa que ele pode lidar com arquivos CSV juntamente com operações do Excel, tornando-se uma ferramenta versátil para desenvolvedores que trabalham com dados de planilhas.

O que torna o IronXL uma solução robusta para gerenciamento de arquivos CSV em C#?

A solução robusta da IronXL para gerenciamento de arquivos CSV deriva de sua API abrangente, que simplifica operações complexas com arquivos CSV e oferece recursos adicionais, como compatibilidade com o Excel e suporte para grandes conjuntos de dados.

Como o IronXL simplifica o processo de salvar em CSV em C#?

O IronXL simplifica o processo ao abstrair as complexidades envolvidas no gerenciamento de arquivos CSV, fornecendo aos desenvolvedores métodos simples para salvar dados em CSV de forma eficiente.

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

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim