C’est pourquoi celle que je présente ici est exactement celle proposée par Billy McCafferty dans son article NHibernate Best Practices with ASP.Net. La méthode utilise un pattern de Singleton dont l’implantation en C# est présentée sur cette page. Un avantage de cette méthode est qu’elle fonctionnera que vous utilisiez ASP.Net ou bien les WinForms.

using System.Runtime.Remoting.Messaging;
using System.Web;
using NHibernate;
using NHibernate.Cache;
using NHibernate.Cfg;

namespace NHibernateHelper
{
    /// <summary>
    /// Handles creation and management of sessions and transactions.  It is a singleton because
    /// building the initial session factory is very expensive. Inspiration for this class came
    /// from Chapter 8 of Hibernate in Action by Bauer and King.  Although it is a sealed singleton
    /// you can use TypeMock (http://www.typemock.com) for more flexible testing.
    /// </summary>
    public sealed class NHibernateSessionManager
    {
        #region Thread-safe, lazy Singleton

        /// <summary>
        /// This is a thread-safe, lazy singleton.  See http://www.yoda.arachsys.com/csharp/singleton.html
        /// for more details about its implementation.
        /// </summary>
        public static NHibernateSessionManager Instance {
            get {
                return Nested.NHibernateSessionManager;
            }
        }

        /// <summary>
        /// Initializes the NHibernate session factory upon instantiation.
        /// </summary>
        private NHibernateSessionManager() {
            InitSessionFactory();
        }

        /// <summary>
        /// Assists with ensuring thread-safe, lazy singleton
        /// </summary>
        private class Nested
        {
            static Nested() { }
            internal static readonly NHibernateSessionManager NHibernateSessionManager =
                new NHibernateSessionManager();
        }

        #endregion

        private void InitSessionFactory() {
            sessionFactory = new Configuration().Configure().BuildSessionFactory();
        }

        /// <summary>
        /// Allows you to register an interceptor on a new session.  This may not be called if there is already
        /// an open session attached to the HttpContext.  If you have an interceptor to be used, modify
        /// the HttpModule to call this before calling BeginTransaction().
        /// </summary>
        public void RegisterInterceptor(IInterceptor interceptor) {
            ISession session = ContextSession;

                if (session != null && session.IsOpen) {
                throw new CacheException("You cannot register an interceptor once a session has already been opened");
            }

            GetSession(interceptor);
        }

        public ISession GetSession() {
            return GetSession(null);
        }

        /// <summary>
        /// Gets a session with or without an interceptor.  This method is not called directly; instead,
        /// it gets invoked from other public methods.
        /// </summary>
        private ISession GetSession(IInterceptor interceptor) {
            ISession session = ContextSession;

            if (session == null) {
                if (interceptor != null) {
                    session = sessionFactory.OpenSession(interceptor);
                }
                else {
                    session = sessionFactory.OpenSession();
                }

                ContextSession = session;
            }

            return session;
        }

        /// <summary>
        /// Flushes anything left in the session and closes the connection.
        /// </summary>
        public void CloseSession() {
            ISession session = ContextSession;

            if (session != null && session.IsOpen) {
                session.Flush();
                session.Close();
            }

            ContextSession = null;
        }

        public void BeginTransaction() {
            ITransaction transaction = ContextTransaction;

            if (transaction == null) {
                transaction = GetSession().BeginTransaction();
                ContextTransaction = transaction;
            }
        }

        public void CommitTransaction() {
            ITransaction transaction = ContextTransaction;

            try {
                if (HasOpenTransaction()) {
                    transaction.Commit();
                    ContextTransaction = null;
                }
            }
            catch (HibernateException) {
                RollbackTransaction();
                throw;
            }
        }

        public bool HasOpenTransaction() {
            ITransaction transaction = ContextTransaction;

            return transaction != null && !transaction.WasCommitted && !transaction.WasRolledBack;
        }

        public void RollbackTransaction() {
            ITransaction transaction = ContextTransaction;

            try {
                if (HasOpenTransaction()) {
                    transaction.Rollback();
                }

                ContextTransaction = null;
            }
            finally {
                CloseSession();
            }
        }

        /// <summary>
        /// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms
        /// specific <see cref="CallContext" />.  Discussion concerning this found at
        /// http://forum.springframework.net/showthread.php?t=572.
        /// </summary>
        private ITransaction ContextTransaction {
            get {
                if (IsInWebContext()) {
                    return (ITransaction)HttpContext.Current.Items[TRANSACTION_KEY];
                }
                else {
                    return (ITransaction)CallContext.GetData(TRANSACTION_KEY);
                }
            }
            set {
                if (IsInWebContext()) {
                    HttpContext.Current.Items[TRANSACTION_KEY] = value;
                }
                else {
                    CallContext.SetData(TRANSACTION_KEY, value);
                }
            }
        }

        /// <summary>
        /// If within a web context, this uses <see cref="HttpContext" /> instead of the WinForms
        /// specific <see cref="CallContext" />.  Discussion concerning this found at
        /// http://forum.springframework.net/showthread.php?t=572.
        /// </summary>
        private ISession ContextSession {
            get {
                if (IsInWebContext()) {
                    return (ISession)HttpContext.Current.Items[SESSION_KEY];
                }
                else {
                    return (ISession)CallContext.GetData(SESSION_KEY);
                }
            }
            set {
                if (IsInWebContext()) {
                    HttpContext.Current.Items[SESSION_KEY] = value;
                }
                else {
                    CallContext.SetData(SESSION_KEY, value);
                }
            }
        }

        private bool IsInWebContext() {
            return HttpContext.Current != null;
        }

        private const string TRANSACTION_KEY = "nhibernate.context.transaction.key";
        private const string SESSION_KEY = "nhibernate.context.session.key";
        private ISessionFactory sessionFactory;
    }
}

Un petite note: peu importe la méthode utilisée, si vous êtes dans un contexte Web, il faut généralement s’assurer que la méthode est Thread-Safe.

Une question demeure toutefois, quand doit-on créer les sessions et transactions et quand doit-on les fermer? La documentation suggère de mettre en oeuvre le pattern Open-In-Session-View afin de mettre à profit les possiblités de lazy-loading de NHibernate. Billy McCafferty mentionnait dans son article:

If you want to leverage NHibernate’s lazy-loading (which you most certainly will), then the Open-Session-in-View pattern is the way to go. (”Session” in this context is the NHibernate ISession…not the ASP.NET Session object.) Essentially, this pattern suggests that one NHibernate session be opened per HTTP request.

Encore une fois, l’approche proposée est celle que je présente. Le pattern signifie qu’une session NHibernate doit être ouverte par requête HTTP. En asp.net, le plus simple pour accomplir cette tâche à mon avis est en effet de créer un IHttpModule. On crée la session au début de la requête et on la ferme à la fin. S’il y a des changements à effectués, ils seront engagés avant la fermeture de la session. S’il y a des erreurs, la transaction sera annulée et la session sera quand même fermée. Voici le code du module qui se veut assez simple.

using System;
using System.Web;

namespace NHibernateHelper.Modules
{
    /// <summary>
    /// Implements the Open-Session-In-View pattern using <see cref="NHibernateSessionManager" />.
    /// Assumes that each HTTP request is given a single transaction for the entire page-lifecycle.
    /// Inspiration for this class came from Ed Courtenay at
    /// http://sourceforge.net/forum/message.php?msg_id=2847509.
    /// </summary>
    public class NHibernateSessionModule : IHttpModule
    {
        public void Init(HttpApplication context) {
            context.BeginRequest += new EventHandler(BeginTransaction);
            context.EndRequest += new EventHandler(CommitAndCloseSession);
        }

        /// <summary>
        /// Opens a session within a transaction at the beginning of the HTTP request.
        /// This doesn't actually open a connection to the database until needed.
        /// </summary>
        private void BeginTransaction(object sender, EventArgs e) {
            NHibernateSessionManager.Instance.BeginTransaction();
        }

        /// <summary>
        /// Commits and closes the NHibernate session provided by the supplied <see cref="NHibernateSessionManager"/>.
        /// Assumes a transaction was begun at the beginning of the request; but a transaction or session does
        /// not *have* to be opened for this to operate successfully.
        /// </summary>
        private void CommitAndCloseSession(object sender, EventArgs e) {
            try {
                NHibernateSessionManager.Instance.CommitTransaction();
            }
            finally {
                NHibernateSessionManager.Instance.CloseSession();
            }
        }

        public void Dispose() { }
    }
}

Voilà, il ne vous reste plus qu’à configurer le module http dans votre web.config et vous serez en mesure de gérer vos sessions NHibernate sans trop de problèmes.

Finalement, un simple exemple pour exécuter une requête via notre gestionnaire de session:

...
ISession session = NHibernateSessionManager.Instance.GetSession();
return session.Get<T>(id);

Si je vous parle NHibernate aujourd’hui, c’est surtout parce que je suis conscient que pour les non-initiés, NHibernate peut paraître complexe. Quoiqu’il existe beaucoup de tutoriels sur le Web, la plupart d’entre eux sont assez simples et ne font que survoler l’architecture requise pour bien tirer avantage de NHibernate. Notamment vis à vis la gestion des sessions et des transactions.

Ainsi, il existe une référence qui porte sur ces aspects et je ne saurais suffisamment vous en recommander la lecture. Il s’agit de l’article NHibernate Best Practices with ASP.Net de Billy McCafferty. L’article présente d’abord les avantages à utiliser un ORM et les bases de l’intégration de NHibernate. Ensuite, il offre plusieurs notions avancées, qui pourront peut-être sembler un peu lourdes pour certains, mais qui sont très intéressantes et surtout essentielles à une bonne utilisation de NHibernate.

Par ailleurs, chacun des thèmes abordés propose des liens et références pour vous permettre de mieux comprendre les différentes notions. Donc, même si vous n’êtes pas à l’aise avec les patterns de Repository et le DDD (Domain-Driven Design), vous serez sûrement en mesure de comprendre l’essentiel.

Je compte éventuellement proposer un petit guide pour l’implantation de NHibernate qui met à profit le pattern Open-Session- In-View pour permettre l’utilisation du lazy-loading de NHibernate. À suivre…

Il s’agit d’un petit programme qui permet de lancer IE7 sans l’installer (vous avez besoin de l’archive d’installation de ie7 toutefois). En effet, ce petit bijou vous permet de tester la plupart des fonctionnalités de ie7 incluant les appels css conditionnels si connu du monde des designers Web.

Il est possible de configurer manuellement le petit programme, mais il est également disponible sous forme de programme d’installation (c’est l’option que je recommande) qui s’occupe de télécharger pour vous l’archive d’installation de ie7 ainsi que de configurer les clés de la base registre nécessaires au fonctionnement.

Voilà, vous êtes maintenant en mesure de tester Internet Explorer 7 sans avoir à dire adieu à ie6!

Ainsi, supposons qu’on veut une largeur maximale, on peut utiliser le code suivant. La propriété max-width sera utilisée par les navigateurs compatibles css2 et ignoreront la propriété contenant la fonction expression(). L’inverse se produira avec ie. Le code javascript pour la propriété width se traduit: si la largeur du body est plus grande que 900, mettre la largeur du selecteur à 900px, sinon laisser le sélecteur se dimensionner automatiquement.

#selecteurCss {
    max-width:900px;
    width:expression(document.body.clientWidth > 900 ? "900px": "auto" );
}

Par ailleurs, cette fonctionnalité devient également utile si on l’utilise en combinaison avec une largeur en pourcentage. Par exemple, le code suivant permet de spécifier une largeur de 75% jusqu’à un maximum de 500px.

#selecteurCss {
    /* Les 2 lignes suivante seront utilisées par les navigateurs compatibles css2 */
    max-width: 500px;
    width: 75%;
    /* celle-ci sera utilisée par ie6 et moins, et remplacera la ligne précédente */
    width:expression(document.body.clientWidth > 500 ? "500px" : "75%" );
}

C’est bien beau tout ça, mais cette méthode n’est évidemment pas valide selon les normes. La validation devient toutefois possible en plaçant le code spécifique à ie dans une feuille css à part et uniquement accessible à ie. Ainsi dans la page, on insère le code suivant qui ne sera lu que par ie6 et moins (car max-width est supposé être fonctionnel dans ie7).

<!--[if lt IE 7]>
    <style type="text/css" media="all">@import "ie.css";</style>
<![endif]-->

En reprenant l’exemple précédent, dans votre feuille de style de base, vous auriez:

#selecteurCss {
    /* Les 2 lignes suivante seront utilisées par les navigateurs compatibles css2 */
    max-width: 500px;
    width: 75%;
}

Et dans ie.css:

* html #selecteurCss {
    width:expression(document.body.clientWidth > 500 ? "500px" : "75%" );
}

Voilà, même si ce n’est pas la plus jolie des méthodes, elle fonctionne et n’empêche pas votre code css de valider. Si vous avez une meilleure façon d’émuler le max-width dans ie6, laissez-le nous savoir dans les commentaires.

Comme je l’ai mentionné sur le nouveau blog de la firme, les activités de Sherpas ont considérablement évolué au cours de dernières années et la refonte entière du site nous a permis de mieux mettre en valeur ces nouvelles orientations.

Quelques détails sur sherpas.ca:

• Réalisé du tout au tout par moi-même ;-)
  Mis à part le contenu qui est principalement tiré de notre plan d’affaires
• Basé sur Drupal 5, une plateforme open-source puissante que nous utilisons pour plusieurs projets
• CSS valide
• XHTML valide

Certains questionneront peut-être la nécessité d’utiliser un CMS open-source pour un simple site corporatif. En fait, pour nous la question ne s’est même pas posée. Certes, ce n’était pas une nécessité, mais Drupal est tellement versatile et personnalisable que la question était davantage: pourquoi ne pas l’utiliser? En basant notre nouveau site sur Drupal, cela nous a permis de nous concentrer sur le design et l’architecture. ce qui a eu pour effet d’accélérer considérablement la production et la mise en ligne.