Blazor  -  Exportando arquivo para o Excel


Hoje veremos como exportar um arquivo para o Excel usando o Blazor.

Eu já publiquei um artigo mostrando como ler dados a partir de um arquivo Excel no Blazor e hoje veremos como exportar um arquivo para o Excel.

Temos muitas opções para fazer isso e também podemos várias abordagens. Neste artigo eu vou criar uma solução contendo dois projetos:

  1. Projeto Web API ASP.NET Core - Responsável por gerar o arquivo Excel;
  2. Projeto Blazor Web Assembly; - Responsável por exportar e baixar o arquivo Excel gerado;

Para nos ajudar a gerar o arquivo Excel vamos usar o pacote Nuget ClosedXML.

Criando o projeto no VS 2022

Vamos criar uma solução em branco no VS 2022 usando o template Blank Solution com o nome ExportaExcel;

Vamos incluir um projeto Blazor Web Assembly na solução com o nome ExportaExcel.Blazor usando o template

A seguir vamos incluir na solução um projeto ASP .NET Core Web API usando o respectivo template com o nome ExportaExcel.Api;

No projeto Web API vamos incluir o pacote Nuget ClosedXML usando o comando : install-package ClosedXML

Para representar os dados a partir do qual iremos gerar o arquivo vamos criar uma pasta Models e nesta pasta criar a classe Aluno:

namespace ExportaExcel.Api.Models;
public class Aluno
{
    public int Id { get; set; }
    public string? Nome { get; set; }
    public string? Email { get; set; }
    public int Idade { get; set; }
}

A seguir vamos criar na mesma pasta a classe AlunoData que vai retornar os dados dos Alunos que vamos usar para gerar o arquivo Excel:

namespace ExportaExcel.Api.Models;

public static class AlunoData
{
    public static List<Aluno> Alunos = new List<Aluno>
    {
       new Aluno { Id = 1, Nome = "Maria", Email = "maria@email.com", Idade = 17 },
       new Aluno { Id = 2, Nome = "Dimas", Email = "dimas@email.com" ,  Idade = 16},
       new Aluno { Id = 3, Nome = "Miriam", Email = "miriam@email.com" , Idade = 15},
       new Aluno { Id = 4, Nome = "Carlos", Email = "carlos@email.com" , Idade = 14},
       new Aluno { Id = 5, Nome = "Marta", Email = "marta@email.com" , Idade = 16}
    };
}

Criando o Serviço para gerar o arquivo Excel

Ainda no projeto Web API crie uma pasta Services e nesta pasta inclua a classe ExportExcelService :

using ClosedXML.Excel;
using ExportaExcel.Api.Models;
using System.Text;

namespace ExportaExcel.Api.Services
{
    public class ExportExcelService
    {
        public byte[] CreateAlunoExport()
        {
            var workbook = new XLWorkbook();
            workbook.Properties.Title = "Exportar de alunos";
            workbook.Properties.Author = "Macoratri";
            workbook.Properties.Subject = "Exportar de alunos";
            workbook.Properties.Keywords = "alunos, macoratti, blazor";

            CreateAlunoWorksheet(workbook);
            return ConvertToByte(workbook);
        }

        public void CreateAlunoWorksheet(XLWorkbook package)
        {
            var worksheet = package.Worksheets.Add("Alunos");

            worksheet.Cell(1, 1).Value = "Id";
            worksheet.Cell(1, 2).Value = "Nome";
            worksheet.Cell(1, 3).Value = "Email";
            worksheet.Cell(1, 4).Value = "Idade";

            for (int index = 1; index <= AlunoData.Alunos.Count; index++)
            {
                worksheet.Cell(index + 1, 1).Value = AlunoData.Alunos[index - 1].Id;
                worksheet.Cell(index + 1, 2).Value = AlunoData.Alunos[index - 1].Nome;
                worksheet.Cell(index + 1, 3).Value = AlunoData.Alunos[index - 1].Email;
                worksheet.Cell(index + 1, 4).Value = AlunoData.Alunos[index - 1].Idade;
            }
        }

         private byte[] ConvertToByte(XLWorkbook workbook)
         {
            var stream = new MemoryStream();
            workbook.SaveAs(stream);

            var content = stream.ToArray();
            return content;
         }
    }
}

Neste código o método CreateAlunoExport() vai invocar o método CreateAlunoWorksheet() para criar a planilha com os dados obtidos de AlunoData e a seguir converter para um array de stream.  A aplicação Blazor vai fazer o download do arquivo gerado.

Agora precisamos registrar o serviço e configurar a aplicação API e habilitar o CORS no projeto API para permitir que a aplicação Blazor use o serviço da API.

O Cross-Origin Resource Sharing ou CORS é um padrão W3C sendo uma especificação de uma tecnologia de navegadores que define meios para um servidor permitir que seus recursos sejam acessados por uma página web de um domínio diferente.

Usando o CORS, um servidor pode permitir algumas solicitações de origem cruzada (domínio) e rejeitar outras. O CORS é mais flexível e seguro do que as técnicas anteriores, como o JSONP.

Assim na classe Program do projeto API vamos incluir o código destacado abaixo:

using ExportaExcel.Api.Services;

var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();

builder.Services.AddTransient<ExportExcelService>();

string PermitirOrigensEspecificas= "minhaPoliticaCORS";

builder.Services.AddCors(options =>
{
    options.AddPolicy(name: PermitirOrigensEspecificas,
        builder =>
        {
            builder.AllowAnyOrigin()
                     .AllowAnyMethod()
                     .AllowAnyHeader();
        });
});

var app = builder.Build();
// Configure the HTTP request pipeline.
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}

app.UseHttpsRedirection();
app.UseAuthorization();
app.UseCors(
PermitirOrigensEspecificas);
app.MapControllers();
app.Run();

Criando o controlador

Vamos agora criar no projeto API o controlador ExportExcelController onde vamos injetar o serviço ExportExcelService para poder usar o método CreateAlunoExport() e gerar o arquivo Excel.

using ExportaExcel.Api.Services;
using Microsoft.AspNetCore.Mvc;

namespace ExportaExcel.Api.Controllers;

[Route("api/[controller]")]
[ApiController]
public class ExportExcelController : ControllerBase
{
    private ExportExcelService _service;

    private string tipoConteudo = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    private string nomeArquivo = "alunos.xlsx";

    public ExportExcelController(ExportExcelService service)
    {
        _service = service;
    }

    [HttpGet]
    public IActionResult DownloadAlunosExport()
    {
        return File(_service.CreateAlunoExport(), tipoConteudo, nomeArquivo);
    }
}

Note que o retorno será o arquivo alunos,xlsx gerado usando o ClosedXML, A seguir iremos baixar este arquivo.

Neste momento se executarmos a solução tendo a aplicação API como a que vai iniciar teremos o resultado a seguir:

Note que após gerar o arquivo Excel temos como resposta um link onde podemos baixar o arquivo diretamente. Clicando no link Download file iremos obter o resultado a seguir:

Na próxima parte do artigo iremos implementar no projeto Blazor a funcionalidade para baixar o arquivo Excel.

"Mas o fruto do Espírito é: amor, gozo, paz, longanimidade, benignidade, bondade, fé, mansidão, temperança.
Contra estas coisas não há lei."
Gálatas 5:22,23

Referências:


José Carlos Macoratti