Entity Framework Core: Mapeando bancos de dados com Database First

Motivaç�o

Adequar uma aplicaç�o orientada a objetos a uma base de dados j� existente pode se mostrar um processo trabalhoso, capaz de tomar mais da metade do tempo de desenvolvimento. Esse tipo de procedimento normalmente acontece em projetos que est�o em execuç�o ou em projetos legados, e a principal tarefa nesses casos � realizar o mapeamento e adequaç�o das tabelas f�sicas em entidades l�gicas (classes).

Por meio do modelo Database First (em que se parte de um banco de dados j� existente para, a partir dele, gerar as classes do sistema) o Entity Framework j� era capaz de auxiliar nesse processo desde suas vers�es anteriores, por�m, o EF Core foi otimizado e agora oferece suporte a m�ltiplas plataformas (Linux, Mac OS e Windows).

Nesse artigo utilizaremos o Entity Framework Core na vers�o 1.0.0, enquanto as suas ferramentas de linha de comando estar�o na vers�o 1.0.0-preview2.

Saiba mais sobre o Entity Framework Core e o modelo Code First.

A base de dados

Na Figura 1 podemos ver o diagrama com as tabelas da nossa base de dados de exemplo, que nesse caso se chama PlantelDb.

Figura 1. Base de dados de exemplo

Aqui utilizamos o SQL Server, no entanto, o EF Core � capaz de efetuar os mesmos procedimentos em outros bancos de dados, como MySQL e PostgreSQL.

Configurando o projeto e suas depend�ncias

Para iniciar nosso projeto devemos criar um diret�rio (chamado Ef7BaseExistente, nesse exemplo) e dentro dele criar uma nova Class Library, chamada Projeto.Repositorio.

Como o Entity Framework Core n�o permite que uma Class Library receba o conte�do gerado pelo procedimento de engenharia reversa - de acordo com a documentaç�o oficial, apenas projetos que cont�m um m�todo Main podem ser utilizados para esse fim -, precisamos implementar esse m�todo.

Para isso, vamos adicionar uma classe chamada Principal.cs na raiz do projeto e nela implementar um m�todo Main vazio. Veja o c�digo apresentado na Listagem 1.


    01 namespace Projeto.Repositorio
    02 {
    03    class Principal
    04    {
    05        static void Main(string[] args)
    06        { }       
    07    }    
    08 }

Listagem 1. Classe Principal.cs

Em seguida, � preciso instalar os pacotes necess�rios para que seja poss�vel utilizar a instruç�o de linha de comandos ef, que � respons�vel por realizar os procedimentos relativos ao Entity Framework Core.

Para isso, em projetos do tipo Class Library, devemos adicionar o pacote Microsoft.EntityFrameworkCore.Design na seç�o dependencies do arquivo project.json, enquanto que em projetos de interaç�o com o usu�rio, como MVC ou Console, devemos utilizar o pacote Microsoft.EntityFrameworkCore.Tools.

Na Listagem 2 podemos ver como deve ficar o arquivo project.json.


    01 {
    02  "version": "1.0.0",
    03  "authors": ["Gabriel Simas"],
    04  "description": "Camada de Infraestutura da Aplicaç�o",
    05  "copyright": "DevMedia 2016 - Todos os direitos reservados.",
    06
    07  "buildOptions": {
    08    "emitEntryPoint": true,
    09    "optimize": true
    10  },
    11
    12  "dependencies": {
    13    "Microsoft.NETCore.App": {
    14      "version": "1.0.0",
    15      "type": "platform"
    16    },
    17    "Microsoft.EntityFrameworkCore.SqlServer":"1.0.0",
    18    "Microsoft.EntityFrameworkCore.Design" :"1.0.0-preview2-final",
    19    "Microsoft.EntityFrameworkCore.SqlServer.Design" : "1.0.0"
    20  },
    21
    22 "tools": {
    23  "Microsoft.EntityFrameworkCore.Tools" : "1.0.0-preview2-final"
    24 },
    25
    26  "frameworks": {
    27  "netcoreapp1.0": {
    28      "imports": [
    29        "dotnet5.6",
    30        "dnxcore50",
    31        "portable-net45+win8"
    32      ]
    33    }
    34 },
    35
    36  "tooling": {
    37    "defaultNamespace": "Projeto.Repositorio"
    38  }
    39 }

Listagem 2. Configuraç�o das depend�ncias necess�rias

Linhas 12 a 20: definiç�o dos pacotes dos quais a aplicaç�o depende para realizar o mapeamento das tabelas do SQL Server em entidades do projeto;

Linhas 22 a 24: configuraç�o das ferramentas que ser�o necess�rias nesse projeto. Nesse caso, trata-se da ferramenta de linha de comando ef.

Agora, podemos executar o comando de restauraç�o e instalaç�o dos pacotes. Para isso, digite a seguinte instruç�o no prompt de comandos, estando dentro do diret�rio do projeto:


    dotnet restore

Database First via linha de comandos

Para efetuar a engenharia reversa da base de dados o EF Core requer a execuç�o de um comando bastante simples, cuja estrutura nos permite utilizar apenas as opç�es de que precisamos. Sua sintaxe � a seguinte:


    dotnet ef dbcontext scaffold [argumentos] [opç�es]

Em [argumentos] devemos informar a string de conex�o do banco de dados, seguida do provedor a ser utilizado, como o Microsoft.EntityFrameworkCore.SqlServer.

J� em [opç�es], podemos informar alguns par�metros adicionais que definir�o comportamentos mais espec�ficos, como a forma de mapeamento, se via Fluent API ou Data Annotations, como veremos a seguir.

Mapeamento com Fluent API

Inicialmente, vamos executar o EF com as opç�es padr�o, informando apenas a string de conex�o e o provedor de dados, como mostra o comando abaixo:


    dotnet ef dbcontext scaffold "Data Source=SERVIDOR\INSTANCIA;Initial Catalog=PlantelDb;Integrated Security=True" Microsoft.EntityFrameworkCore.SqlServer

Observaç�o: � necess�rio que estejamos dentro do diret�rio do projeto, pois a ferramenta dotnet, executada via linha de comando, ir� procurar o arquivo project.json.

Com essa instruç�o, direcionamos a criaç�o dos objetos � raiz do projeto e o mapeamento ser� feito via FluentAPI, que � o comportamento padr�o.

Caso tudo ocorra sem problemas, receberemos uma mensagem de �Done� ao final do processo e, observando nosso projeto, veremos que algumas classes foram criadas, como mostra a Figura 2.

Figura 2. Base de dados de exemplo

Como podemos notar, foram geradas as entidades (Campeonato, Inscrito, Jogador e Time) e a classe PlantelDbContext, essa �ltima herdando de DbContext.

Na Listagem 3 temos um trecho da classe PlantelDbContex, no qual podemos ver um exemplo de mapeamento (da entidade Jogador) realizado via Fluent API.


    modelBuilder.Entity<Jogador>(entity =>
    {
        entity.Property(e => e.Id).HasColumnName("id");
        entity.Property(e => e.Idade).HasColumnName("idade");
        entity.Property(e => e.Nome)
        .IsRequired()
        .HasColumnName("nome")
        .HasColumnType("varchar(100)");
        entity.Property(e => e.Posicao)
        .HasColumnName("posicao")
        .HasColumnType("varchar(30)");
    });

Listagem 3. Exemplo de mapeamento resultante com Fluent API

Mapeamento com Data Annotations

Para alterar o m�teodo de mapeamento de FluentAPI para o Data Annotations, basta adicionar o par�metro �a ou --data-annotations como opç�o no comando que vimos anteriormente. Veja um exemplo na instruç�o abaixo:


    dotnet ef dbcontext scaffold "Data Source=SERVIDOR\INSTANCIA;Initial Catalog=PlantelDb;Integrated Security=True" Microsoft.EntityFrameworkCore.SqlServer �a [ou --data-annotations] --force

Nesse caso, utilizamos ainda o par�metro --force, para evitar que o ef lance uma exceç�o de �objeto j� criado�, devido a j� termos as classses no projeto, e termine o processo.

Na Listagem 4 temos um exemplo de entidade gerada, dessa vez com as anotaç�es sobre os atributos.


    public partial class Jogador
    {
        public Jogador()
        {
            Time = new HashSet<Time>();
        }

        [Column("id")]
        public int Id { get; set; }
        [Required]
        [Column("nome", TypeName = "varchar(100)")]
        public string Nome { get; set; }
        [Column("posicao", TypeName = "varchar(30)")]
        public string Posicao { get; set; }
        [Column("idade")]
        public int? Idade { get; set; }

        [InverseProperty("Jogador")]
        public virtual ICollection<Time> Time { get; set; }
    }

Listagem 4. Exemplo de mapeamento resultante com Data Annotations

Como foi poss�vel verificar, por meio de uma sintaxe simples e flex�vel o Entity Framework Core facilita a adaptaç�o de projetos a bases de dados j� existentes, realizando o mapeamento das tabelas para classes do sistema.

Saiba mais sobre Data Annotations.