关于EF三层结构备忘-2.BLL

2.BLL 业务逻辑通用写法

1.引用Model，Dal；
2.公用基类写法；

namespace ~.BLL
{//可以带逻辑的
    public class BaseBLL<T> where T : class
    {
        BaseDal<T> dal = new BaseDal<T>();
        //虚拟方法可以在子类继承中重载方便使用，
        //或者定义一个类用于返回json格式等等，可以重新下面的返回数据；
        public virtual List<T> GetList(Expression<Func<T, bool>> lambdaWhere)
        {
            return dal.GetEntities(lambdaWhere).ToList();
        }
        public virtual IQueryable<T> GetAll()
        {
            return dal.GetAll();
        }
        public virtual int Add(T entity)
        {   onBeforeInsert(entity);//扩展的方法
          return dal.Add(entity);
        }
        public virtual int update(T entity)
        {
            onBeforeUpdate(entity);
            return dal.update(entity);
        }
        public virtual int delete(T entity)
        {
                  return dal.delete(entity);
        }

          public virtual T AddEntity(T entity)
        {

            onBeforeInsert(entity);//扩展的方法
            return dal.Add2Entity(entity); ;

        }
        protected virtual void onBeforeInsert(T entity)
        {  //留给子类对参数对象进行修改 }
        protected virtual void onBeforeUpdate(T entity) { }



      
        public virtual void AddNoSave(T entity) {  dal.AddNoSave(entity);  }
        public virtual void UpdateNoSave(T entity) { dal.updateNoSave(entity); }
        public virtual void DeleteNoSave(T entity) { dal.deleteNoSave(entity); }
        public virtual int SaveChange() {  return dal.saveChange();     }



     
        /// 返回分页数据
        
        public virtual IQueryable<T> GetPageEntities<S>(int pageSize, int pageIndex, out int total,
                                                    Expression<Func<T, bool>> wheleLambda,
                                                        Expression<Func<T, S>> orderByLambda)
        {

            var temp = dal.GetEntities(wheleLambda)
                .OrderBy<T, S>(orderByLambda)
                .Skip(pageSize * (pageIndex - 1)).Take(pageSize).
                                AsQueryable();

            total = dal.GetEntities(wheleLambda).Count();
            return temp;

        }
       //添加排序方式
           public virtual IQueryable<T> getPageAsc<S>(int pageSize, int pageIndex, out int total,
                                                      Expression<Func<T, bool>> wheleLambda,
                                                          Expression<Func<T, S>> orderByLambda, bool isAsc)
        {
          
            var temp = dal.GetEntities(wheleLambda);
            total = temp.Count();
            if (isAsc)
            {
               temp= temp.OrderBy<T, S>(orderByLambda)
               .Skip(pageSize * (pageIndex - 1)).Take(pageSize).
                               AsQueryable();
                 }
            else
            {
               
                temp= temp.OrderByDescending<T, S>(orderByLambda)
                  .Skip(pageSize * (pageIndex - 1)).Take(pageSize).
                                  AsQueryable();
              
           }

            return temp;
         
        }



        /// <summary>
        /// 直接查询结果的方式
         /// </summary>
        /// <param name="pageNo">页码</param>
        /// <param name="pageCount">页数</param>
        /// <param name="whereFun">查询条件</param>
        /// <param name="selectFun">返回数据</param>
        /// <param name="orderByFun">排序</param>
        /// <param name="total">总数</param>
        /// <param name="isAsc">排序，默认升序</param>
        /// <returns>list</returns>
        public virtual List<T> PageQuery<S>(int pageNo, int pageCount, Expression<Func<T, bool>> whereFun,
            Expression<Func<T, T>> selectFun, Expression<Func<T, S>> orderByFun, out int total, bool isAsc = true)
        {
            total = 0;
            int startIndex = pageCount * (pageNo - 1);
            var list = dal.GetEntities(whereFun);
            total = list.Count();
            if (total <= 0) return new List<T>();
            if (isAsc)
                list = list.OrderBy(orderByFun).Skip(startIndex).Take(pageCount).Select(selectFun);
            else
                list = list.OrderByDescending(orderByFun).Skip(startIndex).Take(pageCount).Select(selectFun);

            return list.ToList();
        }


        public T Find(params object[] keyValues)
        {

            return dal.Find(keyValues);

        }
//根据条件删除

 public int DeleteExpression(Expression<Func<T, bool>> deleWhere)
        {

            return dal.DeleteExpression(deleWhere);
        }


    }
}

3.其他BLL 处理方式

 public  class UserinfoBLL:BaseBll<Userinfo>{   }

4.三层基本完成，对于一些特殊要求的，可以在BLL中进行重写或联立操作等等；