在 Entity Framework Core 中使用 2 个数据库共享一个 model

Question

I have 2 databases, one on-premises and one in the cloud, I want them to be in sync whenever the local database adds or updates data.

I created the 2 databases and both of them share the same model ( School )

public virtual DbSet<School> School { get; set; }

The problem that happens is, when I do:

TestDb1DbContext context;
SecondProjectDb remoteContext;

string connString = ConfigurationManager.ConnectionStrings["TestDb1"].ConnectionString;
var contextOptions = new DbContextOptionsBuilder<TestDb1DbContext>().UseSqlServer(connString).Options;
context = new TestDb1DbContext(contextOptions);

string remoteconnString = ConfigurationManager.ConnectionStrings["RemoteTestDb1"].ConnectionString;
var remotecontextOptions = new DbContextOptionsBuilder<SecondProjectDb>().UseSqlServer(connString).Options;
remoteContext = new SecondProjectDb(remotecontextOptions);

var schools = remoteContext.School.ToList();

I get the results of context database, while the remoteContext is empty because I have not added anything there.

If I try to add a row

school.Id = "one";
school.Name = "myschool";

context.School.Add(school);
remoteContext.School.Add(school);
context.SaveChanges();
>>> remoteContext.SaveChanges();

I get errors of duplicate Ids.

I am not sure how to keep these 2 databases in sync, since it seems that both contexts are sharing the same reference?

Answer 1

So you have a remote database, which is fairly standard. It can be changed using the standard entity framework methods.

You also have a local database, which is very similar to the remote database, except, that when it is to be updated, it also has to update the remote database.

You've learned, that if you have a class that behaves almost exactly like another class, except for a few aberrations, you should at least consider the possibility of derivation.

I want them to be in sync whenever the local database adds or updates data.

Apparently, if the remote database changes, the local database doesn't have to be updated to reflect those changes.

How about this:

// your current DbContext, can handle your local database as well as your remote one
// however, if the local database is updated, this version doesn't update the remote one.

class MyDbContext : DbContext
{
    public MyDbContext(...) : DbContext(...) {...}

    public DbSet<School> Schools {get; set;}
    public DbSet<...>  ... // etc
}

I don't know the parameters of your constructor, let's assume they are:

public MyDbContext(MyDbContextParameters parameters) ...

We create a derived class that represents your local database. To make it more generic: it represent a database, that whenever it is updated, it will also update another database (in your case: the remote database).

The constructor of this class, needs the parameters to create the local database, and the ones to create the remote database.

class MyAutoUpdateDbContext : MyDbContext         // TODO: invent a proper name
{
    private MyDbContextParameters RemoteParameters {get; set;}

    public MyAutoUpdateDbContext(
        MyDbContextParameters localParameters,
        MyDbContextParameters remoteParameters) :

        MyDbContext(localParameters)
    {
        this.RemoteParameters = remoteParameters;
    }

The deviation of a standard MyDbContext is when you call SaveChanges. Instead of only updating the local database, you need to update the remote database as well. Continuing MyAutoUpdateDbContext:

    public override int SaveChanges ()
    {
        // TODO: detect which items are about to be updated
        // update them in the remote database before calling base.SaveChanges
        this.SaveChangesInRemote();
        return this.SaveChanges();
    }

There might be a problem, if some items can't be updated. If you need to handle this scenario, consider to use a transaction before updating the databases. This is a bit out-of-scope of the question, so I'll ignore it.

To save the changes in Remote, you'll need to find out which items will be saved in the local database when you call this.SaveChanges() . You can find these items in this.ChangeTracker .

private int SaveChangesInRemote()
{
    var changeTracker = this.ChangeTracker;
    if (changeTracker.HasChanges)
    {
        IEnumerable<DbEntityEntry> changedEntries = this.changeTracker.Entries
            .Where(entry => entry.State != EntityState.Unchanged);
        return this.SaveInRemote(changedEntries);
    }
}

To save the changed entries in remote database, create the DbContext for the remote database and Attach all changed entries before calling SaveChanges:

private int SaveInRemote(IEnumerable<DbEntityEntry> changedEntries)
{
    using (MyDbContext remoteDbContext = this.CreateRemoteDbContext())
    {
        foreach (DbEntityEntry entry in changedEntries)
        {
            remoteDbContext.Attach(entry);
        }
        return remoteDbContext.SaveChanges();
    }
}