NHibernate初学二之简单执行SQL及HQL、Linq

上篇文章简单介绍NHibernate之简单增删改查，本文将会简单介绍有关执行NHibernate的SQL、HQL及存储过程；

一：执行SQL语句实例，运用CreateSQLQuery方法

        public IList<SchoolModel> GetListBySql()
        {
            string strSql = "select * from T_School where studentNum>250";
            ISQLQuery sqlQuery = isession.CreateSQLQuery(strSql).AddEntity(typeof(SchoolModel));
            return sqlQuery.List<SchoolModel>();
        }

二：执行存储过程实例

2.1：首先定义一个存储过程，传入一个参数

Create PROCEDURE [dbo].[Pro_Hql] 
    @StudentNum int
AS
BEGIN
   select * from T_School where studentNum>@StudentNum
END

2.2：引入using System.Data;using NHibernate.Engine命名空间,NHibernateHelper是帮助类返回SessionFactory；当然也可以通过它来执行SQL语句

        public IList<SchoolModel> GetListByProcedure()
        {
            IList<SchoolModel> list = new List<SchoolModel>();
            ISessionFactoryImplementor imp = (ISessionFactoryImplementor)new NHibernateHelper().GetSessionFactory();
            IDbConnection conn = imp.ConnectionProvider.GetConnection();
            IDbCommand cmd = imp.ConnectionProvider.GetConnection().CreateCommand();
            try
            {
                cmd.CommandText = "Pro_Hql";
                cmd.CommandType = System.Data.CommandType.StoredProcedure;
                IDbDataParameter parameter = cmd.CreateParameter();
                parameter.ParameterName = "StudentNum";
                parameter.Value = 250;
                cmd.Parameters.Add(parameter);
                cmd.Connection = conn;
                IDataReader read = cmd.ExecuteReader();
                while (read.Read())
                {
                    SchoolModel model = new SchoolModel();
                    model.ID = Guid.Parse(read.GetValue(0).ToString());
                    model.SchoolName = read.GetValue(1).ToString();
                    model.BuildDate = DateTime.Parse(read.GetValue(2).ToString());
                    model.Address = read.GetValue(3).ToString();
                    model.IsSenior = bool.Parse(read["IsSenior"].ToString());
                    model.StudentNum = int.Parse(read["StudentNum"].ToString());
                    list.Add(model);
                }
                
            }
            catch (Exception ex)
            {
 
            }
            return list;
        }

三：执行HQL语句实例，此处用CreateQuery并设置参数用":"，当然也可以拼接字符串;

        public IList<SchoolModel> GetListByHql()
        {
            //实体的名称跟属性大小写都要注意
            string hqlStr = "from SchoolModel c where c.StudentNum>:studentNum";
            return isession.CreateQuery(hqlStr).SetString("studentNum", "250").List<SchoolModel>();
        }

 四：Nhibernate也支持Linq的查询功能，其在命名空间NHibernate.Linq；下面列出一些比较常见：

1、限制运算符

Where：筛选序列中的项目
WhereNot:反筛选序列中的项目

2、投影运算符

Select：创建部分序列的投影
SelectMany：创建部分序列的一对多投影

3、分区运算符(分页常用到)

Skip：返回跳过指定数目项目的序列
SkipWhile：返回跳过不满足表达式项目的序列
Take：返回具有指定数目项目的序列
TakeWhile：返回具有满足表达式项目的序列

4、排序运算符

OrderBy：以升序按值排列序列
OrderByDescending：以降序按值排列序列
ThenBy：升序排列已排序的序列
ThenByDescending：降序排列已排序的序列
Reverse：颠倒序列中项目的顺序(用于操作集合)

5、分组运算符

GroupBy：按指定分组方法对序列中的项目进行分组

6、设置运算符

Distinct：返回无重复项目的序列
Except：返回代表两个序列差集的序列(用于操作集合)
Intersect：返回代表两个序列交集的序列(用于操作集合)
Union：返回代表两个序列交集的序列(用于操作集合)

7、转换运算符

Cast：将序列中的元素转换成指定类型
OfType：筛选序列中指定类型的元素
ToArray：从序列返回一个数组
ToDictionary：从序列返回一个字典
ToList：从序列返回一个列表
ToLookup：从序列返回一个查询
ToSequence：返回一个IEnumerable序列

8、元素运算符

DefaultIfEmpty：为空序列创建默认元素(用于操作集合)
ElementAt：返回序列中指定索引的元素(用于操作集合)
ElementAtOrDefault：返回序列中指定索引的元素，或者如果索引超出范围，则返回默认值(用于操作集合)
First：返回序列中的第一个元素
FirstOrDefault：返回序列中的第一个元素，或者如果未找到元素，则返回默认值
Last：返回序列中的最后一个元素(用于操作集合)
LastOrDefault：返回序列中的最后一个元素，或者如果未找到元素，则返回默认值(用于操作集合)
Single：返回序列中的单个元素
SingleOrDefault：返回序列中的单个元素，或者如果未找到元素，则返回默认值

9、生成运算符

Empty：生成一个空序列
Range：生成一个指定范围的序列
Repeat：通过将某个项目重复指定次数来生成一个序列

10、限定符

All：确定序列中的所有项目是否满足某个条件
Any：确定序列中是否有任何项目满足条件
Contains：确定序列是否包含指定项目

11、聚合运算符

Aggregate：对序列执行一个自定义方法
Average：计算数值序列的平均值
Count：返回序列中的项目数（整数）
LongCount：返回序列中的项目数（长型）
Min：查找数字序列中的最小数
Max：查找数字序列中的最大数
Sum：汇总序列中的数字

12、连接运算符

Concat：将两个序列连成一个序列

13、联接运算符

GroupJoin：通过归组将两个序列联接在一起
Join：将两个序列从内部联接起来

        public IList<SchoolModel> GetSchoolList()
        {
            IList<SchoolModel> list = null;
            list = isession.QueryOver<SchoolModel>().List();
            return list;
        }
 public IList<SchoolModel> GetListByLinq()
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().Where(m => m.IsSenior).List();
            return list;
        }
        /// <summary>
        /// 返回符合条件的第一条记录，当为空是，返回一个各属性为null的对应类型的对象
        /// </summary>
        /// <returns></returns>
        public SchoolModel GetModelByLinq()
        {
            SchoolModel model = isession.QueryOver<SchoolModel>().WhereNot(m => m.IsSenior).SingleOrDefault();
            if (model == null)
            {
                return null;
            }
            return model;
        }
        /// <summary>
        /// 相当于WHERE
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListByLindAnd()
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().And(m => m.StudentNum > 390).List();
            return list;
        }
        /// <summary>
        /// 相当于反WHERE
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListByLindAndNot()
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().AndNot(m => m.StudentNum > 400).List();
            return list;
        }
        /// <summary>
        /// 增加限制条件
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListByLinqAndRestrictionOn()
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().AndRestrictionOn(m => m.SchoolName).IsLike("踏浪", NHibernate.Criterion.MatchMode.Anywhere).List();
            return list;
        }
        /// <summary>
        /// 排序 升
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListOrderByAsc()
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().OrderBy(m => m.StudentNum).Asc().List();
            return list;
        }
        /// <summary>
        /// 排序 降
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListOrderByDesc()
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().OrderBy(m => m.StudentNum).Desc().List();
            return list;
        }
        /// <summary>
        /// 近回个数
        /// </summary>
        /// <returns></returns>
        public int GetListByLinqCount()
        {
            return isession.QueryOver<SchoolModel>().RowCount();
        }
        /// <summary>
        /// 这个东西与前面说的AdnRestrictionOn是一样的，也是可以添加条件啥乱七八糟的
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListByWhereRestritionOn()
        {
            int[] intList=new int[]{390,400};
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().WhereRestrictionOn(m => m.StudentNum).IsIn(intList).List();
            return list;
        }
        /// <summary>
        /// 跳过指定数量的记录
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListBySkip() 
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().Skip(5).List();
            return list;
        }
        /// <summary>
        /// 获取指定数量的记录，与Skip配合使用是经常用到的分页效果
        /// </summary>
        /// <returns></returns>
        public IList<SchoolModel> GetListByTake()
        {
            IList<SchoolModel> list = isession.QueryOver<SchoolModel>().Take(10).List();
            return list;
        }
        /// <summary>
        /// 告知NHibernate你想要查询的是什么东西 相当于select StudentNum from T_School
        /// </summary>
        /// <returns></returns>
        public IList<int> GetListBySelect()
        {
            IList<int> list = isession.QueryOver<SchoolModel>().Select(m => m.StudentNum).List<int>();
            return list;
        }
        /// <summary>
        /// Future()与List()的区别在于Future返回的是IEnumerable<>集合，而List()返回的是IList()
        /// </summary>
        /// <returns></returns>
        public IEnumerable<SchoolModel> GetEnumListByFuture()
        {
            IEnumerable<SchoolModel> list = isession.QueryOver<SchoolModel>().Where(m => m.SchoolName == "踏浪帅").Future();
            return list;
        }
        /// <summary>
        /// 返回最大值
        /// </summary>
        /// <returns></returns>
        public int GetByMax()
        {
            var StudentNumMax = (from m in GetSchoolList() select m.StudentNum).Max();
            return (int)StudentNumMax;
        }
        /// <summary>
        /// 返回最小值
        /// </summary>
        /// <returns></returns>
        public int GetBYMin()
        {
            var StudentNumMin = (from m in GetSchoolList() select m.StudentNum).Min();
            return (int)StudentNumMin;
        }
        /// <summary>
        /// 返回平均值
        /// </summary>
        /// <returns></returns>
        public int GetByAverage()
        {
            var StudentNumAverage = (from m in GetSchoolList() select m.StudentNum).Average();
            return (int)StudentNumAverage;
        }
        /// <summary>
        /// 返回所有的和
        /// </summary>
        /// <returns></returns>
        public int GetBySum()
        {
            var studentNumSum = (from m in GetSchoolList() select m.StudentNum).Sum();
            return (int)studentNumSum;
        }

 

感谢您的阅读，坚持每天进步一点点，离成功就更新一步；希望文章对您有所帮助；

转载：http://www.cnblogs.com/wujy/p/3581137.html