Category Archive

First of all, Steve Strong made a Christmas gift to community by presenting a new Linq implementation for NHibernate, which is now incorporated in the trunk. Kudos for a such great work!

Another valuable addition to NHibernate is the QueryOver<T> API that wrapped ICriteria API and made it easier to use. Thanks to Richard Brown.

Both features are not crucial for the success of NHibernate, but they are very nice improvements that will attract new users and will keep the old ones. It’s easier to advocate for NHibernate when you can point not only at his advanced features. The hype around Linq makes difference when features are compared. Having a provider for NHibernate will be a strong decision argument.

I hope that soon after New Year’s holidays I’ll try to switch to NHibernate 3.0. If migration of our project will be painless and all tests will still green, I think we’ll run with the trunk. It’s the least we can do to help make this project better.

“why is this a problem?” may ask you…

Let’s review the ways that NHibernate lets you register your own event listeners. You can do it in configuration file:

<listener class=”NHTest.Listeners.CustomSaveEventListener, NHTest” type=”save” />

… or in code:

Configuration cfg = new Configuration();
cfg.EventListeners.SaveEventListeners =
    new ISaveOrUpdateEventListener[] {new CustomSaveEventListener() };

Nice, so far…

It’s not if you want to add a listener, not to replace them. Both registrations are just replacing default event listeners with your own implementations. Very often it’s not want you want!

In our case, we want default listeners do the job and just add few our own listeners to run the business. No problem, let’s code:

var listeners = configuration.EventListeners;
listeners.SaveEventListeners =
    new List<ISaveOrUpdateEventListener>(listeners.SaveEventListeners)
    {new CustomSaveEventListener()}
    .ToArray();

Since I wrote that code some day I hated it. Too verbose, too obscure, hard to read & understand. But event registration infrastructure doesn’t offer an easy and simple way to add a listener. Few times I tried to come with a nice solution for that, even tried to modify NH’s code.

Today, I’ve done it:

configuration.AddListener(el => el.SaveEventListeners, new CustomSaveEventListener());

Some expression’s magic and we end up with a very clean & readable code.

Implementation:

public static class NHibernateConfigurationExtensions
{
    public static void AddListener<TListener>(
        this Configuration configuration,
        Expression<Func<EventListeners, TListener[]>> expression,
        TListener listenerImpl)
    {
        var propertyInfo = ReflectionHelper.GetProperty(expression);
        var existentListeners = (TListener[]) propertyInfo.GetValue(configuration.EventListeners, null);
        var newListeners = new List<TListener>(existentListeners) { listenerImpl }.ToArray();
        propertyInfo.SetValue(configuration.EventListeners, newListeners, null);
    }

    public static void AddListeners<TListener>(
        this Configuration configuration,
        Expression<Func<EventListeners, TListener[]>> expression,
        IEnumerable<TListener> listeners)
    {
        foreach (var listener in listeners)
        {
            configuration.AddListener(expression, listener);
        }
    }
}

Have a nice day...

Ayende is running a series of posts detailing and explaining how NHibernate maps entity classes to database. Posts include XML mappings, code and SQL queries generated when saving or querying the database so that you have everything to understand what NHibernate do to persist your data. The series is a nice addition to NHibernate Reference Documentation.

NHibernate Mapping:

• Properties <property/>
• Components <component/>
• Many to one relationships <many-to-one/>
• Inheritance
• Dynamic components <dynamic-component/>
• Collections <set/>
• Concurrency
• Database objects <database-object/>
• Named queries <query/> & <sql-query/>
• One to one relations <one-to-one/>
• Joined classes <join/>
• Any type mappings <any/>
• Many to any relationships <many-to-any/>

It was a nice reading. I’ve refreshed few things in my memory and learned few new tricks.

This post will be updated as new chunks will be published (I hope it will) by Ayende.