例如,假设您正在从服务层使用存储库,则服务构造函数可能如下所示：

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 ... */
}

这似乎很多工作,但使用这种方法会使所有东西松散耦合并且可以进行单元测试.我是否错过了一种更简单的方法,或者如果我要抽象出实体框架,这是一个很好的方法吗？