Ability to exclude/skip/ignore parts of the model from migrations so that a table is not created (for overlapping bounded contexts)

[brent-russell]

I suggest having an attribute that can be applied to DbSet properties in a DbContext, which indicates whether or not to include them in the migration scaffolding process.

An example use case is when part of an application's database is replicated from another environment. Replicated entities will be included in the same DbContext as custom-developed entities so they can be queried. During development many migrations may be performed. Each time a migration is scaffolded, the replicated entities will be added to the migration, and then must be removed manually.

If an attribute only used for EF commands is too polluting to include in the DbContext, some alternatives might be: an additional config file that can be specified on the command line listing which entities should be excluded. Or perhaps additional command line arguments that allow a migration to be generated for specified entities only instead of scanning and comparing all entities.

Also consider the scenario of inherited models when looking at this feature #5572

[rowanmiller]

Agreed that this would be good to enable. Generalized the title a bit as an attribute may or may not be the best way to do this. An attribute may be good sugar over a more powerful hook to exclude parts of the model.

Moving to backlog as we will look at this after the first stable release.

[wwarby]

+1, this to would be extremely useful.

[maleet]

+1

[ownakas1mon]

+1

[soeron]

+1 any status on this item?

[neridonk]

+1 any status on this item?

[rowanmiller]

No updates. We want to do it, but there are several items higher than it on the backlog.

[omayhemo]

Those items listed as higher on the backlog have now been closed. When can we expect inclusion to a sprint?

[rowanmiller]

The main features we talk about being higher priority are the ones listed here https://docs.microsoft.com/en-us/ef/efcore-and-ef6/features. There is still quite a list of them that have not been implemented.

[thiennn]

I just found a workaround

1. Create another DbContext that inherit your DbContext, for example MigrationDbContext. Override the OnModelCreating method and ingore entities that you want it's table not being generated.

 protected override void OnModelCreating(ModelBuilder builder)
 {
     base.OnModelCreating(builder);
     builder.Ignore<Category>();
 }

2. Create another class that implement IDbContextFactory. For example

    public class MigrationContextFactory : IDbContextFactory<MigrationDbContext>
    {
        public MigrationDbContext Create()
        {
            var optionsBuilder = new DbContextOptionsBuilder<MigrationDbContext>();
            optionsBuilder.UseSqlite("Data Source=blog.db");

            return new MigrationDbContext(optionsBuilder.Options);
        }
    }

The migration tool will discover this MigrationContextFactory and use the MigrationDbContext.

[Oskarsson]

+1, This would make it possible to use ef core in plugin based architectures with each context inheriting from the core context with working relationships between contexts.

[Mucaccino]

+1

[soeron]

+1

[webwarrior06]

I solved it checking from where the entity builder is called, (from "add-migration Xyz" command or the normal dbContext operations) If a migration operation calls the builder, I ignore the entity that I want to ignore just for migration purposes.
Here is my workaround;
https://stackoverflow.com/a/62281191/1928672

[aloksharma1]

did this ever got added in new versions, +1000000 btw :)

[AndriySvyryd]

@aloksharma1 Yes, it's in 5.0.0

[VeMike]

So how would I ignore just a base class, but not a derived class using this approach?

Consider the following model:

[Table(nameof(Human))]
public class Human
{
    [Key]
    [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
    public int HumanId { get; set; }
    
    public int Age { get; set; }
}

[Table(nameof(Developer))]
public class Developer : Human
{
    public string MainLanguage { get; set; }
}

The database context for this model is the following

public class FooContext : DbContext
{
    public DbSet<Developer> Developers { get; set; } = null!;

    /// <inheritdoc />
    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        // This is made to get TPT
        modelBuilder.Entity<Human>().ToTable(nameof(Human));
        modelBuilder.Entity<Developer>().ToTable(nameof(Developer));
        
        modelBuilder.Entity<Human>().ToTable(nameof(Human), t => t.ExcludeFromMigrations());
    }

    /// <inheritdoc />
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        base.OnConfiguring(optionsBuilder);

        optionsBuilder.UseSqlServer("<FooBarConnectionString>");
    }
}

As you can see I only want Developer to be in the migration. Human should be excluded. Why would I want to do this? I am extending an existing model and the base (Human) already exists in the database. I want to add Developer to this existing model.

But if I create a migration the whole hierarchy of Human is excluded (basically all classes of type Human). But I want the Developer to be created.

Of course, I could just remove the line

modelBuilder.Entity<Human>().ToTable(nameof(Human), t => t.ExcludeFromMigrations());

and then manually remove the added Human from the migration. But is there a way to do this automatically?

[ajcvickers]

@VeMike Moved here: #30079