Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. Tutorial de leitura de arquivo CSV em C#
USANDO O IRONXL
Como ler arquivos CSV em C# usando o IronXL

Lendo arquivos CSV em C#: um tutorial

Jordi Bardia
Jordi Bardia
Atualizado:

Trabalhar com vários formatos de Excel frequentemente requer leitura de dados e depois reconfiguração programática. Neste artigo, vamos aprender a ler um arquivo CSV e analisar dados de uma planilha do Excel em C# usando o IronXL, a ferramenta perfeita para o trabalho.

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

Leitura de arquivos CSV em C#: um Tutorial, Figura 1: Pesquise IronXL no Gerenciador de Pacotes NuGet no Visual Studio 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");
' Load a CSV file and interpret it as an Excel-like workbook
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")

' Access the default worksheet in the workbook
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Save the workbook to a new Excel file
workbook.SaveAs("Csv_To_Excel.xlsx")
$vbLabelText   $csharpLabel

Saída:

Leitura de arquivos CSV em C#: um Tutorial, Figura 2: Saída do arquivo CSV com delimitador de vírgula 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.

Leitura de arquivos CSV em C#: um Tutorial, Figura 3: Dados exibidos no Microsoft Excel 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
' Load the Excel file
Dim wb As WorkBook = WorkBook.Load("sample.xlsx") ' Excel file path
$vbLabelText   $csharpLabel

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
' Access a specific worksheet by name
Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1") ' by sheet name
$vbLabelText   $csharpLabel

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();
    }
}
Imports IronXL

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Iterate through a range of cells and display their values
		For Each cell In ws("A2:A10")
			Console.WriteLine("Value is: {0}", cell.Text)
		Next cell
		Console.ReadKey()
	End Sub
End Class
$vbLabelText   $csharpLabel

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
Dim dt As DataTable = ws.ToDataTable(True) ' Converts the worksheet to a DataTable, using the first row as column names
$vbLabelText   $csharpLabel

Use os seguintes namespaces:

using IronXL;
using System.Data;
using IronXL;
using System.Data;
Imports IronXL
Imports System.Data
$vbLabelText   $csharpLabel

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();
        }
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' Your Excel file Name
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Parse worksheet into datatable
		Dim dt As DataTable = ws.ToDataTable(True) ' Parse Sheet1 of sample.xlsx file into DataTable

		' Iterate through rows and columns to display their values
		For Each row As DataRow In dt.Rows ' Access rows
			For i As Integer = 0 To dt.Columns.Count - 1 ' Access columns of corresponding row
				Console.Write(row(i) & "  ")
			Next i
			Console.WriteLine()
		Next row
	End Sub
End Class
$vbLabelText   $csharpLabel

Leitura de arquivos CSV em C#: um Tutorial, Figura 4: Saída do console de um objeto DataTable 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);
        }
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and convert it to a DataSet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ds As DataSet = wb.ToDataSet() ' Parse WorkBook wb into DataSet

		' Iterate through tables to display their names
		For Each dt As DataTable In ds.Tables
			Console.WriteLine(dt.TableName)
		Next dt
	End Sub
End Class
$vbLabelText   $csharpLabel

Leitura de arquivos CSV em C#: um Tutorial, Figura 5: Acessar nome da folha a partir do objeto DataSet 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();
            }
        }
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and convert it to a DataSet
		Dim wb As WorkBook = WorkBook.Load("Weather.xlsx")
		Dim ds As DataSet = wb.ToDataSet() ' Treat the complete Excel file as DataSet

		' Iterate through each table and its rows and columns
		For Each dt As DataTable In ds.Tables ' Treat Excel WorkSheet as DataTable
			For Each row As DataRow In dt.Rows ' Corresponding Sheet's Rows
				For i As Integer = 0 To dt.Columns.Count - 1 ' Sheet columns of corresponding row
					Console.Write(row(i) & "  ")
				Next i
				Console.WriteLine()
			Next row
		Next dt
	End Sub
End Class
$vbLabelText   $csharpLabel

Leitura de arquivos CSV em C#: um Tutorial, Figura 6: Saída do console do objeto Dataset 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();
}
' Load a CSV file, specify the file format and delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("Weather.csv", fileFormat:= ExcelFileFormat.XLSX, ListDelimiter:= ",")

' Access the default worksheet from the workbook
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Convert worksheet to DataTable    
Dim dt As DataTable = ws.ToDataTable(True) ' Parse Sheet1 of sample.xlsx file into DataTable

' Iterate through rows and columns to display their values
For Each row As DataRow In dt.Rows ' Access rows
	For i As Integer = 0 To dt.Columns.Count - 1 ' Access columns of corresponding row
		Console.Write(row(i) & "  ")
	Next i
	Console.WriteLine()
Next row
$vbLabelText   $csharpLabel

Leitura de arquivos CSV em C#: um Tutorial, Figura 7: Saída do console do DataTable 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();
' Access the data by cell addressing
Dim val As String = ws("Cell Address").ToString()
$vbLabelText   $csharpLabel

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();
    }
}
Imports IronXL

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Parse Excel cell value into string
		Dim str_val As String = ws("B3").Value.ToString()

		' Parse Excel cell value into Int32
		Dim int32_val As Int32 = ws("G3").Int32Value

		' Parse Excel cell value into Decimal
		Dim decimal_val As Decimal = 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()
	End Sub
End Class
$vbLabelText   $csharpLabel

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.

Leitura de arquivos CSV em C#: um Tutorial, Figura 8: Tabela resumo para cada tipo de dado 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();
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Parse Excel cell value into string
		Dim str_val As String = ws("B3").Value.ToString()

		' Parse Excel cell value into Int32
		Dim int32_val As Int32 = ws("G3").Int32Value

		' Parse Excel cell value into Decimal
		Dim decimal_val As Decimal = 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()
	End Sub
End Class
$vbLabelText   $csharpLabel

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

Leitura de arquivos CSV em C#: um Tutorial, Figura 9: Saída do console com tipo de dado correto Saída do console com o tipo de dado correto

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

Leitura de arquivos CSV em C#: um Tutorial, Figura 10: Exibir tipo de dado correto no Excel 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;
' Access a cell value as a boolean
Dim Val As Boolean = ws("Cell Address").BoolValue
$vbLabelText   $csharpLabel

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();
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Convert a range into an array
		Dim array = ws("B6:F6").ToArray()

		' Get the count of items in the array
		Dim item As Integer = array.Count()

		' Get the first item as a string
		Dim total_items As String = 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()
	End Sub
End Class
$vbLabelText   $csharpLabel

10.1 Como Analisar uma WorkSheet do Excel em um DataTable

Uma excelente característica do IronXL é que podemos facilmente converter uma WorkSheet específica do Excel em um DataTable. Para este propósito, podemos usar a função .ToDataTable() do IronXL da seguinte forma:

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);
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ws As WorkSheet = 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
		Dim dt As DataTable = ws.ToDataTable(True)
	End Sub
End Class
$vbLabelText   $csharpLabel

10.2 Como Analisar um Arquivo Excel em um DataSet

Se quisermos analisar um arquivo Excel completo em um DataSet, então, para este propósito, podemos usar a função .ToDataSet() no IronXL.

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];
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load an entire workbook into a DataSet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")

		' Convert workbook to DataSet
		Dim ds As DataSet = wb.ToDataSet()

		' We can also get a DataTable from the DataSet which corresponds to a WorkSheet
		Dim dt As DataTable = ds.Tables(0)
	End Sub
End Class
$vbLabelText   $csharpLabel

10.3 Lendo Dados do Excel dentro de um Intervalo Específico

O IronXL fornece um método inteligente para ler dados de arquivos Excel dentro de um intervalo específico. O intervalo pode ser aplicado tanto a linhas quanto a colunas.

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();
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Get specified range values by loop
		For Each item In ws("B3:B8")
			Console.WriteLine("Value is: {0}", item)
		Next item
		Console.ReadKey()
	End Sub
End Class
$vbLabelText   $csharpLabel

O código acima exibe a seguinte saída:

Leitura de arquivos CSV em C#: um Tutorial, Figura 11: Saída do console para acessar todos os valores no intervalo B3:B8 Saída do console para acessar todos os valores no intervalo B3:B8

E produz os valores do arquivo Excel sample.xlsx:

Leitura de arquivos CSV em C#: um Tutorial, Figura 12: Exibição de dados do sample.xlsx Exibição de dados de sample.xlsx

Além disso, o IronXL é também compatível com muitos métodos do Excel para interagir com células, incluindo estilo e borda, funções matemáticas, formatação condicional ou criação de gráficos a partir de dados disponíveis.

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();
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("sample.xlsx")
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Traverse a range and output boolean values
		For Each item In ws("G1:G10")
			Console.WriteLine("Condition is: {0}", item.BoolValue)
		Next item
		Console.ReadKey()
	End Sub
End Class
$vbLabelText   $csharpLabel

A partir disso, obtemos a saída:

Leitura de arquivos CSV em C#: um Tutorial, Figura 13: Saída do console ao obter Dados Booleanos Saída do console ao obter Dados Booleanos

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

Leitura de arquivos CSV em C#: um Tutorial, Figura 14: Exemplar do Excel para comparar com a saída do console 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();
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load the workbook and access a specific worksheet
		Dim wb As WorkBook = WorkBook.Load("Weather.xlsx") ' Your Excel File Name
		Dim ws As WorkSheet = wb.GetWorkSheet("Sheet1")

		' Traverse all rows of Excel WorkSheet
		For i As Integer = 0 To ws.Rows.Count() - 1
			' Traverse all columns of specific Row
			For j As Integer = 0 To ws.Columns.Count() - 1
				' Get the values
				Dim val As String = ws.Rows(i).Columns(j).Value.ToString()
				Console.WriteLine("Value of Row {0} and Column {1} is: {2}", i, j, val)
			Next j
		Next i
		Console.ReadKey()
	End Sub
End Class
$vbLabelText   $csharpLabel

Leitura de arquivos CSV em C#: um Tutorial, Figura 15: Saída do console a partir da leitura de todos os valores 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;
Imports IronXL
Imports System
Imports System.Linq
$vbLabelText   $csharpLabel

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);
        }
    }
}
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Load an Excel file and access the first worksheet
		Dim workbook As WorkBook = WorkBook.Load("Weather.xlsx")
		Dim sheet As WorkSheet = workbook.WorkSheets.First()

		' Select cells easily in Excel notation and return the calculated value
		Dim cellValue As Integer = sheet("A2").IntValue

		' Read from ranges of cells elegantly
		For Each cell In sheet("A2:A10")
			Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text)
		Next cell
	End Sub
End Class
$vbLabelText   $csharpLabel

Leitura de arquivos CSV em C#: um Tutorial, Figura 16: Saída do console de cada célula 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.

Leitura de arquivos CSV em C#: um Tutorial, Figura 17: 5 produtos da Iron Suite 5 produtos da Iron Suite

Perguntas frequentes

Como posso ler um arquivo CSV em C#?

Para ler um arquivo CSV em C#, você pode usar o IronXL instalando a biblioteca via NuGet no Visual Studio. Após a instalação, use o método WorkBook.LoadCSV para carregar e interpretar o arquivo CSV.

O que é CSV e por que pode ser complexo manipulá-lo em C#?

O CSV é um formato de dados simples, mas pode ser complexo de manipular devido à variedade de delimitadores. O IronXL simplifica a leitura e a análise de arquivos CSV em projetos C#.

Posso converter arquivos CSV para Excel usando C#?

Sim, o IronXL permite converter arquivos CSV para formatos do Excel, como XLS ou XLSX, carregando o CSV e salvando-o usando o método WorkBook.SaveAs .

Como faço para instalar o IronXL em um projeto C#?

Você pode instalar o IronXL usando o Gerenciador de Pacotes NuGet no Visual Studio. Procure por 'IronXL.Excel' e adicione-o ao seu projeto para começar a trabalhar com arquivos do Excel.

É possível analisar dados de células do Excel e convertê-los em tipos de dados específicos usando C#?

Sim, com o IronXL, você pode analisar os valores das células do Excel e convertê-los em tipos de dados específicos, como numéricos e booleanos, usando métodos como Int32Value e BoolValue .

Como posso ler dados de um intervalo específico de células em uma planilha do Excel usando C#?

Usando o IronXL, você pode ler dados de células específicas iterando pelo intervalo com um loop e acessando os valores das células por meio dos recursos de indexação do IronXL.

Como faço para converter uma planilha do Excel em um DataTable em C#?

Você pode converter uma planilha do Excel em um DataTable usando o método WorkSheet.ToDataTable do IronXL, que analisa a planilha de forma eficiente e a transforma em um objeto DataTable para manipulação de dados.

Preciso do Microsoft Office Interop para ler arquivos do Excel programaticamente?

Não, com o IronXL, você pode ler e manipular arquivos do Excel sem precisar do Microsoft Office Interop, tornando-o uma solução independente e eficiente.

Quais são as vantagens de usar o IronXL para lidar com arquivos Excel e CSV?

O IronXL oferece fácil instalação, não depende do Interop, suporta múltiplos formatos do Excel e é compatível com várias estruturas .NET, aumentando a produtividade no processamento de arquivos CSV e Excel.

Como faço para ler uma planilha completa do Excel em C#?

Para ler uma planilha completa do Excel usando o IronXL, você pode usar loops aninhados para percorrer todas as linhas e colunas e extrair os valores das células usando os métodos do IronXL.

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

Obtenha o seu GRÁTIS

Obtenha uma chave de avaliação de 30 dias instantaneamente.

Obtenha uma chave de avaliação de 15 dias instantaneamente.

Greencheck In Yellowcircle related to Lendo arquivos CSV em C#: um tutorial
O formulário de inscrição para o teste foi enviado.
Com sucesso.

Sua chave de avaliação deve estar no e-mail.
Caso contrário, entre em contato.
support@ironsoftware.com

bullet_checkedNão é necessário cartão de crédito nem criação de conta.
teste de balaTeste em produção
sem marcas d'água
calendário de marcadores30 dias completos
produto funcional
suporte_de_balasSuporte técnico 24 horas por dia, 5 dias por semana.
apoio durante o julgamento
Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

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