第十九节: 结合【表达式目录树】来封装EF的BaseDal层的方法

一. 简介

　　该章节，可以说是一个简单轻松的章节，只要你对Expression表达式树、EF的基本使用、泛型有所了解，那么本章节实质上就是一个非常简单的封装章节，便于我们快捷开发。

　PS：在该章节对于EF的上下文怎么处理，怎么来的，不做介绍，在后续的框架篇将详细介绍，下面的EF上下文，将直接使用db代替。

　如果你对Expression、EF的增删改查、泛型生疏的话，可以先阅读以下章节:

　　(1). Expression表达式目录树：http://www.cnblogs.com/yaopengfei/p/7486870.html

　　(2). EF的基本增删改查：http://www.cnblogs.com/yaopengfei/p/7674715.html

　　(3). 泛型的使用：http://www.cnblogs.com/yaopengfei/p/6880629.html

二. 代码封装分享

　　下面的代码封装，主要就是围绕EF的增删改查进行封装以及各自对应的扩展，其中包括事务一体的封装、事务分离的封装、集成 Z.EntityFramework.Extensions 插件的封装、以及EF调用SQL语句的封装。

1. EF调用SQL语句：

         /// <summary>
         /// 执行增加,删除,修改操作(或调用存储过程)
         /// </summary>
         /// <param name="sql"></param>
         /// <param name="pars"></param>
         /// <returns></returns>
         public int ExecuteSql(string sql, params SqlParameter[] pars)
         {
             return db.Database.ExecuteSqlCommand(sql, pars);
         }

         /// <summary>
         /// 执行查询操作
         /// </summary>
         /// <typeparam name="T"></typeparam>
         /// <param name="sql"></param>
         /// <param name="pars"></param>
         /// <returns></returns>
         public List<T> ExecuteQuery<T>(string sql, params SqlParameter[] pars)
         {
             return db.Database.SqlQuery<T>(sql, pars).ToList();
         }

2. EF增删改查封装(事务一体)

 (1). 新增

   public int Add(T model)
   {
        DbSet<T> dst = db.Set<T>();
        dst.Add(model);
        return db.SaveChanges();
   }

(2). 删除

         /// <summary>
         /// 删除(适用于先查询后删除的单个实体)
         /// </summary>
         /// <param name="model">需要删除的实体</param>
         /// <returns></returns>
         public int Del(T model)
         {
             db.Set<T>().Attach(model);
             db.Set<T>().Remove(model);
             return db.SaveChanges();
         }
         /// <summary>
         /// 根据条件删除(支持批量删除)
         /// </summary>
         /// <param name="delWhere">传入Lambda表达式(生成表达式目录树)</param>
         /// <returns></returns>
         public int DelBy(Expression<Func<T, bool>> delWhere)
         {
             List<T> listDels = db.Set<T>().Where(delWhere).ToList();
             listDels.ForEach(d =>
             {
                 db.Set<T>().Attach(d);
                 db.Set<T>().Remove(d);
             });
             return db.SaveChanges();
         }        

(3). 查询

         /// <summary>
         /// 根据条件查询
         /// </summary>
         /// <param name="whereLambda">查询条件(lambda表达式的形式生成表达式目录树)</param>
         /// <returns></returns>
         public List<T> GetListBy(Expression<Func<T, bool>> whereLambda)
         {
             return db.Set<T>().Where(whereLambda).ToList();
         }
         /// <summary>
         /// 根据条件排序和查询
         /// </summary>
         /// <typeparam name="Tkey">排序字段类型</typeparam>
         /// <param name="whereLambda">查询条件</param>
         /// <param name="orderLambda">排序条件</param>
         /// <param name="isAsc">升序or降序</param>
         /// <returns></returns>
         public List<T> GetListBy<Tkey>(Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
         {
             List<T> list = null;
             if (isAsc)
             {
                 list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda).ToList();
             }
             else
             {
                 list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda).ToList();
             }
             return list;
         }
         /// <summary>
         /// 分页查询
         /// </summary>
         /// <typeparam name="Tkey">排序字段类型</typeparam>
         /// <param name="pageIndex">页码</param>
         /// <param name="pageSize">页容量</param>
         /// <param name="whereLambda">查询条件</param>
         /// <param name="orderLambda">排序条件</param>
         /// <param name="isAsc">升序or降序</param>
         /// <returns></returns>
         public List<T> GetPageList<Tkey>(int pageIndex, int pageSize, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
         {

             List<T> list = null;
             if (isAsc)
             {
                 list = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
                .Skip((pageIndex - ) * pageSize).Take(pageSize).ToList();
             }
             else
             {
                 list = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
               .Skip((pageIndex - ) * pageSize).Take(pageSize).ToList();
             }
             return list;
         }
         /// <summary>
         /// 分页查询输出总行数
         /// </summary>
         /// <typeparam name="Tkey">排序字段类型</typeparam>
         /// <param name="pageIndex">页码</param>
         /// <param name="pageSize">页容量</param>
         /// <param name="whereLambda">查询条件</param>
         /// <param name="orderLambda">排序条件</param>
         /// <param name="isAsc">升序or降序</param>
         /// <returns></returns>
         public List<T> GetPageList<Tkey>(int pageIndex, int pageSize, ref int rowCount, Expression<Func<T, bool>> whereLambda, Expression<Func<T, Tkey>> orderLambda, bool isAsc = true)
         {
             int count = ;
             List<T> list = null;
             count = db.Set<T>().Where(whereLambda).Count();
             if (isAsc)
             {
                 var iQueryList = db.Set<T>().Where(whereLambda).OrderBy(orderLambda)
                    .Skip((pageIndex - ) * pageSize).Take(pageSize);

                 list = iQueryList.ToList();
             }
             else
             {
                 var iQueryList = db.Set<T>().Where(whereLambda).OrderByDescending(orderLambda)
                  .Skip((pageIndex - ) * pageSize).Take(pageSize);
                 list = iQueryList.ToList();
             }
             rowCount = count;
             return list;
         }

(4). 修改

         /// <summary>
         /// 修改
         /// </summary>
         /// <param name="model">修改后的实体</param>
         /// <returns></returns>
         public int Modify(T model)
         {
             db.Entry(model).State = EntityState.Modified;
             return db.SaveChanges();
         }

         /// <summary>
         /// 单实体扩展修改（把不需要修改的列用LAMBDA数组表示出来）
         /// </summary>
         /// <param name="model">要修改的实体对象</param>
         /// <param name="ignoreProperties">不须要修改的相关字段</param>
         /// <returns>受影响的行数</returns>
         public int Modify(T model, params Expression<Func<T, object>>[] ignoreProperties)
         {
             using (DbContext db = new DBContextFactory().GetDbContext())
             {
                 db.Set<T>().Attach(model);

                 DbEntityEntry entry = db.Entry<T>(model);
                 entry.State = EntityState.Unchanged;

                 Type t = typeof(T);
                 List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();

                 Dictionary<string, PropertyInfo> dicPros = new Dictionary<string, PropertyInfo>();
                 proInfos.ForEach(
                     p => dicPros.Add(p.Name, p)
                     );

                 if (ignoreProperties != null)
                 {
                     foreach (var ignorePropertyExpression in ignoreProperties)
                     {
                         //根据表达式得到对应的字段信息
                         var ignorePropertyName = new PropertyExpressionParser<T>(ignorePropertyExpression).Name;
                         dicPros.Remove(ignorePropertyName);
                     }
                 }

                 foreach (string proName in dicPros.Keys)
                 {
                     entry.Property(proName).IsModified = true;
                 }
                 return db.SaveChanges();
             }
         }

         /// <summary>
         /// 批量修改（非lambda）
         /// </summary>
         /// <param name="model">要修改实体中 修改后的属性 </param>
         /// <param name="whereLambda">查询实体的条件</param>
         /// <param name="proNames">lambda的形式表示要修改的实体属性名</param>
         /// <returns></returns>
         public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params string[] proNames)
         {
             List<T> listModifes = db.Set<T>().Where(whereLambda).ToList();
             Type t = typeof(T);
             List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
             Dictionary<string, PropertyInfo> dicPros = new Dictionary<string, PropertyInfo>();
             proInfos.ForEach(p =>
             {
                 if (proNames.Contains(p.Name))
                 {
                     dicPros.Add(p.Name, p);
                 }
             });
             foreach (string proName in proNames)
             {
                 if (dicPros.ContainsKey(proName))
                 {
                     PropertyInfo proInfo = dicPros[proName];
                     object newValue = proInfo.GetValue(model, null);
                     foreach (T m in listModifes)
                     {
                         proInfo.SetValue(m, newValue, null);
                     }
                 }
             }
             return db.SaveChanges();
         }

         /// <summary>
         /// 批量修改（支持lambda）
         /// </summary>
         /// <param name="model">要修改实体中 修改后的属性 </param>
         /// <param name="whereLambda">查询实体的条件</param>
         /// <param name="proNames">lambda的形式表示要修改的实体属性名</param>
         /// <returns></returns>
         public int ModifyBy(T model, Expression<Func<T, bool>> whereLambda, params Expression<Func<T, object>>[] proNames)
         {
             List<T> listModifes = db.Set<T>().Where(whereLambda).ToList();
             Type t = typeof(T);
             List<PropertyInfo> proInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();
             Dictionary<string, PropertyInfo> dicPros = new Dictionary<string, PropertyInfo>();
             if (proNames != null)
             {
                 foreach (var myProperyExp in proNames)
                 {
                     var my_ProName = new PropertyExpressionParser<T>(myProperyExp).Name;
                     proInfos.ForEach(p =>
                     {
                         if (p.Name.Equals(my_ProName))
                         {
                             dicPros.Add(p.Name, p);
                         }
                     });
                     if (dicPros.ContainsKey(my_ProName))
                     {
                         PropertyInfo proInfo = dicPros[my_ProName];
                         object newValue = proInfo.GetValue(model, null);
                         foreach (T m in listModifes)
                         {
                             proInfo.SetValue(m, newValue, null);
                         }
                     }
                 }
             }
             return db.SaveChanges();
         }
    

3. EF增删改封装(事务分离)

 (1). 事务批量处理

         /// <summary>
         /// 事务批量处理
         /// </summary>
         /// <returns></returns>
         public int SaveChange()
         {
             return db.SaveChanges();
         }

(2). 新增

         /// <summary>
         /// 新增
         /// </summary>
         /// <param name="model">需要新增的实体</param>
         public void AddNo(T model)
         {
             db.Set<T>().Add(model);
         }

(3). 修改

         /// <summary>
         /// 修改
         /// </summary>
         /// <param name="model">修改后的实体</param>
         public void ModifyNo(T model)
         {
             db.Entry(model).State = EntityState.Modified;
         }

(4). 删除

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="model">需要删除的实体</param>
        public void DelNo(T model)
        {
            db.Entry(model).State = EntityState.Deleted;
        }
         /// <summary>
         /// 条件删除
        /// </summary>
        /// <param name="delWhere">需要删除的条件</param>
        public void DelByNo(Expression<Func<T, bool>> delWhere)
        {
            List<T> listDels = db.Set<T>().Where(delWhere).ToList();
            listDels.ForEach(d =>
            {
                db.Set<T>().Attach(d);
                db.Set<T>().Remove(d);
            });
        }

4. Z.EntityFramework.Extensions 插件封装

方案一：在使用EF事务分离的方法的前提下，单独调用提交方法

         /// <summary>
         /// 事务提交，速度约为saveChange的10倍-15倍
         /// </summary>
         public void BulkSaveChanges()
         {
             db.BulkSaveChanges();
         }

方案二：插件特有的增删改方法

        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="model">新增的实体集合</param>
        public void BulkInsert(List<T> model)
        {
            db.BulkInsert<T>(model);
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="model">需要删除的实体集合</param>
        public void BulkDelete(List<T> model)
        {
            db.BulkDelete<T>(model);
        }
        /// <summary>
        /// 根据条件删除
        /// </summary>
        /// <param name="delWhere">删除条件</param>
        public void BulkDeleteBy(Expression<Func<T, bool>> delWhere)
        {
            List<T> listDels = db.Set<T>().Where(delWhere).ToList();
            db.BulkDelete<T>(listDels);
        }
        /// <summary>
        /// 需要修改的实体集合
        /// </summary>
        /// <param name="model"></param>
        public void BulkUpdate(List<T> model)
        {
            db.BulkUpdate<T>(model);
        }

　　未完，后续会不断更新。