关于NHibernate的一些代码

SessionManager

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Web;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Context;
 
namespace Northwind.Repositories
{
    /// <summary>
    /// A static (singleton) class to manage NHibernate.
    /// Manage NHibernate sessions using <see cref="Session"/>
    /// </summary>
    public sealed class SessionManager
    {
        private const string SESSIONKEY = "NHIBERNATE.SESSION";
        [ThreadStatic]
        private static ISession _Session; //this session is not used in web
        private readonly Configuration _configuration;
        private readonly ISessionFactory _sessionFactory;
 
        #region Constructor
 
        #region Singleton
        public static SessionManager Instance
        {
            get
            {
//#if !INSTANCE
                return Singleton.Instance;
//#else
//                return new SessionManager();
//#endif
            }
        }
 
//#if !INSTANCE
        private class Singleton
        {
            static Singleton() { }
            internal static readonly SessionManager Instance = new SessionManager();
        }
//#endif
        #endregion
 
        /// <summary>
        /// Initializes a new instance of the <see cref="SessionManager"/> class.
        /// </summary>
        private SessionManager()
        {
            _configuration = RestoreConfiguration();
            if (_configuration == null)
            {
                _configuration = new Configuration();
                BuildConfiguration();
            }
            //get the session factory
            _sessionFactory = Configuration.BuildSessionFactory();
        }
 
        private void BuildConfiguration()
        {
            Configuration.Configure(); //configure from the app.config
 
            Configuration.AddAssembly(GetType().Assembly);//default- mapping is in this assembly
            //other examples:
            //Configuration.AddFile("file.hbm.xml"); //add files
            //Configuration.AddAssembly(assembly); //add assembly
            //Configuration.AddAssembly(assemblyName); //add assembly by name
            //foreach (string assemblyName in assemblyNames) //add enumerable of assemblies
            //    Configuration.AddAssembly(assemblyName);
#if !DEBUG
            SaveConfiguration(Configuration);
#endif
        }
        #endregion
 
        #region Configuration Serialization
        //specify a full path if required
        private const string _configurationFilePath = "Configuration.save";
        private static void SaveConfiguration(Configuration configuration)
        {
            IFormatter serializer = new BinaryFormatter();
 
            using (Stream stream = File.OpenWrite(_configurationFilePath))
            {
                try
                {
                    serializer.Serialize(stream, configuration);
                }
                catch (UnauthorizedAccessException)
                {
                    Console.WriteLine("No write access to " + _configurationFilePath);
                }
            }
        }
 
        /// <summary>
        /// Optimization- you could deploy the serialization file.
        /// </summary>
        private static Configuration RestoreConfiguration()
        {
#if DEBUG
            return null;
#endif
            if (!File.Exists(_configurationFilePath)) return null;
            IFormatter serializer = new BinaryFormatter();
 
            using (Stream stream = File.OpenRead(_configurationFilePath))
            {
                return serializer.Deserialize(stream) as Configuration;
            }
        }
        #endregion
 
        #region NHibernate Setup
        /// <summary>
        /// Gets the <see cref="NHibernate.Cfg.Configuration"/>.
        /// </summary>
        internal Configuration Configuration { get { return _configuration; } }
 
        /// <summary>
        /// Gets the <see cref="NHibernate.ISessionFactory"/>
        /// </summary>
        internal ISessionFactory SessionFactory { get { return _sessionFactory; } }
 
        /// <summary>
        /// Closes the session factory.
        /// </summary>
        public void Close()
        {
            SessionFactory.Close();
        }
 
        internal static bool IsWeb { get { return (HttpContext.Current != null); } }
        #endregion
 
        #region NHibernate SessionContext (1.2+)
 
        /// <summary>
        /// Opens the conversation (if already existing, reuses it). Call this from Application_BeginPreRequestHandlerExecute
        /// </summary>
        /// <returns>A <see cref="NHibernate.ISession"/></returns>
        public ISession OpenConversation()
        {
            //you must set <property name="current_session_context_class">web</property> (or thread_static etc)
            ISession session = Session; //get the current session (or open one). We do this manually, not using SessionFactory.GetCurrentSession()
            //for session per conversation (otherwise remove)
            session.FlushMode = FlushMode.Never; //Only save on session.Flush() - because we need to commit on unbind in PauseConversation
            session.BeginTransaction(); //start a transaction
            CurrentSessionContext.Bind(session); //bind it
            return session;
        }
 
        /// <summary>
        /// Ends the conversation. If an exception occurs, rethrows it ensuring session is closed. Call this (or <see cref="PauseConversation"/> if session per conversation) from Application_PostRequestHandlerExecute
        /// </summary>
        public void EndConversation()
        {
            ISession session = CurrentSessionContext.Unbind(SessionFactory);
            if (session == null) return;
            try
            {
                session.Flush();
                session.Transaction.Commit();
            }
            catch (Exception)
            {
                session.Transaction.Rollback();
                throw;
            }
            finally
            {
                session.Close();
            }
        }
 
        /// <summary>
        /// Pauses the conversation. Call this (or <see cref="EndConversation"/>) from Application_EndRequest
        /// </summary>
        public void PauseConversation()
        {
            ISession session = CurrentSessionContext.Unbind(SessionFactory);
            if (session == null) return;
            try
            {
                session.Transaction.Commit(); //with flushMode=Never, this closes connections but doesn't flush
            }
            catch (Exception)
            {
                session.Transaction.Rollback();
                throw;
            }
            //we don't close the session, and it's still in Asp SessionState
        }
        #endregion
 
        #region NHibernate Sessions
 
        /// <summary>
        /// Explicitly open a session. If you have an open session, close it first.
        /// </summary>
        /// <returns>The <see cref="NHibernate.ISession"/></returns>
        public ISession OpenSession()
        {
            ISession session = SessionFactory.OpenSession();
            if (IsWeb)
                HttpContext.Current.Items.Add(SESSIONKEY, session);
            else
                _Session = session;
            return session;
        }
 
        /// <summary>
        /// Gets the current <see cref="NHibernate.ISession"/>. Although this is a singleton, this is specific to the thread/ asp session. If you want to handle multiple sessions, use <see cref="OpenSession"/> directly. If a session it not open, a new open session is created and returned.
        /// </summary>
        /// <value>The <see cref="NHibernate.ISession"/></value>
        public ISession Session
        {
            get
            {
                //use threadStatic or asp session.
                ISession session = IsWeb ? HttpContext.Current.Items[SESSIONKEY] as ISession : _Session;
                //if using CurrentSessionContext, SessionFactory.GetCurrentSession() can be used
 
                //if it's an open session, that's all
                if (session != null && session.IsOpen)
                    return session;
 
                //if not open, open a new session
                return OpenSession();
            }
        }
        #endregion
 
    }
}

NHibernateModule:

using System;
using System.Web;
using NHibernate;
using NHibernate.Context;
using Northwind;
 
/// <summary>
/// A simple HttpModule which loads NHibernate session
/// </summary>
public class NHibernateModule : IHttpModule
{
    #region Implementation of IHttpModule
 
    /// <summary>
    /// Initializes a module and prepares it to handle requests.
    /// </summary>
    /// <param name="context">An <see cref="T:System.Web.HttpApplication"/> that provides access to the methods, properties, and events common to all application objects within an ASP.NET application 
    /// </param>
    public void Init(HttpApplication context)
    {
        context.BeginRequest += context_BeginRequest;
        context.EndRequest += context_EndRequest;
    }
 
    private static void context_BeginRequest(object sender, EventArgs e)
    {
        //use my session manager
        ISession session = SessionManager.Instance.OpenSession();
        CurrentSessionContext.Bind(session);
    }
 
    private static void context_EndRequest(object sender, EventArgs e)
    {
        ISessionFactory sessionFactory = SessionManager.Instance.SessionFactory;
        ISession session = CurrentSessionContext.Unbind(sessionFactory);
 
        if (session == null) return;
        if (session.Transaction != null)
        {
            if (session.Transaction.IsActive)
            {
                //if there is an active session, commit it
                session.Transaction.Commit();
            }
            else
            {
                //
                session.Transaction.Rollback();
            }
        }
 
        session.Close();
    }
 
    /// <summary>
    /// Disposes of the resources (other than memory) used by the module that implements <see cref="T:System.Web.IHttpModule"/>.
    /// </summary>
    public void Dispose()
    {
    }
 
    #endregion
}
Web.config

It needs to include these lines...

<configuration>
   <!-- IIS 6 -->
    <system.web>
         <httpModules>
            <add name="NHibernateModule" type="NHibernateModule"/>
        </httpModules>
     </system.web>
     <!-- IIS 7 and Cassini. -->
    <system.webServer>
         <modules>
            <add name="NHibernateModule" type="NHibernateModule"/>
        </modules>
    </system.webServer>
</configuration>
NHibernate configuration

The config file needs to include this line.

<property name="current_session_context_class">
web
</property>

　　GenericRepository:

using System;
using System.Collections.Generic;
using NHibernate;
 
namespace Northwind
{
    /// <summary>
    /// A generic repository. Normally this would be a base class of customized entity repositories- not directly exposed.
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <remarks>
    /// All operations are wrapped with <see cref="TransactionRequired"/>. If there is NO open transaction, they open a transaction and commit immediately. If there is an open transaction, nothing is commited, so you should commit at a higher level.
    /// </remarks>
    public class GenericRepository<T> where T : new()
    {
        protected ISession Session
        {
            get { return SessionManager.Instance.Session; }
        }
 
        #region Read
        /// <summary>
        /// Loads the specified id. Throws an exception if not in database.
        /// </summary>
        public T Load(object id)
        {
            using (TransactionRequired transaction = new TransactionRequired())
            {
                return Session.Load<T>(id);
            }
        }
 
        /// <summary>
        /// Gets the Id. Returns null if there is no matching row
        /// </summary>
        public T GetById(object id)
        {
            using (TransactionRequired transaction = new TransactionRequired())
            {
                return Session.Get<T>(id);
            }
        }
 
        /// <summary>
        /// Finds all records. Consider <see cref="FindPage"/> for large result sets.
        /// </summary>
        public ICollection<T> FindAll()
        {
            using (TransactionRequired transaction = new TransactionRequired())
            {
                return Session.CreateCriteria(typeof(T)).List<T>();
            }
        }
 
        /// <summary>
        /// Counts the number of records.
        /// </summary>
        public int Count()
        {
            ICriteria criteria = Session.CreateCriteria(typeof(T));
            using (TransactionRequired transaction = new TransactionRequired())
            {
                return criteria.SetProjection(NHibernate.Criterion.Projections.RowCount()).UniqueResult<int>();
            }
        }
 
        /// <summary>
        /// Finds records by page.
        /// </summary>
        /// <param name="pageStartRow">The page start row.</param>
        /// <param name="pageSize">Size of the page.</param>
        public IList<T> FindPage(int pageStartRow, int pageSize)
        {
            ICriteria criteria = Session.CreateCriteria(typeof(T));
            criteria.SetFirstResult(pageStartRow);
            criteria.SetMaxResults(pageSize);
            using (TransactionRequired transaction = new TransactionRequired())
            {
                return criteria.List<T>();
            }
        }
 
        /// <summary>
        /// Finds records by page, sorted.
        /// </summary>
        public IList<T> FindSortedPage(int pageStartRow, int pageSize, string sortBy, bool descending)
        {
            ICriteria criteria = Session.CreateCriteria(typeof(T));
 
            if (descending)
                criteria.AddOrder(NHibernate.Criterion.Order.Desc(sortBy));
            else
                criteria.AddOrder(NHibernate.Criterion.Order.Asc(sortBy));
 
            criteria.SetFirstResult(pageStartRow);
            criteria.SetMaxResults(pageSize);
            using (TransactionRequired transaction = new TransactionRequired())
            {
                return criteria.List<T>();
            }
        }
        #endregion
 
        #region Update
        /// <summary>
        /// Saves the specified object within a transaction.
        /// </summary>
        public void Save(T entity)
        {
            using (TransactionRequired transaction = new TransactionRequired())
            {
                Session.Save(entity);
                transaction.Commit(); //flush to database
            }
        }
 
        /// <summary>
        /// Saves the specified object within a transaction.
        /// </summary>
        public void SaveOrUpdate(T entity)
        {
            using (TransactionRequired transaction = new TransactionRequired())
            {
                Session.SaveOrUpdate(entity);
                transaction.Commit(); //flush to database
            }
        }
 
        /// <summary>
        /// Deletes the specified object within a transaction.
        /// </summary>
        public void Delete(T entity)
        {
            using (TransactionRequired transaction = new TransactionRequired())
            {
                Session.Delete(entity);
                transaction.Commit(); //flush to database
            }
        }
        #endregion
    }
}

TransactionRequired:

using System;
using NHibernate;
 
namespace Northwind.Repositories
{
    /// <summary>
    /// Ensure a code block is transactional.
    /// If the session transaction is not open, create a transaction; otherwise there is an existing transaction so don't do anything.
    /// </summary>
    /// <remarks>
    /// Equivalent to <see cref="System.Transactions.TransactionScope"/> with default <see cref="System.Transactions.TransactionScopeOption"/> value <c>Required</c> (enlist in enclosing transaction or create a new one if it doesn't exist).
    /// </remarks>
    public sealed class TransactionRequired : IDisposable
    {
        private const string TRANSACTIONKEY = "NHIBERNATE.TRANSACTION";
        private ITransaction _transaction;
        private bool _shouldCommit;
        private bool _completed;
 
        #region Constructor
        public TransactionRequired(ISession session)
        {
            if (session == null) throw new ArgumentNullException("session");
            _transaction = session.Transaction; //equal to Transaction.Current
            if (!IsOpenTransaction(_transaction))
            {
                _transaction = session.BeginTransaction();
                ShouldCommit = true;
            }
        }
        #endregion
 
        #region NHibernate Transactions
 
        /// <summary>
        /// Gets or sets a value indicating whether this transaction should commit. If there is an open transaction, by default calling Commit will not do anything- it will leave the transaction open.
        /// </summary>
        /// <value><c>true</c> if should commit; otherwise, <c>false</c>.</value>
        public bool ShouldCommit
        {
            get { return _shouldCommit; }
            set { _shouldCommit = value; }
        }
 
        public void Commit()
        {
            if (!ShouldCommit) return;
 
            if (_completed)
                throw new InvalidOperationException("The current transaction is already committed. You should dispose the transaction.");
 
            _completed = true;
 
            try
            {
                if (IsOpenTransaction(_transaction))
                {
                    _transaction.Commit();
                    _transaction = null;
                }
            }
            catch (HibernateException)
            {
                RollbackTransaction();
                throw;
            }
        }
 
        public void RollbackTransaction()
        {
            if (!ShouldCommit) return;
            _completed = true;
 
            if (IsOpenTransaction(_transaction))
                _transaction.Rollback();
            _transaction = null;
        }
 
        private static bool IsOpenTransaction(ITransaction transaction)
        {
            return transaction != null && !transaction.WasCommitted && !transaction.WasRolledBack;
        }
 
        #endregion
 
 
        #region IDisposable Members
 
        public void Dispose()
        {
            if (!ShouldCommit) return;
            RollbackTransaction();
        }
 
        #endregion
    }
}

原文出处：http://www.martinwilley.com/net/code/nhibernate/index.html