[英]Dependency injection in unit of work pattern using repositories
我想创建一个环绕在类似的方式对存储库工作类的单元此 。
我遇到的问题是尝试通过用IRepository接口替换示例中的通用存储库来实现依赖注入。 在链接文章中的uow中,他们使用getter来检查存储库是否被实例化,如果不是,则实例化它。
public GenericRepository<Department> DepartmentRepository
{
get
{
if (this.departmentRepository == null)
{
this.departmentRepository = new GenericRepository<Department>(context);
}
return departmentRepository;
}
}
这是强烈耦合的。
我可以通过两种方式看到这一点。
1的问题是,如果我注入所有存储库,我必须实例化每个存储库,即使我不在特定的工作单元实例中使用它们。 因此招致了这样做的开销。 我想象使用一个数据库范围的工作单元,这会导致很多不必要的实例化和一个巨大的构造函数。
2的问题是很容易忘记设置和结束空引用异常。
在这种情况下是否有任何最佳实践? 还有其他我错过的选择吗?
我刚刚进入依赖注入并完成了我可以在这个主题上找到的所有研究,但我可能会遗漏一些关键。
解决这个问题的方法是不要让UnitOfWork
负责通过Container注入创建每个Repository
,而是让每个Repository
负责确保UnitOfWork
在实例化时知道它的存在。
这将确保这一点
UnitOfWork
不需要为每个新Repository
进行更改 一些代码最好地证明了这一点 - 我使用SimpleInjector,因此示例基于此:
从Repository
抽象开始:
public interface IRepository
{
void Submit();
}
public interface IRepository<T> :IRepository where T : class { }
public abstract class GenericRepository<T> : IRepository<T> where T : class { }
和UnitOfWork
public interface IUnitOfWork
{
void Register(IRepository repository);
void Commit();
}
每个Repository
必须使用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());
最后,运行此Console测试代码:
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,并建议您在此处和此处阅读这两篇文章。
注入单个工厂对象而不是注入存储库实例,这将负责创建这些实例。 然后,您的吸气剂将使用该工厂。
我的解决方案是UnitOfWork仍负责创建Repository,但我在UnitOfWork中创建了一个GetRepository()工厂方法来执行此操作。
public interface IUnitOfWork : IDisposable
{
T GetRepository<T>() where T : class;
void Save();
}
public class UnitOfWork : IUnitOfWork
{
private Model1 db;
public UnitOfWork() : this(new Model1()) { }
public UnitOfWork(TSRModel1 dbContext)
{
db = dbContext;
}
public T GetRepository<T>() where T : class
{
var result = (T)Activator.CreateInstance(typeof(T), db);
if (result != null)
{
return result;
}
return null;
}
public void Save()
{
db.SaveChanges();
}
private bool disposed = false;
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
db.Dispose();
}
}
this.disposed = true;
}
public void Dispose()
{
Dispose(true);
GC.SuppressFinalize(this);
}
}
public class TestRepository : GenericRepository<Test>, ITestRepository
{
public TestRepository(Model1 db)
: base(db)
{
}
}
public class TestManager: ITestManager
{
private IUnitOfWork unitOfWork;
private ITestRepository testRepository;
public TestManager(IUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
testRepository = unitOfWork.GetRepository<TestRepository>();
}
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.