Method that works without I call you directly

Question

I’m messing with the Entity Framework and I was mapping to a Many to Many class.

What happens is I used a method I can use inside the DbContext to rename a table, and it works smoothly.

But I was wondering how this method works being that I do not call it anywhere in my program? In case it would be the method OnModelCreating().

class EfContext : DbContext
{
    public DbSet<Editora> EditorasDbSet { get; set; }
    public DbSet<Cliente> ClientesDbSet { get; set; }
    public DbSet<Estado> EstadosDbSet { get; set; }
    public DbSet<Governador> GovernadorsDbSet { get; set; }
    public DbSet<Departamento> DepartamentosDbSet { get; set; }
    public DbSet<Funcionario> FuncionariosDbSet { get; set; }
    public DbSet<Pedido> PedidosDbSet { get; set; }
    public DbSet<Consumidor> ConsumidoresDbSet { get; set; }
    public DbSet<Autor> AutorsDbSet { get; set; }
    public DbSet<Livro> LivrosDbSet { get; set; }

    public EfContext()
    {
        CustomDBInitializer initializer = new CustomDBInitializer();
        Database.SetInitializer<EfContext>(initializer);
    }

    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Autor>().HasMany(autor => autor.Livros).WithMany(livro => livro.Autores).Map( x => 
        {
            x.ToTable("livros_e_autores");
            x.MapLeftKey("autor_id");
            x.MapRightKey("livro_id");
        });
    }

}

Answer 1

First you need to understand what is a framework.

You are inheriting from DbContext that the Entity Framework knows what it is and knows there is a method OnModelCreating(). Somewhere within the entire RU infrastructure this method is called when it is suitable. It knows when it needs it.

What it lets you do is write the implementation of this method in its inherited class, so it establishes the virtual and you do it with override.

So when you pass an object EfContext in a place that awaits a DbContext, After all they are compatible, and this is polymorphism, it will call your method and not the method of DbContext. He knows what to call, but does not know what will be executed, you define it. Clever, not?

A different example of this can be seen in What is the difference between using virtual property or not in EF?.