Entity Framework : Sharing entities across different DbContexts

ef-code-first ef-migrations entity-framework entity-framework-6


I'm developing a plugin application with EF6, code first.

I have one main context with an entity called User:

public class MainDataContext : DbContext
    public MainDataContext(): base("MainDataContextCS") {}
    public DbSet<User> Users { get; set; }

And then another context for PluginX, on another project which references the base one:

public class PluginDataContext : DbContext
    public PluginDataContext () : base("MainDataContextCS") {

    protected override void OnModelCreating(DbModelBuilder modelBuilder) {

    public DbSet<Booking> Bookings { get; set; }

And this neatly creates, on the same Database (same connection string), the PluginX.Bookings Table.

The problem here is that the Booking entity contains a reference to User entity:

public class Booking
    public int Id { get; set;}
    public virtual User CreationUser { get; set;}
    public BookingStatus Status { get; set; }

And when running Add-Migration for the plugin context EF will try to create another User entity called PluginX.User.

How can this be solved? Is there a way to share a common entity, in another DbContext?

1/16/2015 8:05:56 AM

Accepted Answer

When you work with multiple contexts you have two options:

  1. Treat each context like they were separate applications. Imagine your user is an external resource that you get from a web service. You won't be able to add a foreign key to that. What you would do in this is either add only the userId in your tables and when you need the user details call the external service to get them or have a local light copy of the user in the Bookings context that you would update every now and then from the Users context. This approach is good when you work with a large system and you want to isolate the parts (read about DDD and bounded contexts)
  2. Apart from your 2 contexts, create a third context with the whole model (users, bookings, etc). You will use the complete context to create the migrations and maintain the DB structure, but in the application you will use the smaller contexts. This is a very simple solution. It's easy to maintain the migrations with a single context and it still allows you to isolate the DB operation in smaller contexts that don't have access to unrelated entities.
12/26/2019 6:47:41 PM

Popular Answer

When you add the Booking entity, don't use the DbSet.Add() method. Instead use the DbSet.Attach() method and set the DbContext.Entry(Entity).State property for the Booking to EntityState.Added and make sure the DbContext.Entry(Entity).State for User stays EntityState.Unchanged.

So for example instead of doing this:


Do this:

pluginDataContext.Entry(myNewBooking).State = EntityState.Added;

This is because the Add() method marks all entities in the object graph as EntityState.Added which will cause inserts without checking if the entity already exists in the database. The Attach() method simply makes the context begin tracking the entity.

This is why I almost never use DbSet.Add().

Related Questions


Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow