Entity Framework Core - Usando o MySql

 Neste artigo vamos criar uma aplicação ASP .NET Core usando o Entity Framework Core e acessando o MySql e realizando o CRUD básico.

O Entity Framework Core (EF Core) é uma versão leve, extensível e multiplataforma do Entity Framework. O EF Core introduz muitas melhorias e novos recursos quando comparado com o EF6.x.  O EF Core mantém a experiência do desenvolvedor do EF6.x e a maioria das APIs de alto nível permanecem as mesmas, então o EF Core vai te parecer muito familiar se você conhece o Entity Framework 6.x.

Ao mesmo tempo, o EF Core é construído sobre um conjunto completamente novo de componentes principais. Isso significa que o EF Core não herda automaticamente todos os recursos do EF6.x. Alguns desses recursos serão exibidos em lançamentos futuros (como o lazy loading e a resiliência de conexão), outros recursos menos usados não serão implementados no EF Core.  O novo núcleo, extensível e leve também permitiu adicionar alguns recursos ao EF Core que não serão implementados no EF6.x.

Para acompanhar este artigo você precisa ter instalado o Visual Studio Community 2017 com os seguintes workloads(cargas de trabalho) instalados:

Criando o projeto web Exemplo :  Livros

A aplicação exemplo que vamos construir nesse artigo é um simples site para gerenciar as informações de livros onde iremos focar na utilização do Entity Framework Core com o MySql.

Vamos iniciar criando uma aplicação ASP .NET Core MVC Web Application.

Abra no VS Community 2017 e no menu File clique em New Project;

A seguir selecione o template Visual C# -> .NET Core e marque ASP .NET Core Web Application (.NET Core);

Dessa forma estamos criando uma aplicação web (MVC com views e controllers) usando o framework .NET Core.

Informe o nome Livraria (ou outro a seu gosto) e clique no botão OK;

Na próxima janela escolha a versão ASP .NET Core 1.1 e marque o template Web Application sem autenticação e clique no botão OK;

Temos assim uma aplicação funcional, na verdade , um simples projeto inicial, que será o nosso ponto de partida.

Adicionando o suporte para o Entity Framework Core via Nuget

Vamos adicionar o suporte ao EF Core em nosso projeto e instalar o provedor do banco de dados que vamos usar. No exemplo deste artigo vamos instalar o provedor MySql : Pomelo.EntityFrameworkCore.MySql

Para instalar esse via menu Tools e e clicar em Nuget Package Manager e a seguir em Manage Nuget Packages for Solution;

Vamos instalar os pacotes :

Estes pacote e suas dependências fornecem o suporte em tempo de execução ao EF e as ferramentas de design para o MySql.

Vamos instalar também o pacote Microsoft.EnityFrameworkCore.Tools no projeto para ter acesso ao Migrations :

Nota:  O EF para no .NET Core não possui todas as funcionalidades do EF 6. (lazy loading não esta suportado ainda)

Criando o nosso modelo de dados

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

Se você não sabe o que é um Controller então pode ler os seguintes artigos  :

Os Controllers ou Controladores são os componentes que lidam com a interação do usuário, trabalham com o modelo e, finalmente, selecionam uma exibição de renderização que mostra essa interface ao usuário. Por padrão os controladores são colocados na pasta Controllers da solução.

A criação automática dos métodos Actions para realizar o CRUD e as Views é conhecida como Scaffolding. O Scaffolding irá criar automaticamente os métodos Action e as Views, e, quando você precisar personalizar o código gerado, você pode usar classes parciais ou você regenera o código quando as houver alterações.

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

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