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

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

Curtis Chau
Curtis Chau
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

O pacote é direcionado para .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. Após a restauração do pacote, adicione using IronXL; no topo de qualquer arquivo que chame a biblioteca.

Para obter opções detalhadas de configuração, incluindo a instalação global de ferramentas e a configuração do pipeline CI/CD, consulte 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 de StreamReader ou pacotes de terceiros, o IronXL fornece um único método que lida com arquivos CSV juntamente com 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}");
}
Imports IronXL

' Load the CSV file directly using the full file path
Dim csv = WorkBook.LoadCSV("products.csv")
Dim worksheet As WorkSheet = csv.DefaultWorkSheet

' Access CSV data by iterating through rows
For Each row In worksheet.Rows
    Dim productName As String = row.Columns(1).StringValue
    Dim price As Decimal = row.Columns(2).DecimalValue
    Console.WriteLine($"Product: {productName}, Price: {price}")
Next
$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 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 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; }
}
Public Class Product
    Public Property Id As Integer
    Public Property Name As String = String.Empty
    Public Property Price As Decimal
    Public Property Quantity As Integer
End Class
$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.");
Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim records As New List(Of Product)()

' Skip header row (index 0), iterate through data rows
For i As Integer = 1 To ws.Rows.Count() - 1
    Dim row = ws.Rows(i)
    Dim product As New Product With {
        .Id = row.Columns(0).IntValue,
        .Name = row.Columns(1).StringValue,
        .Price = row.Columns(2).DecimalValue,
        .Quantity = row.Columns(3).IntValue
    }
    records.Add(product)
Next

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 mais lógica de negócios. 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;
' Reading an optional DateTime field
Dim lastUpdated As DateTime? = If(String.IsNullOrEmpty(row.Columns(4).StringValue), Nothing, 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?

Construir um endpoint de API que aceita carregamentos 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}");
        }
    }
}
Imports IronXL
Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Threading.Tasks

<Route("api/[controller]")>
<ApiController>
Public Class CsvController
    Inherits ControllerBase

    <HttpPost("upload")>
    Public Async Function UploadCsv(file As IFormFile) As Task(Of IActionResult)
        If file Is Nothing OrElse file.Length = 0 Then
            Return BadRequest("Please upload a valid CSV file.")
        End If

        Try
            Using stream As New MemoryStream()
                Await file.CopyToAsync(stream)
                stream.Position = 0

                Dim workbook As WorkBook = WorkBook.Load(stream, "csv")
                Dim ws As WorkSheet = workbook.DefaultWorkSheet
                Dim records As New List(Of Product)()

                ' Skip header row, iterate through data rows
                For i As Integer = 1 To ws.Rows.Count() - 1
                    Dim row = ws.Rows(i)
                    records.Add(New Product With {
                        .Id = row.Columns(0).IntValue,
                        .Name = row.Columns(1).StringValue,
                        .Price = row.Columns(2).DecimalValue,
                        .Quantity = row.Columns(3).IntValue
                    })
                Next

                Return Ok(New With {
                    .message = "Import successful",
                    .count = records.Count,
                    .data = records
                })
            End Using
        Catch ex As Exception
            Return BadRequest($"Error processing file: {ex.Message}")
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

Configurando o Endpoint e o Formulário Multipart

Para que a ação [HttpPost("upload")] aceite carregamentos de arquivos, o projeto deve suportar dados de formulário multipart. Em Program.cs para uma configuração mínima de API, certifique-se de ter 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 de 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 requisição, adicione uma chave chamada file e anexe o arquivo CSV. O controlador retorna um objeto JSON contendo a contagem de registros e o array de dados analisados, que pode ser consumido imediatamente pelo JavaScript do lado do cliente.

ASP Importar CSV: Um Guia Completo para Desenvolvedores 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.");
Dim extension As String = Path.GetExtension(file.FileName).ToLowerInvariant()
If extension <> ".csv" AndAlso extension <> ".txt" Then
    Return BadRequest("Only CSV files are accepted.")
End If
$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 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();
    }
}
Imports IronXL

Public Class CsvImportService
    Private ReadOnly _context As AppDbContext

    Public Sub New(context As AppDbContext)
        _context = context
    End Sub

    Public Async Function ImportProductsAsync(csvStream As Stream) As Task(Of Integer)
        Dim workbook As WorkBook = WorkBook.LoadCSV(csvStream)
        Dim ws As WorkSheet = workbook.DefaultWorkSheet
        Dim products As New List(Of Product)()

        For Each row In ws.Rows.Skip(1)
            products.Add(New Product With {
                .Id = row.Columns(0).IntValue,
                .Name = row.Columns(1).StringValue,
                .Price = row.Columns(2).DecimalValue,
                .Quantity = row.Columns(3).IntValue
            })
        Next

        Await _context.Products.AddRangeAsync(products)
        Return Await _context.SaveChangesAsync()
    End Function
End Class
$vbLabelText   $csharpLabel

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

Registre CsvImportService em Program.cs para que o controlador possa solicitá-lo através de injeção de construtor:

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

Em seguida, atualize o construtor do controlador para aceitar o serviço e chamar ImportProductsAsync em vez de construir a lista inline. Esta separação mantém as ações do controlador finas e move a lógica de acesso aos 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 tem um bom desempenho para arquivos CSV contendo milhares de linhas.

Para importações muito grandes (dezenas de milhares de linhas), considere usar as Extensões em Massa do EF Core ou uma instrução SQL BULK INSERT crua para reduzir viagens para o 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, o que é útil para gerar relatórios ou enviar dados para sistemas a jusante:

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.");
Imports IronXL

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)
Dim ws As WorkSheet = 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 locais europeus, chame SaveAsCsv("export.csv", ";") com um argumento delimitador explícito. Você também pode salvar para 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 com todos estes corretamente em um loop customizado de StreamReader requer testes significativos 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 padrão de WorkBook.Load e 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 a partir de um caminho em vez 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 carregamentos XLSX juntamente com CSV não requer mudanças de código adicionais -- 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.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
Redator Técnico

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

Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de Suporte Iron

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