Agora que temos o suporte ao EF Core vamos criar as classes das entidades para a nossa aplicação.

Como nossa aplicação é bem simples e vai gerenciar informações de livros ela vai ter apenas uma entidade chamada Livro.

Vamos agora criar  a classe que representa a nossa entidade.

Criando a entidade Livro

Vamos criar uma pasta chamada "Models" no projeto para nesta pasta definir o modelo de entidades.

Nota: Você pode colocar classes do modelo em qualquer lugar em seu projeto, mas a pasta Models é usada por convenção.

Na janela Solution Explorer, clique com o botão direito do mouse no projeto e selecione Add -> New Folder e informe o nome Models.

As classes são criadas na pasta Models clicando com o botão direito sobre a pasta, selecionando Add -> Class e a seguir informando o nome da classe.

Vamos iniciar criando o arquivo Livro.cs e nele vamos definir a classe Livro conforme abaixo:

using System;

namespace Livraria.Models
{
    public class Livro
    {
        public int Id { get; set; }
        public string Nome { get; set; }
        public string Autor { get; set; }
        public decimal Preco { get; set; }
        public DateTime Lancamento { get; set; } = DateTime.UtcNow;
    }
}

A propriedade Id será a coluna de chave primária da tabela de banco de dados que corresponde a essa classe. Por padrão, o Entity Framework interpreta uma propriedade que é chamada de ID ou nome_classeID como sendo a chave primária.(Podemos alterar esse comportamento com annotations)

Nota : O Entity Framework por padrão adota algumas convenções (Conventions) que ele usa para realizar algumas operações.

Criando a classe de contexto do Banco de dados

O Entity Framework permite consultar, inserir, atualizar e excluir dados, usando objetos CLR(Common Language Runtime) conhecidos como entidades; ele mapeia as entidades e relacionamentos que são definidos no seu modelo de entidades para um banco de dados e fornece facilidades para realizar as seguintes tarefas:

1- Materializar dados retornados do banco de dados como objetos de entidade;
2- Controlar as alterações que foram feitas nos objetos;
3- Lidar com concorrência;
4- Propagar as alterações feitas nos objetos de volta ao banco de dados;
5- Vincular objetos a controles.

A principal classe responsável pela interação com os objetos de dados é a classe System.Data.Entity.DbContext (muitas vezes referida como o contexto).

Essa classe de contexto administra os objetos entidades durante o tempo de execução, o que inclui preencher objetos com dados de um banco de dados, controlar alterações, e persistir dados para o banco de dados.

A maneira recomendada para trabalhar com o contexto é definir uma classe que deriva de DbContext e expõe as propriedades de DbSet que representam as coleções das entidades especificadas no contexto.

Essa classe é chamada de classe de contexto do banco de dados e coordena a funcionalidade do Entity Framework para um dado modelo de dados. No código dessa classe você especifica quais entidades estão incluídas no modelo de dados. Você também pode personalizar determinado comportamento do Entity Framework. Neste projeto, a nossa classe de contexto será chamada LivroContexto.

Para simplificar eu vou criar essa classe na pasta Models. Então crie o arquivo LivroContexto.cs na pasta Models e a seguir inclua o código abaixo na classe LivroContexto:

using Microsoft.EntityFrameworkCore;

namespace Livraria.Models
{
    public class LivroContexto : DbContext
    {
        public LivroContexto(DbContextOptions<LivroContexto> options) : base(options)
        {
        }
        public DbSet<Livro> Livros { get; set; }
    }
}

Este código cria uma propriedade DbSet para cada a entidade Livro. Na terminologia Entity Framework, um conjunto de entidades corresponde a uma tabela de banco de dados e uma entidade corresponde a uma linha na tabela.

Registrando o contexto com injeção de dependência

A ASP.NET Core implementa a injeção de dependência por padrão. Os serviços (como o contexto de banco de dados do EF) são registrados com injeção de dependência durante a inicialização do aplicativo. Componentes que requerem esses serviços (como controladores MVC) fornecem esses serviços através de parâmetros do construtor. Mais adiante iremos definir no construtor do controlador a instância do contexto.

Para registrar o nosso contexto LivroContexto como um serviço, abra o arquivo Startup.cs e adicione as linhas realçadas ao método ConfigureServices:

using Microsoft.EntityFrameworkCore;
using Livraria.Models;
...

								....

       // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            var connection = Configuration["ConexaoMySql:MySqlConnectionString"];
            services.AddDbContext<LivroContexto>(options =>
                options.UseMySql(connection)
            );

            // Add framework services.
            services.AddMvc();
        }
....

O nome da string de conexão é passada para o contexto pela chamada do método no objeto DbContextOptionsBuilder. Para o desenvolvimento local a ASP .NET Core obtém a string de conexão do arquivo appsettings.json.

Vamos então abrir o arquivo appsettings.json e adicionar a string de conexão conforme mostrado a seguir:

{
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "ConexaoMySql": {
    "MySqlConnectionString": "Server=localhost;DataBase=Livraria;Uid=root;Pwd=*******"
  }
}

A string de conexão especifica um banco de dados identificado pelo nome Livraria.

Inicializando o banco de dados com informações

Vamos criar uma classe chamada InicializaBD na pasta Models e nela definir o código que vai inicializar a tabela Livros do banco de dados com algumas informações de forma que quando nossa aplicação for executada a página Index irá apresentar alguma informação.

Clique com o botão direito do mouse sobre a pasta  Models e selecione Add -> Class e a seguir informando o nome do arquivo: InicializaBD.cs

A seguir inclua o código abaixo neste arquivo:

using System;
using System.Linq;

namespace Livraria.Models
{
    public static class InicializaBD
    {
        public static void Initialize(LivroContexto context)
        {
            context.Database.EnsureCreated();

            // Procura por livros
            if (context.Livros.Any())
            {
                return;   //O BD foi alimentado
            }

            var livros = new Livro[]
            {
              new Livro{Nome="ASP, ADO Banco de dados na web", Autor="Macoratti", Preco=3.99M, 
Lancamento= DateTime.Now},
              new Livro{Nome="A Cabana", Autor="Willian P. Young", Preco=29.55M, Lancamento=DateTime.Now},
            };
            foreach (Livro p in livros)
            {
                context.Livros.Add(p);
            }
            context.SaveChanges();
        }
    }
}

Neste código verificamos se existem dados na tabela Livros e a seguir incluimos informação de dois livros usando o método SaveChanges.

Criando um novo Controller e suas Views

Vamos iniciar criando um controlador em nosso projeto. Clique com o botão direito do mouse sobre a pasta Controllers, e a seguir clique em Add -> Controller;

Na janela Add MVC Dependencies selecione a opção - Minimal Dependencies e clique no botão Add;

O VS 2017 vai adicionar as dependências necessárias para montar o controller.

Após isso repita o procedimento e clique com o botão direito do mouse sobre a pasta Controllers, e a seguir clique em Add -> Controller;

Na janela Add Scaffold selecione a opção : MVC Controller with views, using Entity Framework :

Clique no botão Add.

Agora na janela Add Controller vamos fazer as seguintes definições :

Model Class :  Selecione Livro(Livraria.Models)

Data context class :  clique no botão + e selecione LivroContexto(Livraria.Models) e clique no botão Add;

Ao clicar no botão Add, o mecanismo de Scaffolding do Visual Studio irá criar um arquivo LivrosController.cs, na pasta Controllers, e um conjunto de Views (arquivos .cshtml), na pasta /Views/Livros, que funcionam com o controlador.

A figura abaixo mostra o resultado:

Note que o controlador toma o nosso contexto, LivroContexto, como um parâmetro de construtor.

A injeção de dependência do contâiner ASP .NET Core vai cuidar de passar uma instância de LivroContexto para o controlador porque isso foi configurado no arquivo Startup.cs, lembra... ?

O controlador contém um método Action Index que exibe todos os livros existentes no banco de dados, ele obtém uma lista de livros do conjunto de entidades Livros lendo a propriedade Livros da instância do contexto do banco de dados.

        // GET: Livros
        public async Task<IActionResult> Index()
        {
            return View(await _context.Livros.ToListAsync());
        }

Note que é retornado uma View, a view Index.cshtml, que exibe uma lista de Livros em uma tabela: (Eu já traduzi os textos)

Antes de executar o projeto vamos alterar o arquivo Startup.cs alterando o controlador para Livros conforme mostra a figura a seguir:

Executando o projeto iremos obter o seguinte resultado:

Observe que a página esta exibindo as informações dos livros que definimos na classe InicializaBD.

Para confirmar vamos abrir o MySql WorkBench e verificar o banco de dados Livraria e a tabela livros criada com as informações iniciais:

Criamos assim uma aplicação ASP .NET MVC para gerenciar informações de livros usando a ASP .NET Core e o EntityFramework Core acessando o MySql.

Pegue o projeto completo aqui: Livraria_MySQL.zip

Mas a hora vem, e agora é, em que os verdadeiros adoradores adorarão o Pai em espírito e em verdade; porque o Pai procura a tais que assim o adorem.
Deus é Espírito, e importa que os que o adoram o adorem em espírito e em verdade.
João 4:23,24