15

使用此示例和此实现提供的组合，我正在尝试创建一个解决方案，将UnitOfWork类与各个存储库分离，因为它们违反了开闭原则，因为每次添加新存储库时，您都必须修改UnitOfWork类. 我使用 Unity 作为 IoC 容器来连接依赖项。

我遇到的问题是，在使用 Unity 自动连接UnitOfWork、IDbContext和存储库（IEmployeeRepository和ICustomerRepository）时，存储库将被注入 的单独实例UnitOfWork，这当然违背了目的。我需要在存储库之间共享上下文，看来我错过了这个难题的一部分 - 目前（请参阅服务层）UnitOfWork实例化将与UnitOfWork每个存储库不同。

如何使用 Unity 和依赖注入将其IUnitOfWork注入服务层并将这个实例化的共享 UnitOfWork类传递给各自的存储库？

这是我提出的（制造的）解决方案：

存储库

public interface IRepository<TEntity> where TEntity : class
{
    TEntity Create();
    // omitted for brevity
}

public class Repository<TEntity> : IRepository<TEntity>
    where TEntity : class
{       
    private readonly DbContext _context;

    public Repository(IUnitOfWork uow)
    {
        _context = uow.Context;
    }

    public virtual TEntity Create(TEntity entity)
    {
        return _context.Set<TEntity>().Add(entity);         
    }   

    // omitted for brevity      
}

public interface IEmployeeRepository : IRepository<Employee>
{
}

public interface ICustomerRepository : IRepository<Customer>
{
}

public class EmployeeRepository : Repository<Employee>
{
    public EmployeeRepository(IUnitOfWork uow)
        : base(uow)
    {
    }
}

public class CustomerRepository : Repository<Customer>
{
    public CustomerRepository(IUnitOfWork uow)
        : base(uow)
    {
    }
}

数据库上下文工厂

public interface IDbContextFactory
{
    DbContext GetContext();
}

public class DbContextFactory : IDbContextFactory
{
    private readonly DbContext _context;

    public DbContextFactory()
    {
        _context = new MyDbContext("ConnectionStringName");
    }

    public DbContext GetContext()
    {
        return _context;
    }
}

工作单元

public interface IUnitOfWork
{
    void SaveChanges();
    DbContext Context { get; }
}

public class UnitOfWork : IUnitOfWork, IDisposable
{
    private readonly DbContext _context;
    private bool disposed = false;

    public UnitOfWork(IDbContextFactory contextFactory)
    {
        _context = contextFactory.GetContext();
    }

    public void SaveChanges()
    {
        if (_context != null)
        {
            _context.SaveChanges();
        }
    }

    public DbContext Context
    {
        get { return _context; }
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!disposed)
        {
            if (disposing)
            {
                _context.Dispose();
            }
        }
        disposed = true;
    }

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

服务

public class CompanyService
{
    private readonly IUnitOfWork _uow;
    private readonly IEmployeeRepository _employeeRepository;
    private readonly ICustomerRepository _customerRepository;

    public CompanyService(IUnitOfWork uow, IEmployeeRepository employeeRepository, ICustomerRepository customerRepository)
    {           
        _uow = uow;
        _employeeRepository = employeeRepository;
        _customerRepository = customerRepository;
    }

    // over-simplified example method
    public void AddEmployeeAndCustomer()
    {
        _employeeRepository.Create(new Employee {Id = 1, Name = "Test Employee"});
        _customerRepository.Create(new Customer { Id = 2, Name = "Test Customer" });

        _uow.SaveChanges();
    }

}
4

1 回答 1

8

我认为您正在寻找的是每个请求生命周期管理器，以便在请求期间您只获得一个 UnitOfWork 实例和一个 DbContext 实例。Unity 3 具有适用于 ASP.NET MVC 的 Unity 引导程序，它有一个PerRequestLifetimeManager可让您执行此操作。

如果您不使用 ASP.NET，那么您可能会使用 PerResolveLifetimeManager。我见过的另一种方法是 HierarchicalLifetimeManager 与子容器相结合（这使得注册成为子容器中的单例）。

于 2013-10-01T14:47:57.197 回答