使用存储库的工作单元模式中的依赖项注入

我想创建一个工作单元类，以类似的方式包装存储库this.

我遇到的问题是尝试通过用 IRepository 接口替换示例中的通用存储库来实现依赖项注入。在链接文章的 uow 中，他们使用 getter 来检查存储库是否已实例化，如果没有则实例化它。

public GenericRepository<Department> DepartmentRepository
{
    get
    {
        if (this.departmentRepository == null)
        {
            this.departmentRepository = new GenericRepository<Department>(context);
        }
        return departmentRepository;
    }
}

这是强耦合的。

我可以看到两种解决方法。

1. 使用构造函数注入。
2. 使用 setter 注入。

1 的问题是，如果我注入所有存储库，即使我不在特定的工作单元实例中使用它们，我也必须实例化每个存储库。从而产生这样做的开销。我想象使用一个数据库范围的工作单元类，因此这将导致大量不必要的实例化和巨大的构造函数。

2 的问题是很容易忘记设置并最终导致空引用异常。

在这种情况下有什么最佳实践吗？还有其他我错过的选择吗？

我刚刚开始依赖注入，并完成了我能找到的关于该主题的所有研究，但我可能遗漏了一些关键的东西。

解决这个问题的一种方法是不使UnitOfWork负责创建每个Repository通过容器注入，而是让它成为每个人的责任Repository以确保UnitOfWork在实例化时知道它的存在。

这将确保

• your UnitOfWork不需要为每个新的改变Repository
• 您没有使用服务定位器（许多人认为是反模式)

这可以通过一些代码得到最好的证明 - 我使用简单注入器所以这些例子都是基于这个：

从Repository抽象：

public interface IRepository 
{
    void Submit();
}
public interface IRepository<T> :IRepository where T : class { }
public abstract class GenericRepository<T> : IRepository<T> where T : class { }

and the UnitOfWork

public interface IUnitOfWork
{
    void Register(IRepository repository);
    void Commit();
}

Each Repository must将自己注册到UnitOfWork这可以通过更改抽象父类来完成GenericRepository确保完成：

public abstract class GenericRepository<T> : IRepository<T> where T : class
{
    public GenericRepository(IUnitOfWork unitOfWork)
    {
        unitOfWork.Register(this);
    }
}

每一个真实的Repository继承自GenericRepository:

public class Department { }
public class Student { }

public class DepartmentRepository : GenericRepository<Department> 
{
    public DepartmentRepository(IUnitOfWork unitOfWork): base(unitOfWork) { }
}

public class StudentRepository : GenericRepository<Student>
{
    public StudentRepository(IUnitOfWork unitOfWork) : base(unitOfWork) { }
}

添加到物理实现中UnitOfWork一切准备就绪：

public class UnitOfWork : IUnitOfWork
{
    private readonly Dictionary<string, IRepository> _repositories;
    public UnitOfWork()
    {
        _repositories = new Dictionary<string, IRepository>();
    }

    public void Register(IRepository repository)
    {
        _repositories.Add(repository.GetType().Name, repository);
    }

    public void Commit()
    {
        _repositories.ToList().ForEach(x => x.Value.Submit());
    }
}

容器注册可以设置为自动拾取所有定义的实例IRepository并在生命周期范围内注册它们，以确保它们在您的交易生命周期内都存活：

public static class BootStrapper
{
    public static void Configure(Container container)
    {
        var lifetimeScope = new LifetimeScopeLifestyle();

        container.Register<IUnitOfWork, UnitOfWork>(lifetimeScope);

        container.RegisterManyForOpenGeneric(
            typeof(IRepository<>),
            lifetimeScope,
            typeof(IRepository<>).Assembly);
    }
}

有了这些抽象和围绕 DI 构建的架构，您就拥有了UnitOfWork知道一切的Repository已在任何服务调用中实例化，并且您可以在编译时验证所有存储库均已定义。你的代码是对扩展开放，对修改关闭.

要测试这一切 - 添加这些类

public class SomeActivity
{
    public SomeActivity(IRepository<Department> departments) { }
}

public class MainActivity
{
    private readonly IUnitOfWork _unitOfWork;
    public MainActivity(IUnitOfWork unitOfWork, SomeActivity activity) 
    {
        _unitOfWork = unitOfWork;
    }

    public void test()
    {
        _unitOfWork.Commit();
    }
}

将这些行添加到BootStrapper.Configure()

//register the test classes
container.Register<SomeActivity>();
container.Register<MainActivity>();

在代码行上放置一个断点：

_repositories.ToList().ForEach(x => x.Value.Submit());

最后，运行此控制台测试代码：

class Program
{
    static void Main(string[] args)
    {
        Container container = new Container();
        BootStrapper.Configure(container);
        container.Verify();
        using (container.BeginLifetimeScope())
        {
            MainActivity entryPoint = container.GetInstance<MainActivity>();
            entryPoint.test();
        }
    }
}

您会发现代码在断点处停止，并且您有一个活动的实例IRepository准备好并等待Submit()对数据库的任何更改。

您可以装饰您的 UnitOfWork 来处理事务等。此时我将遵循强大的 .NetJunkie 并建议您阅读这两篇文章here and here.