Como Ler Arquivo Excel no Blazor com C# e IronXL (Tutorial com Exemplos)
Introdução
Blazor é um framework Web .NET de código aberto criado pela Microsoft. Uma aplicação Blazor funciona compilando o código C# em JavaScript e HTML compatíveis com o navegador. Neste tutorial, você aprenderá o método mais fácil para ler arquivo Excel — incluindo como criar planilha Excel e exibir seus dados — em uma aplicação Blazor do lado do servidor usando a biblioteca C# IronXL.
Como Ler Arquivo Excel no Blazor
- Instalar biblioteca C# para ler arquivo Excel no Blazor
- Crie um botão de upload de arquivos em seu aplicativo Blazor.
- Utilize a biblioteca C# para ler um arquivo Excel do disco.
- Configure o aplicativo Blazor para exibir os dados lidos em uma tabela na janela.
Comece a usar o IronXL
Passo 1 - Criar um Projeto Blazor no Visual Studio
Tenho um arquivo XLSX contendo os seguintes dados que vou ler e abrir no Blazor Server App:
| Planilha Excel de Entrada XLSX | Resultado no Navegador do Blazor Server | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
Comece criando um Projeto Blazor no IDE do Visual Studio:
Escolha o tipo de Projeto Blazor Server App:
Vá em frente e execute o Aplicativo sem mudar a solução com a chave F5. Navegue até a guia Fetch data do Aplicativo assim:
Nosso objetivo será carregar nosso arquivo Excel no aplicativo Blazor com um botão de upload e, em seguida, exibi-lo nesta página.
Passo 2 - Adicione o IronXL à sua Solução
IronXL: Biblioteca Excel .NET (Instruções de Instalação):
IronXL é uma biblioteca .NET que permite tratar a planilha do Microsoft Excel como um objeto, permitindo que o desenvolvedor use todo o poder do C# e do .NET Framework para manipular fluxos de dados. Como desenvolvedor, queremos uma maneira agradável através da qual possamos obter as células de cada linha e informações de coluna de documentos/planilhas Excel em nossas aplicações ou bancos de dados.
Com o IronXL, é possível obter todos os tipos de informações de uma planilha, como valores de células, conteúdo das células, imagens, referências e formatação. O IronXL é melhor do que NPOI em muitos aspectos. O IronXL fornece mais funções e pode tornar a escrita de lógica complexa mais fácil. Ele também tem licenças mais preferíveis e a equipe de suporte é mais competente.
O IronXL suporta todas as versões mais recentes do .NET (8, 7 e 6) e o .NET Core Framework 4.6.2+.
Adicione o IronXL à sua solução usando um dos métodos abaixo e depois construa a solução.
Opção 2A - Use o Gerenciador de Pacotes NuGet
Install-Package IronXL.Excel
Opção 2B - Adicionar PackageReference no arquivo csproj
Você pode adicionar o IronXL diretamente ao seu projeto adicionando a seguinte linha a qualquer <ItemGroup> no arquivo .csproj da sua solução:
<PackageReference Include="IronXL.Excel" Version="*" />
<PackageReference Include="IronXL.Excel" Version="*" />
Conforme mostrado aqui no Visual Studio:
Passo 3 - Codificação do Upload e Visualização de Arquivos
Na Visual Studio Solution View, vá até a pasta Pages/ e encontre o arquivo FetchData.razor. Você pode usar qualquer outro arquivo razor, mas usaremos este porque ele vem com o Modelo de Aplicativo Blazor Server.
Substitua o conteúdo do arquivo pelo seguinte código:
@using IronXL;
@using System.Data;
@page "/fetchdata"
<PageTitle>Excel File Viewer</PageTitle>
<h1>Open Excel File to View</h1>
<InputFile OnChange="@OpenExcelFileFromDisk" />
<table>
<thead>
<tr>
@foreach (DataColumn column in displayDataTable.Columns)
{
<th>
@column.ColumnName
</th>
}
</tr>
</thead>
<tbody>
@foreach (DataRow row in displayDataTable.Rows)
{
<tr>
@foreach (DataColumn column in displayDataTable.Columns)
{
<td>
@row[column.ColumnName].ToString()
</td>
}
</tr>
}
</tbody>
</table>
@code {
// Create a DataTable instance
private DataTable displayDataTable = new DataTable();
// This method is triggered when a file is uploaded
async Task OpenExcelFileFromDisk(InputFileChangeEventArgs e)
{
IronXL.License.LicenseKey = "PASTE TRIAL OR LICENSE KEY";
// Load the uploaded file into a MemoryStream
MemoryStream ms = new MemoryStream();
await e.File.OpenReadStream().CopyToAsync(ms);
ms.Position = 0;
// Create an IronXL workbook from the MemoryStream
WorkBook loadedWorkBook = WorkBook.FromStream(ms);
WorkSheet loadedWorkSheet = loadedWorkBook.DefaultWorkSheet; // Or use .GetWorkSheet()
// Add header Columns to the DataTable
RangeRow headerRow = loadedWorkSheet.GetRow(0);
for (int col = 0; col < loadedWorkSheet.ColumnCount; col++)
{
displayDataTable.Columns.Add(headerRow.ElementAt(col).ToString());
}
// Populate the DataTable with data from the Excel sheet
for (int row = 1; row < loadedWorkSheet.RowCount; row++)
{
IEnumerable<string> excelRow = loadedWorkSheet.GetRow(row).ToArray().Select(c => c.ToString());
displayDataTable.Rows.Add(excelRow.ToArray());
}
}
}
@using IronXL;
@using System.Data;
@page "/fetchdata"
<PageTitle>Excel File Viewer</PageTitle>
<h1>Open Excel File to View</h1>
<InputFile OnChange="@OpenExcelFileFromDisk" />
<table>
<thead>
<tr>
@foreach (DataColumn column in displayDataTable.Columns)
{
<th>
@column.ColumnName
</th>
}
</tr>
</thead>
<tbody>
@foreach (DataRow row in displayDataTable.Rows)
{
<tr>
@foreach (DataColumn column in displayDataTable.Columns)
{
<td>
@row[column.ColumnName].ToString()
</td>
}
</tr>
}
</tbody>
</table>
@code {
// Create a DataTable instance
private DataTable displayDataTable = new DataTable();
// This method is triggered when a file is uploaded
async Task OpenExcelFileFromDisk(InputFileChangeEventArgs e)
{
IronXL.License.LicenseKey = "PASTE TRIAL OR LICENSE KEY";
// Load the uploaded file into a MemoryStream
MemoryStream ms = new MemoryStream();
await e.File.OpenReadStream().CopyToAsync(ms);
ms.Position = 0;
// Create an IronXL workbook from the MemoryStream
WorkBook loadedWorkBook = WorkBook.FromStream(ms);
WorkSheet loadedWorkSheet = loadedWorkBook.DefaultWorkSheet; // Or use .GetWorkSheet()
// Add header Columns to the DataTable
RangeRow headerRow = loadedWorkSheet.GetRow(0);
for (int col = 0; col < loadedWorkSheet.ColumnCount; col++)
{
displayDataTable.Columns.Add(headerRow.ElementAt(col).ToString());
}
// Populate the DataTable with data from the Excel sheet
for (int row = 1; row < loadedWorkSheet.RowCount; row++)
{
IEnumerable<string> excelRow = loadedWorkSheet.GetRow(row).ToArray().Select(c => c.ToString());
displayDataTable.Rows.Add(excelRow.ToArray());
}
}
}
Private IronXL As [using]
Private System As [using]
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
'@page "/fetchdata" (Of PageTitle) Excel File Viewer</PageTitle> (Of h1) Open Excel File @to View</h1> <InputFile OnChange="@OpenExcelFileFromDisk" /> (Of table) (Of thead) (Of tr) @foreach(DataColumn column in displayDataTable.Columns)
' {
' <th> @column.ColumnName </th>
' }
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' </tr> </thead> (Of tbody) @foreach(DataRow row in displayDataTable.Rows)
' {
' <tr> @foreach(DataColumn column in displayDataTable.Columns)
' {
' <td> @row[column.ColumnName].ToString() </td>
' }
' </tr>
' }
'INSTANT VB TODO TASK: Local functions are not converted by Instant VB:
' </tbody> </table> @code
' {
' ' Create a DataTable instance
' private DataTable displayDataTable = New DataTable();
'
' ' This method is triggered when a file is uploaded
' async Task OpenExcelFileFromDisk(InputFileChangeEventArgs e)
' {
' IronXL.License.LicenseKey = "PASTE TRIAL OR LICENSE KEY";
'
' ' Load the uploaded file into a MemoryStream
' MemoryStream ms = New MemoryStream();
'
' await e.File.OpenReadStream().CopyToAsync(ms);
' ms.Position = 0;
'
' ' Create an IronXL workbook from the MemoryStream
' WorkBook loadedWorkBook = WorkBook.FromStream(ms);
' WorkSheet loadedWorkSheet = loadedWorkBook.DefaultWorkSheet; ' Or use .GetWorkSheet()
'
' ' Add header Columns to the DataTable
' RangeRow headerRow = loadedWorkSheet.GetRow(0);
' for (int col = 0; col < loadedWorkSheet.ColumnCount; col++)
' {
' displayDataTable.Columns.Add(headerRow.ElementAt(col).ToString());
' }
'
' ' Populate the DataTable with data from the Excel sheet
' for (int row = 1; row < loadedWorkSheet.RowCount; row++)
' {
' IEnumerable<string> excelRow = loadedWorkSheet.GetRow(row).ToArray().@Select(c => c.ToString());
' displayDataTable.Rows.Add(excelRow.ToArray());
' }
' }
'}
Resumo
O componente <InputFile> permite que você faça upload de um arquivo nesta página web. Definimos o retorno de chamada do evento invocado para chamar OpenExcelFileFromDisk, que é o método assíncrono no bloco @code na parte inferior. O HTML renderizará sua planilha do Excel como uma tabela na aba.
IronXL.Excel é uma biblioteca de software .NET independente para leitura de uma ampla variedade de formatos de planilhas. Não requer Microsoft Excel instalado e não é dependente de Interop.
Leitura complementar
Explore a Referência da API para IronXL, detalhando todos os recursos, namespaces, classes, métodos, campos e enums do IronXL.
Consulte a Referência da API.Baixe o produto de software.
Perguntas frequentes
Como posso ler arquivos do Excel em uma aplicação Blazor do lado do servidor?
Para ler arquivos Excel em uma aplicação Blazor do lado do servidor, você pode usar a biblioteca IronXL C#. Ela permite fácil integração com seu projeto Blazor, bastando usar o Gerenciador de Pacotes NuGet para instalar a biblioteca e, em seguida, implementar o código para ler e exibir os dados do Excel.
Quais são os passos para configurar um projeto Blazor para ler arquivos do Excel?
Primeiro, instale o IronXL através do Gerenciador de Pacotes NuGet. Em seguida, crie um botão de upload de arquivo em sua aplicação Blazor. Utilize o IronXL para ler o arquivo Excel carregado e configure a aplicação para exibir os dados em uma tabela usando componentes Razor.
É possível ler arquivos do Excel em um aplicativo Blazor sem que o Excel esteja instalado?
Sim, com o IronXL, você pode ler e manipular arquivos do Excel em um aplicativo Blazor sem precisar ter o Microsoft Excel instalado no seu sistema.
Como posso exibir dados do Excel em um aplicativo Blazor?
Após ler o arquivo Excel usando o IronXL, você pode usar componentes Razor em seu aplicativo Blazor para exibir os dados em formato de tabela, aprimorando a interface do usuário.
Quais são as vantagens que o IronXL oferece em comparação com outras bibliotecas do Excel?
O IronXL oferece ampla funcionalidade, facilidade no gerenciamento de lógica complexa, termos de licenciamento superiores e suporte dedicado, tornando-o uma escolha preferível em relação a alternativas como o NPOI.
Quais versões do .NET são suportadas pelo IronXL para manipulação de arquivos Excel?
O IronXL é compatível com todas as versões mais recentes do .NET, incluindo as versões 8, 7 e 6, bem como com o .NET Core Framework 4.6.2+, garantindo ampla compatibilidade com aplicativos modernos.
Como faço para integrar uma biblioteca do Excel ao meu projeto Blazor?
Você pode integrar uma biblioteca do Excel como o IronXL ao seu projeto Blazor usando o Gerenciador de Pacotes NuGet com o comando dotnet add package IronXL.Excel ou adicionando uma PackageReference no arquivo ` .csproj .
Quais etapas de solução de problemas posso seguir se meu aplicativo Blazor não conseguir ler um arquivo do Excel?
Certifique-se de que o IronXL esteja instalado corretamente via NuGet e que seu aplicativo Blazor tenha as permissões necessárias para ler arquivos do disco. Verifique novamente se o caminho do arquivo Excel está correto e se o formato do arquivo é compatível com o IronXL.

