ASP .NET Core MVC - Ajustando o projeto para usar o MySQL - II

 Neste artigo vamos criar uma aplicação ASP .NET Core MVC no ambiente Linux.

Neste artigo vamos ajustar a aplicação criada neste artigo  para usar um banco de dados MySQL. Após isso vamos criar uma imagem da aplicação e a seguir um contêiner que vai se comunicar com o contêiner do MySQL que foi criado neste artigo : Docker - Uma introdução básica - X

Ajustando a aplicação - Incluindo os pacotes para o MySql

Nosso objetivo é preparar a aplicação ASP .NET Core MVC, que criamos no artigo citado, para poder acessar dados do MySQL, e, para isso vamos usar os recursos do Entity Framework Core (EF Core).

Vamos então incluir os pacotes necessários para referenciar o EF Core e o provedor de banco de dados MySQL e poder usar a ferramenta Migrations que iremos usar no projeto para criar o script que vai gerar o banco de dados e a tabela.

Vamos acessar a pasta onde o projeto foi criado para poder incluir os pacotes:

cd projetos
cd App1



 Vamos começar incluindo o pacote do provedor para o MySql :

Além disso temos que instalar os seguintes pacotes:

Para instalar um pacote usando a NET CLI usamos o comando : dotnet add package <pacote>

Digite os comandos abaixo no terminal para incluir os pacotes no projeto:

dotnet add package Pomelo.EntityFrameworkCore.MySql

dotnet add package Pomelo.EntityFrameworkCore.MySql.Design

dotnet add package Microsoft.EntityFrameworkCore.Tools

Terminando a execução dos comandos e abrindo o arquivo de projeto App1.csproj no VS Code devemos ver as referências aos pacotes:

Agora podemos usar o provedor do MySQL para acessar o banco de dados e os recursos do EF Core para acessar os dados e usar o Migrations.

Criando o arquivo de contexto

Como vamos fazer o acesso aos dados do MySQL via EF Core precisamos criar uma classe de contexto que herda da classe DbContext, e, precisamos definir o mapeamento entre a entidade Produto da aplicação e a tabela Produtos do banco de dados.(que ainda iremos criar)

Para isso vamos criar uma arquivo chamado AppDbContext.cs na pasta Models com o código abaixo:

A classe AppDbContext vai fornecer acesso aos objetos Produto no banco de dados através da propriedade Produtos.

Agora vamos criar um repositório para acessar os dados criando uma arquivo chamado ProdutoRepository.cs na pasta Models que vai herdar da interface IRepository com o código abaixo:

Para este projeto criamos um repositório simples de produtos que expõe os objetos Produto no banco de dados por meio de uma propriedade Produtos que acessa dos dados a partir da instância do contexto.

Nota: Em um projeto real, o repositório também forneceria métodos para criar e modificar objetos.

Precisamos agora definir os dados iniciais que serão incluidos na aplicação quando o banco de dados for criado e estiver vazio. Para isso vamos criar um arquivo chamado Populadb.cs na pasta Models com o código abaixo:

using Microsoft.AspNetCore.Builder;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using System.Linq;
namespace App1.Models
{
    public static class Populadb
    {
         public static void IncluiDadosDB(IApplicationBuilder app) 
         {
            IncluiDadosDB(
                app.ApplicationServices.GetRequiredService<AppDbContext>());
         }
        public static void IncluiDadosDB(AppDbContext context)
        {
            System.Console.WriteLine("Aplicando Migrations...");
            context.Database.Migrate();
            if (!context.Produtos.Any()) 
            {
                System.Console.WriteLine("Criando dados...");
                context.Produtos.AddRange(
                    new Produto("Luvas de goleiro", "Futebol", 25),
                    new Produto("Bola de basquete", "Basquete", 48.95m),
                    new Produto("Bola de Futebol", "Futebol", 19.50m),
                    new Produto("Óculos para natação", "Aquáticos", 34.95m),
                    new Produto("Meias Grandes", "Futebol", 50),
                    new Produto("Calção de banho", "Aquáticos", 16),
                    new Produto("Cesta para quadra", "Basquete", 29.95m)
                );
                context.SaveChanges();
            } else {
                System.Console.WriteLine("Dados já existem...");
            }
        }
    }
}

O método estático IncluiDadosDB cria um objeto de contexto do banco de dados e o utiliza para adicionar objetos Produto no banco de dados.

A declaração mais importante na classe Populadb é :  context.Database.Migrate()

O EF Core gerencia o esquema do banco de dados usando um recurso chamado Migrations, que geralmente é aplicado ao banco de dados por meio de uma ferramenta de linha de comando. Isso não funciona quando usamos o Docker porque é difícil executar etapas de configuração manual ao implantar um aplicativo.

Em vez disso, o método Database.Migrate() é chamado durante a inicialização do aplicativo para aplicar quaisquer migrações pendentes ao banco de dados.

Isso garante que o esquema do banco de dados será criado sem a necessidade de qualquer intervenção de linha de comando.

Configurando a aplicação

Para configurar a aplicação e habilitar os serviços do EF Core vamos alterar o código do arquivo Startup.cs.

No método ConfigureServices() vamos definir a string de conexão com o banco de dados MySQL usando a senha(numsey) que definimos neste artigo, onde criamos o contêiner com a imagem do MySQL.

Vamos registrar como serviço o repositório ProdutoRepository. Observe que o nome do banco de dados usado foi produtos e que a senha usada (numsey) foi a mesma senha que definimos na criação do contêiner do MySQL.

 public void ConfigureServices(IServiceCollection services)
  {
            services.Configure<CookiePolicyOptions>(options =>
            {
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });
            var host = Configuration["DBHOST"] ?? "localhost";
            var port = Configuration["DBPORT"] ?? "3306";
            var password = Configuration["DBPASSWORD"] ?? "numsey";

            services.AddDbContext<AppDbContext>(options =>
                options.UseMySql($"server={host};userid=root;pwd={password};"
                    + $"port={port};database=produtos"));

            services.AddTransient<IRepository, ProdutoRepository>();

            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
        }


No método Configure() vamos chamar o método IncluiDadosDB da classe Populadb:

 public void Configure(IApplicationBuilder app, IHostingEnvironment env)
 {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                app.UseHsts();
            }
            app.UseHttpsRedirection();
            app.UseStaticFiles();
            app.UseCookiePolicy();
            Populadb.IncluiDadosDB(app);
            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
 }

Na primeira execução a chamada ao método IncluiDadosDB() vai aplicar o script de migração que esta pendente e criar o banco de dados e a tabela Produtos.

Criando o script de migração

Continuando, vamos criar o script de migração inicial do Entity Framework Core que irá definir o schema para a aplicação com base no arquivo AppDbContext e na classe Produto.

Vamos usar a ferramenta de linha de comando NET CLI e usar o comando :

dotnet ef migrations add Inicial

Com isso estamos usando os recursos do migrations que vai gerar o script para criar o banco de dados e a tabela da nossa aplicação.

Examinando a estrutura da nossa aplicação no VS Code teremos o seguinte:

Observe que foi criada a pasta Migrations contendo os arquivos usados para fazer a migração.

No arquivo 20181107205017_Inicial temos o script que vai gerar a tabela Produtos.

Desta forma temos uma migração pendente que será aplicada pelo comando context.Database.Migrate() que definimos no método IncluiDadosDB da classe Populadb.

Podemos agora retornar para o artigo do Docker e criar a imagem e a seguir o contêiner para a nossa aplicação.

Pegue o projeto completo aqui :

Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti