nHibernate [TransactionAttribute] for UoW conflicts with Repository Pattern

Doing research into the best way to design IRepository<T> structures, I came across a project called 'Whiteboard' (http://whiteboardchat.codeplex.com/) while looking through some forums for NHProf.

I dug around its source code for a while, and found a really interesting attribute for MVC called TransactionAttribute, defined as follows; (I have made brief adjustment to suit my IoC solution)

using System;
using System.Linq;

using Ninject;

namespace System.Web.Mvc
{
    /// <summary>
    /// This will allow ASP.NET MVC to apply Transactions to the controllers.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class)]
    public class TransactionAttribute : ActionFilterAttribute
    {
        [Inject]
        public NHibernate.ISession Session 
      开发者_开发问答  { 
            get; 
            set; 
        } 

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            Session.BeginTransaction();
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            if (Session.Transaction.IsActive)
            {
                if (filterContext.Exception == null)
                {
                    Session.Flush();
                    Session.Transaction.Commit();
                }
                else
                {
                    Session.Transaction.Rollback();
                }
            }
        }
    }
}

This is really interesting; And useful, however something about it bothers me. When I run my queries using NHProf, it gives me warnings about 'Not using transactions properly', and suggests I wrap all queries in a Transaction. Alright, that's fine and good...

So then I go and decorate my Repository<T> : IRepository<T> class like this ...

    public T Update(T instance)
    {
        using (var transaction = session.BeginTransaction())
        {
            // attempt to perform the given update
            session.SaveOrUpdate(instance);

            try
            {
                // commit the transaction to the database
                transaction.Commit();

                // update succeeded, so we'll return true
                return instance;
            }
            catch
            {
                // restore the database to its previous state if we failed.
                transaction.Rollback();

                // update failed, so return a null object
                return default(T);
            }
        }
    }

Here's the problem I am running into.

Everywhere I read, the common practice is to always use a Repository for adding to the collections. However the TransactionAttribute, which in itself was brought to my attention by Ayende Rahien's blog, who is from what I can gather one of the primary developers of NHProf, and one of the people working on this Whiteboard project, makes the assumption that you are performing Repository commands at the MVC Controller Level.

So which is it? I'm utterly confused now where my Transaction logic is supposed to go for the best practice. I'm literally finding conflicting answers, and in some cases from the same people.

You are not supposed to deal with transactions inside repositories. A controller (like you have) or HTTP module should start and commit/rollback transactions. Saves or updates are not supposed to be done in isolation. They will be committed at the end of the operation by the controller. This way you can take advantage of ADO batching and other NHibernate features.

Also, make sure to set the FlushMode of the nhibernate ISession to Commit.

Are you decorating your action method or controller class with the [Transaction] attribute? If not, this action filter code won't even be called.

Also, you will need to ensure that you [Inject] the session object into your repository as well and that the session object is scoped to the request.

as an example:

public class MyRepository
{
    [Inject]
    public ISession Session { get; set; }

    public void Save(MyModel model) { Session.Save(model); }
}

public class MyController : Controller
{
    [Inject]
    public MyRepository MyRepository { get; set; }

    [Transaction]
    public ActionResult Save(MyModel model)
    {
        MyRepository.Save(model);
    }
}

and when registering your session;

var configuration = new NHibernateConfiguration();
Bind<ISessionFactory>().ToConstant(configuration.GetSessionFactory());
Bind<ISession>().ToMethod(x => x.Kernel.Get<ISessionFactory>().OpenSession()).InRequestScope();

notice the InRequestScope() part

Posting this for @Fatal.

The original response answered my question, but this is inevitably what I ended up doing to avoid using method level attributes.

Instead of declaring the code to control my transaction in an attribute, I included it right in my ISession management for Ninject.

        Bind<ISession>()
            .ToMethod(c => OpenSession())
            .InRequestScope()
            .OnActivation(session =>
            {
                session.BeginTransaction();
                session.FlushMode = FlushMode.Commit;
            })
            .OnDeactivation(session =>
            {
                if (session.Transaction.IsActive)
                {
                    try
                    {
                        session.Transaction.Commit();
                    }
                    catch
                    {
                        session.Transaction.Rollback();
                    }
                }
            });

What this does is open the new ISession each request where an ISession is injected, and when it is activated it begins a new transaction. At this point, Ninject now tracks the state and handles the consequences of rolling it back, thus implementing a very simplistic unit of work pattern.

I do not know if this is the best approach in the world, but I have shown it to a few people and it has not been shot down for bad practice, and it has worked well for me so far.