1

Question

我们有两个数据库，其中包含用户表格，如下所示：

MasterDB.AspNetUsers
Customer1DB.AspNetUsers

我们使用 MasterDb 登录用户，然后将它们连接到客户数据库，例如 Customer1DB （或某些其他客户数据库，具体取决于用户）。两个用户表都具有基于ASP.NET Identity Framework的相同模式，我们可以使用IdentityManager来管理 MasterDb 上的用户。

现在我想要的是对 MasterDb 用户记录执行的任何更改，将其镜像到客户数据库上的users表（具有相同的用户ID）。我想知道最好的方法是什么？我是否需要修改UserStore，RoleStore，UserManager，RoleManager上的所有操作？我有一个获取UserId的函数，并将其从第一个db添加或更新到第二个db，但我不确定我应该如何将它集成到Identity Framework实现中。

谢谢！

Answer 1

我认为你有两个选择：

为您需要的商店和功能创建适配器。适配器将在两个数据库上调用相同的方法。
在Master DbContext中，当您使用SaveChanges时，您会查看ChangeTracker并将更改复制到其他DbContext。

每种方法都有优点和不便之处。

1

示例适配器：

class MultiDatabaseUserStore<T> : IUserStore<T>
    where T : IdentityUser
{
    private readonly UserStore<T>[] stores;

    public MultiDatabaseUserStore(params IdentityDbContext[] dbContexts)
    {
        if (dbContexts == null || dbContexts.Length <= 0)
        {
            throw new ArgumentException("At least one db context is required.", "dbContexts");
        }

        this.stores = dbContexts.Select(x => new UserStore<T>(x)).ToArray();
    }

    public void Dispose()
    {
        foreach (var store in this.stores)
        {
            store.Dispose();
        }
    }

    public Task CreateAsync(T user)
    {
        return this.ExecuteOnAll(x => x.CreateAsync(user));
    }

    public Task UpdateAsync(T user)
    {
        return this.ExecuteOnAll(x => x.UpdateAsync(user));
    }

    public Task DeleteAsync(T user)
    {
        return this.ExecuteOnAll(x => x.DeleteAsync(user));
    }

    public Task<T> FindByIdAsync(string userId)
    {
        return this.stores.First().FindByIdAsync(userId);
    }

    public Task<T> FindByNameAsync(string userName)
    {
        return this.stores.First().FindByNameAsync(userName);
    }

    private Task ExecuteOnAll(Func<UserStore<T>, Task> function)
    {
        return Task.WhenAll(this.stores.Select(function));
    }
}

它整合如下：

var store = new MultiDatabaseUserStore<IdentityUser>(new MasterDb(), new Customer1DB());
var userManager = new UserManager<IdentityUser>(store);

这可行，但根据您的需要，您将有更多的接口来实现：

IUserLoginStore
IUserClaimStore
IUserRoleStore
IUserPasswordStore
IUserSecurityStampStore
IQueryableUserStore
IUserEmailStore
IUserPhoneNumberStore
IUserTwoFactorStore
IUserLockoutStore

2

Sample Master DbContext：

class MasterDb : IdentityDbContext
{
    public MasterDb()
    {
    }

    public override int SaveChanges()
    {
        var changes = this.GetChangesToReplicate();

        var i = base.SaveChanges();

        this.SaveReplicatedChanges(changes);

        return i;
    }

    public override Task<int> SaveChangesAsync()
    {
        return Task.Run(async () =>
        {
            var changes = this.GetChangesToReplicate();

            var i = await base.SaveChangesAsync();

            this.SaveReplicatedChanges(changes);

            return i;
        });
    }

    private void SaveReplicatedChanges(IEnumerable<Action<IdentityDbContext>> changes)
    {
        if (changes != null)
        {
            using (var db = new Customer1DB())
            {
                foreach (var change in changes)
                {
                    change(db);
                }

                db.SaveChanges();
            }
        }
    }

    private IEnumerable<Action<IdentityDbContext>> GetChangesToReplicate()
    {
        var actions = new List<Action<IdentityDbContext>>();
        var userTye = typeof(IdentityUser);
        var changedEntries = this.ChangeTracker.Entries();
        var users = changedEntries.Where(x => x.Entity.GetType() == userTye).ToList();

        foreach (var u in users)
        {
            switch (u.State)
            {
                case EntityState.Added:
                    var userToAdd = (IdentityUser)u.Entity;
                    actions.Add(db => db.Users.Add(userToAdd));
                    break;

                case EntityState.Modified:
                    var userToUpdate = (IdentityUser)u.Entity; ;
                    actions.Add(db =>
                    {
                        db.Users.Attach(userToUpdate);
                        db.Entry(userToUpdate).State = EntityState.Modified;
                    });
                    break;

                case EntityState.Deleted:
                    var userToDelete = (IdentityUser)u.Entity; ;
                    actions.Add(db =>
                    {
                        db.Users.Attach(userToDelete);
                        db.Entry(userToDelete).State = EntityState.Deleted;
                    });
                    break;
            }
        }

        return actions;
    }
}

这也有效，但仅限于用户实体。您必须根据需要添加角色，声明等的复制。

2改进

考虑到这一点，您可以跳过类型检查，并将所有更改复制到其他DbContext。这简化了很多代码，它将适用于角色/声明。您还需要添加bool属性IsReplicatingChanges以仅在必要时启用复制。

您必须仅为标识存储创建实例，并将标记设置为true：

var dbContext = new MasterDb { IsReplicatingChanges = true };
var userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(dbContext));
var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(dbContext));

GetChangesToReplicate()成为：

private IEnumerable<Action<IdentityDbContext>> GetChangesToReplicate()
{
    if (!this.IsReplicatingChanges) // Flag
    {
        // Return null when not activated
        return null;
    }

    var actions = new List<Action<IdentityDbContext>>();
    var changedEntries = this.ChangeTracker.Entries().Where(x => x.State != EntityState.Unchanged);

    foreach (var u in changedEntries)
    {
        var entity = u.Entity;
        var state = u.State;

        actions.Add(db =>
        {
            db.Set(entity.GetType()).Attach(entity);
            db.Entry(entity).State = state;
        });
    }

    return actions;
}

不要忘记将空检查添加到SaveReplicatedChanges()。

让IdentityManager在两个不同的数据库上进行更改

1 个答案:

1

2

2改进