Mapeando suas entidades no Entity Framework Core 2.0

Ter um domínio limpo, livre de dependências e rico é uma preocupação que todos nós temos com os nossos softwares. Além de um domínio limpo e rico, nós buscamos que todas as demais partes do nosso software tenham métodos claros, que realizam apenas uma tarefa e simples de ser entendido por qualquer desenvolvedor.

Até a versão 6.x do Entity Framework, utilizando o Code First para modelagem de domínio, ao mapear as nossas entidades que serão tabelas no banco de dados, informando nome da tabela, colunas e etc, podemos utilizar Data Anotations ou o Fluent Map.

Com o Fluent Map, nós criamos uma classe separadamente do nosso domínio herdando da classe concreta EntityTypeConfiguration, informando no método construtor desta classe quais são as propriedades de mapeamento da entidade para o banco de dados, e então apenas chamar esta classe no método OnModelCreating do DataContext.

Veja um exemplo abaixo de mapeamento utilizando Fluent Map até a versão 6.x do Entity Framework:

Modelo

public class Category
{
    public Category ()
    {
        this.Products = new List<Product>();
    }
    
    public int Id { get; set; }
    public string Title { get; set; }
    public string Descricao { get; set; }
    public virtual ICollection<Product> Products { get; set; }
}

Mapeamento

public class CategoryMap : EntityTypeConfiguration<Category>
{
    public CategoryMap()
    {
        ToTable("Categorias");
        HasKey(x => x.Id);
        Property(x => x.Title)
        .HasMaxLength(60);
        .HasMany(x => x.Products);

        Property(x => x.Descricao)
        .HasMaxLength(100);
    }
}

Data Context

public class MyDataContext : DbContext
{
    public MyDataContext() : base("db_entity")
    {}

    public DbSet<Category> Categories { get; set; }
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Configurations.Add(new ProductMap());
        modelBuilder.Configurations.Add(new CategoryMap());
    }
}

Após o lançamento do Asp.net Core, o Entity Framework também iniciou o desenvolvimento e lançou sua versão Entity Framework Core para utilização em projetos .net core.

Entretanto até a versão 1.x do Entity Framework Core não havia uma implementação que viabilize o mapeamento das entidades que forma simples e organizada como nas versões anteriores (até 6.x). Para realizar o mapeamento das entidades você poderia utilizar as Data Anotations (o que acabaria adicionando de certa forma uma dependência ao seu modelo) ou aplicar todas as configurações de todas as suas entidades no método OnModelCreating, veja um exemplo abaixo:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Customer>().ToTable("Consumidores");
    modelBuilder.Entity<Customer>().HasKey(x => x.Id);
    modelBuilder.Entity<Customer>()
    .Property(x => x.Name)
    .HasColumnName("Nome")
    .HasMaxLength(500);
}

Com apenas uma entidade isto pode até não parece tão ruim, mas imagine isto em larga escala, o método ficaria muito grande, pouco separado e muito difícil de entender.

Você poderia utilizar algumas outras abordagens para realizar o mapeamento de forma separada, utilizando classes de mapeamento, como extension methods, mas também não seria algo simples.

Após o lançamento da versão 2.0 do Entity Framework Core, foi adicionado o método ApplyConfiguration a classe ModelBuilder que recebe uma classe que implemente a interface IEntityTypeConfiguration. Com este método podemos então criar uma classe de mapeamento/configuração implementando a classe IEntityTypeConfiguration.

Veja abaixo:

Modelo

public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}

Mapeamento/Configuração

public class CuatomerConfiguration : IEntityTypeConfiguration<Customer>
{
    public void Configure(EntityTypeBuilder<Customer> builder)
    {
        builder.ToTable("Consumidores");
        builder.HasKey(x => x.Id);
        builder.Property(x => x.Name)
        .HasColumnName("Nome")
        .HasMaxLength(200);
    }
}

E então passar esta classe para o método ApplyConfiguration no método OnModelBuilder do DataContext:

public class AppDataContext : DbContext
{
    public AppDataContext(DbContextOptions<AppDataContext> options) : base(options)
    {}
    
    public DbSet<Customer> Customers { get; set; }
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.ApplyConfiguration(new CuatomerMap());
    }
}

Após esta implementação na versão 2.0 podemos manter o nosso método OnModelCreating simples apenas chamando as classes de configuração/mapeamento. Muito parecido como utilizamos até a versão 6.x.

That’s all folks!

#Ubuntu