在使用实体框架时，存储库应该是工作单元上的属性吗?

我在网上搜索了使用实体框架的存储库/工作单元模式的良好实现。我所遇到的一切要么在抽象的某个点上紧密耦合，要么假设工作单元和存储库使用的DbContext是共享的，并且应该为整个HTTP请求(通过依赖注入的每个请求实例)而存在。

public DirectoryService(IUnitOfWork unitOfWork, ICountryRepository countryRepo, IProvinceRepository provinceRepo)
{
    /* set member variables... */
}

工作单元构造函数可能是:

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

和一个存储库构造函数可能看起来像:

CountryRepository(IDbContext context)
{
    _context = context;
}

该解决方案盲目地假设依赖注入正在设置工作单元和存储库，以使用每个请求实例共享相同的IDbContext。这样的假设真的安全吗?

如果你对每个请求实例使用依赖注入，同样的IDbContext将被注入到多个工作单元中。功的单位不再是原子的了，是吗?我可能在一个服务中有挂起的更改，然后在另一个服务中提交，因为上下文是跨多个工作单元共享的。

对我来说，设置一个IDbContextFactory并获得每个工作单元的新数据库上下文似乎更有意义。

public interface IDbContextFactory
{
    IDbContext OpenContext();
}
public class UnitOfWork 
{
    private IDbContextFactory _factory;
    private IDbContext _context;
    UnitOfWork(IDbContextFactory factory)
    {
        _factory = factory;
    }
    internal IDbContext Context
    {
        get { return _context ?? (_context = _factory.OpenContext()); }
    }
}

问题就变成了，我如何使我的工作单元实现对注入的存储库可用?我不想假设每个请求都有一个实例，因为那样我就会回到我开始的同一条船上。

我能想到的唯一一件事就是遵循实体框架的领导，使存储库(IDbSet<T>)成为工作单元(DbContext)的一部分。

那么我可能有这样的功单位:

public class DirectoryUnitOfWork : IDirectoryUnitOfWork
{
    private IDbContextFactory _factory;
    private IDbContext _context;
    public DirectoryUnitOfWork(IDbContextFactory factory)
    {
        _factory = factory;
    }
    protected IDbContext Context 
    {
        get { return _context ?? (_context = _factory.OpenContext()); }
    }
    public ICountryRepository CountryRepository
    {
        get { return _countryRepo ?? (_countryRepo = new CountryRepository(Context)); }
    }
    public IProvinceRepository ProvinceRepository
    {
        get { return _provinceRepo ?? (_provinceRepo = new ProvinceRepository(Context)); }
    }
    void Commit()
    {
        Context.SaveChanges();
    }
}

然后我的目录服务开始看起来像这样

public class DirectoryService : IDirectoryService
{
    private IDirectoryUnitOfWork _unitOfWork;
    public DirectoryService(IDirectoryUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }
    public GetCountry(int id)
    {
        return _unitOfWork.CountryRepository.GetById(id);
    }
    public GetProvince(int id)
    {
        return _unitOfWork.ProvinceRepository.GetById(id);
    }
    public void AddProvince(Province province)
    {
        _unitOfWork.ProvinceRepository.Create(province);
        Country country = GetCountry(province.CountryId);
        country.NumberOfProvinces++; // Update aggregate count
        _unitOfWork.Commit();
    }
    /* ... and so on ... */
}

看起来工作量很大，但是使用这种方法使所有东西都松散耦合并且可以进行单元测试。我错过了一个更容易的方法，还是这是一个很好的方法来做它 if 我要抽象掉实体框架?