Nhibernate 数据操作封装类 可以执行hql 原生sql 返回DataSet

最新推荐文章于 2017-09-25 22:23:54 发布
最新推荐文章于 2017-09-25 22:23:54 发布
阅读量1.9k 收藏 1
点赞数 1
分类专栏： c# asp.net 文章标签： Nhibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/malongning/article/details/8330945
版权
c# 同时被 2 个专栏收录
23 篇文章 0 订阅
订阅专栏
asp.net
6 篇文章 0 订阅
订阅专栏 
public class SessionManager
    {
        # region 当前单实例

        private readonly static SessionManager instance = new SessionManager();
        /// <summary>
        /// 当前实例
        /// </summary>
        public static SessionManager CurrInstance
        {
            get
            {
                return instance;
            }
        }

        # endregion

        private ISessionFactory _sessionFactory;
        private SessionManager()
        {
            _sessionFactory = GetSessionFactory();
        }
        private ISessionFactory GetSessionFactory()
        {
            //string strFilePaht = System.AppDomain.CurrentDomain.BaseDirectory.ToString() + "hibernate.cfg.xml";
            Configuration config = (new Configuration()).Configure();
            glo.DataBaseDerived = config.GetDerivedProperties()["connection.driver_class"].ToString();
             
            return config.BuildSessionFactory();
        }
        /// <summary>
        /// 获取Session
        /// </summary>
        /// <returns></returns>
        public ISession GetSession()
        {
            return _sessionFactory.OpenSession();
        }

        /// <summary>
        /// 初始数据库设置
        /// </summary>
        public void DbInitial()
        {
            ISession _session= _sessionFactory.OpenSession();
            _session.Close();
        }
    }
 
public class NhibernateHelper : IDbHelper
    {
        # region 当前单实例
        private readonly static NhibernateHelper instance = new NhibernateHelper();
        public static NhibernateHelper CurrInstance
        {
            get
            {
                return instance;
            }
        }
        # endregion
        /// <summary>
        /// 新增记录
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public bool CreateModel(object Model)
        {
            bool bl = true;
            
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                ITransaction tx = _session.BeginTransaction();
                try
                {   _session.Save(Model);
                    _session.Flush();
                    tx.Commit();
                }
                catch (HibernateException ex)
                {
                    bl = false;
                    tx.Rollback();
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
            return bl;
        }
        /// <summary>
        /// 修改记录
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public bool UpdateModel(object Model)
        {
            bool bl = true;
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                ITransaction tx = _session.BeginTransaction();
                try
                {
                    _session.Update(Model);
                    _session.Flush();
                    tx.Commit();
                }
                catch (HibernateException ex)
                {
                    bl = false;
                    tx.Rollback();
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
            return bl;
        }
        /// <summary>
        /// 批量保存更新实体类
        /// </summary>
        /// <param name="Models"></param>
        /// <returns></returns>
        public bool SaveOrUpdateModel(IList<object> Models)
        {
            bool bl = true;
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                ITransaction tx = _session.BeginTransaction();
                try
                {
                    foreach (var Model in Models)
                    {
                        _session.Update(Model);
                    }
                    _session.Flush();
                    tx.Commit();
                }
                catch (HibernateException ex)
                {
                    bl = false;
                    tx.Rollback();
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
            return bl;
        }
        /// <summary>
        /// 删除记录
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public bool DeleteModel(object Model)
        {
            bool bl = true;
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                ITransaction tx = _session.BeginTransaction();
                try
                {
                    _session.Delete(Model);
                    _session.Flush();
                    tx.Commit();
                }
                catch (HibernateException ex)
                {
                    bl = false;
                    tx.Rollback();
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
            return bl;
        }
        /// <summary>
        /// 删除记录(ByID)
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public bool DeleteModelByID(string entityName, object ID)
        {
            bool bl = true;
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                ITransaction tx = _session.BeginTransaction();
                try
                {
                    object Model=_session.Get(entityName, ID);
                    _session.Delete(Model);
                    _session.Flush();
                    tx.Commit();
                }
                catch (HibernateException ex)
                {
                    bl = false;
                    tx.Rollback();
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
            return bl;
        }
        /// <summary>
        /// 按ID查找记录
       /// </summary>
       /// <param name="entityName">实体类的名字</param>
       /// <param name="ID">记录ID</param>
       /// <returns></returns>
        public object GetModelById(string entityName,object ID)
        {
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                try
                {
                   return _session.Get(entityName, ID);                       
                }
                catch (HibernateException ex)
                {
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 执行Hql查询语句
        /// </summary>
        /// <param name="hql"></param>
        /// <returns></returns>
        public IList<object> CreateHqlQuery(string hql)
        {
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                try
                {
                    return _session.CreateQuery(hql).List<object>();
                }
                catch (HibernateException ex)
                {
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 执行Hql查询语句,不直接释放session，请在外部使用时加using释放
        /// </summary>
        /// <param name="hql"></param>
        /// <returns></returns>
        public IList<object> CreateHqlQueryNoRelease(string hql, ref ISession _session)
        {
            try
            {
                _session = SessionManager.CurrInstance.GetSession();
                return _session.CreateQuery(hql).List<object>();
            }
            catch(HibernateException ex)
            {
                throw ex;
            }
                
        }
        /// <summary>
        /// 执行Hql语句,并返回object[],例子：select c.Name, count(c.Name) from Gbook c group by c.Name
        /// </summary>
        /// <param name="hql"></param>
        /// <returns></returns>
        public IList<object[]> CreateHqlQuery_Arry(string hql)
        {
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                try
                {
                    return _session.CreateQuery(hql).List<object[]>();
                }
                catch (HibernateException ex)
                {
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 执行Hql,更新、删除语句,多条语句使用 ; 间隔
        /// </summary>
        /// <param name="hql"></param>
        /// <returns>返回执行记录数</returns>
        public int CreateHqlQuery_UpdateAndDelete(string hql)
        {
            int Count = 0;
            int i = 0;
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                ITransaction tx = _session.BeginTransaction();
                try
                {
                    string[] strArry=hql.Split(';');
                    foreach (string strhql in strArry)
                    {
                        i = _session.CreateQuery(strhql).ExecuteUpdate();
                        Count += i;
                    }
                    _session.Flush();
                    tx.Commit();                    
                }
                catch (HibernateException ex)
                {
                    Count = -1;
                    tx.Rollback();
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
            return Count;
        }
        /// <summary>
        /// 执行Sql查询语句
        /// </summary>
        /// <param name="hql"></param>
        /// <returns></returns>
        public IList<object> CreateSqlQuery(string sql)
        {
            using (ISession _session = SessionManager.CurrInstance.GetSession())
            {
                try
                {
                    return _session.CreateSQLQuery(sql).List<object>();
                }
                catch (HibernateException ex)
                {
                    throw ex;
                }
                finally
                {
                    if (_session != null)
                    {
                        _session.Close();
                    }
                }
            }
        }
        /// <summary>
        /// 执行sql语句，没有返回数据集，提供事务支持
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public bool ExecuteNonQuery(string sql)
        {
            return ExecuteNonQuery(sql, null);
        }
        /// <summary>
        /// 执行sql语句，没有返回数据集，提供事务支持
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramenters"></param>
        /// <returns></returns>
        public bool ExecuteNonQuery(string sql, IDbDataParameter[] paramenters)
        {
            bool bl = false;
            ISession _session = null;
            ITransaction transaction = null;
            try
            {
                _session = SessionManager.CurrInstance.GetSession();
                transaction = _session.BeginTransaction();
                IDbCommand command = _session.Connection.CreateCommand();
                transaction.Enlist(command);//注意此处要把command添加到事物中
                command.CommandText = sql;
                if (paramenters != null)
                {
                    foreach (IDataParameter parm in paramenters)
                    {
                        command.Parameters.Add(parm);
                    }
                }
                int i=command.ExecuteNonQuery();
                transaction.Commit();
            }
            catch (Exception ex)
            {
                if (transaction != null)
                {
                    transaction.Rollback();
                }
                throw ex;
            }
            finally
            {
                if (_session != null)
                {
                    _session.Close();
                }
            }
            return bl;
        }
        /// <summary>
        /// 填充DataSet，方法二
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public DataSet ExecuteDataset2(string sql)
        {
            ISession _session = null;
            DataSet ds = new DataSet();
            try
            {
                _session = SessionManager.CurrInstance.GetSession();
                IDbCommand command = _session.Connection.CreateCommand();
                command.CommandText = sql;
                IDataReader reader = command.ExecuteReader();
                DataTable result = new DataTable();
                //result.Load(reader);//此方法亦可
                DataTable schemaTable = reader.GetSchemaTable();
                for (int i = 0; i < schemaTable.Rows.Count; i++)
                {
                    string columnName = schemaTable.Rows[i][0].ToString();
                    result.Columns.Add(columnName);
                }
                while (reader.Read())
                {
                    int fieldCount = reader.FieldCount;
                    object[] values = new Object[fieldCount];
                    for (int i = 0; i < fieldCount; i++)
                    {
                        values[i] = reader.GetValue(i);
                    }
                    result.Rows.Add(values);
                }
                ds.Tables.Add(result);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (_session != null)
                {
                    _session.Close();
                }
            }
            return ds;
        }
        /// <summary>
        /// 填充DataSet（此方法亦可）
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public DataSet ExecuteDataset(string sql)
        {
            return ExecuteDataset(sql, null);
        }
        /// <summary>
        /// 填充DataSet
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public DataSet ExecuteDataset(string sql,IDbDataParameter[] paramenters)
        {
            ISession _session = null;
            DataSet ds = new DataSet();
            try
            {
                _session = SessionManager.CurrInstance.GetSession();
                IDbCommand command = _session.Connection.CreateCommand();
                command.CommandText = sql;
                if (paramenters != null)
                {
                    foreach (IDataParameter parm in paramenters)
                    {
                        command.Parameters.Add(parm);
                    }
                }
                switch (glo.DataBaseType)
                {
                    case DataBaseType.SqlServer:
                        SqlDataAdapter da = new SqlDataAdapter(command as SqlCommand);
                        da.Fill(ds);
                        break;
                    case DataBaseType.MySql:
                        MySqlDataAdapter daMy = new MySqlDataAdapter(command as MySqlCommand);
                        daMy.Fill(ds);
                        break;
                    case DataBaseType.Oracle:
                        OracleDataAdapter daOrl = new OracleDataAdapter(command as OracleCommand);
                        daOrl.Fill(ds);
                        break; 
                    default:
                        break;
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                if (_session != null)
                {
                    _session.Close();
                }
            }
            return ds;
        }

    }
    /// <summary>
    /// 数据库类型 
    /// </summary>
    public enum DataBaseType
    {
        MySql,
        SqlServer,
        Oracle
    }
    public class glo
    {
        private static string dataBaseDerived = "";
        /// <summary>
        /// Nhibernate数据库驱动配置
        /// </summary>
        public static string DataBaseDerived
        {
            set
            {
                dataBaseDerived = value;
                switch (dataBaseDerived)
                {
                    case "NHibernate.Driver.MySqlDataDriver":
                        dataBaseType = DataBaseType.MySql;
                        break;
                    case "NHibernate.Driver.SqlClientDriver":
                        dataBaseType = DataBaseType.SqlServer;
                        break;
                    case "NHibernate.Driver.OracleClientDriver":
                        dataBaseType = DataBaseType.Oracle;
                        break;
                }
            }
            get
            {
                return dataBaseDerived;
            }
        }
        private static DataBaseType dataBaseType;
        /// <summary>
        /// 数据库类型
        /// </summary>
        public static DataBaseType DataBaseType
        {
            get
            {
                if (glo.DataBaseDerived == "")
                {
                    SessionManager.CurrInstance.DbInitial();                    
                }
                return dataBaseType;
            }
        }
        #region 使用web.config的配置方法
        //private static DataBaseType baseType;
        //public static DataBaseType BaseType
        //{
        //    get
        //    {
        //        string strDbtype = ConfigHelper.GetConfigString("DataType"); 
        //        switch (strDbtype)
        //        {
        //            case "MYSQL":
        //                baseType=DataBaseType.MySql;
        //                break;
        //            case "SQLSERVER":
        //                baseType=DataBaseType.SqlServer;
        //                break;
        //            case "ORACLE":
        //                baseType=DataBaseType.Oracle;
        //                break;
        //        }                
        //        return baseType;
        //    }
        //}
        #endregion
    }

malongning
关注
专栏目录
使用.NET语言借助NHibernate数据引擎操作SQL Server2008数据库
06-12
程序功能：通过C#语言，使用NHibernate数据引擎，以SQL Server2008数据库为数据支撑，进行数据的插入、更新、删除等操作。（没有设计页面，仅仅是实现功能，程序包含了我的辛苦，仅象征性收取一分的赞助分） 简要...
nhibernate中数据的配置和映射Hql语句PPT
06-18
详细记录了 在nhibernate框架下 ，hql语句的各种应用查询以及在项目中的实战应用……
NHibernate 操作原生SQL以及查询DataTable，DataSet
a65783305的博客
09-28 120
publicvoidExecuteNonQuery(stringsql) { ISessionsession=null; ITransactiontransaction=null; try { ...
NHibernate执行原始SQL代码的方法小结
热门推荐
阿飞的专栏
09-26 1万+
在使用NHibernate过程中经常会使用到复杂的sql查询，但是使用hql又比较麻烦的情况下，我们往往都会想到采用原始的sql来执行。但是如何利用NHibernate来执行sql呢？问题来了，在NHibernate中也有AdoTemplate的方法可以执行sql的，但是这里要介绍的是另外一种方法：CreateSQLQuery。以下部分例子源自于网络。  实例一（源自于http://b
NHibernate与DataSet
weixin_34101784的博客
11-18 133
今天作一个测试，在三层结构系统中，将一个20个字段，一万条数据，读取并传递到客户端，在Nhibernate中，会以List形式返回，DataSet以DataTable返回，本以为DataTable传递，会有一些传换，会要慢一些，结果，Nhibernate平均用时12秒，而DataSet平均用时9秒，这样看来，DataSet强大，但不笨拙。...
按照NHIBERNATE使用习惯封装的SQL操作类
weixin_30588729的博客
12-09 93
工作中数据层开始的时候我们是用NHIBERNATE的，后来发觉这个学习成本比较高，还有就是业务比较复杂的时候配置等各方面都比较麻烦，而且控制不好的话链接很容易爆满，后来我们该用直接用ADO.NET自己封装了一个操作类来满足这方面的需求，下面的代码是这个HELPER类的雏形。看起来都比较容易明白，所以注析就少了点。 这个类是按照NHIBERNATE的操作习惯进行封装的，该类把常用的基本操作和...
nhibernate使用sql查询
王老欠
06-06 1274
在使用NHibernate的时候，我们经常会发现需要使用sql语句来查询某些关系比较复杂的表，通常使用sql语句查询出的结果集需要转换成实体的集合形式，进行过滤和序列化展示等操作。Nhibernate已经为我们提供了非常方便的方法，示例如下: 首先我们需要一个实体类 假设A表中有字段A1,A2,A3，B表中有字段B1,B2,B3 public class ReportModel { pub
SqlServer与MongoDB结合使用NHibernate
09-09
首先，为了能够同时操作两种类型的数据库，我们需要配置NHibernate以支持SqlServer和MongoDB。在配置文件中，我们需要为每一种数据库提供连接字符串，例如文中给出的SqlServerConnectionString和...
sql类.rar_SQL C#类_sql 类_sql类
最新发布
09-21
在SQL和C#编程中，将SQL操作封装到类中是一种常见的做法，目的是为了提高代码的可重用性和模块化。这个"sql类.rar"压缩包可能包含了一个或多个C#类，这些类用于简化与数据库的交互。下面我们将详细讨论SQL C#类的...
NHibernate hql 可用函数,函数大全
05-13
### NHibernate HQL 可用函数详解 #### 一、查询基本语法与示例 **1....- **语法**: `FROM <类名> [WHERE <条件>]` - **示例**: `FROM Category c ...通过这些示例,你可以更好地理解和应用HQL来完成数据库操作任务。
一个有用的NHibernate工具类NHibernateUtil (第二版)
冰河の泥鱼的专栏
05-23 1870
using System;namespace Com.W3oa.Hibernate{ ///  /// Summary description for HibernateUtil. ///  public class HibernateUtil {  [ThreadStatic]  private static NHibernate.ISession threadLocal;  private
五、NHibernate之事务处理
soldierluo的专栏
10-12 4792
一、事务概述Ø  定义：所谓事务是指其中的一个或多个操作要么都执行要么都不执行Ø  为什么要使用：确保数据的安全和完整Ø  何时使用：在任何时候都要使用事务，即使是在读取、查询数据的时候，为什么呢？因为你不清楚数据库什么时候操作失败，如何恢复原来数据。而的事务可以帮助我们完成这些事情。Ø  注意事项：请结合using()和异常处理来一起使用 二、事务处理举例以下函数添加
Photon_对NHibernate增删改查的封装_008
杨勇博客之家
09-25 485
第一步：使用单例模式封装一个Hibernate的一个工具类，增加对代码的重用。using System; using System.Collections.Generic; using System.IO; using System.Linq; using System.Text; using NHibernate; using NHibernate.Cfg; namespace YYEdu {
ORM利器：NHibernate（三）五部曲+简单对象CRUD+HQL
chestnut
08-01 2437
NHibernate的使用做Demo解析，分为五部曲：1、创建表；2、创建类；3、创建映射文件（表和类是如何对应的）；4、NH配置文件（连接数据库）；5、利用API操作。 其中，2、3 我们采用CodeSmith自动生成映射类和映射文件；4就是我们曾做的连接数据库操作；5通过NHibernate提供的API，通过对对象操作，已达到操作数据库的目的，避免了冗长复杂的sql语句。
NHibernate统一类封装代码
weixin_30451709的博客
03-20 110
NHibernate已经成为.net主流的ORM框架，当然，在开发中如果需要使用NHibernate的话，我们一般会对她进行一次封装，以便在项目中使用更方便，以及对NHibernate有一个全局的控制。而对NHibernate的封装也不是那么简单的，比如说NHibernate无法做到夸层的封装，意思就是在其他层使用封装的代码的时候，也是需要引用NHibernate的，比如一般的IQuery条件...
【Hibernate】关于hibernate中使用createSQLQuery后返回的结果处理
Share
11-11 7458
在hibernate 中使用createSQLQuery（特别是多表结合的时候或复杂SQL时使用比较方便）后，会返回一个LIST，如果自己新建一个BEAN然后一个一个进行SET的话，比较麻烦，维护也比较难。 这样可以利用SQLQuery 类中ResultTransformer进行结果的转换（直接转换到自己定义的BEAN中）。 但这里要自己定义一个BEAN的转换类继承自ResultTransfo
NHibernate之旅(3)：探索查询之NHibernate查询语言(HQL)
weixin_34067049的博客
10-15 149
NHibernate之旅(3)：探索查询之NHibernate查询语言(HQL) 本节内容 NHibernate中的查询方法 NHibernate查询语言(HQL) 1.from子句 2.select子句 3.where子句 4.order by子句 5.group by子句 实例分析 结语 上一节，我们初步搭建了一个NHi...
Nhibernate操作原生SQL以及查询DataTable
ddxkjddx的专栏
04-28 1119
<br /><br />使用Nhibernate时我们很方便实现实体映射，但是如果遇到复杂查询则显得力不从心，这是我们可以利用Nhibernate来操作原生sql来查询到DataTable来实现我们复杂的查询及其它操作。以下实例已经过调试，现与大家分享。<br />/// <summary><br />/// 执行ExecuteNonQuery<br />/// </summary><br />/// <param name="sql"></param><br />public void ExecuteNo
Nhibernate 使用sql语句查询
Hi-Jimmy
01-07 2793
在Nhibernate里当要使用复杂的查询逻辑时，相比SQL总感觉差强人意（毕竟SQL我们更加熟悉） 比如当使用联合多表查询等等情况就可以使用CreateSQLQuery（）方法在Nhibernate中使用SQL语句。 下面是个简单例子： IList list = null; string selectHql = string.Format(@"s
NHibernate HQL基础教程：面向对象的SQL查询
在项目实践中，为了保持代码组织清晰，通常会在数据访问层（DAL）创建专门的类（如`QueryHql.cs`）来封装HQL查询方法，而在业务逻辑层（BLL）直接调用这些方法。测试代码通常放在测试层（如`QueryHqlFixture.cs`），...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值