Lendo arquivos CSV em C#: um tutorial

O que é CSV?

CSV é um formato de dados simples, mas pode haver muitas diferenças; pode ser difícil de ler programaticamente em nossos projetos em C# porque usa vários delimitadores para diferenciar entre linhas e colunas de dados. Este artigo mostrará como usar a biblioteca IronXL para ler arquivos CSV.

1. How to read a CSV File in C#

Antes de poder usar o IronXL para ler arquivos CSV em MVC, ASP.NET ou .NET Core, você precisa instalá-lo. Aqui está um passo a passo rápido.

1. No Visual Studio, selecione o menu Projeto
2. Gerenciar Pacotes NuGet
3. Pesquisar por IronXl.Excel
4. Instalar

Pesquisar por IronXL no Gerenciador de Pacotes NuGet no Visual Studio

Quando você precisa ler arquivos CSV em C#, o IronXL é a ferramenta perfeita. Você pode ler um arquivo CSV com vírgulas, ou qualquer outro delimitador, conforme visto nos segmentos de código abaixo.

// Load a CSV file and interpret it as an Excel-like workbook
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");

// Access the default worksheet in the workbook
WorkSheet ws = workbook.DefaultWorkSheet;

// Save the workbook to a new Excel file
workbook.SaveAs("Csv_To_Excel.xlsx");

// Load a CSV file and interpret it as an Excel-like workbook
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");

// Access the default worksheet in the workbook
WorkSheet ws = workbook.DefaultWorkSheet;

// Save the workbook to a new Excel file
workbook.SaveAs("Csv_To_Excel.xlsx");

Saída:

Arquivo CSV de saída com delimitador de vírgula

Explicação do código:

Um objeto WorkBook é criado. O método LoadCSV para o objeto WorkBook é então usado para especificar o nome do CSV, seu formato e quais delimitadores são usados no arquivo CSV que está sendo lido. Neste caso, vírgulas são usadas como delimitadores.

Um objeto WorkSheet é então criado. É aqui que o conteúdo do arquivo CSV será colocado. O arquivo é salvo com um novo nome e formato.

Dados exibidos no Microsoft Excel

2. IronXL para Arquivos Excel

Use IronXL para o seu projeto como uma maneira simplificada de trabalhar com formatos de arquivo Excel em C#. Você pode instalar o IronXL via download direto. Alternativamente, você pode usar NuGet Install para o Visual Studio. O software é gratuito para desenvolvimento.

dotnet add package IronXl.Excel

3. Carregar WorkBook e Acessar WorkSheet

WorkBook é a classe do IronXL cujo objeto fornece acesso total ao arquivo Excel e todas as suas funções. Por exemplo, se quisermos acessar um arquivo Excel, usaríamos o código:

// Load the Excel file
WorkBook wb = WorkBook.Load("sample.xlsx"); // Excel file path

// Load the Excel file
WorkBook wb = WorkBook.Load("sample.xlsx"); // Excel file path

Para acessar a planilha específica de um arquivo Excel, o IronXL fornece a classe WorkSheet.

// Access a specific worksheet by name
WorkSheet ws = wb.GetWorkSheet("Sheet1"); // by sheet name

// Access a specific worksheet by name
WorkSheet ws = wb.GetWorkSheet("Sheet1"); // by sheet name

Uma vez que você obteve a planilha do Excel ws, você pode extrair qualquer tipo de dado dela e executar todas as funções do Excel nela. Os dados podem ser acessados da planilha do Excel ws através deste processo:

using IronXL;

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Iterate through a range of cells and display their values
        foreach (var cell in ws["A2:A10"])
        {
            Console.WriteLine("Value is: {0}", cell.Text);
        }
        Console.ReadKey();
    }
}

using IronXL;

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Iterate through a range of cells and display their values
        foreach (var cell in ws["A2:A10"])
        {
            Console.WriteLine("Value is: {0}", cell.Text);
        }
        Console.ReadKey();
    }
}

4. Lendo uma Planilha do Excel como DataTable

Usando o IronXL, é muito fácil operar com um Excel WorkSheet como um DataTable.

DataTable dt = ws.ToDataTable(true); // Converts the worksheet to a DataTable, using the first row as column names

DataTable dt = ws.ToDataTable(true); // Converts the worksheet to a DataTable, using the first row as column names

Use os seguintes namespaces:

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Escreva o seguinte código:

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel file Name
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse worksheet into datatable
        DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable

        // Iterate through rows and columns to display their values
        foreach (DataRow row in dt.Rows) // Access rows
        {
            for (int i = 0; i < dt.Columns.Count; i++) // Access columns of corresponding row
            {
                Console.Write(row[i] + "  ");
            }
            Console.WriteLine();
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel file Name
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse worksheet into datatable
        DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable

        // Iterate through rows and columns to display their values
        foreach (DataRow row in dt.Rows) // Access rows
        {
            for (int i = 0; i < dt.Columns.Count; i++) // Access columns of corresponding row
            {
                Console.Write(row[i] + "  ");
            }
            Console.WriteLine();
        }
    }
}

Saída de console de um objeto DataTable

Neste exemplo, veremos como usar um arquivo Excel como um DataSet.

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and convert it to a DataSet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        DataSet ds = wb.ToDataSet(); // Parse WorkBook wb into DataSet

        // Iterate through tables to display their names
        foreach (DataTable dt in ds.Tables)
        {
            Console.WriteLine(dt.TableName);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and convert it to a DataSet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        DataSet ds = wb.ToDataSet(); // Parse WorkBook wb into DataSet

        // Iterate through tables to display their names
        foreach (DataTable dt in ds.Tables)
        {
            Console.WriteLine(dt.TableName);
        }
    }
}

Acessar nome da planilha a partir do objeto DataSet

Vamos ver outro exemplo de como acessar o valor de cada célula em todas as planilhas do Excel. Aqui, podemos acessar o valor de cada célula de cada Planilha em um arquivo Excel.

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and convert it to a DataSet
        WorkBook wb = WorkBook.Load("Weather.xlsx");
        DataSet ds = wb.ToDataSet(); // Treat the complete Excel file as DataSet

        // Iterate through each table and its rows and columns
        foreach (DataTable dt in ds.Tables) // Treat Excel WorkSheet as DataTable
        {
            foreach (DataRow row in dt.Rows) // Corresponding Sheet's Rows
            {
                for (int i = 0; i < dt.Columns.Count; i++) // Sheet columns of corresponding row
                {
                    Console.Write(row[i] + "  ");
                }
                Console.WriteLine();
            }
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and convert it to a DataSet
        WorkBook wb = WorkBook.Load("Weather.xlsx");
        DataSet ds = wb.ToDataSet(); // Treat the complete Excel file as DataSet

        // Iterate through each table and its rows and columns
        foreach (DataTable dt in ds.Tables) // Treat Excel WorkSheet as DataTable
        {
            foreach (DataRow row in dt.Rows) // Corresponding Sheet's Rows
            {
                for (int i = 0; i < dt.Columns.Count; i++) // Sheet columns of corresponding row
                {
                    Console.Write(row[i] + "  ");
                }
                Console.WriteLine();
            }
        }
    }
}

Saída de console do objeto Dataset

5. Análise de CSV em C# .NET

Os arquivos CSV têm uma abundância de problemas com a forma como as quebras de linha são tratadas nos campos, ou como os campos podem estar contidos em aspas que bloqueiam completamente uma abordagem simples de divisão de string. Recentemente descobri as seguintes opções ao converter CSV em C# .NET especificando um delimitador personalizável em vez de usar string.Split(',') para separar os valores em uma vírgula.

6. Lendo Dados CSV em Registros C

Este processo avança o leitor pelo próximo arquivo. Nós lemos os arquivos de campo CSV em TryGetField. Usamos a função de leitura em campos de campo dos arquivos CSV como campos de registro.

// Load a CSV file, specify the file format and delimiter
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");

// Access the default worksheet from the workbook
WorkSheet ws = workbook.DefaultWorkSheet;

// Convert worksheet to DataTable    
DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable

// Iterate through rows and columns to display their values
foreach (DataRow row in dt.Rows) // Access rows
{
    for (int i = 0; i < dt.Columns.Count; i++) // Access columns of corresponding row
    {
        Console.Write(row[i] + "  ");
    }
    Console.WriteLine();
}

// Load a CSV file, specify the file format and delimiter
WorkBook workbook = WorkBook.LoadCSV("Weather.csv", fileFormat: ExcelFileFormat.XLSX, ListDelimiter: ",");

// Access the default worksheet from the workbook
WorkSheet ws = workbook.DefaultWorkSheet;

// Convert worksheet to DataTable    
DataTable dt = ws.ToDataTable(true); // Parse Sheet1 of sample.xlsx file into DataTable

// Iterate through rows and columns to display their values
foreach (DataRow row in dt.Rows) // Access rows
{
    for (int i = 0; i < dt.Columns.Count; i++) // Access columns of corresponding row
    {
        Console.Write(row[i] + "  ");
    }
    Console.WriteLine();
}

Saída de console de DataTable

7. Obtendo Dados de Arquivos Excel

Agora podemos facilmente obter qualquer tipo de dado, usando uma variedade de métodos, da planilha Excel aberta WorkSheet. No exemplo a seguir, podemos ver como acessar o valor de uma célula específica e analisá-lo para string:

// Access the data by cell addressing
string val = ws["Cell Address"].ToString();

// Access the data by cell addressing
string val = ws["Cell Address"].ToString();

Na linha acima, ws é o WorkSheet, que foi definido no Passo 2. Esta é 'a abordagem simples', mas você pode ler mais e ver exemplos diferentes de como acessar dados de arquivos Excel.

8. How to Parse Excel Files in C#

Ao usar Planilhas Excel para construir aplicações, muitas vezes analisamos os resultados com base nos dados e precisamos analisar os dados dos arquivos Excel dentro do C# no formato requerido para obter os resultados corretos. Analisar dados em diferentes formatos é fácil no ambiente C# com o uso do IronXL; veja os passos abaixo.

using IronXL;

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse Excel cell value into string
        string str_val = ws["B3"].Value.ToString();

        // Parse Excel cell value into Int32
        Int32 int32_val = ws["G3"].Int32Value;

        // Parse Excel cell value into Decimal
        decimal decimal_val = ws["E5"].DecimalValue;

        // Output parsed values to the console
        Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
        Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
        Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);

        Console.ReadKey();
    }
}

using IronXL;

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse Excel cell value into string
        string str_val = ws["B3"].Value.ToString();

        // Parse Excel cell value into Int32
        Int32 int32_val = ws["G3"].Int32Value;

        // Parse Excel cell value into Decimal
        decimal decimal_val = ws["E5"].DecimalValue;

        // Output parsed values to the console
        Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
        Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
        Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);

        Console.ReadKey();
    }
}

9. Como Analisar Dados do Excel em Valores Numéricos e Booleanos

Agora passamos para como analisar dados de arquivos Excel. Primeiro, analisamos como lidar com dados numéricos do Excel e, em seguida, como analisá-los no formato exigido.

Tabela de resumo para cada tipo de dado

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse Excel cell value into string
        string str_val = ws["B3"].Value.ToString();

        // Parse Excel cell value into Int32
        Int32 int32_val = ws["G3"].Int32Value;

        // Parse Excel cell value into Decimal
        decimal decimal_val = ws["E5"].DecimalValue;

        // Output parsed values to the console
        Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
        Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
        Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);

        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse Excel cell value into string
        string str_val = ws["B3"].Value.ToString();

        // Parse Excel cell value into Int32
        Int32 int32_val = ws["G3"].Int32Value;

        // Parse Excel cell value into Decimal
        decimal decimal_val = ws["E5"].DecimalValue;

        // Output parsed values to the console
        Console.WriteLine("Parse B3 Cell Value into String: {0}", str_val);
        Console.WriteLine("Parse G3 Cell Value into Int32: {0}", int32_val);
        Console.WriteLine("Parse E5 Cell Value into decimal: {0}", decimal_val);

        Console.ReadKey();
    }
}

Este código exibirá a seguinte saída:

Saída do console com o tipo de dado correto

E podemos ver aqui os valores do arquivo Excel sample.xlsx:

Exibindo o tipo de dado correto no Excel

Para analisar dados de arquivo Excel em tipo de dado Booleano, o IronXL fornece a função BoolValue. Ele pode ser usado da seguinte forma:

// Access a cell value as a boolean
bool Val = ws["Cell Address"].BoolValue;

// Access a cell value as a boolean
bool Val = ws["Cell Address"].BoolValue;

10. Como Analisar Arquivos Excel em Coleções C

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Convert a range into an array
        var array = ws["B6:F6"].ToArray();

        // Get the count of items in the array
        int item = array.Count();

        // Get the first item as a string
        string total_items = array[0].Value.ToString();

        // Output information about the array to the console
        Console.WriteLine("First item in the array: {0}", item);
        Console.WriteLine("Total items from B6 to F6: {0}", total_items);

        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Convert a range into an array
        var array = ws["B6:F6"].ToArray();

        // Get the count of items in the array
        int item = array.Count();

        // Get the first item as a string
        string total_items = array[0].Value.ToString();

        // Output information about the array to the console
        Console.WriteLine("First item in the array: {0}", item);
        Console.WriteLine("Total items from B6 to F6: {0}", total_items);

        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse Sheet1 of sample.xlsx file into DataTable
        // Setting 'true' makes the first row in Excel as the column names in DataTable
        DataTable dt = ws.ToDataTable(true);
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Parse Sheet1 of sample.xlsx file into DataTable
        // Setting 'true' makes the first row in Excel as the column names in DataTable
        DataTable dt = ws.ToDataTable(true);
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load an entire workbook into a DataSet
        WorkBook wb = WorkBook.Load("sample.xlsx");

        // Convert workbook to DataSet
        DataSet ds = wb.ToDataSet();

        // We can also get a DataTable from the DataSet which corresponds to a WorkSheet
        DataTable dt = ds.Tables[0];
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load an entire workbook into a DataSet
        WorkBook wb = WorkBook.Load("sample.xlsx");

        // Convert workbook to DataSet
        DataSet ds = wb.ToDataSet();

        // We can also get a DataTable from the DataSet which corresponds to a WorkSheet
        DataTable dt = ds.Tables[0];
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Get specified range values by loop
        foreach (var item in ws["B3:B8"])
        {
            Console.WriteLine("Value is: {0}", item);
        }
        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Get specified range values by loop
        foreach (var item in ws["B3:B8"])
        {
            Console.WriteLine("Value is: {0}", item);
        }
        Console.ReadKey();
    }
}

11. Como Ler Dados Booleanos em um Arquivo Excel

No desenvolvimento de aplicações, precisamos tomar decisões com base no tipo de dado Booleano em arquivos Excel.

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Traverse a range and output boolean values
        foreach (var item in ws["G1:G10"])
        {
            Console.WriteLine("Condition is: {0}", item.BoolValue);
        }
        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("sample.xlsx");
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Traverse a range and output boolean values
        foreach (var item in ws["G1:G10"])
        {
            Console.WriteLine("Condition is: {0}", item.BoolValue);
        }
        Console.ReadKey();
    }
}

A partir disso, obtemos a saída:

Saída do console ao obter Dados Booleanos

E o arquivo Excel sample.xlsx com valores de C1 a C10:

Amostra do Excel para comparar com a saída do Console

12. Como Ler uma Planilha Excel Completa

É simples ler uma planilha Excel completa usando índices de linhas e colunas. Para este propósito, usamos dois loops: um para percorrer todas as linhas e o segundo para percorrer todas as colunas de uma linha específica. Então podemos facilmente obter todos os valores das células dentro de toda a Planilha Excel.

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel File Name
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Traverse all rows of Excel WorkSheet
        for (int i = 0; i < ws.Rows.Count(); i++)
        {
            // Traverse all columns of specific Row
            for (int j = 0; j < ws.Columns.Count(); j++)
            {
                // Get the values
                string val = ws.Rows[i].Columns[j].Value.ToString();
                Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j, val);
            }
        }
        Console.ReadKey();
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load the workbook and access a specific worksheet
        WorkBook wb = WorkBook.Load("Weather.xlsx"); // Your Excel File Name
        WorkSheet ws = wb.GetWorkSheet("Sheet1");

        // Traverse all rows of Excel WorkSheet
        for (int i = 0; i < ws.Rows.Count(); i++)
        {
            // Traverse all columns of specific Row
            for (int j = 0; j < ws.Columns.Count(); j++)
            {
                // Get the values
                string val = ws.Rows[i].Columns[j].Value.ToString();
                Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j, val);
            }
        }
        Console.ReadKey();
    }
}

Saída do console ao ler todos os valores

13. Como Ler Arquivos Excel sem Interop

IronXL é uma Biblioteca Excel para C# e .NET que permite aos desenvolvedores ler e editar dados do Excel em Documentos XLS e XLSX sem usar Microsoft.Office.Interop.Excel.

A API permite criar, ler, manipular, salvar e exportar arquivos Excel de maneira intuitiva para:

1. .NET Framework 4.5+
2. .NET Core 2+
3. .NET Standard
4. Xamarin
5. Windows Mobile
6. Mono
7. & Hospedagem em Nuvem Azure
8. Blazor
9. .NET MAUI

Adicione os seguintes namespaces:

using IronXL;
using System;
using System.Linq;

using IronXL;
using System;
using System.Linq;

Agora escreva o seguinte código dentro da função principal.

class Program
{
    static void Main(string[] args)
    {
        // Load an Excel file and access the first worksheet
        WorkBook workbook = WorkBook.Load("Weather.xlsx");
        WorkSheet sheet = workbook.WorkSheets.First();

        // Select cells easily in Excel notation and return the calculated value
        int cellValue = sheet["A2"].IntValue;

        // Read from ranges of cells elegantly
        foreach (var cell in sheet["A2:A10"])
        {
            Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        // Load an Excel file and access the first worksheet
        WorkBook workbook = WorkBook.Load("Weather.xlsx");
        WorkSheet sheet = workbook.WorkSheets.First();

        // Select cells easily in Excel notation and return the calculated value
        int cellValue = sheet["A2"].IntValue;

        // Read from ranges of cells elegantly
        foreach (var cell in sheet["A2:A10"])
        {
            Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
        }
    }
}

Saída do console de cada célula

IronXL também oferece suporte completo para ASP.NET, MVC, Windows, macOS, Linux, iOS, e desenvolvimento de aplicativos móveis Android.

14. Conclusão e Oferta Especial da Iron XL

Além de analisar CSV em C#, o IronXL converte arquivos CSV para Excel com apenas duas linhas de código!

Usando C# ou VB.NET, é muito fácil usar a API do Excel do IronXL sem a necessidade de Interop. Você pode ler, editar e criar planilhas do Excel ou trabalhar com outros formatos Excel, como XLS/XLSX/CSV/TSV. Com o suporte de vários frameworks, você pode comprar 5 produtos pelo preço de dois. Clique na nossa página de preços para mais informações.

5 produtos da Iron Suite