Como importar arquivos do Excel para o SQL Server em C#
Em muitos contextos de negócios diferentes, importar dados do Excel para o SQL Server é uma necessidade típica. Ler dados de um arquivo do Excel e inseri-los em um banco de dados SQL Server são as tarefas envolvidas nesta atividade. Embora o assistente de exportação seja frequentemente utilizado, o IronXL oferece uma abordagem mais programática e flexível para manipulação de dados. O IronXL é uma poderosa biblioteca C# que pode importar dados do Excel a partir de arquivos; portanto, é possível agilizar essa operação. Para esse fim, este post oferecerá um guia completo sobre como configurar, executar e aprimorar a importação do Excel para o SQL Server usando C#.

How to Import Excel to SQL Server in C
- Configure Seu Ambiente de Desenvolvimento
- Prepare Seu Arquivo Excel
- Conecte-se ao Seu Banco de Dados SQL Server
- Leia Dados dos Arquivos Excel Usando IronXL
- Exporte Dados e Gere um Relatório PDF Usando IronPDF
- Revise o Relatório PDF
O que é IronXL?
O IronXL, às vezes referido como IronXL.Excel, é uma biblioteca C# rica em recursos feita para facilitar o trabalho com arquivos Excel em aplicativos .NET. Esta ferramenta robusta é ideal para aplicativos no lado do servidor, pois permite que os desenvolvedores leiam, criem e editem arquivos Excel sem precisar instalar o Microsoft Excel no computador. Os formatos Excel 2007 e posteriores (.xlsx) e Excel 97–2003 (.xls) são suportados pelo IronXL, proporcionando versatilidade no gerenciamento de várias versões de arquivos Excel. Permite uma significativa manipulação de dados, como a manipulação de planilhas, linhas e colunas, além da inserção, atualização e remoção de dados.
O IronXL também suporta formatação de células e fórmulas do Excel, permitindo a geração programada de planilhas complexas e bem formatadas. Com sua otimização de desempenho e compatibilidade com múltiplas plataformas .NET, incluindo. NET Framework, .NET Core e .NET 5/6, o IronXL garante um manuseio eficaz de grandes conjuntos de dados. É uma opção flexível para desenvolvedores que desejam integrar operações de arquivos Excel em seus aplicativos, seja para atividades simples de importação/exportação de dados ou sistemas de relatórios complexos, graças à sua interface suave com outras estruturas .NET.
Principais características
Leitura e Escrita de Arquivos Excel
Os desenvolvedores podem ler e escrever dados de e para arquivos Excel usando IronXL. É simples criar novos arquivos Excel e editar os que já existem.
Não é Necessária Instalação do Microsoft Excel
O IronXL não requer a instalação do Microsoft Excel no computador que hospeda o aplicativo, ao contrário de algumas outras bibliotecas. Isso o torna perfeito para aplicações no lado do servidor.
Suporte para Vários Formatos Excel
A biblioteca oferece versatilidade no gerenciamento de vários tipos de arquivos Excel, suportando os formatos .xls (Excel 97-2003) e .xlsx (Excel 2007 e posteriores).
Criar um novo projeto do Visual Studio
É simples criar um projeto de console no Visual Studio. No Visual Studio, siga as seguintes ações para criar uma Aplicação Console:
- Abra o Visual Studio: Certifique-se de ter o Visual Studio instalado em seu computador antes de abri-lo.
- Iniciar um Novo Projeto: Escolha
File->New->Project.

- No painel esquerdo da caixa
Create a new project, escolha o seu idioma de programação preferido—por exemplo, C#. - Selecione o modelo
Console AppouConsole App (.NET Core)da lista de modelos de projeto disponíveis. - No campo Nome, dê um nome ao seu projeto.

- Decida um local para salvar o projeto.
- Clique em Criar para iniciar um projeto de aplicação para um Console.

Instalando a Biblioteca IronXL
Instalar a biblioteca IronXL é necessário por causa da próxima atualização. Finalmente, para finalizar o procedimento, abra o Console do Gerenciador de Pacotes NuGet e digite o seguinte comando:
Install-Package IronXL.Excel

Usar o Gerenciador de Pacotes NuGet para procurar o pacote IronXL é outro método. Isso nos permite selecionar qual dos pacotes NuGet vinculados ao IronXL baixar.

Importar Excel para SQL com IronXL
Lendo Dados de Excel Usando IronXL
O processo de leitura de dados de arquivos Excel é facilitado com o IronXL. O exemplo a seguir mostra como usar o IronXL para ler dados de um arquivo Excel. Com essa abordagem, os dados são lidos e salvos em uma lista de dicionários, cada um correspondendo a uma linha na planilha Excel.
using IronXL;
using System;
using System.Collections.Generic;
public class ExcelReader
{
public static List<Dictionary<string, object>> ReadExcelFile(string filePath)
{
// Initialize a list to store data from Excel
var data = new List<Dictionary<string, object>>();
// Load the workbook from the file path provided
WorkBook workbook = WorkBook.Load(filePath);
// Access the first worksheet in the workbook
WorkSheet sheet = workbook.WorkSheets[0];
// Retrieve column headers from the first row
var headers = new List<string>();
foreach (var header in sheet.Rows[0].Columns)
{
headers.Add(header.ToString());
}
// Loop through each row starting from the second row
for (int i = 1; i < sheet.Rows.Count; i++)
{
// Create a dictionary to store the row data associated with column headers
var rowData = new Dictionary<string, object>();
for (int j = 0; j < headers.Count; j++)
{
rowData[headers[j]] = sheet.Rows[i][j].Value;
}
data.Add(rowData);
}
return data;
}
}
using IronXL;
using System;
using System.Collections.Generic;
public class ExcelReader
{
public static List<Dictionary<string, object>> ReadExcelFile(string filePath)
{
// Initialize a list to store data from Excel
var data = new List<Dictionary<string, object>>();
// Load the workbook from the file path provided
WorkBook workbook = WorkBook.Load(filePath);
// Access the first worksheet in the workbook
WorkSheet sheet = workbook.WorkSheets[0];
// Retrieve column headers from the first row
var headers = new List<string>();
foreach (var header in sheet.Rows[0].Columns)
{
headers.Add(header.ToString());
}
// Loop through each row starting from the second row
for (int i = 1; i < sheet.Rows.Count; i++)
{
// Create a dictionary to store the row data associated with column headers
var rowData = new Dictionary<string, object>();
for (int j = 0; j < headers.Count; j++)
{
rowData[headers[j]] = sheet.Rows[i][j].Value;
}
data.Add(rowData);
}
return data;
}
}
Imports IronXL
Imports System
Imports System.Collections.Generic
Public Class ExcelReader
Public Shared Function ReadExcelFile(ByVal filePath As String) As List(Of Dictionary(Of String, Object))
' Initialize a list to store data from Excel
Dim data = New List(Of Dictionary(Of String, Object))()
' Load the workbook from the file path provided
Dim workbook As WorkBook = WorkBook.Load(filePath)
' Access the first worksheet in the workbook
Dim sheet As WorkSheet = workbook.WorkSheets(0)
' Retrieve column headers from the first row
Dim headers = New List(Of String)()
For Each header In sheet.Rows(0).Columns
headers.Add(header.ToString())
Next header
' Loop through each row starting from the second row
For i As Integer = 1 To sheet.Rows.Count - 1
' Create a dictionary to store the row data associated with column headers
Dim rowData = New Dictionary(Of String, Object)()
For j As Integer = 0 To headers.Count - 1
rowData(headers(j)) = sheet.Rows(i)(j).Value
Next j
data.Add(rowData)
Next i
Return data
End Function
End Class
Conectando-se ao SQL Server
Use a classe SqlConnection do namespace System.Data.SqlClient para estabelecer uma conexão com o SQL Server. Certifique-se de ter a string de conexão correta, que normalmente consiste no nome do banco de dados, nome do servidor e informações de autenticação. Como conectar-se a um banco de dados SQL Server e adicionar dados é abordado no exemplo a seguir.
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
public class SqlServerConnector
{
private string connectionString;
// Constructor accepts a connection string
public SqlServerConnector(string connectionString)
{
this.connectionString = connectionString;
}
// Inserts data into the specified table
public void InsertData(Dictionary<string, object> data, string tableName)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
// Construct an SQL INSERT command with parameterized values to prevent SQL injection
var columns = string.Join(",", data.Keys);
var parameters = string.Join(",", data.Keys.Select(key => "@" + key));
string query = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})";
using (SqlCommand command = new SqlCommand(query, connection))
{
// Add parameters to the command
foreach (var kvp in data)
{
command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
}
// Execute the command
command.ExecuteNonQuery();
}
}
}
}
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
public class SqlServerConnector
{
private string connectionString;
// Constructor accepts a connection string
public SqlServerConnector(string connectionString)
{
this.connectionString = connectionString;
}
// Inserts data into the specified table
public void InsertData(Dictionary<string, object> data, string tableName)
{
using (SqlConnection connection = new SqlConnection(connectionString))
{
connection.Open();
// Construct an SQL INSERT command with parameterized values to prevent SQL injection
var columns = string.Join(",", data.Keys);
var parameters = string.Join(",", data.Keys.Select(key => "@" + key));
string query = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})";
using (SqlCommand command = new SqlCommand(query, connection))
{
// Add parameters to the command
foreach (var kvp in data)
{
command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
}
// Execute the command
command.ExecuteNonQuery();
}
}
}
}
Imports System
Imports System.Collections.Generic
Imports System.Data.SqlClient
Imports System.Linq
Public Class SqlServerConnector
Private connectionString As String
' Constructor accepts a connection string
Public Sub New(ByVal connectionString As String)
Me.connectionString = connectionString
End Sub
' Inserts data into the specified table
Public Sub InsertData(ByVal data As Dictionary(Of String, Object), ByVal tableName As String)
Using connection As New SqlConnection(connectionString)
connection.Open()
' Construct an SQL INSERT command with parameterized values to prevent SQL injection
Dim columns = String.Join(",", data.Keys)
Dim parameters = String.Join(",", data.Keys.Select(Function(key) "@" & key))
Dim query As String = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})"
Using command As New SqlCommand(query, connection)
' Add parameters to the command
For Each kvp In data
command.Parameters.AddWithValue("@" & kvp.Key, If(kvp.Value, DBNull.Value))
Next kvp
' Execute the command
command.ExecuteNonQuery()
End Using
End Using
End Sub
End Class
Combinando IronXL com SQL Server
Uma vez que a lógica para ler arquivos Excel e inserir dados em um banco de dados SQL foi estabelecida, integre essas funcionalidades para concluir o processo de importação. O aplicativo que segue recebe informações de um arquivo Excel e as adiciona a um banco de dados Microsoft SQL Server.
using System;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
// Define the path to the Excel file, SQL connection string, and target table name
string excelFilePath = "path_to_your_excel_file.xlsx";
string connectionString = "your_sql_server_connection_string";
string tableName = "your_table_name";
// Read data from Excel
List<Dictionary<string, object>> excelData = ExcelReader.ReadExcelFile(excelFilePath);
// Create an instance of the SQL connector and insert data
SqlServerConnector sqlConnector = new SqlServerConnector(connectionString);
foreach (var row in excelData)
{
sqlConnector.InsertData(row, tableName);
}
Console.WriteLine("Data import completed successfully.");
}
}
using System;
using System.Collections.Generic;
class Program
{
static void Main(string[] args)
{
// Define the path to the Excel file, SQL connection string, and target table name
string excelFilePath = "path_to_your_excel_file.xlsx";
string connectionString = "your_sql_server_connection_string";
string tableName = "your_table_name";
// Read data from Excel
List<Dictionary<string, object>> excelData = ExcelReader.ReadExcelFile(excelFilePath);
// Create an instance of the SQL connector and insert data
SqlServerConnector sqlConnector = new SqlServerConnector(connectionString);
foreach (var row in excelData)
{
sqlConnector.InsertData(row, tableName);
}
Console.WriteLine("Data import completed successfully.");
}
}
Imports System
Imports System.Collections.Generic
Friend Class Program
Shared Sub Main(ByVal args() As String)
' Define the path to the Excel file, SQL connection string, and target table name
Dim excelFilePath As String = "path_to_your_excel_file.xlsx"
Dim connectionString As String = "your_sql_server_connection_string"
Dim tableName As String = "your_table_name"
' Read data from Excel
Dim excelData As List(Of Dictionary(Of String, Object)) = ExcelReader.ReadExcelFile(excelFilePath)
' Create an instance of the SQL connector and insert data
Dim sqlConnector As New SqlServerConnector(connectionString)
For Each row In excelData
sqlConnector.InsertData(row, tableName)
Next row
Console.WriteLine("Data import completed successfully.")
End Sub
End Class
Esta classe é responsável por usar o IronXL para ler os dados do arquivo Excel fornecido. A função ReadExcelFile carrega o workbook Excel, abre a primeira planilha e coleta dados percorrendo as linhas da planilha de dados. Para facilitar o manuseio das tabelas, as informações são mantidas em uma lista de dicionários.

Os dados são inseridos na tabela designada do banco de dados por esta classe, que também gerencia a conexão com o banco de dados SQL Server. O método InsertData emprega consultas parametrizadas para evitar injeção de SQL e constrói uma consulta SQL INSERT dinamicamente com base nas chaves do dicionário, que representam nomes de colunas.
Usando a classe ExcelReader para ler os dados no SQL table do arquivo Excel e a classe SqlServerConnector para inserir cada linha na tabela do SQL Server, a função Main gerencia todo o processo.

O tratamento de erros e a otimização são cruciais para garantir um processo de importação robusto e eficiente. A implementação de tratamento robusto de erros pode gerenciar problemas potenciais, como arquivos ausentes, formatos de dados inválidos e exceções SQL. Aqui está um exemplo de incorporação de tratamento de erros.
try
{
// Insert the importing logic here
}
catch (Exception ex)
{
Console.WriteLine("An error occurred: " + ex.Message);
}
try
{
// Insert the importing logic here
}
catch (Exception ex)
{
Console.WriteLine("An error occurred: " + ex.Message);
}
Try
' Insert the importing logic here
Catch ex As Exception
Console.WriteLine("An error occurred: " & ex.Message)
End Try
Conclusão
Finalmente, um método eficaz e confiável para gerenciar arquivos Excel em aplicativos .NET é importar dados do Excel para um banco de dados MS SQL usando C# e IronXL. O IronXL é compatível com múltiplos formatos Excel e possui capacidades robustas que facilitam a leitura e escrita de dados Excel sem a necessidade de instalar o Microsoft Excel. Por meio da integração de System.Data.SqlClient com IronXL, os desenvolvedores podem mover facilmente dados entre SQL Servers usando consultas parametrizadas para melhorar a segurança e evitar injeção de SQL.
Finalmente, adicionar IronXL e Iron Software ao seu conjunto de ferramentas de desenvolvimento .NET permite que você manipule eficientemente Excel, crie PDFs, faça OCR e utilize códigos de barras. Combinando o conjunto flexível da Iron Software com a simplicidade de uso, interoperabilidade e desempenho do IronXL garante um desenvolvimento simplificado e capacidades aprimoradas de aplicativos. Com opções de licença claras que são personalizadas para os requisitos do projeto, os desenvolvedores podem selecionar o modelo correto com confiança. Ao utilizar esses benefícios, os desenvolvedores podem enfrentar efetivamente uma gama de desafios enquanto mantêm conformidade e transparência.
Perguntas frequentes
Qual a melhor maneira de importar dados do Excel para o SQL Server usando C#?
Utilizando a biblioteca IronXL, você pode importar dados do Excel para o SQL Server de forma eficiente, lendo o arquivo Excel e inserindo os dados no banco de dados sem precisar ter o Microsoft Excel instalado.
Como posso ler arquivos do Excel em C# sem usar o Microsoft Excel?
IronXL permite ler arquivos Excel em C# sem a necessidade do Microsoft Excel. Você pode carregar a pasta de trabalho do Excel, acessar as planilhas e extrair dados usando métodos simples.
Quais são os passos para conectar um arquivo Excel ao SQL Server em uma aplicação C#?
Primeiro, utilize o IronXL para ler o arquivo Excel. Em seguida, estabeleça uma conexão com o SQL Server utilizando a classe SqlConnection e use SqlCommand para inserir dados no banco de dados SQL.
Por que devo usar o IronXL para operações com o Excel em aplicações .NET?
O IronXL oferece gerenciamento eficiente de dados, compatibilidade com múltiplas plataformas .NET e não requer a instalação do Excel, tornando-o ideal para aplicações do lado do servidor e para o processamento de grandes conjuntos de dados.
Como posso lidar com grandes conjuntos de dados do Excel em C#?
O IronXL oferece suporte robusto para grandes conjuntos de dados, permitindo que você leia e manipule dados em arquivos do Excel de forma eficiente e os integre em aplicativos sem problemas de desempenho.
Quais estratégias de tratamento de erros devem ser usadas ao importar arquivos do Excel para o SQL Server?
Implemente blocos try-catch para lidar com possíveis erros, como arquivo não encontrado, formatos de dados inválidos ou exceções SQL, para garantir um processo de importação tranquilo.
Posso automatizar a importação de dados do Excel para o SQL Server em uma aplicação C#?
Sim, usando o IronXL, você pode automatizar o processo de importação escrevendo um aplicativo em C# que lê arquivos do Excel e insere os dados no SQL Server com intervenção manual mínima.
Como as consultas parametrizadas previnem a injeção de SQL em C#?
Em C#, as consultas parametrizadas permitem inserir dados com segurança no SQL Server usando marcadores de posição para parâmetros em comandos SQL, o que ajuda a prevenir ataques de injeção de SQL.
Como posso otimizar o desempenho da importação de dados do Excel para o SQL Server?
Otimize o desempenho usando inserções em lote, processando grandes conjuntos de dados de forma eficiente com o IronXL e garantindo que sua conexão e comandos do SQL Server estejam configurados corretamente.
Quais são as opções de licenciamento para usar o IronXL em um projeto?
A IronXL oferece opções de licenciamento flexíveis, adaptadas às necessidades do projeto, permitindo que os desenvolvedores escolham o plano mais adequado aos requisitos da aplicação e ao orçamento disponível.



