NHibernate 基础类

[TOC]

### NHibernate ORM访问数据库基础类

```SQL
using NHibernate;
using NHibernate.Linq;
using NHibernate.Cfg;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using NHibernate.Transform;

namespace DAL
{
    public class NHibernateRepository<T>
    {
        /// <summary>
        /// 获取hibernate配置文件信息
        /// </summary>
        public static readonly Configuration cfg = new NHibernate.Cfg.Configuration().Configure(string.Format(@"{0}\APP_Config\hibernate.cfg.xml", HttpRuntime.AppDomainAppPath));
        /// <summary>
        /// Session工厂
        /// </summary>
        public static ISessionFactory sessionFactory;
        /// <summary>
        /// 构造函数
        /// </summary>
        public NHibernateRepository()
        {
            if (sessionFactory == null)
            {
                //创建Session工厂
                sessionFactory = cfg.BuildSessionFactory();
            }
        }
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public virtual object Save(T entity)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        var id = session.Save(entity);
                        session.Flush();
                        tran.Commit();
                        return id;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="entity"></param>
        public void Update(T entity)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        session.Update(entity);
                        session.Flush();
                        tran.Commit();
                    }
                    catch (Exception ex) {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="query"></param>
        public void Update(string query)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        int id = session.CreateSQLQuery(query).ExecuteUpdate();
                        session.Flush();
                        tran.Commit();
                        //return result;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="entity"></param>
        public void Delete(T entity)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        session.Delete(entity);
                        session.Flush();
                        tran.Commit();
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="query"></param>
        public int Delete(string query)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        int result = session.Delete(query);
                        session.Flush();
                        tran.Commit();
                        return result;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 获取单条记录
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Get(object id)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        T t = session.Get<T>(id);
                        tran.Commit();
                        return t; 
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 获取模型对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Load(object id)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        T t = session.Load<T>(id);
                        tran.Commit();
                        return t; 
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 获取模型对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public TK Load<TK>(object id)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        TK t = session.Load<TK>(id);
                        tran.Commit();
                        return t;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 获取模型对象
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public TK Load<TK>(string sql)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        TK t = session.CreateSQLQuery(sql).SetResultTransformer(Transformers.AliasToBean<TK>()).List<TK>().FirstOrDefault();
                        tran.Commit();
                        return t;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 获取多条记录
        /// </summary>
        /// <param name="sql">查询的sql语句</param>
        /// <returns></returns>
        public IList<T> LoadAll(string sql)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        IList<T> list = session.CreateSQLQuery(sql).SetResultTransformer(Transformers.AliasToBean<T>()).List<T>();
                        tran.Commit();
                        return list;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 分页获取列表信息
        /// </summary>
        /// <param name="pageStart">开始查找的记录条</param>
        /// <param name="pageLimit">显示数量</param>
        /// <param name="sql">查询的sql语句</param>
        /// <returns></returns>
        public IList<T> GetPageList(int pageStart, int pageLimit, string sql)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        IList<T> list = session.CreateSQLQuery(sql).
                            SetFirstResult(pageStart).
                            SetMaxResults(pageLimit).
                            SetResultTransformer(Transformers.AliasToBean<T>()).
                            List<T>();
                        tran.Commit();
                        return list;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 分页获取列表信息
        /// </summary>
        /// <param name="pageStart">开始查找的记录条</param>
        /// <param name="pageLimit">显示数量</param>
        /// <param name="sql">查询的sql语句</param>
        /// <returns></returns>
        public IList<TK> GetPageList<TK>(int pageStart, int pageLimit, string sql)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        IList<TK> list = session.CreateSQLQuery(sql).SetFirstResult(pageStart).SetMaxResults(pageLimit).SetResultTransformer(Transformers.AliasToBean<TK>()).List<TK>();
                        tran.Commit();
                        return list;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
        /// <summary>
        /// 获取数据总记录数
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public int GetRecordCount(string sql)
        {
            using (ISession session = sessionFactory.OpenSession())
            {
                using (ITransaction tran = session.BeginTransaction())
                {
                    try
                    {
                        int count = Convert.ToInt32(session.CreateSQLQuery(sql).AddScalar("C",NHibernateUtil.Int32).UniqueResult());
                        tran.Commit();
                        return count;
                    }
                    catch (Exception ex)
                    {
                        tran.Rollback();
                        throw ex;
                    }
                }
            }
        }
    }
}
```