Question

我继承了一些具有UnitOfWorkFactory的代码，该代码在每个存储库方法中创建一个工作单元。问题是单个存储库方法很少是完整的工作单元，所以如果说OrderService.PlaceOrder出现问题，它就不能回滚/丢弃该工作单元，因为它不是一个单元。

查看代码我认为应该将工作单元移动到服务类或演示者中。那么我遇到的问题是如何将其传递给服务或存储库？演示者将传递服务的实例，并且服务将传递存储库的实例。

我可以创建工作单元并让它注入服务，存储库和演示者的构造函数，但之后它将超越单个工作单元。这是一个桌面应用程序，因此演示者及其传递的任何服务都可以用于多个工作单元。

我认为可以通过工作单元的唯一方法是将其作为参数添加到所有服务/存储库方法中。我不禁想到必须有比这更好的方法，但是我错过了什么吗？

代码看起来像这样：

存储库：

class OrderRepository
{
    public UnitOfWorkFactory UnitOfWorkFactory;

    public OrderRepository(UnitOfWorkFactory unitOfWorkFactory)
    {
        UnitOfWorkFactory = unitOfWorkFactory;
    }

    public void Save(Order order)
    {
        using(var uow = UnitOfWorkFactory.Create())
        {
            // save order
            uow.commit();
        }
    }
}

Serivce：

class OrderService
{
    protected IOrderRepository OrderRepository;
    protected IProductService ProductService;

    public OrderService(IOrderRepository orderRepository, IProductRepository productService)
    {
        OrderRepository = orderRepository;
        ProductService = productService;
    }

    public void PlaceOrder(Order order)
    {
        foreach(var item in order.Items)
        {
            if(!ProductService.IsInstock(item.Product, item.Quantity))
                throw new ProductOutOfStockException(product);

            ProductService.MarkForDispatch(item.Product, item.Quantity);
        }

        OrderRepository.Save(order);
    }

    public void CancelOrder(Order order)
    {
        ProductService.UnmarkForDispatch(item.Product, item.Quantity);

        order.IsCanceled = true;
        OrderRepository.Save(order);
    }
}

主讲人：

class OrderPresenter
{
    protected IOrderView OrderView;
    protected IOrderService OrderService;

    public OrderPresenter(IOrderView orderView, IOrderService orderService)
    {
        OrderView = orderView;
        OrderService = orderService;
    }

    public void PlaceOrder()
    {
        OrderService.PlaceOrder(order);
    }

    public void CanelOrder()
    {
        OrderService.CancelOrder(order);
    }
}

Answer 1

我对此没有简短的答案。你可以在我之前写过的关于这个主题的博客文章中查看完整的答案。 [Yet Another UoW, Repository Article]。
（如果您阅读该文章，请告诉我您的想法）

Answer 2

我决定最后使用工厂并通过工作单位。然后工厂使用传递的UOW创建其他所有内容。

这就是如果最终做的那样：

存储库：

public class Repository : IRepoository
{
    IUnitOfWork UnitOfWork;

    public Repository(IUnitOfWork uow)
    {
        UnitOfWork = uow;
    }

    public void SomeOtherMethod(int id)
    {
        // Do something
    }
}

服务：

public class Service : IService
{
    IUnitOfWork UnitOfWork;
    IRepoository Repository;

    public Service(IUnitOfWork uow, IRepoository repository)
    {
        UnitOfWork = uow;
        Repository = repository;
    }

    public void SomeMethod(int id)
    {
        Repository.SomeOtherMethod(id);
        // do other stuff
    }
}

工厂：

public class IUnitOfWorkFactory
{
    IUnitOfWork Create();
}

public class IServiceFactory
{
    IService Create(IUnitOfWork uow);
}

IServiceFactory.Create方法创建服务所依赖的服务和存储库，并为它们提供传递的工作单元。

Preseter：

public class Presenter
{
    protected UnitOfWorkFactory UnitOfWorkFactory;
    protected IServiceFactory ServiceFactory;

    public Presenter(IUnitOfWorkFactory unitOfWorkFactory, IServiceFactory serviceFactory)
    {
        UnitOfWorkFactory = unitOfWorkFactory;
        ServiceFactory = serviceFactory;
    }

    public void DoSomething()
    {
        // Get a new UOW from the factory
        using(var uow = unitOfWorkFactory.Create())
        {
            // Then create the service and repository with the new UOW via the ServiceFactory
            var service = serviceFactory.Create(uow);
            service.SomeMethod(20);

            uow.Commit();
        }
    }
}

如何使用依赖注入和存储库处理工作单元

2 个答案: