Ícone de mensagem
Ir para o conteúdo do rodapé
  1. Iron Software
  2. Blog IronXL
  3. Usando o IronXL
  4. Importar CSV
USANDO O IRONXL

Importar CSV em C# | Tutorial ASP.NET Core | IronXL

Jordi Bardia
Jordi Bardia
Atualizado:

Importar um arquivo CSV em C# com ASP.NET Core significa ler um fluxo de arquivo, analisar linhas delimitadas e mapear cada registro para um objeto tipado -- tudo antes de poder fazer qualquer coisa útil com os dados. IronXL lida com cada passo através de uma única API que funciona igualmente bem para arquivos CSV, XLSX e TSV, então você gasta tempo na sua lógica de aplicação ao invés de se preocupar com casos extremos de divisão de strings.

Comece seu teste gratuito para acompanhar e testar esses exemplos de código em seu próprio ambiente.

Como instalar o IronXL em um projeto .NET?

Antes de escrever qualquer código de análise, adicione IronXL ao seu projeto. Abra o Console do Gerenciador de Pacotes no Visual Studio ou um terminal no diretório do seu projeto e execute um dos seguintes comandos:

Install-Package IronXl.Excel
dotnet add package IronXl.Excel
Install-Package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

O pacote é direcionado for .NET 10, .NET 6+, .NET Framework 4.6.2+ e .NET Standard 2.0, portanto, se adapta a qualquer tipo de projeto moderno. Não é necessária a instalação do Microsoft Office no servidor. Depois de restaurar o pacote, adicione using IronXL; no topo de qualquer arquivo que chame a biblioteca.

Para opções de configuração detalhadas, incluindo instalação da ferramenta global e configuração do pipeline CI/CD, visite o guia de instalação do IronXL.

Como Importar um Arquivo CSV no ASP.NET Core?

A importação de um arquivo CSV no ASP.NET Core requer a leitura do fluxo de arquivo do servidor, a análise de cada linha e o mapeamento dos valores para uma classe de modelo. Enquanto alguns desenvolvedores optam por implementações manuais StreamReader ou pacotes de terceiros, IronXL oferece um único método que lida com arquivos CSV ao lado de formatos Excel sem configuração adicional.

O código a seguir mostra como carregar um arquivo CSV usando o método WorkBook.LoadCSV do IronXL:

using IronXL;

// Load the CSV file directly using the full file path
var csv = WorkBook.LoadCSV("products.csv");
WorkSheet worksheet = csv.DefaultWorkSheet;

// Access CSV data by iterating through rows
foreach (var row in worksheet.Rows)
{
    string productName = row.Columns[1].StringValue;
    decimal price = row.Columns[2].DecimalValue;
    Console.WriteLine($"Product: {productName}, Price: {price}");
}
using IronXL;

// Load the CSV file directly using the full file path
var csv = WorkBook.LoadCSV("products.csv");
WorkSheet worksheet = csv.DefaultWorkSheet;

// Access CSV data by iterating through rows
foreach (var row in worksheet.Rows)
{
    string productName = row.Columns[1].StringValue;
    decimal price = row.Columns[2].DecimalValue;
    Console.WriteLine($"Product: {productName}, Price: {price}");
}
$vbLabelText   $csharpLabel

Compreendendo o Método WorkBook.LoadCSV

O método WorkBook.LoadCSV lê o arquivo CSV e cria uma planilha onde cada linha se torna uma linha e cada valor delimitado se torna uma célula. O IronXL detecta automaticamente o delimitador (vírgula, ponto e vírgula ou tabulação) e lida com campos entre aspas que contêm vírgulas dentro do valor. Você não precisa configurar um delimitador manualmente para arquivos CSV padrão.

Acessores de valor de célula como StringValue, DecimalValue, IntValue, e DateTimeValue lidam com a conversão de tipo, evitando assim a necessidade de análise manual com int.TryParse ou decimal.Parse. Quando uma célula está vazia ou contém um valor não reconhecido, esses acessores retornam o padrão do tipo em vez de lançar uma exceção, o que previne erros não tratados durante operações de importação em massa.

Esta abordagem elimina a análise manual de strings propensa a erros que as implementações personalizadas exigem, particularmente para casos extremos como aspas escapadas, finais de linha no estilo Windows e valores de células multilinhas. Para mais detalhes sobre formatos suportados e opções de delimitadores, consulte a documentação CSV do IronXL.

ASP Importar CSV: Um Guia Completo para Desenvolvedores em C#: Imagem 1 - Importando um arquivo CSV simples e lendo a saída no console

Como Você Cria uma Classe de Modelo para Dados CSV?

Mapear dados CSV para objetos fortemente tipados requer uma classe de modelo que espelhe a estrutura do arquivo. Você converte dados brutos de strings em tipos específicos como inteiros, decimais e valores DateTime. Para dados de inventário de produtos, crie uma classe com propriedades correspondentes a cada coluna CSV:

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
public class Product
{
    public int Id { get; set; }
    public string Name { get; set; } = string.Empty;
    public decimal Price { get; set; }
    public int Quantity { get; set; }
}
$vbLabelText   $csharpLabel

Analisando Linhas CSV em Coleções Tipadas

Com a classe de modelo definida, você pode analisar registros CSV em uma coleção tipada. O exemplo a seguir ignora a linha de cabeçalho usando um índice de loop e mapeia cada linha subsequente para um objeto Product:

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        Quantity = row.Columns[3].IntValue
    };
    records.Add(product);
}

Console.WriteLine($"Loaded {records.Count} products.");
using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();

// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
    var row = ws.Rows[i];
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        Quantity = row.Columns[3].IntValue
    };
    records.Add(product);
}

Console.WriteLine($"Loaded {records.Count} products.");
$vbLabelText   $csharpLabel

A coleção records agora contém objetos Product tipados prontos para operações de banco de dados, serialização JSON ou lógica de negócios adicional. Os acessores de valor de célula do IronXL lidam com a conversão de tipo automaticamente, incluindo o tratamento de nulos para campos opcionais.

Lidando com Campos Opcionais e Anuláveis

Arquivos CSV do mundo real frequentemente contêm células vazias ou colunas opcionais. Os acessores de valor do IronXL retornam valores padrão em vez de exceções quando uma célula está em branco. Para tipos anuláveis, você pode usar uma verificação condicional:

// Reading an optional DateTime field
DateTime? lastUpdated = string.IsNullOrEmpty(row.Columns[4].StringValue)
    ? null
    : row.Columns[4].DateTimeValue;
// Reading an optional DateTime field
DateTime? lastUpdated = string.IsNullOrEmpty(row.Columns[4].StringValue)
    ? null
    : row.Columns[4].DateTimeValue;
$vbLabelText   $csharpLabel

Este padrão mantém seu código de importação defensivo sem envolver cada acesso de célula em um bloco try-catch. Para orientações sobre como lidar com tipos de dados complexos e arquivos grandes, visite a documentação do IronXL WorkSheet.

Como Lidar com Uploads de Arquivos CSV em uma API Web?

Criar um endpoint de API que aceita uploads de arquivos CSV a partir de um navegador requer a combinação do IFormFile do ASP.NET Core com as capacidades de análise do IronXL. O seguinte código demonstra uma implementação completa de controlador que analisa o arquivo carregado e retorna uma resposta JSON:

using IronXL;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class CsvController : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> UploadCsv(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("Please upload a valid CSV file.");

        try
        {
            using var stream = new MemoryStream();
            await file.CopyToAsync(stream);
            stream.Position = 0;

            WorkBook workbook = WorkBook.Load(stream, "csv");
            WorkSheet ws = workbook.DefaultWorkSheet;
            var records = new List<Product>();

            // Skip header row, iterate through data rows
            for (int i = 1; i < ws.Rows.Count(); i++)
            {
                var row = ws.Rows[i];
                records.Add(new Product
                {
                    Id = row.Columns[0].IntValue,
                    Name = row.Columns[1].StringValue,
                    Price = row.Columns[2].DecimalValue,
                    Quantity = row.Columns[3].IntValue
                });
            }

            return Ok(new
            {
                message = "Import successful",
                count = records.Count,
                data = records
            });
        }
        catch (Exception ex)
        {
            return BadRequest($"Error processing file: {ex.Message}");
        }
    }
}
using IronXL;
using Microsoft.AspNetCore.Mvc;

[Route("api/[controller]")]
[ApiController]
public class CsvController : ControllerBase
{
    [HttpPost("upload")]
    public async Task<IActionResult> UploadCsv(IFormFile file)
    {
        if (file == null || file.Length == 0)
            return BadRequest("Please upload a valid CSV file.");

        try
        {
            using var stream = new MemoryStream();
            await file.CopyToAsync(stream);
            stream.Position = 0;

            WorkBook workbook = WorkBook.Load(stream, "csv");
            WorkSheet ws = workbook.DefaultWorkSheet;
            var records = new List<Product>();

            // Skip header row, iterate through data rows
            for (int i = 1; i < ws.Rows.Count(); i++)
            {
                var row = ws.Rows[i];
                records.Add(new Product
                {
                    Id = row.Columns[0].IntValue,
                    Name = row.Columns[1].StringValue,
                    Price = row.Columns[2].DecimalValue,
                    Quantity = row.Columns[3].IntValue
                });
            }

            return Ok(new
            {
                message = "Import successful",
                count = records.Count,
                data = records
            });
        }
        catch (Exception ex)
        {
            return BadRequest($"Error processing file: {ex.Message}");
        }
    }
}
$vbLabelText   $csharpLabel

Configurando o Endpoint e o Formulário Multipart

Para que a ação [HttpPost("upload")] aceite uploads de arquivos, o projeto deve suportar dados de formulário multipart. Em Program.cs para uma configuração de API mínima, garanta que você tenha chamado builder.Services.AddControllers() e app.MapControllers(). O endpoint torna-se acessível em /api/csv/upload.

Ao testar a partir de um formulário em navegador, defina o atributo enctype do formulário para multipart/form-data e use um elemento de entrada de arquivo. Para clientes de API como Postman, selecione "form-data" no corpo da solicitação, adicione uma chave nomeada file e anexe o arquivo CSV. O controlador retorna um objeto JSON contendo a contagem de registros e o array de dados analisados, que o JavaScript do lado do cliente pode consumir imediatamente.

ASP Importar CSV: Um Guia Completo para Desenvolvedores em C#: Imagem 2 - Saída bem-sucedida com os dados lidos do arquivo CSV importado

Validando o Tipo de Arquivo Antes da Análise

Antes de passar o fluxo para o IronXL, valide a extensão do arquivo para rejeitar uploads que não sejam CSV:

var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
if (extension != ".csv" && extension != ".txt")
    return BadRequest("Only CSV files are accepted.");
var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
if (extension != ".csv" && extension != ".txt")
    return BadRequest("Only CSV files are accepted.");
$vbLabelText   $csharpLabel

Esta verificação impede que dados binários malformados alcancem o analisador e fornece uma mensagem de erro clara aos consumidores da API. Você pode estender essa validação para verificar o tipo MIME usando file.ContentType para uma aplicação mais rigorosa.

Como Salvar Dados CSV em um Banco de Dados?

Depois de analisar arquivos CSV em objetos tipados, você geralmente persiste os registros em um banco de dados. O exemplo a seguir estende o padrão da camada de serviço usando o AddRangeAsync do Entity Framework Core para inserções em massa:

using IronXL;

public class CsvImportService
{
    private readonly AppDbContext _context;

    public CsvImportService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<int> ImportProductsAsync(Stream csvStream)
    {
        WorkBook workbook = WorkBook.LoadCSV(csvStream);
        WorkSheet ws = workbook.DefaultWorkSheet;
        var products = new List<Product>();

        foreach (var row in ws.Rows.Skip(1))
        {
            products.Add(new Product
            {
                Id = row.Columns[0].IntValue,
                Name = row.Columns[1].StringValue,
                Price = row.Columns[2].DecimalValue,
                Quantity = row.Columns[3].IntValue
            });
        }

        await _context.Products.AddRangeAsync(products);
        return await _context.SaveChangesAsync();
    }
}
using IronXL;

public class CsvImportService
{
    private readonly AppDbContext _context;

    public CsvImportService(AppDbContext context)
    {
        _context = context;
    }

    public async Task<int> ImportProductsAsync(Stream csvStream)
    {
        WorkBook workbook = WorkBook.LoadCSV(csvStream);
        WorkSheet ws = workbook.DefaultWorkSheet;
        var products = new List<Product>();

        foreach (var row in ws.Rows.Skip(1))
        {
            products.Add(new Product
            {
                Id = row.Columns[0].IntValue,
                Name = row.Columns[1].StringValue,
                Price = row.Columns[2].DecimalValue,
                Quantity = row.Columns[3].IntValue
            });
        }

        await _context.Products.AddRangeAsync(products);
        return await _context.SaveChangesAsync();
    }
}
$vbLabelText   $csharpLabel

Conectando o Serviço à Injeção de Dependência

Registre CsvImportService em Program.cs para que o controlador possa requisitá-lo por meio de injeção de construtor:

builder.Services.AddScoped<CsvImportService>();
builder.Services.AddScoped<CsvImportService>();
$vbLabelText   $csharpLabel

Então, atualize o construtor do controlador para aceitar o serviço e chamar ImportProductsAsync em vez de construir a lista em linha. Essa separação mantém as ações do controlador enxutas e move a lógica de acesso a dados para uma classe de serviço testável. O Entity Framework Core agrupa a chamada AddRangeAsync em uma única instrução INSERT por lote, o que atua bem para arquivos CSV contendo milhares de linhas.

Para importações muito grandes (dezenas de milhares de linhas), considere usar as Extensões de Bulk do EF Core ou uma instrução SQL bruta BULK INSERT para reduzir as idas e voltas ao banco de dados.

Como Exportar Dados de Volta para CSV Usando o IronXL?

O IronXL não se limita a ler arquivos CSV -- também os escreve. O método SaveAsCsv exporta qualquer planilha para um arquivo CSV, sendo útil para gerar relatórios ou enviar dados para sistemas downstream:

using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLS);
WorkSheet ws = workbook.DefaultWorkSheet;

// Write headers
ws["A1"].Value = "Id";
ws["B1"].Value = "Name";
ws["C1"].Value = "Price";

// Write data rows
ws["A2"].Value = 1;
ws["B2"].Value = "Widget A";
ws["C2"].Value = 9.99;

ws["A3"].Value = 2;
ws["B3"].Value = "Widget B";
ws["C3"].Value = 14.49;

// Save as CSV
workbook.SaveAsCsv("export.csv");
Console.WriteLine("CSV export complete.");
using IronXL;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLS);
WorkSheet ws = workbook.DefaultWorkSheet;

// Write headers
ws["A1"].Value = "Id";
ws["B1"].Value = "Name";
ws["C1"].Value = "Price";

// Write data rows
ws["A2"].Value = 1;
ws["B2"].Value = "Widget A";
ws["C2"].Value = 9.99;

ws["A3"].Value = 2;
ws["B3"].Value = "Widget B";
ws["C3"].Value = 14.49;

// Save as CSV
workbook.SaveAsCsv("export.csv");
Console.WriteLine("CSV export complete.");
$vbLabelText   $csharpLabel

O arquivo exportado usa delimitadores de vírgula por padrão. Para arquivos delimitados por ponto e vírgula comuns em localidades europeias, chame SaveAsCsv("export.csv", ";") com um argumento delimitador explícito. Você também pode salvar em um MemoryStream e retornar o resultado como um download de arquivo de um endpoint de API usando File(stream, "text/csv", "export.csv").

Para uma referência completa sobre opções de exportação, visite a documentação de salvamento e exportação do IronXL.

Por Que o IronXL é uma Escolha Melhor do que a Análise Manual de CSV?

A análise manual de CSV parece simples até que você encontre casos extremos: valores que contêm vírgulas entre aspas, novas linhas embutidas em uma célula, aspas escapadas e marcas de ordem de bytes no início de arquivos UTF-8. Lidar corretamente com tudo isso em um loop customizado StreamReader requer um teste significativo e manutenção contínua.

O IronXL trata todos esses casos internamente. Comparar as duas abordagens mostra vantagens claras:

IronXL vs. StreamReader Manual para Análise de CSV em C#
Capacidade IronXL StreamReader Manual
Detecção automática de delimitadores Sim Não -- deve configurar manualmente
Manipulação de campos citados Embutido Requer lógica personalizada
Conversão de tipo (int, decimal, DateTime) Acessores integrados Requer chamadas Parse/TryParse
Valores de células multilinha Tratado automaticamente Difícil de implementar corretamente
Manipulação de BOM Automático Requer configuração de StreamReader
Suporte a formatos Excel (XLSX, XLS) Mesma API Requer biblioteca separada
Exportar para CSV Método SaveAsCsv Requer lógica de gravação separada

Consistência entre Formatos

Uma das vantagens práticas do IronXL é que o mesmo WorkBook.Load e padrão de iteração de planilha funciona para arquivos XLSX, XLS, ODS e CSV. Se sua aplicação precisa aceitar vários formatos de planilha dos usuários, você pode alternar entre formatos sem alterar a lógica de análise. Passe o fluxo de arquivo para WorkBook.Load e o IronXL detecta o formato automaticamente com base na assinatura do arquivo.

Esta API entre formatos significa que você escreve e testa um caminho de código em vez de manter implementações separadas para CSV e Excel. Para uma lista completa de formatos suportados, consulte a página de formatos de arquivo suportados pelo IronXL.

Considerações de Desempenho para Arquivos Grandes

Para arquivos CSV com menos de 100 MB, o IronXL tem um bom desempenho sem qualquer ajuste. Para arquivos maiores, considere estas estratégias:

  • Carregue o arquivo de um caminho ao invés de copiá-lo para um MemoryStream para reduzir a alocação de memória.
  • Processe as linhas em lotes ao inserir em um banco de dados em vez de coletar todos os registros antes da primeira inserção.
  • Use ws.Rows.Skip(1) com LINQ para evitar materializar a linha de cabeçalho como um objeto Product.

O guia de desempenho do IronXL cobre otimizações adicionais para cenários de importação de alto volume, incluindo processamento paralelo e modos de streaming.

Quais são os seus próximos passos?

Você agora tem um padrão funcional para cada estágio da importação de CSV no ASP.NET Core: instalar a biblioteca, carregar arquivos do disco ou fluxos enviados, mapear linhas para objetos modelo tipificados, persistir registros em um banco de dados com o Entity Framework Core e exportar dados de volta para CSV quando necessário.

Para construir sobre esta base, explore estes recursos:

Com o IronXL em seu projeto, adicionar suporte para uploads de XLSX ao lado de CSV não requer mudanças adicionais no código -- a mesma chamada WorkBook.Load lida com ambos. Essa consistência significa que você pode expandir o conjunto de recursos do seu endpoint de importação de forma incremental à medida que os requisitos do seu aplicativo crescem.

Perguntas frequentes

Como posso importar arquivos CSV em uma aplicação ASP.NET Core?

Você pode importar arquivos CSV em uma aplicação ASP.NET Core usando o IronXL , que lida com o upload de arquivos, analisa os dados CSV e os mapeia para objetos de classe do modelo. O IronXL fornece uma API para facilitar essas tarefas de forma eficiente.

Quais são os benefícios de usar o IronXL para importar arquivos CSV em C#?

A IronXL oferece uma API que simplifica o processo de importação de arquivos CSV. Ela permite analisar dados facilmente, mapeá-los para modelos e converter registros em JSON, tornando-a uma escolha ideal para aplicações orientadas a dados.

O IronXL consegue analisar dados CSV e convertê-los em objetos de classe de modelo?

Sim, o IronXL consegue analisar dados CSV e convertê-los em objetos de classe de modelo, permitindo que você trabalhe com dados estruturados de forma eficiente em sua aplicação .NET.

Como o IronXL auxilia na integração com o banco de dados ao importar arquivos CSV?

O IronXL facilita a integração com bancos de dados, permitindo analisar dados CSV e mapeá-los para objetos de modelo que podem ser facilmente inseridos ou atualizados no seu banco de dados.

É possível retornar registros CSV como JSON usando o IronXL?

Sim, com o IronXL, você pode converter registros CSV para o formato JSON, o que é útil para criar APIs da web ou integrar com aplicativos de front-end.

Além de CSV, quais formatos de arquivo o IronXL consegue processar?

Além do CSV, o IronXL também é compatível com diversos formatos de arquivo do Excel, como XLSX, XLS e outros, oferecendo versatilidade para diferentes necessidades de planilhas.

O IronXL suporta a importação de arquivos CSV grandes?

O IronXL foi projetado para lidar com importações de arquivos CSV grandes de forma eficiente, garantindo desempenho e confiabilidade em aplicações orientadas a dados.

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