适用于NHibernate3.0的Helper

不多说了，直接上代码

NhHelper.css

View Code

using System;
using NHibernate;
using System.Data;
using System.Linq;
using System.Text;
using fmtx.Entity;
using NHibernate.Linq;
using NHibernate.Criterion;
using NHibernate.Transform;
using System.Data.SqlClient;
using System.Linq.Expressions;
using System.Collections.Generic;
using NHibernate.Criterion.Lambda;


namespace fmtx.Hibernate.Utiltiy
{
    /// <summary>
    /// Hibernate操作Helper 
    /// 作者：覃乃林 感谢bobo tanw 提供帮助
    /// 2012-5-10
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class NhHelper<T> where T : EntityBase    
    {
        #region 构造
        private int configNum = 1;
        public NhHelper() { }
        public NhHelper(int configNum)
        {
            this.configNum = configNum;
        } 
        #endregion

        #region 获取一个实体
        /// <summary>
        /// 获取一个实体（一级缓存）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Load(object id)
        {
            try
            {
                return GetSession.Load<T>(id);
            }
            catch (Exception)
            {
                throw;
            }
        } 
        #endregion

        #region 获取一个实体（缓存）
        /// <summary>
        /// 获取一个实体（二级缓存）
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T Get(object id)
        {
            try
            {
                return GetSession.Get<T>(id);
            }
            catch (Exception)
            {
                throw;
            }
        } 
        #endregion

        #region 获取全部数据
        /// <summary>
        /// 获取全部数据
        /// </summary>
        /// <returns></returns>
        public IEnumerable<T> GetAll()
        {
            IEnumerable<T> list = null;
            ICriteria ic = GetSession.CreateCriteria(typeof(T));
            list = ic.List<T>();
            if (list==null)
            {
                list = new List<T>();
            }
            return list;
        } 
        #endregion

        #region 插入或者更新数据
        /// <summary>
        /// 插入或者更新数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public object SaveOrUpdate(T entity)
        {
            var session = GetSession;
            ITransaction tan = session.BeginTransaction();
            entity = (T)session.Merge(entity);
            try
            {
                tan.Begin();
                var obj = session.Save(entity);
                session.Flush();
                tan.Commit();
                return obj;
            }
            catch (Exception)
            {
                tan.Rollback();
                throw;
            }
        } 
        #endregion

        #region 插入数据(没有单独主键时使用)
        /// <summary>
        /// 插入数据(没有单独主键时使用)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public object Save(T entity)
        {
            var session = GetSession;
            ITransaction tan = session.BeginTransaction();
            try
            {
                tan.Begin();
                var obj = session.Save(entity);
                session.Flush();
                tan.Commit();
                return obj;
            }
            catch (Exception)
            {
                tan.Rollback();
                throw;
            }
        }
        #endregion

        #region 插入或者更新数据(不带事务)
        /// <summary>
        /// 插入或者更新数据(不带事务)
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public object SaveOrUpdateNotTan(T entity)
        {
            var session = GetSession;
            entity = (T)session.Merge(entity);
            try
            {
                var obj = session.Save(entity);
                return obj;
            }
            catch (Exception)
            {
                throw;
            }
        }
        #endregion

        #region 更新数据
        /// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Update(T entity)
        {
            int result = 0;
            ITransaction tan = GetSession.BeginTransaction();
            entity = (T)GetSession.Merge(entity);
            try
            {
                tan.Begin();
                GetSession.Update(entity);
                GetSession.Flush();
                tan.Commit();
                result++;
            }
            catch (Exception)
            {
                tan.Rollback();
                throw;
            }
            return result;
        } 
        #endregion

        #region 删除一条数据
        /// <summary>
        /// 删除一条数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public int Delete(object id)
        {
            int result = 0;
            object item = Get(id);
            ITransaction tan = GetSession.BeginTransaction();
            try
            {
                tan.Begin();
                GetSession.Delete(item);
                GetSession.Flush();
                tan.Commit();
                result++;
            }
            catch (Exception)
            {
                tan.Rollback();
                throw;
            }

            return result;
        } 
        #endregion

        #region 删除一个实体对象
        /// <summary>
        /// 删除一个实体对象
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public int Delete(EntityBase entity)
        {
            int result = 0;
            ITransaction tan = GetSession.BeginTransaction();
            try
            {
                tan.Begin();
                GetSession.Delete(entity);
                GetSession.Flush();
                tan.Commit();
                result++;
            }
            catch (Exception)
            {
                tan.Rollback();
                throw;
            }
            return result;
        } 
        #endregion

        #region 查询数据列表
        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="keyWhere">筛选条件</param>
        /// <returns></returns>
        public IEnumerable<T> Query(Expression<Func<T, bool>> keyWhere)
        {
            var ss = GetSession.Query<T>().Where(keyWhere);
            try
            {
                if (ss.Count() > 0)
                {
                    return ss.ToList();
                }
            }
            catch (Exception)
            {

            }
            return new List<T>();
        }  
        #endregion

        #region 查询数据列表
        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="keyWhere">筛选条件</param>
        /// <returns></returns>
        public IEnumerable<T> Query(List<Expression<Func<T, bool>>> keyWheres)
        {
            var ss = GetSession.Query<T>();
            foreach (var item in keyWheres)
            {
                ss = ss.Where(item);
            }
            try
            {
                if (ss.Count() > 0)
                {
                    return ss.ToList();
                }
            }
            catch (Exception)
            {

            }
            return new List<T>();
        }
        #endregion

        #region 查询数据列表
        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="keyWhere">筛选条件</param>
        /// <returns></returns>
        public IEnumerable<T> Query<Tkey>(Expression<Func<T, bool>> keyWhere, Expression<Func<T, Tkey>> KeyOrder)
        {
            var ss = GetSession.Query<T>().Where(keyWhere).OrderByDescending(KeyOrder);
            try
            {
                if (ss.Count() > 0)
                {
                    return ss.ToList();
                }
            }
            catch (Exception)
            {

            }
            return new List<T>();
        }
        #endregion

        #region 分页数据数据
        /// <summary>
        /// 分页数据数据
        /// </summary>
        /// <typeparam name="Tkey"></typeparam>
        /// <param name="pageIndex">起始页最小值1</param>
        /// <param name="pageSize">页项数</param>
        /// <param name="keyOrder">排序字段</param>
        /// <param name="keyWhere">筛选条件</param>
        /// <param name="desc">排序正反,0正序,1，反序</param>
        /// <param name="rowCount">总项数</param>
        /// <returns></returns>
        public IEnumerable<T> Query<Tkey>(int pageIndex, int pageSize, Expression<Func<T, Tkey>> keyOrder, Expression<Func<T, bool>> keyWhere, int? desc, ref int rowCount)
        {
            var ss = GetSession.Query<T>().Where(keyWhere);
            switch (desc)
            {
                case 1:
                    ss = ss.OrderByDescending(keyOrder);
                    break;
                case 0:
                    ss = ss.OrderBy(keyOrder);
                    break;
                default:
                    break;
            }
            if (ss.Count() > 0)
            {
                rowCount = ss.Count();
                return ss.Take(pageSize).Skip((pageIndex - 1) * pageSize).ToList();
            }
            return new List<T>();
        } 
        #endregion

        #region 分页数据数据
        /// <summary>
        /// 分页数据数据
        /// </summary>
        /// <typeparam name="Tkey"></typeparam>
        /// <param name="pageIndex">起始页最小值1</param>
        /// <param name="pageSize">页项数</param>
        /// <param name="keyOrder">排序字段</param>
        /// <param name="keyWhere">筛选条件组（多个条件）</param>
        /// <param name="desc">排序正反,0正序,1，反序</param>
        /// <param name="rowCount">总项数</param>
        /// <returns></returns>
        public IEnumerable<T> Query<Tkey>(int pageIndex, int pageSize, Expression<Func<T, Tkey>> keyOrder, Expression<Func<T, bool>>[] keyWhere, int? desc, ref int rowCount)
        {
            var ss = GetSession.Query<T>();
            foreach (var item in keyWhere)
            {
                ss = ss.Where(item);
            }
            switch (desc)
            {
                case 1:
                    ss = ss.OrderByDescending(keyOrder);
                    break;
                case 0:
                    ss = ss.OrderBy(keyOrder);
                    break;
                default:
                    break;
            }
            if (ss.Count() > 0)
            {
                rowCount = ss.Count();
                return ss.Take(pageSize).Skip((pageIndex - 1) * pageSize).ToList();
            }
            return new List<T>();
        }
        #endregion        

        #region 分页数据数据
        /// <summary>
        /// 分页数据数据
        /// </summary>
        /// <typeparam name="Tkey"></typeparam>
        /// <param name="pageIndex">起始页最小值1</param>
        /// <param name="pageSize">页项数</param>
        /// <param name="selectlist">过滤字段(null=*)</param>
        /// <param name="keyOrder">排序字段</param>
        /// <param name="keyWhere">筛选条件组（多个条件）</param>
        /// <param name="desc">排序正反,0正序,1，反序</param>
        /// <param name="rowCount">总项数</param>
        /// <returns></returns>
        public IEnumerable<T> QueryOver(int pageIndex, int pageSize, Func<QueryOverProjectionBuilder<T>, QueryOverProjectionBuilder<T>> selectlist, Expression<Func<T, object>> keyOrder, Expression<Func<T, bool>>[] keyWhere, int? desc, ref int rowCount)
        {
            var ss = GetQueryOver();
            foreach (var item in keyWhere)
            {
               ss= ss.Where(item);
            }
            if (selectlist != null)
            {
                ss = ss.SelectList(selectlist).TransformUsing(Transformers.AliasToBean<T>());
            }
            switch (desc)
            {
                case 1:
                    ss = ss.OrderBy(keyOrder).Desc;
                    break;
                case 0:
                    ss = ss.OrderBy(keyOrder).Asc;
                    break;
                default:
                    break;
            }
            if (ss.RowCount() > 0)
            {
                rowCount = ss.RowCount();
                return ss.Take(pageSize).Skip((pageIndex - 1) * pageSize).List<T>();//
            }
            return new List<T>();
        }
        #endregion

        #region 查询-ICriterion
        /// <summary> 
        /// 查询所有满足条件的项 
        /// </summary> 
        /// <param name="criterionList">查询条件数组</param> 
        /// <returns>返回条件项集合</returns> 
        public IEnumerable<T> Query(params ICriterion[] criterionList)
        {
            return Query(0, null, criterionList);
        }

        /// <summary> 
        /// 查询所有满足条件的项 
        /// </summary> 
        /// <param name="iCriterion">查询条件数组</param> 
        /// <returns>返回条件项集合</returns> 
        public IEnumerable<T> Query(Order[] orderList, params ICriterion[] criterionList)
        {
            return Query(0, orderList, criterionList);
        }

        /// <summary> 
        /// 查询所有满足条件的项 
        /// </summary> 
        /// <param name="criterionList">查询条件数组</param> 
        /// <returns>返回条件项集合</returns> 
        public IEnumerable<T> Query(int top, Order[] orderList, params ICriterion[] criterionList)
        {
            ICriteria criteria = GetSession.CreateCriteria(typeof(T));
            if (criterionList != null)
                foreach (ICriterion criterion in criterionList)
                    if (criterion != null) criteria.Add(criterion);
            if (orderList != null)
                foreach (Order o in orderList)
                    criteria.AddOrder(o);
            return top > 0 ? criteria.SetMaxResults(top).List<T>() : criteria.List<T>();
        }
        /// <summary>
        /// 分页查询 2011-7-22 tanw
        /// </summary>
        /// <param name="pageSize">页大小</param>
        /// <param name="pageIndex">页索引</param>
        /// <param name="recordCount">总记录数</param>
        /// <param name="orderList">排序方式</param>
        /// <param name="criterionList">查询条件</param>
        /// <returns></returns>
        public IEnumerable<T> Query(int pageIndex, int pageSize, ref int recordCount, Order[] orderList, params ICriterion[] criterionList)
        {
            ICriteria criteria = GetSession.CreateCriteria(typeof(T));
            if (criterionList != null)
                foreach (ICriterion criterion in criterionList)
                    if (criterion != null) criteria.Add(criterion);
        

            if (recordCount >= 0)
            {
                //获取记录总数
                ICriteria criteriaRecordCount = CriteriaTransformer.Clone(criteria);
                recordCount = criteriaRecordCount.SetProjection(NHibernate.Criterion.Projections.RowCount())
                    .UniqueResult<int>();
            }

            criteria.SetFirstResult(pageIndex * pageSize).SetMaxResults(pageSize);

            if (orderList != null)
                foreach (Order o in orderList)
                    criteria.AddOrder(o);

            return criteria.List<T>();
        }
        #endregion

        #region 查询-IQuery
        public IEnumerable<T> QueryByHql(int maxResults, string queryString)
        {
            IQuery query = GetSession.CreateQuery(queryString).SetMaxResults(maxResults);
            return query.List<T>();
        }
        public T QueryByHql(string queryString)
        {
            IQuery query = GetSession.CreateQuery(queryString);
            return query.UniqueResult<T>();
        }
        public bool IsExitsByHql(string queryString)
        {
            return GetObjectByHql(queryString) != null;
        }
        public int GetCountByHql(string queryString)
        {
            return Convert.ToInt32(GetObjectByHql(queryString));
        }
        public object GetObjectByHql(string queryString)
        {
            IQuery query = GetSession.CreateQuery(queryString);
            return query.UniqueResult();
        }
        #endregion        
       
        #region  获取linq查询数据源
        /// <summary>
        /// 获取linq查询数据源
        /// </summary>
        /// <returns></returns>
        public IQueryable<T> GetQueryable()
        {
            return GetSession.Query<T>();
        } 
        #endregion

        #region QueryOver
        /// <summary>
        /// QueryOver
        /// </summary>
        /// <returns></returns>
        public IQueryOver<T,T> GetQueryOver()
        {
            return GetSession.QueryOver<T>();
        } 
        #endregion

        #region ADO.Net操作
        public DataTable GetDataTable(string sql)
        {
            DataSet ds = GetDataSet(sql);
            if (ds != null && ds.Tables.Count > 0)
                return ds.Tables[0];
            return new DataTable();
        }

        public DataSet GetDataSet(string sql)
        {
            ISession session = GetSession;
            ITransaction trans = null;
            DataSet ds = new DataSet();

            try
            {
                trans = session.BeginTransaction();
                IDbCommand command = session.Connection.CreateCommand();
                trans.Enlist(command);//注意此处要把command添加到事物中
                command.CommandText = sql;
                IDataAdapter da = new SqlDataAdapter(command as SqlCommand);
                da.Fill(ds);
            }
            catch (Exception ex)
            {
                trans.Rollback();
                throw new Exception(ex.Message);
            }
            return ds;
        }

        public int RunProcedure(string procedureName, IDataParameter[] parameters)
        {
            ISession session = GetSession;
            ITransaction trans = null;
            try
            {
                trans = session.BeginTransaction();
                IDbCommand command = session.Connection.CreateCommand();
                if (parameters != null)
                    foreach (SqlParameter parm in parameters)
                        command.Parameters.Add(parm);

                trans.Enlist(command);//注意此处要把command添加到事物中
                command.CommandType = CommandType.StoredProcedure;
                command.CommandText = procedureName;
                int rowsAffected = command.ExecuteNonQuery();
                trans.Commit();
                return rowsAffected;
            }
            catch (Exception ex)
            {
                trans.Rollback();
                throw new Exception(ex.Message);
            }
        }

        public int RunProcedure(string sql)
        {
            ISession session = GetSession;
            ITransaction trans = null;
            try
            {
                trans = session.BeginTransaction();
                IDbCommand command = session.Connection.CreateCommand();

                trans.Enlist(command);//注意此处要把command添加到事物中
                command.CommandText = sql;
                int rowsAffected = command.ExecuteNonQuery();
                trans.Commit();
                return rowsAffected;
            }
            catch (Exception ex)
            {
                trans.Rollback();
                throw new Exception(ex.Message);
            }
        }  

        #endregion

        #region  获取session（注：此值不可以保存为静态变量，切切!!）
        /// <summary>
        /// 获取session（注：此值不可以保存为静态变量，切切!!）
        /// </summary>
        public ISession GetSession
        {
            get
            {
                return  SessionBuilder.GetCurrentSession();
            }
        } 
        #endregion
    }
}

SessionBuilder.cs

View Code

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using NHibernate;
using NHibernate.Cfg;
using NHibernate.Context;

namespace fmtx.Hibernate.Utiltiy
{
        /// <summary>
        /// 主要用于管理session的SessionBuilder
        /// 作者：覃乃林 
        /// 2012-5-10
        /// </summary>
        public class SessionBuilder 
        {

            #region 变量
            public static readonly ISessionFactory SessionFactory;
            private static Configuration configuration = null; 
            #endregion

            #region 获取配置文件
            /// <summary>
            /// 获取配置文件
            /// </summary>
            private static void CreateConfiguration()
            {
                string configfile = System.Configuration.ConfigurationManager.AppSettings["nhibernate.config"];
                string actualFile = System.Web.HttpContext.Current.Request.MapPath(configfile);
                configuration = new Configuration().Configure(actualFile);
                string log4netpath = System.Configuration.ConfigurationManager.AppSettings["log4net.config"];
                string log4netPaths = System.Web.HttpContext.Current.Request.MapPath(log4netpath);
                log4net.Config.XmlConfigurator.ConfigureAndWatch(new System.IO.FileInfo(log4netPaths));
            } 
            #endregion

            #region 初始化SessionFactory
            /// <summary>
            /// 初始化SessionFactory
            /// </summary>
            static SessionBuilder()
            {
                CreateConfiguration();
                SessionFactory = configuration.BuildSessionFactory();
            } 
            #endregion

            #region 打开session
            /// <summary>
            /// 打开session
            /// </summary>
            /// <returns></returns>
            private static ISession OpenSession()
            {
                return SessionFactory.OpenSession();
            } 
            #endregion

            #region 请求周期处理事件
            /// <summary>
            /// 在一次会话请求开始的时候初始化当前的Httpcontext的session
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            public static void BeginRequest()
            {
                var session = SessionBuilder.OpenSession();
                session.BeginTransaction();
                CurrentSessionContext.Bind(session);
            }
            /// <summary>
            /// 在服务器端返回消息前，关闭当前httpcontext的session
            /// </summary>
            /// <param name="sender"></param>
            /// <param name="e"></param>
            public static void EndRequest()
            {
                if (CurrentSessionContext.HasBind(SessionBuilder.SessionFactory))
                {
                    ISession session = WebSessionContext.Unbind(SessionBuilder.SessionFactory);
                    //session.Flush();
                    session.Close();
                }

            } 
            #endregion

            #region 只允许在Global.asax中的初始化使用
            /// <summary>
            /// 只允许在Global.asax中的初始化使用(并且要及时关闭)
            /// </summary>
            /// <returns></returns>
            public static ISession InitSession()
            {
                return OpenSession();
            } 
            #endregion

            #region 获取session（不允许保存为静态变量）
            /// <summary>
            /// 获取session（不允许保存为静态变量）
            /// </summary>
            /// <returns></returns>
            public static ISession GetCurrentSession()
            {
                ISession session = SessionFactory.GetCurrentSession();
                if (!session.IsOpen)
                {
                    session = SessionFactory.OpenSession();
                }
                return session;
            } 
            #endregion
        }
}

在实体类库中添加类

EntityBase.cs

View Code

using System;
using System.Collections.Generic;
using System.Text;

namespace fmtx.Entity
{
    [Serializable]
    public class EntityBase
    {
    }
}

配置文件

nhibernate.config

View Code

<?xml version="1.0" encoding="utf-8" ?>

<hibernate-configuration  xmlns="urn:nhibernate-configuration-2.2" >
  <session-factory >
    <property name="connection.driver_class">NHibernate.Driver.SqlClientDriver</property>
    <property name="connection.connection_string">
      Data Source=
    </property>
    <property name="adonet.batch_size">16</property>
    <property name="show_sql">true</property>
    <property name="dialect">NHibernate.Dialect.MsSql2005Dialect</property>
    <property name="command_timeout">60</property>
    <property name="current_session_context_class">web</property>
    <mapping assembly="fmtx.Entity" />
  </session-factory>
</hibernate-configuration>

Global.asax (这是one request per session模式也就是每次请求只打开一次session,很实用！)

View Code

        public override void Init()
        {
            // 并不是每一次请求都需要一个 Session 来访问数据库。
            // 文中 Global.asax 的代码给所有的请求在开始的时候都进行WebSessionContext.Bind()，会照成很多 Session 的浪费，
            // 虽然 NHibernate 的 Session 是轻量级的，较为合理的做法是在“真正需要”时绑定。
            BeginRequest += new EventHandler(MvcApplication_BeginRequest);
            EndRequest += new EventHandler(MvcApplication_EndRequest);
        }

       
        #region  预载nhibernate信息


        private void MvcApplication_BeginRequest(object sender, EventArgs e)
        {
            SessionBuilder.BeginRequest();
        }

        private void MvcApplication_EndRequest(object sender, EventArgs e)
        {
            SessionBuilder.EndRequest();
        }
        #endregion

posted on 2011-12-10 11:17 凤鸣阅读(1290) 评论(1) 收藏举报

刷新页面返回顶部

导航

公告

适用于NHibernate3.0的Helper