Try fast search NHibernate

07 January 2009

Aspect Conversation-per-BusinessTransaction

Part I : Conversation-per-Business-Transaction
Part II : Implementing Conversation per Business Transaction
Part III (without AOP) : Using Conversation per Business Transaction


For this post I’ll use the same example of the Part III but using a real IoC framework (Castle Windsor). To abstract “aspect” the conversation stuff, from its implementation, I will use some custom Attribute defined in uNhAddIns.Adapters assembly. As you can see, downloading the example, there are few classes changed from the previous example, that are the more simple, and less intrusive, implementation of the FamilyCrudModel and, obviously, the implementation of ServiceLocatorProvider.


The implementation of “Aspect Conversation-per-BusinessTransaction” presented here is only one of the possible implementations. Gustavo Ringel (blog link not available so far) are working in a real-world example using Conversation-per-BusinessTransaction pattern in a Win-Form application with its implementation of uNhAddIns (the example is available here).

“Model” implementation comparison

The new FamilyCrudModel complete implementation is:
public class FamilyCrudModel<TAnimal> : IFamilyCrudModel<TAnimal> where TAnimal : Animal
private readonly IAnimalReadOnlyDao<TAnimal> animalDao;
private readonly IFamilyDao<TAnimal> familyDao;

public FamilyCrudModel(IDaoFactory factory)
animalDao = factory.GetDao<IAnimalReadOnlyDao<TAnimal>>();
familyDao = factory.GetDao<IFamilyDao<TAnimal>>();

#region Implementation of IFamilyCrudModel<TAnimal>

public IList<TAnimal> GetExistingComponentsList()
return animalDao.GetAll();

public IList<Family<TAnimal>> GetEntirelyList()
return familyDao.GetAll();

public Family<TAnimal> GetIfAvailable(int id)
return familyDao.Get(id);

public Family<TAnimal> Save(Family<TAnimal> entity)
if (entity == null)
throw new ArgumentNullException("entity");
return familyDao.MakePersistent(entity);

public void Delete(Family<TAnimal> entity)
if (entity == null)
throw new ArgumentNullException("entity");

[PersistenceConversation(ConversationEndMode = EndMode.End)]
public void AcceptAll() { }

[PersistenceConversation(ConversationEndMode = EndMode.Abort)]
public void CancelAll() { }

Differences, from the previous implementation are:
  1. don’t need to inherits from any kind of base class.
  2. the constructor injection is more simple
  3. the implementation of each method don’t have boiled code
  4. the class and each persistent-method are marked with a custom attribute
I can avoid the point (4) depending on the AOP framework features, using Castle, for example, I can inject the behavior using XML or Fluent-Interface-Configuration.
The point(3) is, for example, this comparison:
From the point of view of Conversation-per-Business-Transaction usage that it’s all.

A more deep view

Behind the AOP I’m using, in this example, uNhAddIns.CastleAdapters. For who are familiar with Castle, the CastleAdapters assembly contains:
  • The TransactionProtectionWrapper and its factory; it is a ISession wrapper to ensure the transaction usage for certain ISession methods. The wrapper is used in all session-handlers implementations available in uNhAddIns (a NoWrappedSessionWrapper implementation is available in uNhAddIns core).
  • The AutomaticConversationManagement Castle-Windsor-Facility.
  • uNhAddIns-PersistenceConversation-nh-default.config file to use it as an include in the Windsor configuration, if you want use XML configuration.
If you want use Fluent-Castle-configuration a possible implementation is:
var sfp = new SessionFactoryProvider();
sfp.AfterConfigure += ((sender, e) => new SchemaExport(e.Configuration).Create(false, true));
Note that the class SessionFactoryProvider is the implementation for one-db application and I’m explicit instancing it only because I’m using the AfterConfigure event to create the DB (in production you don’t need to do it).
For who are not familiar with ICurrentSessionContext NHibernate's feature is important to remember that it need a specific NHibernate configuration property:
<property name="current_session_context_class">
uNhAddIns.SessionEasier.Conversations.ThreadLocalConversationalSessionContext, uNhAddIns
If you want download the example of this post, as usual, the code is available here.

kick it on


  1. once again (some problems with GMail ID), would it be possible to use PostSharp instead of Castle library?

  2. Sure, it is.
    In our TODO list there is:
    Unity, LinFu, Spring, PostSharp depending on developers request/contributions.
    As you can see uNhAddIns don't has a direct reference to Castle.

  3. another question, is this pattern "o.k." to use in web applications? (ASP.NET MVC in particular)

    or we should stick to "session per request", as you are mentioning that it only suits Winform developement (e.g. single user scenarios).

  4. The pattern is sure useful in WEB too (check the first post of the series).

  5. I have in ProductCrudModel this simple method :
    [PersistenceConversation(ConversationEndMode = EndMode.Continue)]
    public IEnumerable[Product] FindByProductName(string name) {
    return productReadOnlyDao.FindByName(name);
    In FindByName(name) method, simple Criteria.List[Product]()

    This works very slowly about 4 seconds.
    If i work with CastleNhibernateIntegration facility it works very quick 20-40 ms.

    Why the conversation works so slowly ?

  6. In CpBT we are only managing the nh-session.
    Please try to create a simple test.

  7. Thanx Fabio for reply,
    I create simple test for this situation:

  8. Is it possible to implement Conversation-per-BusinessTransaction in Silverlight. We are using NH and also sending the NH entities via WCF to the SL client. I know that some ses this as bad practice but it works and we see WCF as a transport layer not a service (SOA).

    Another question: Will there bee a implementation of NHV for Silverlight?

  9. Excellent article, thanks for the great job on this pattern.