C# para ler arquivos Excel e exportar dados para DataTable e banco de dados

Os arquivos Excel continuam sendo um formato onipresente para armazenar dados tabulares, tornando crucial a capacidade de ler e extrair informações deles com eficiência. C#, beneficiando-se da extensa funcionalidade do .NET Framework, é capaz de manipulação eficiente de dados. Utilizando C# para ler arquivos Excel e gravar seus dados em bancos de dados e tabelas de dados, ou usar os dados para outros fins, é uma excelente solução para desenvolvedores manipularem dados do Excel.

Este artigo se concentra em como usar C# para ler arquivos Excel. Inclui as seguintes partes:

• Vantagens e API para leitura de arquivos Excel em C#
• Introdução à leitura de arquivos do Excel usando C#
• Leia arquivos Excel em texto com código C#
• Script em C# para leitura de arquivos Excel em DataTable
• Código C# para ler arquivos Excel e inserir em bancos de dados
• Obtenha uma licença gratuita para a API

Vantagens e API para leitura de arquivos Excel em C#

Aproveitar C# para leitura de arquivos Excel traz as seguintes vantagens:

• Automação e escalabilidade: C#, com .NET Framework e APIs, permite automatizar tarefas de leitura de arquivos Excel, possibilitando o processamento eficiente de grandes volumes de dados. Os desenvolvedores podem criar scripts ou aplicativos que podem lidar com processamento em lote, tarefas agendadas ou operações de importação/exportação de dados, economizando tempo e esforço.
• Flexibilidade e personalização: O .NET Framework junto com as APIs fornecem um alto nível de flexibilidade e personalização ao trabalhar com arquivos Excel. Os desenvolvedores podem definir lógica personalizada para extrair e transformar dados, aplicar formatação específica ou realizar cálculos. Isso permite adaptar o processo de leitura a requisitos ou regras de negócios específicos.

No entanto, ler arquivos Excel apenas com C# e .NET Framework pode ser uma tarefa desafiadora. A biblioteca nativa fornecida pelo .NET Framework para manipulação de arquivos Excel é Microsoft.Office.Interop.Excel. Porém, a utilização desta biblioteca requer a instalação do MS Excel, e a lógica do código para processamento de arquivos Excel com ela é extremamente complexa, dificultando a leitura eficiente de arquivos Excel. Como resultado, os desenvolvedores preferem bibliotecas de terceiros para trabalhar com arquivos Excel de forma eficiente e conveniente.

Spire.XLS for .NET é uma API C# profissional para processamento de arquivos Excel. Possui amplo suporte a formatos e manipulação eficiente de dados do Excel, incluindo leitura de arquivos Excel e gravação de dados em banco de dados, tabela de dados, etc. baixe Spire.XLS for .NET do site oficial ou instale-o através do NuGet.

PM> Install-Package Spire.XLS

Introdução à leitura de arquivos do Excel em C#

O Spire.XLS for .NET permite que os desenvolvedores criar, ler, escrever e manipular arquivos Excel em seus aplicativos .NET com código simples.

Para trabalhar efetivamente com o Spire.XLS, você interagirá com várias classes, propriedades e métodos. Aqui está uma tabela resumindo alguns dos principais, juntamente com suas descrições:

O fluxo de trabalho típico de uso do Spire.XLS for .NET para ler arquivos Excel envolve estas etapas:

1. Carregue o arquivo Excel usando o método Workbook.LoadFromFile().
2. Acesse planilhas através da propriedade Workbook.Worksheets[].
3. Acesse as células através da propriedade Worksheet.Range[].
4. Acesse o texto exibido nas células através da propriedade CellRange.Text ou acesse o valor das células (texto, números, fórmulas, etc.) através da propriedade CellRange.Value
5. Recupere os dados, grave-os em arquivos de texto, bancos de dados, etc., ou execute outras operações desejadas.
6. Para exportar valores de células para uma tabela de dados, os desenvolvedores podem usar diretamente o método Worksheet.ExportDataTable() e ele retornará um objeto DataTable.
7. Alternativamente, os desenvolvedores também podem converter diretamente a pasta de trabalho usando o método Workbook.SaveToFile() para qualquer formato compatível.

Resumindo, esta API fornece classes e propriedades que permitem aos desenvolvedores carregar arquivos Excel e ler seu conteúdo usando código direto, tornando a leitura de arquivos Excel com C# eficiente e simples. Além disso, permite acesso direto conversão de pastas de trabalho e planilhas para PDF, HTML, XML e outros formatos de arquivo.

C# para ler arquivos Excel em texto

Etapas para ler arquivos Excel e gravar dados em arquivos de texto com C#:

1. Importe os namespaces necessários.
2. Crie um objeto da classe Workbook e carregue um arquivo Excel usando o método Workbook.LoadFromFile().
3. Obtenha a primeira planilha por meio da propriedade Workbook.Worksheets[].
4. Crie um arquivo de texto para escrever os dados na planilha.
5. Itere pelas linhas e colunas alocadas, acesse as células por meio da propriedade Worksheet.Range[] e obtenha o texto exibido de cada célula por meio da propriedade CellRange.Text e grave-o no arquivo de texto.
6. Liberar recursos.

Exemplo de código:

using Spire.Xls;
    using System.IO;
    
    class Program
    {
        static void Main(string[] args)
        {
            // Load the Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("Sample.xlsx");
    
            // Get the first worksheet
            Worksheet worksheet = workbook.Worksheets[0];
    
            // Create an output text file
            string outputFile = "Output.txt";
            StreamWriter writer = new StreamWriter(outputFile);
    
            // Iterate through the rows and columns of the worksheet and write the data to the text file
            for (int row = 1; row <= worksheet.LastRow; row++)
            {
                for (int col = 1; col <= worksheet.LastColumn; col++)
                {
                    CellRange range = worksheet.Range[row, col];
                    string cellValue = range.Text == null ? string.Empty : range.Text.ToString();
                    writer.Write(cellValue + "\t"); // Separate cell data using a tab character
                }
                writer.WriteLine(); // Write a line break
            }
    
            // Close the writer and save the text file
            writer.Close();
    
            // Release resources
            workbook.Dispose();
        }
    }

The reading result:

Código em C Sharp para leitura de arquivos Excel em DataTables

DataTable é um objeto que representa uma tabela de dados no .NET Framework. Ele é usado para armazenar e manipular dados na memória e pode realizar operações como classificação, filtragem, modificação e exportação. Os desenvolvedores podem usar C# para ler dados de arquivos Excel e gravá-los no objeto DataTable, facilitando assim o processamento adicional dos dados. A seguir estão as etapas:

1. Importe os namespaces necessários.
2. Crie um objeto da classe Workbook e carregue um arquivo Excel usando o método Workbook.LoadFromFile().
3. Obtenha a primeira planilha por meio da propriedade Workbook.Worksheets[].
4. Exporte os dados da planilha para um objeto usando o método Worksheet.ExportDataTable().
5. Liberar recursos.

using Spire.Xls;
    using System.Data;
    
    namespace ExcelToAccess
    {
        class Program
        {
            static void Main(string[] args)
            {
                // Create an object of Workbook class
                Workbook workbook = new Workbook();
    
                // Load an Excel file
                workbook.LoadFromFile("Sample.xlsx");
    
                // Get the first worksheet
                Worksheet worksheet = workbook.Worksheets[0];
    
                // Export the data from the worksheet to a DataTable object
                DataTable dataTable = worksheet.ExportDataTable();
    
                workbook.Dispose();
            }
        }
    }

Install-Package System.Data.OleDb

using Spire.Xls;
    using System.Data.OleDb;
    
    class Program
    {
        static void Main(string[] args)
        {
            // Set the Excel file path
            string excelFilePath = "Sample.xlsx";
            // Set the Access database file path
            string accessDbFilePath = "Sample.accdb";
    
            // Load the Excel file
            Workbook workbook = new Workbook();
            workbook.LoadFromFile(excelFilePath);
    
            // Get the first worksheet
            Worksheet worksheet = workbook.Worksheets[0];
    
            // Use the worksheet name as the table name
            string tableName = worksheet.Name;
    
            // Get the first row as column names
            CellRange headerRange = worksheet.Rows[0];
            string[] columnNames = new string[headerRange.Columns.Length];
            for (int i = 0; i < headerRange.Columns.Length; i++)
            {
                columnNames[i] = headerRange.Columns[i].Value.Replace(" ", "_");
            }
    
            // Connect to the Access database
            string connectionString = $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={accessDbFilePath};Persist Security Info=False;";
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                connection.Open();
    
                // Create the table
                string createTableQuery = $"CREATE TABLE [{tableName}] ({string.Join(", ", columnNames.Select(c => $"[{c}] Memo"))})";
                using (OleDbCommand createTableCommand = new OleDbCommand(createTableQuery, connection))
                {
                    createTableCommand.ExecuteNonQuery();
                }
    
                // Insert data
                string insertQuery = $"INSERT INTO [{tableName}] ({string.Join(", ", columnNames.Select(c => $"[{c}]"))}) VALUES ({string.Join(", ", columnNames.Select(c => $"@{c}"))})";
                using (OleDbCommand insertCommand = new OleDbCommand(insertQuery, connection))
                {
                    foreach (CellRange row in worksheet.Rows.Cast().Skip(1))
                    {
                        for (int i = 0; i < row.Columns.Length; i++)
                        {
                            insertCommand.Parameters.AddWithValue($"@{columnNames[i]}", row.Columns[i].Value);
                        }
    
                        insertCommand.ExecuteNonQuery();
                        insertCommand.Parameters.Clear();
                    }
                }
    
                connection.Close();
                workbook.Dispose();
            }
        }
    }