How to implement UnitOfWork with Onion Architecture without introducing dependencies?

Question

I am setting up an asp.Net Mvc 4 app and looking to configure it using the Onion Architecture Pattern. In the past I have used the Unit of Work Pattern like this

public class UnitOfWork : IUnitOfWork, IDisposable
{

private IRepository<CallModel> _callRepo;
private IRepository<UserModel> _userRepo;

    public IRepository<CallModel> CallRepo
    {
        get
        {
            if (_callRepo == null)
            {
                _callRepo = new Repository<CallModel>();
            }
            return _callRepo;
        }
    }

    public IRepository<UserModel> UserRepo
    {
        get
        {
            if (_userRepo == null)
            {
                _userRepo = new Repository<UserModel>();
            }
            return _userRepo;
        }
    }
}

I would then pass the instance of the UnitOfWork Class to the Controller to do simple CRUD stuff like this.

    public class QuestionsController : Controller
{
    private IUnitOfWork _unitOfWork;

    [Inject]
    public QuestionsController(IUnitOfWork unitOfWork)
    {
        _unitOfWork = unitOfWork;
    }

I have seperated the app into three projects.

1. Core
2. Infrastructure
3. Web

I have my Interfaces all in the Core project and the implementation of the IRepository interface in the Infrastructure project. If I put the UnitOfWork Class in the Core Project then since it calls for a new Repository in the Infrastructure project I am creating a dependency from the Core to the Infrastructure. If I include it in the Infrastructure then the Web project (which has the controllers) will have a dependency on the Infrastructure and the whole Solution ends up looking less like an Onion and more like spaghetti.

Answer 1

I have my Interfaces all in the Core project and the implementation of the IRepository interface in the Infrastructure project. If I put the UnitOfWork Class in the Core Project then since it calls for a new Repository in the Infrastructure project I am creating a dependency from the Core to the Infrastructure.

Hmm, not really. Your unit of work class should have a dependency on IRepository, not the Repository implementation itself. If you are using Dependency Injection, this should not pose a problem, as it should find the right type and provide it at runtime. I'm not sure whether the Onion architecture is even possible without using DI.

See david.s's answer as well, as this is exactly how I set things up--have a project for the sole purpose of wiring up dependencies.

Answer 2

What I do is have another project named DependencyResolution which has references to Core and Infrastructure an where I configure my IoC container. Then I can refence only DependencyResolution from the Web project.

Answer 3

I would do like david.s create project named DependencyResolution but let it referance Web, Core and Infrastructure.

In that project you could do:

[assembly: PreApplicationStartMethod(typeof(Start), "Register")]

namespace DependencyResolution
{
    public static class Start
    {
        public static void Register()
        {
            UnityConfig.Register();
        }
    }
}

and to register DI.

namespace DependencyResolution
{    
    public static class UnityConfig
    {
        public static void Register()
        {
            DependencyResolver.SetResolver(new UnityDependencyResolver());
        }
    }
}

So no referance between Web and infrastructure is needed.

Best regards

Answer 4

For what it's still worth, I have implemented my own library that applies the UnitOfWork-pattern a little differently than I've seen in any code sample before, but I have found it to work very well in practice. In short: I kinda copied the way .NET Transactions work by creating a scope and then enlisting resources in the ambient unitofwork(-manager) where necessary. What basically happens is that when a new message/request is being handled, this code is executed:

public void Handle<TMessage>(TMessage message)
{
    using (var scope = CreateMessageProcessorContextScope())
    {
        HandleMessage(message);
        scope.Complete();
    }
}

Now just as with transactions, as soon as the Thread is still inside the scope, an ambient UnitOfWork-controller is present in which all resources that are used and changed during the request can enlist dynamically. They do this by implementing the IUnitOfWork-interface that has two methods:

public interface IUnitOfWork
{
    bool RequiresFlush();

    void Flush();
}

Instances that implement this interface can then enlist themselves as follows:

MessageProcessorContext.Current.Enlist(this);

Typically, a Repository-class will implement this interface, and when it detects it's managed aggregates are changed/added/removed, it can enlist itself (double enlistments are ignored).

In my case, the framework assumes that you are using an IOC-framework that will resolve all message-handlers and repositories for you, so I made enlistment to the ambient unit of work controller easier by letting it inject an instance of the current IUnitOfWorkManager into the constructor where required. This way the dependencies of the unit of work manager and the actual pieces that require to be flushed (repositories, services, etc) are reversed:

internal sealed class OrderRepository : IOrderRepository, IUnitOfWork
{
    private readonly IUnitOfWorkManager _manager;
    private readonly Dictionary<Guid, Order> _orders;

    public OrderRepository(IUnitOfWorkManager manager)
    {
        if (manager == null)
        {
            throw new ArgumentNullException("manager");
        }
        _manager = manager;
    }

    bool IUnitOfWork.RequiresFlush()
    {
        return _orders.Values.Any(order => order.HasChanges());
    }

    void IUnitOfWork.Flush()
    {
        // Flush here...
    }

    public void Add(Order order)
    {
        _orders.Add(order.Id, order);
        _manager.Enlist(this);
    }
}

As soon as a request has been handled succesfully (no exceptions thrown), scope.Complete() will be called which triggers the controller to check with all enlisted items whether they (still) need to be flushed (by calling RequiresFlush()), and if so, flushes them (by calling Flush()).

All in all, this allows for a very maintainable solution (in my perspective) in which new repositories and other dependencies can be added on the fly without changing any master unitofwork class, just like the TransactionManager doesn't need to know upfront which items may take part in any given Transaction.