使用工作单元在同一事务中从不同的存储库调用不同的方法

本文关键字：存储 方法 调用 事务 工作 单元 | 更新日期: 2023-09-27 17:55:26

我还在学习UnitOfWork模式，我还不适应这个模式。我找到了很多例子，但没有一个足以解决我的问题。我想将 UnitOfWork 与 Ado.Net 一起使用。我有很多存储库。我想使用工作单元在同一事务中调用来自不同存储库的不同方法。

例如，a 有这 2 个存储库。

public class FirstRepository : IFirstRepository
    {
        private readonly ILogger logger;
        private readonly IImportConfiguration configuration;
        public FirstRepository(ILogger logger, IImportConfiguration configuration)
        {
            this.logger = logger;
            this.configuration = configuration;
        }   
        public int Save()
        {
            //Save to DB with Ado.Net
            return 1;
        }
    }
public class SecondRepository : ISecondRepository
    {
        private readonly ILogger logger;
        private readonly IImportConfiguration configuration;
        public SecondRepository(ILogger logger, IImportConfiguration configuration)
        {
            this.logger = logger;
            this.configuration = configuration;
        }
        public int Update()
        {
            //Update in DB with Ado.Net
            return 1;
        }
    }

我想在同一个事务中调用函数 Save（） 和 Update（）。

using (var uow = UnitOfWorkFactory.Create())
{
     firstRepository.Save(); 
     secondRepository.Update();
     _unitOfWork.SaveChanges();
}

问题是如何在两个存储库中使用相同的工作单元？我唯一能看到的是向函数添加附加参数

//in first repository
Save(IUnitOfWork uow)
//in second repository
Update(IUnitOfWork uow)
//****************************
using (var uow = UnitOfWorkFactory.Create())
{
     firstRepository.Save(uow); 
     secondRepository.Update(uow);
     _unitOfWork.SaveChanges();
}

这是一个丑陋的解决方案，因为我必须在所有与DB一起使用的函数中都有这个参数。我正在使用依赖注入。ILogger 和 IImportConfiguration 注入了 AutoFac。也许在 UnitOfWork 中注册所有存储库会很好？但是怎么做呢？我不能在所有存储库中只注入一个实例。知道吗？

使用工作单元在同一事务中从不同的存储库调用不同的方法

public class UnitOfWork
{
    public DbSet<Company> Companies { get; set; }
    public int SaveChanges()
    {
        underlyingContext.SaveChanges();
    }
}
public class UnitOfWorkFactory
{
    public UnitOfWork Create() 
    {
        // real creation logic
        return new UnitOfWork();
    }
}
public class CompanyRepository
{
    private readonly UnitOfWork uow;
    public CompanyRepository(UnitOfWork uow)
    {
        uow = uow;
    }
    public void Add(Company company)
    {
        uow.Companies.Add(company);
    }  
}
public class CompanyRepositoryFactory
{
    public Create(UnitOfWork uow)
    {
        new CompanyRepository(uow);
    }
}

将它们捆绑在一起：

var uow = new UnitOfWorkFactory().Create();
var companyRepository = new CompanyRepositoryFactory().Create(uow);

因此，要使用 DI，您需要为所有这些创建接口。

工作单元基于某些数据层连接，例如，EF 使用将在基础UnitOfWork类中使用的DbContext。

您可以做的其他事情是使IUnitOfWork（接口）继承IDisposable以便使用using()。

为了使它没有一百个存储库类（尽管不是一件坏事），你可以让它成为通用的，所以IRepository<T>和Repository<T>

因此，对于使用 EF 的泛型存储库和工作单元。

public class UnitOfWork : IUnitOfWork
{
    ProjectDbContext context;
    public UnitOfWork() {
        context = new ProjectDbContext();    
    }
    public IQueryable<T> Query<T>(Expression<Func<bool, t>> predicate)
    {
        return context.Set<T>().Where(predicate);
    }
    public void Add<T>(T entity)
    {
        context.Set<T>().Add(entity);
    }
    public int SaveChanges()
    {
        return context.SaveChanges();
    }
    public void Dispose()
    {
        context.Dispose();
    }
}
public class UnitOfWorkFactory
{
    Lazy<UnitOfWork> lazyUOW = new Lazy<UnitOfWork>(() => new UnitOfWork());
    public UnitOfWork Create() 
    {
        // having the DI initialise as Singleton isn't enough.
        return lazyUOW.Value;
    }
}
public class Repository<T> : IRepository<T>
{
    private readonly IUnitOfWork uow;
    public Repository(IUnitOfWork uow)
    {
        uow = uow;
    }
    public void Add(T entity)
    {
        uow.Add(entity);
    }
    public List<T> AllBySomePredicate(Expression<Func<bool, T>> predicate)
    {
        return uow.Query(predicate).ToList();
    }  
}
public class RepositoryFactory : IRepositoryFactory 
{
    public Create<T>(UnitOfWork uow)
    {
        new Repistory<T>(uow);
    }
}

用法：

public class CompanyController : Controller
{
     private readonly IUnitOfWorkFactory uowFactory;
     private readonly IRepositoryFactory repoFactory;
     public CompanyController (
             IUnitOfWorkFactory uowFactory,
             IRepositoryFactory repoFactory)
     {
          uowFactory = uowFactory;
          repoFactory = repoFactory;
     }
     public ActionResult Index()
     {
         using(var uow = uowFactory.Create()) 
         {
             var companyRepo = repoFactory.Create<Company>(uow);
             return View(companyRepo.AllBySomePredicate(x => x.CompanyJoined == DateTime.Now.AddMonths(-2)));
         }
     }
}
相关文章：