Entity Framework Core: Criando bases de dados com Migrations

Motivaç�o

Em projetos onde a arquitetura � centralizada nas classes do dom�nio, a base de dados geralmente � criada no final da modelagem, por meio de um processo realizado automaticamente por ferramentas espec�ficas ou frameworks.

Seguindo essa linha de projeto, neste artigo veremos como o Entity Framework Core, atrav�s do padr�o Code First e da Fluent API, permite realizar o mapeamento das classes e a geraç�o autom�tica da base de dados a partir delas. Tudo isso ser� feito por meio de ferramentas de linha de comando, sem a necessidade de utilizar o Visual Studio.

Saiba mais sobre como utilizar o ASP.NET Core.

Passo 1: Modelar as entidades

Para modelar as entidades, que posteriormente ser�o refletidas em tabelas do banco de dados, criaremos aqui um projeto do tipo Class Library chamado Projeto.Dominio com duas classes: Cliente e Pedido, cujo c�digo pode ser visto na Listagem 1.


01 namespace Projeto.Dominio
02 {
03    public class Cliente
04    {
05        public Nullable<long> Id { get; set; }
06        public string Nome { get; set; }
07        public String Email { get; set; }        
08        public IList<Pedido> Pedidos { get; set; }
09        public Cliente()
10        { }        
11    }
12    public class Pedido
13    {
14        public Nullable<long> Id { get; set; }
15        public Double Total { get; set; }
16    }
17 }

Listagem 1. Entidades do sistema

Note, na linha 8, que o cliente possui uma lista de pedidos, o que representa um relacionamento unidirecional.

Passo 2: Adicionar as depend�ncias

Com o intuito de centralizar as configuraç�es de persist�ncia, criaremos uma segunda Class Library, com o nome Projeto.Repositorio. Feito isso, para que nela o Entity Framework funcione como esperado, precisamos inserir as depend�ncias abaixo no arquivo project.json na seç�o dependencies:


01 "Microsoft.NETCore.App": "1.0.0",
02 "Microsoft.EntityFrameworkCore": "1.0.0",
03 "Microsoft.EntityFrameworkCore.Design": "1.0.0-preview2-final",
04 "Microsoft.EntityFrameworkCore.SqlServer": "1.0.0",
05 "Projeto.Dominio": "1.0.0"

O pacote Microsoft.EntityFrameworkCore.Design, na linha 03, � o respons�vel por permitir a execuç�o do Migrations, que � um recurso do Entity Framework capaz de gerar e alterar bases de dados a partir das classes de modelo do projeto. J� na linha 05, estamos referenciando outra Class Library da nossa aplicaç�o, a Projeto.Dominio. Essa � a forma com que o .NET Core lida com refer�ncias entre Class Libraries dentro de um mesmo projeto.

Passo 3: Criar o DbContext

Neste passo criaremos a classe que servir� de intermedi�ria entre o modelo de classes e o banco de dados. Ela ser� respons�vel por processar o mapeamento objeto-relacional e fazer com que os dados trafeguem para ambos os lados: dom�nio e banco.

Sabendo disso, vamos criar um diret�rio chamado FonteDeDados e dentro dele a classe PersisteContext.cs, cujo c�digo � apresentado na Listagem 2.


01 using Projeto.Dominio;
02 namespace Projeto.Repositorio.FonteDeDados
03 {
04    public class PersisteContext : DbContext
05    {
06        public PersisteContext()
07        { }
08
09        public PersisteContext(DbContextOptions<PersisteContext> opcoes )
10            :base(opcoes)
11        { }
12
13        public DbSet<Cliente> Clientes { get; set; }
14        public DbSet<Pedido> Pedidos { get; set; }
15    }
16 }

Listagem 2. PClasse PersisteContext.cs

Linhas 09 e 10: criamos um novo construtor para permitir a injeç�o de depend�ncias do ASP.NET Core na camada de apresentaç�o;

Linhas 13 e 14: mapeamos as classes para que sejam reconhecidas no processo de mapeamento objeto-relacional.

Passo 4: Mapear as entidades com Fluent API

A nova vers�o do EF aposentou a classe EntityTypeConfiguration. Diante disso, n�o podemos mais criar mapeamentos com a Fluent API separadamente do resto do c�digo do DbContext. A partir de agora utilizaremos a classe ModelBuilder, que � passada como par�metro ao m�todo sobrescrito OnModelCreating, analisado mais adiante.

Antes de trabalhar diretamente nesse m�todo, no entanto, criaremos na PersisteContext o mapeamento das entidades Cliente e Pedido. Para tal, utilizaremos m�todos separados, um para cada entidade, passando ModelBuilder como par�metro, de acordo com a Listagem 3.


  01 private void ConfiguraCliente(ModelBuilder construtorDeModelos)
  02 {
  03     construtorDeModelos.Entity<Cliente>( etd=>
  04     {
  05           etd.ToTable("tbCliente");
  06           etd.HasKey(c => c.Id).HasName("id");
  07           etd.Property(c => c.Id).HasColumnName("id").ValueGeneratedOnAdd();
  08           etd.Property(c => c.Nome).HasColumnName("nome").HasMaxLength(100);
  09           etd.Property(c => c.Email).HasColumnName("email").HasMaxLength(30);
  10     });                
  11 }
  12
  13 private void ConfiguraPedido(ModelBuilder construtorDeModelos)
  14 {
  15     construtorDeModelos.Entity<Pedido>(etd =>
  16     {
  17           etd.ToTable("tbPedido");
  18           etd.HasKey(p => p.Id).HasName("id");
  19           etd.Property(p => p.Id).HasColumnName("id").ValueGeneratedOnAdd();
  20           etd.Property(p => p.Total).HasColumnName("total");
  21           etd.HasOne(c => c.Cliente).WithMany(p => p.Pedidos);
  22     });
  23 }

Listagem 3. Novas formas de mapeamento do EF7

Em seguida, sobrescrevemos o m�todo OnModelCreating e fazemos refer�ncia aos mapeamentos criados, como vemos na Listagem 4, concluindo assim a nossa classe de contexto.


01 protected override void OnModelCreating(ModelBuilder construtorDeModelos)
02 {
03	construtorDeModelos.ForSqlServerUseIdentityColumns();
04	construtorDeModelos.HasDefaultSchema("ControlePedidos");
05
06	ConfiguraCliente(construtorDeModelos);
07	ConfiguraPedido(construtorDeModelos);
08 }

Listagem 4. Refer�ncia dos m�todos de mapeamento

Linha 3: instru�mos o EF para que o banco de dados escolhido converta as chaves prim�rias utilizando o tipo Identity, que incrementa um valor inteiro a cada novo registro, trabalhando em conjunto com o m�todo ValueGeneratedOnAdd(), visto na Listagem 3;

Linha 04: definimos o nome do banco de dados que ser� gerado pelo EF;

Linhas 6 e 7: invocamos os m�todos criados anteriormente para realizar o mapeamento das duas entidades, evitando que o c�digo do OnModelCreating se torne muito extenso.

Saiba mais sobre mapeamento com Entity Framework Code First e Fluent API.

Passo 5: Permitir � Class Library executar o Migrations

At� aqui, criamos a nossa camada de reposit�rio desacoplada das demais, mas o Entity Framework Core n�o permite a criaç�o de bancos de dados via Migrations em Class Libraries.

Caso executemos os comados do Migrations nesse momento, receberemos duas mensagens de erro espec�ficas. A primeira delas �:


"Could not invoke this command on the startup project 'Projeto.Repositorio'.
This preview of Entity Framework tools does not support commands on class library projects in ASP.NET Core and .NET Core applications."

Para resolver essa situaç�o � necess�rio criar um m�todo Main na mesma Class Library, e para tal precisaremos adicionar uma classe na raiz do Projeto.Repositorio, chamada Principal.cs, cujo c�digo pode ser visto no c�digo abaixo:


01 public class Principal
02 {       
03  static void Main(string[] args){}   
04 }

Tamb�m precisamos abrir o project.json e dentro da seç�o buildOptions mudar o valor de "emitEntryPoint" para true, indicando que essa Class Library vai precisar gerar um execut�vel. Uma regra b�sica que podemos utilizar para decidir qual valor atribuir a essa propriedade �: caso haja um m�todo Main, ent�o esse valor dever� ser true, caso n�o exista esse m�todo, o valor ser� false.

Ao executarmos novamente qualquer comando do Migrations, receberemos uma outra mensagem de erro:


"No database provider has been configured for this DbContext.
A provider can be configured by overriding the DbContext. OnConfiguring method or by using AddDbContext on the application service provider.
If AddDbContext is used, then also ensure that your DbContext type accepts a DbContextOptions<TContext> object in its constructor and passes it to the base constructor for DbContext."

Para permitir esse procedimento, de acordo com a mensagem precisamos criar uma classe estendendo uma interface do EF: IDbContextFactory. Na Listagem 5 criamos essa classe dentro da camada de reposit�rio, para que o Migrations a localize e permita a criaç�o do banco de dados.


  01 namespace Projeto.Repositorio.FonteDeDados
  02 {
  03    public class FabricaPersisteContext : IDbContextFactory<PersisteContext>
  04    {
  05        private const string CONNECTIONSTRING = @"Data Source=GABRIEL-LAPTOP\SQLEXPRESSR2;Initial Catalog=ControlePedidos;Integrated Security=True"; 
  06        public PersisteContext Create(DbContextFactoryOptions options)
  07        {
  08           var construtor = new DbContextOptionsBuilder<PersisteContext>(); 
  09            construtor.UseSqlServer(CONNECTIONSTRING);
  10            return new PersisteContext(construtor.Options);
  11        }
  12    }
  13 }

Listagem 5. Criaç�o de uma f�brica de DbContext

Assim, quando o DbContext for chamado via injeç�o de depend�ncias do ASP.NET Core, nas camadas mais altas, automaticamente essa factory ser� chamada e ent�o devolver� uma nova inst�ncia do DbContext, dependendo do tipo de injeç�o.

Passo 6: Criando a base de dados com Migrations

Para criar a primeira migration, devemos inserir no prompt de comandos o seguinte c�digo:

dotnet ef migrations add Pedidos

Executado esse passo, receberemos a seguinte mensagem:

Done. To undo this action, use 'dotnet ef migrations remove'

Com esse comando, o Migrations criar� uma estrutura semelhante � que vemos na Figura 1, a partir da qual ser� gerado o nosso banco de dados.

Figura 1. Estrutura criada pelo Migrations

Agora, para sincronizar o modelo de classes com o banco de dados, digitamos o comando abaixo:

dotnet ef database update

Caso tudo ocorra sem quaisquer problemas, receberemos a seguinte resposta do Migrations:

Applying migration '20160710033248_ControlePedidos'.Done.

Nesse momento j� podemos verificar se realmente o banco e suas tabelas foram criadas, como mostra a Figura 2.

Figura 2. Banco de dados e tabelas criados

Com essa proposta, quando alteraç�es forem feitas nas entidades, basta adicionar novas migrations e execut�-las para que o banco seja atualizado.