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

Leitor de Arquivos CSV em C#: Analise e processe dados CSV com IronXL

Jordi Bardia
Jordi Bardia
Atualizado:

Arquivos CSV (Vírgula Separated Values) estão por toda parte em aplicativos de negócios, variando de relatórios financeiros a exportações de dados de clientes. O formato CSV é aparentemente simples na superfície, mas analisá-lo no código de produção pode se tornar difícil rapidamente ao lidar com campos entre aspas, múltiplos tipos de delimitadores, quebras de linha embutidas e a necessidade de converter texto bruto em objetos .NET fortemente tipados. IronXL é uma biblioteca .NET que fornece tratamento de CSV pronto para a empresa, permitindo que os desenvolvedores convertam dados CSV em Excel, XML, ou outros formatos com código mínimo.

Este guia o orienta sobre como o IronXL funciona como um leitor de arquivos CSV em C# e como você pode implementá-lo em seus aplicativos .NET 10. Experimente o IronXL por si mesmo com uma licença de teste gratuita e acompanhe para aprender como ele lida com tarefas de CSV e Excel.

Como instalar o IronXL para leitura de CSV?

Inserir o IronXL em seu projeto leva apenas um momento. Você pode instalá-lo através do Gerenciador de Pacotes NuGet no Visual Studio ou pela linha de comando usando tanto o .NET CLI quanto o Console do Gerenciador de Pacotes NuGet no PowerShell. Ambas as abordagens instalam o mesmo pacote e funcionam com qualquer tipo de projeto .NET 10.

# .NET CLI
dotnet add package IronXl.Excel

# NuGet Package Manager Console
Install-Package IronXl.Excel
# .NET CLI
dotnet add package IronXl.Excel

# NuGet Package Manager Console
Install-Package IronXl.Excel
SHELL

Para mais detalhes sobre opções de instalação e configuração, consulte a documentação de instalação do IronXL.

Uma vez instalado, ler seu primeiro arquivo CSV requer muito pouco código. O exemplo abaixo usa declarações de nível superior do .NET 10:

using IronXL;

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell
string cellValue = sheet["A1"].StringValue;

// Iterate through all rows and cells
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}
using IronXL;

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell
string cellValue = sheet["A1"].StringValue;

// Iterate through all rows and cells
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}
$vbLabelText   $csharpLabel

O método WorkBook.LoadCSV lida com a identificação de cabeçalhos, cria uma estrutura de dados interna e realiza uma análise eficiente de memória -- simplificando o gerenciamento de dados desde a primeira linha de código.

Tutorial de Leitor de Arquivo CSV em C#: Analisar e Converter Dados CSV com o IronXL: Imagem 1 - Instalação do IronXL via NuGet

Como ler arquivos CSV com delimitadores personalizados?

Arquivos CSV do mundo real nem sempre usam vírgulas. Pontos e vírgulas, pipes e abas são alternativas comuns, especialmente em conjuntos de dados internacionais onde vírgulas servem como separadores decimais. O IronXL lida com qualquer delimitador através de suas opções de carregamento flexíveis.

using IronXL;

// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimitador: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimitador: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimitador: "|");

// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

Console.WriteLine($"Total sales: {totalSales}");
using IronXL;

// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimitador: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimitador: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimitador: "|");

// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

Console.WriteLine($"Total sales: {totalSales}");
$vbLabelText   $csharpLabel

O parâmetro listDelimitador aceita qualquer string, dando a você controle total sobre o comportamento de análise. O IronXL preserva os valores das colunas e os tipos de dados durante a análise -- valores numéricos permanecem números, datas ficam como objetos DateTime, e fórmulas mantêm seus relacionamentos.

Para arquivos com formatação inconsistente, o tratamento de erros do IronXL gerencia linhas malformadas sem travar o aplicativo, de modo que dados válidos continuam a ser processados mesmo quando linhas individuais são problemáticas.

Tutorial de Leitor de Arquivo CSV em C#: Analisar e Converter Dados CSV com o IronXL: Imagem 2 - Saída de exemplo inicial

Formatos e Delimitadores de Arquivo Suportados

O IronXL suporta o carregamento dos seguintes tipos de delimitadores ao ler arquivos CSV:

Tipos comuns de delimitadores suportados pelo método LoadCSV do IronXL
Delimitador Personagem Caso de uso comum
Vírgula `,` CSV padrão, exportações de localidades dos EUA
Ponto e vírgula `;` Exportações de localidades europeias (onde vírgula é o separador decimal)
Tabulação ` ` Valores separados por tabulação (TSV), exportações de banco de dados
Pipe `|` Arquivos de log, exportações de sistema
String personalizada Qualquer Formatos de dados proprietários, delimitadores de múltiplos caracteres

Como analisar dados CSV em objetos C#?

Transformar linhas CSV em objetos fortemente tipados simplifica o processamento de dados e habilita operações LINQ. O IronXL torna este mapeamento direto através de seus métodos de acesso a células. O código a seguir demonstra como mapear um arquivo CSV em uma lista de objetos tipados usando declarações de nível superior do .NET 10:

using IronXL;

// Define a typed model matching your CSV structure
public record Product(string Name, decimal Price, int Stock, DateTime? LastUpdated);

// Load and parse CSV file
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

var products = new List<Product>();

// Start from row 2 to skip the header row
for (int row = 2; row <= sheet.RowCount; row++)
{
    products.Add(new Product(
        Name: sheet[$"A{row}"].StringValue,
        Price: sheet[$"B{row}"].DecimalValue,
        Stock: sheet[$"C{row}"].IntValue,
        LastUpdated: sheet[$"D{row}"].DateTimeValue
    ));
}

// Use LINQ for analysis after loading
var lowStock = products.Where(p => p.Stock < 10).ToList();
var highValue = products.Where(p => p.Price > 100m).OrderByDescending(p => p.Price).ToList();

Console.WriteLine($"Products with low stock: {lowStock.Count}");
Console.WriteLine($"High-value products: {highValue.Count}");
using IronXL;

// Define a typed model matching your CSV structure
public record Product(string Name, decimal Price, int Stock, DateTime? LastUpdated);

// Load and parse CSV file
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

var products = new List<Product>();

// Start from row 2 to skip the header row
for (int row = 2; row <= sheet.RowCount; row++)
{
    products.Add(new Product(
        Name: sheet[$"A{row}"].StringValue,
        Price: sheet[$"B{row}"].DecimalValue,
        Stock: sheet[$"C{row}"].IntValue,
        LastUpdated: sheet[$"D{row}"].DateTimeValue
    ));
}

// Use LINQ for analysis after loading
var lowStock = products.Where(p => p.Stock < 10).ToList();
var highValue = products.Where(p => p.Price > 100m).OrderByDescending(p => p.Price).ToList();

Console.WriteLine($"Products with low stock: {lowStock.Count}");
Console.WriteLine($"High-value products: {highValue.Count}");
$vbLabelText   $csharpLabel

As propriedades de valor tipado do IronXL -- StringValue, DecimalValue, IntValue, DateTimeValue -- lidam com conversões de forma segura, retornando valores padrão para dados inválidos em vez de lançar exceções. Essa abordagem defensiva garante que as aplicações lidem com dados imperfeitos sem interrupção. Combina naturalmente com tipos de registro C#, introduzidos no C# 9 e que fornecem um modelo de dados imutável e conciso para linhas CSV mapeadas.

A página de recursos do IronXL oferece uma visão completa dos tipos de acessadores de valor disponíveis para leitura de dados de célula.

Tutorial de Leitor de Arquivo CSV em C#: Analisar e Converter Dados CSV com o IronXL: Imagem 3 - Saída para leitura de diferentes delimitadores

Como Filtrar e Consultar Dados CSV com LINQ?

Uma vez que os dados CSV são carregados em um WorkSheet, você pode trabalhar com eles utilizando seletores de alcance ou convertê-los em objetos para consultas LINQ. Para operações de coluna diretas, o acesso baseado em faixa é o caminho mais direto:

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales-data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read entire columns using range notation
var productNames = sheet["A2:A100"]
    .Select(cell => cell.StringValue)
    .Where(name => !string.IsNullOrEmpty(name))
    .ToList();

// Aggregate numeric columns directly
decimal totalRevenue = sheet["C2:C100"].Sum();
decimal averageOrder = sheet["C2:C100"].Avg();

Console.WriteLine($"Products loaded: {productNames.Count}");
Console.WriteLine($"Total revenue: {totalRevenue:C}");
Console.WriteLine($"Average order value: {averageOrder:C}");
using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales-data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read entire columns using range notation
var productNames = sheet["A2:A100"]
    .Select(cell => cell.StringValue)
    .Where(name => !string.IsNullOrEmpty(name))
    .ToList();

// Aggregate numeric columns directly
decimal totalRevenue = sheet["C2:C100"].Sum();
decimal averageOrder = sheet["C2:C100"].Avg();

Console.WriteLine($"Products loaded: {productNames.Count}");
Console.WriteLine($"Total revenue: {totalRevenue:C}");
Console.WriteLine($"Average order value: {averageOrder:C}");
$vbLabelText   $csharpLabel

Essa abordagem baseada em faixas evita a iteração linha por linha para agregações simples, o que melhora o desempenho em arquivos maiores. Consulte os documentos do IronXL para a lista completa de operações de faixa suportadas.

Como Converter CSV para o Formato Excel em C#?

Muitos fluxos de trabalho empresariais requerem dados CSV no formato Excel para análise avançada, formatação ou distribuição. O IronXL torna essa conversão simples, preservando toda a integridade dos dados.

using IronXL;

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;

// Apply formatting before saving
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

// Apply currency format to price column
sheet["B2:B1000"].FormatString = "$#,##0.00";

// Apply date format to date column
sheet["D2:D1000"].FormatString = "yyyy-MM-dd";

// Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx");

Console.WriteLine("Conversion complete: monthly-report.xlsx");
using IronXL;

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;

// Apply formatting before saving
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

// Apply currency format to price column
sheet["B2:B1000"].FormatString = "$#,##0.00";

// Apply date format to date column
sheet["D2:D1000"].FormatString = "yyyy-MM-dd";

// Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx");

Console.WriteLine("Conversion complete: monthly-report.xlsx");
$vbLabelText   $csharpLabel

A conversão preserva a precisão numérica, os formatos de data e os caracteres especiais que muitas vezes causam problemas com métodos manuais de conversão. O IronXL otimiza automaticamente a estrutura do arquivo Excel resultante, criando arquivos eficientes que abrem rapidamente mesmo com grandes conjuntos de dados.

Para controle adicional sobre o formato de saída, o guia de como exportar cobre opções, incluindo exportação para XLSX, XLS, CSV e PDF. Você também pode aprender como escrever arquivos Excel e criar arquivos Excel do zero.

Tutorial de Leitor de Arquivo CSV em C#: Analisar e Converter Dados CSV com o IronXL: Imagem 4 - Saída de análise de dados CSV

Convertendo CSV para DataSet para Operações de Banco de Dados

Quando você precisar carregar dados CSV em um DataSet para processamento adicional ou inserção em banco de dados, o IronXL fornece suporte para conversão direta. O guia de Excel para DataSet explica isso em detalhes:

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.LoadCSV("customer-export.csv");

// Convert entire workbook to DataSet
DataSet dataSet = workbook.ToDataSet();

// The first sheet becomes the first DataTabulaçãole
DataTabulaçãole customerTabulaçãole = dataSet.Tabulaçãoles[0];

Console.WriteLine($"Rows loaded: {customerTabulaçãole.Rows.Count}");
Console.WriteLine($"Columns: {customerTabulaçãole.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerTabulaçãole.Rows)
{
    string name = row["Name"]?.ToString() ?? string.Empty;
    string email = row["Email"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Customer: {name} <{email}>");
}
using IronXL;
using System.Data;

WorkBook workbook = WorkBook.LoadCSV("customer-export.csv");

// Convert entire workbook to DataSet
DataSet dataSet = workbook.ToDataSet();

// The first sheet becomes the first DataTabulaçãole
DataTabulaçãole customerTabulaçãole = dataSet.Tabulaçãoles[0];

Console.WriteLine($"Rows loaded: {customerTabulaçãole.Rows.Count}");
Console.WriteLine($"Columns: {customerTabulaçãole.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerTabulaçãole.Rows)
{
    string name = row["Name"]?.ToString() ?? string.Empty;
    string email = row["Email"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Customer: {name} <{email}>");
}
$vbLabelText   $csharpLabel

Essa abordagem integra diretamente com fluxos de trabalho ADO.NET e é útil ao enviar dados CSV para SQL Server, SQLite ou outros bancos de dados relacionais através de adaptadores de dados padrão. Porque DataSet e DataTabulaçãole são tipos centrais do .NET, este caminho não requer dependências adicionais além do próprio IronXL.

Como Lidar com Arquivos CSV Grandes e Otimização de Desempenho?

O processamento de arquivos CSV grandes -- dezenas de milhares de linhas ou mais -- requer atenção sobre como os dados são acessados e como a memória é gerenciada. O IronXL inclui recursos que ajudam em cenários de arquivos grandes.

Usando Operações de Faixa para Desempenho

Para um desempenho ideal com grandes conjuntos de dados, use operações de faixa em vez de acessar células individuais uma de cada vez. As operações de faixa são processadas de forma mais eficiente pelo motor interno do IronXL:

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;

Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns");

// Efficient: read entire range at once
var allData = sheet[$"A1:{GetColumnLetter(colCount)}{rowCount}"]
    .Select(cell => cell.StringValue)
    .ToList();

// Efficient: aggregate a column without row-by-row iteration
decimal columnSum = sheet[$"B2:B{rowCount}"].Sum();

Console.WriteLine($"Column B total: {columnSum}");

static string GetColumnLetter(int col)
{
    string result = string.Empty;
    while (col > 0)
    {
        col--;
        result = (char)('A' + col % 26) + result;
        col /= 26;
    }
    return result;
}
using IronXL;

WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;

Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns");

// Efficient: read entire range at once
var allData = sheet[$"A1:{GetColumnLetter(colCount)}{rowCount}"]
    .Select(cell => cell.StringValue)
    .ToList();

// Efficient: aggregate a column without row-by-row iteration
decimal columnSum = sheet[$"B2:B{rowCount}"].Sum();

Console.WriteLine($"Column B total: {columnSum}");

static string GetColumnLetter(int col)
{
    string result = string.Empty;
    while (col > 0)
    {
        col--;
        result = (char)('A' + col % 26) + result;
        col /= 26;
    }
    return result;
}
$vbLabelText   $csharpLabel

O IronXL lida automaticamente com variações de codificação de texto (UTF-8, UTF-16, ASCII) ao carregar arquivos CSV, garantindo que caracteres internacionais em valores de coluna sejam exibidos corretamente sem configuração adicional. Isso é particularmente importante para arquivos exportados de sistemas em regiões onde o BOM UTF-8 ou codificações alternativas são comuns.

Tratamento de Erros para Fontes CSV Não Confiáveis

Ao processar arquivos CSV de fontes não confiáveis ou variáveis, envolver operações em blocos try-catch fornece uma camada extra de segurança:

using IronXL;

string filePath = "user-uploaded-data.csv";

try
{
    WorkBook workbook = WorkBook.LoadCSV(filePath);
    WorkSheet sheet = workbook.DefaultWorkSheet;

    Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}");

    for (int row = 2; row <= sheet.RowCount; row++)
    {
        string value = sheet[$"A{row}"].StringValue;
        if (!string.IsNullOrWhiteSpace(value))
        {
            Console.WriteLine(value);
        }
    }
}
catch (IronXl.Exceptions.IronXLException ex)
{
    Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}");
}
catch (IOException ex)
{
    Console.WriteLine($"File access error: {ex.Message}");
}
using IronXL;

string filePath = "user-uploaded-data.csv";

try
{
    WorkBook workbook = WorkBook.LoadCSV(filePath);
    WorkSheet sheet = workbook.DefaultWorkSheet;

    Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}");

    for (int row = 2; row <= sheet.RowCount; row++)
    {
        string value = sheet[$"A{row}"].StringValue;
        if (!string.IsNullOrWhiteSpace(value))
        {
            Console.WriteLine(value);
        }
    }
}
catch (IronXl.Exceptions.IronXLException ex)
{
    Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}");
}
catch (IOException ex)
{
    Console.WriteLine($"File access error: {ex.Message}");
}
$vbLabelText   $csharpLabel

Os guias de como importar do IronXL cobrem padrões de importação de dados para várias fontes, incluindo arquivos, streams e arrays de bytes.

Tutorial de Leitor de Arquivo CSV em C#: Analisar e Converter Dados CSV com o IronXL: Imagem 5 - Convertendo CSV para formato Excel

Implantação multiplataforma

O IronXL opera independentemente do Microsoft Office, tornando-o adequado para ambientes de servidor e implantações em nuvem. Quer seja para implantar no Windows, Linux, macOS, contêineres Docker ou funções em nuvem no Azure ou AWS, o IronXL entrega resultados consistentes em todas as plataformas sem alterações de configuração.

Essa capacidade de plataforma cruzada é valiosa para arquiteturas de microsserviços onde contêineres leves lidam com tarefas de processamento de dados. A visão geral de recursos do IronXL detalha a lista completa de ambientes suportados e alvos de tempo de execução.

Como Obter uma Licença para IronXL?

O IronXL requer uma chave de licença para uso em ambientes de produção. Uma licença de teste gratuito está disponível para avaliação, e as licenças comerciais estão disponíveis para desenvolvedores individuais, equipes e organizações.

Aplique a chave de licença em sua aplicação antes de fazer qualquer chamada ao IronXL:

using IronXL;

// Apply license key at application startup
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Verify the license is active
if (IronXl.License.IsValidLicense("YOUR-LICENSE-KEY-HERE"))
{
    Console.WriteLine("IronXL license is active.");
}

// Now use IronXL normally
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows.");
using IronXL;

// Apply license key at application startup
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Verify the license is active
if (IronXl.License.IsValidLicense("YOUR-LICENSE-KEY-HERE"))
{
    Console.WriteLine("IronXL license is active.");
}

// Now use IronXL normally
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows.");
$vbLabelText   $csharpLabel

Para opções de teste e licenciamento, visite a página de licenciamento do IronXL.

O Que Torna o IronXL a Escolha Certa para o Processamento de CSV?

O IronXL transforma a leitura de arquivos CSV em C# de uma tarefa de análise tediosa em uma operação simples. A biblioteca lida com os casos extremos comuns que a análise manual erra -- vírgulas incorporadas, quebras de linha dentro de campos citados, delimitadores inconsistentes, variações de codificação e linhas malformadas -- sem exigir código personalizado para cada cenário. Quer você precise de uma importação rápida de dados única ou de um pipeline de produção processando milhares de arquivos por dia, a mesma API funciona em ambos os contextos.

Análise manual de CSV com string.Split ou StreamReader quebra rapidamente quando campos entre aspas contêm o caractere delimitador, ou quando quebras de linha aparecem dentro dos valores de campo. O IronXL lida com esses casos corretamente por padrão, seguindo a especificação CSV para tratamento de campos citados e sequências de escape.

As principais vantagens que diferenciam o IronXL para o trabalho com CSV no .NET 10:

  • Sem dependência do Office: implantações em servidor e nuvem funcionam sem instalar o Microsoft Office ou qualquer interoperabilidade COM
  • Delimitadores personalizados: Qualquer caractere ou string de delimitador é suportado através do parâmetro listDelimitador
  • Acesso a células com segurança de tipo: StringValue, DecimalValue, IntValue, e DateTimeValue retornam padrões seguros em vez de lançar exceções para dados errados
  • Operações em intervalos: Agregue e consulte dados em intervalos sem iteração linha a linha
  • Conversão de formato: Carregue CSV e salve como XLSX, XLS, PDF ou outros formatos em um único fluxo de trabalho
  • Integração com DataSet: Converter livros carregados para DataSet / DataTabulaçãole para operações com ADO.NET e banco de dados
  • Multiplataforma: Funciona no Windows, Linux, macOS, Docker e ambientes em nuvem sem alterações

A documentação do IronXL e o guia de formatação de células fornecem mais detalhes sobre formatação, suporte a fórmulas e operações avançadas de planilhas.

Pronto para lidar com arquivos CSV com confiança? Comece com uma versão de teste gratuita e explore o conjunto completo de recursos do IronXL.

Perguntas frequentes

O que é um arquivo CSV e por que ele é tão utilizado?

Um arquivo CSV, ou arquivo de valores separados por vírgula, é um formato de texto simples para armazenar dados tabulares. É amplamente utilizado em aplicações comerciais para exportar e importar dados entre diferentes sistemas devido à sua simplicidade e facilidade de uso.

Como o IronXL auxilia na análise de arquivos CSV em C#?

IronXL simplifica a análise de arquivos CSV em C# ao fornecer ferramentas robustas para lidar com estruturas CSV complexas, incluindo diferentes separadores de coluna, campos entre aspas e conversões de tipo de dados.

O IronXL consegue converter dados CSV para outros formatos?

Sim, o IronXL permite que os desenvolvedores convertam dados CSV em vários formatos, como XML e Excel, tornando-o versátil para diferentes necessidades de processamento de dados.

Quais são alguns dos desafios comuns na análise de arquivos CSV?

Os desafios comuns incluem lidar com diferentes separadores de coluna, gerenciar campos entre aspas e realizar conversões precisas de tipos de dados. O IronXL ajuda a mitigar esses problemas com seus recursos avançados de análise sintática.

O IronXL é adequado para o processamento de arquivos CSV em nível empresarial?

Sim, o IronXL foi projetado para ser ideal para ambientes corporativos, oferecendo soluções robustas e escaláveis para manipulação de arquivos CSV em aplicações .NET.

O IronXL suporta o processamento eficiente de arquivos CSV grandes?

O IronXL foi otimizado para desempenho, permitindo o processamento eficiente de arquivos CSV grandes sem comprometer a velocidade ou a precisão.

O IronXL consegue lidar com arquivos CSV com delimitadores personalizados?

Sim, o IronXL suporta arquivos CSV com delimitadores personalizados, oferecendo aos desenvolvedores flexibilidade ao lidar com formatos CSV não padronizados.

Como o IronXL lida com campos entre aspas em arquivos CSV?

O IronXL analisa com precisão os campos entre aspas em arquivos CSV, garantindo a integridade dos dados e a conversão adequada durante o processo de leitura.

Quais linguagens de programação podem ser usadas com o IronXL para análise de arquivos CSV?

IronXL é uma biblioteca .NET, portanto pode ser usada com linguagens suportadas pelo framework .NET, como C# e VB.NET.

Existem exemplos de código disponíveis para usar o IronXL com arquivos CSV?

Sim, a documentação do IronXL fornece exemplos de código completos para leitura, análise e processamento de arquivos CSV em aplicações C#.

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