4

我继承了一些具有 UnitOfWorkFactory 的代码，它在每个存储库方法中创建一个工作单元。问题是单个存储库方法很少是完整的工作单元，因此如果 say 出现问题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();
        }
    }
}

服务：

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);
    }
}
4

2 回答 2

2

我没有一个简短的答案。您可以在我之前写过的关于这个主题的这篇博文中查看完整的答案。[另一个 UoW，存储库文章]。
（如果你读了这篇文章，请告诉我你的想法）

于 2013-02-26T23:19:56.990 回答
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方法创建服务和服务所依赖的存储库，并为它们提供传递的工作单元。

预置器：

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();
        }
    }
}
于 2013-03-02T19:59:54.153 回答