Question

I am trying to use the Unity IoC with the unit of work & repository patterns, however I’m struggling to work out how my repository would get it’s Nhibernate session to perform it’s work…

Below I have my IUnityContainer which does my IoC bindings.. I then have my NHibernate repo which needs to be provided with a ISession, which should be provided from the NHibernate unit of work, but I am now sure how I can tell Unity to provide it in it’s constructor..

I have made a binding for the IUnitOfWork to a Nhib… one, but how does one pass that value in the IRepository RegisterType?

private static IUnityContainer BuildUnityContainer()
    {
        var container = new UnityContainer();
        NHibernateHelper helper = new NHibernateHelper();

        // register all your components with the container here
        // e.g. container.RegisterType<ITestService, TestService>();            

        container.RegisterControllers();
        container.RegisterType<IUnitOfWork, NHibernateUnitOfWork>(new HierarchicalLifetimeManager());
        container.RegisterInstance<ISessionFactory>(helper.SessionFactory);
        container.RegisterType<IRepository, NHibernateRepository>() ;

        return container;
    }



public class NHibernateRepository : IRepository
{

public NHibernateRepository(ISession session)
        {
            _session = session;
        }
}


    public class NHibernateUnitOfWork : IUnitOfWork
    {
        private readonly ISessionFactory _sessionFactory;
        private readonly ITransaction _transaction;
        public ISession Session { get; private set; }

        public NHibernateUnitOfWork(ISessionFactory sessionFactory)
        {
            _sessionFactory = sessionFactory;
            Session = _sessionFactory.OpenSession();
            Session.FlushMode = FlushMode.Auto;
            _transaction = Session.BeginTransaction(IsolationLevel.ReadCommitted);
        }
}

Answer 1

Register your ISession with your IUnityContainer like so:

container.RegisterType<ISession>(new InjectionFactory(c => c.Resolve<ISessionFactory>().OpenSession());

Then when an ISession is required, an ISessionFactory will be resolved and a session started.

In the applications I work on, we define our repositories and unit of work like so:

public class NhUnitOfWork : IUnitOfWork
{
    readonly ISession _session;

    public IRepository<T> GetRepository<T>() where T : class
    {
        return new NhRepository<T>(_session);
    }

    public NhUnitOfWork(ISession session)
    {
        _session = session;
    }

    public void Dispose()
    {
        // Dispose logic, i.e. save/rollback
    }
}

public class NhRepository<T> : IRepository<T> where T : class
{
    readonly ISession _session;

    public void Add(T item)
    {
        _session.Save(item);
    }

    public void Delete(T item)
    {
        _session.Delete(item);
    }

    public void Update(T item)
    {
        _session.Update(item);
    }

    public NhRepository(ISession session)
    {
        _session = session;
    }
}

Then your services use it something like this:

public class MyService
{
    readonly Func<IUnitOfWork> _unitOfWorkFactory;

    public MyService(Func<IUnitOfWork> unitOfWorkFactory)
    {
        _unitOfWorkFactory = unitOfWorkFactory;
    }

    public void DoServiceStuff()
    {
        using(var uow = _unitOfWorkFactory())
        {
            var newUser = new User() { Username = "My User" };

            var userRepo = uow.GetRepository<User>();
            userRepo.Add(newUser);

            uow.Save();
        }
    }
}