具有多个 DbContext 的存储库和工作单元模式的最佳实践

Question

我计划使用 ASP.NET MVC 和 Entity Framework 6 (Code First / POCO) 开发一个 Web 应用程序。我还想在我的应用程序中使用通用存储库和工作单元模式。这个应用程序连接到两个以上的数据库，所以我必须在应用程序中使用多个 DbContext。

public class ContextOne : DbContext
{
    public DbSet<Model_One1>
    public DbSet<Model_One2>
}

public class ContextTwo : DbContext
{
    public DbSet<Model_Two1>
    public DbSet<Model_Two2>
}

public class ContextThree : DbContext
{
    public DbSet<Model_Three1>
    public DbSet<Model_Three2>
}

public interface IRepository<T> where T : DbContext
{
    void Add<T>(T entity) where T : class;
}

public class Repository<T> where T : DbContext
{
    void Add<T>(T entity) where T : class
    {
        //T is DbContext and Model. So confusing
    }
}

public interface IUnitOfWork<IRepository>
{
}

public class UnitOfWork<IRepository>
{
    //IRepository contains more than one DbContext how can I initiate them here?
}

//in application should look like this
public class BaseController : Controller
{
    protected IRepository repository = new .. //here I have no idea with multiple DbContext
}

public class HomeController : BaseController
{
    public ActionResult Add(Model_Two2 model)
    {
        base.repository.Add<Model_Two2>(model)
    }
}

如果我从 Controller 调用 IRepository 和 IUnitOfWork 我如何知道匹配的上下文？这个问题的最佳实践是什么？

Answer 1

我建议您使用 Constructor 参数创建 UnitOfWork 模式以接受 DbContext -

public class UnitOfWork : IUnitOfWork
{
    private readonly IDbContext _context;

    private bool _disposed;
    private Hashtable _repositories;

    public UnitOfWork(IDbContext context)
    {
        _context = context;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    public void Save()
    {
        _context.SaveChanges();
    }

    public virtual void Dispose(bool disposing)
    {
        if (!_disposed)
            if (disposing)
                _context.Dispose();

        _disposed = true;
    }

    public IRepository<TEntity> Repository<TEntity>() where TEntity : class
    {
        if (_repositories == null)
            _repositories = new Hashtable();

        var type = typeof(TEntity).Name;

        if (_repositories.ContainsKey(type)) return (IRepository<TEntity>) _repositories[type];

        var repositoryType = typeof (Repository<>);

        var repositoryInstance =
            Activator.CreateInstance(repositoryType
                .MakeGenericType(typeof (TEntity)), _context);

        _repositories.Add(type, repositoryInstance);

        return (IRepository<TEntity>) _repositories[type];
    }
}

IDbContext 在哪里 -

public interface IDbContext
{
    IDbSet<T> Set<T>() where T : class;
    int SaveChanges();
    void Dispose();
}

而存储库实现将是 -

 public class Repository<TEntity> : IRepository<TEntity> where TEntity : class
    {
        internal IDbContext Context;
        internal IDbSet<TEntity> DbSet;

        public Repository(IDbContext context)
        {
            Context = context;
            DbSet = context.Set<TEntity>();
        }

        public virtual TEntity FindById(object id)
        {
            return DbSet.Find(id);
        }

        public virtual void Update(TEntity entity)
        {
            DbSet.Attach(entity);
        }
        public virtual void Delete(object id)
        {
            var entity = DbSet.Find(id);
            var objectState = entity as IObjectState;
            if (objectState != null)
                objectState.State = ObjectState.Deleted;
            Delete(entity);
        }

        public virtual void Delete(TEntity entity)
        {
            DbSet.Attach(entity);
            DbSet.Remove(entity);
        }

        public virtual void Insert(TEntity entity)
        {
            DbSet.Attach(entity);
        }

        public virtual List<TEntity> GetAll()
        {
            return DbSet.ToList();
        }
    }

使用这种方法，您可以为单个 DBContext 创建一个 UnitOfWork，并且您可以在 UnitOfWork 中提交或回滚特定的逻辑。

Answer 2

我会将UnitOfWork 实现为ActionAttribute，其中OnActionExecuting 我打开事务，OnActionExecuted 我提交事务，如果一切正常，如果ActionContext 出现异常，事务应该回滚。

棘手的是您有 2 个 DbContext。我认为，您应该懒惰地创建 dbContexts。引入一种标志变量，在UnitOfWork.OnActionExecuting中设置为True。然后，当你第一次接触 dbContext 时，你应该检查你是否正在处理UnitOfWork，如果是，你应该为这个特定的 dbContext 打开事务。所有打开的交易都可以放入一个可以从UnitOfWork.ActionExecuted 访问的列表中。最后检查ActionContext中是否有异常：是-Rollback，否-Commit。