不成功的MVC Repository模式，记录下来，后面看看原因在哪里(二) Repository类

 public class Repository<T> : IRepository<T> where T : class
    {
        public WBIDbContext m_Context=WBIContextFactory.GetCurrentContext();//上下文数据库
        public DbSet<T> dbSet;
        public Repository(WBIDbContext dbContext)
        {
            this.m_Context = dbContext;
            this.dbSet = dbContext.Set<T>();
        }

        protected IRepository<T> m_currentRepository1 { get; set; }
        protected IDevTypeRepository m_currentRepository { get; set; }
        public Repository(IDevTypeRepository currentRepository)
        {
            m_currentRepository = currentRepository;
        }

        public T Add(T entity)
        {
            //设置实体的状态 add
            m_Context.Entry<T>(entity).State = System.Data.Entity.EntityState.Added;
            //将上下文中所做的更改保存到数据库中
            m_Context.SaveChanges();
            //返回保存后的实体
            return entity;
        }

        public bool Update(T entity)
        {
            m_Context.Set<T>().Attach(entity);
            m_Context.Entry<T>(entity).State = System.Data.Entity.EntityState.Modified;
            return m_Context.SaveChanges() > 0;
        }

        public bool Delete(T entity)
        
        {
            m_Context.Set<T>().Attach(entity);
            m_Context.Entry<T>(entity).State = System.Data.Entity.EntityState.Deleted;
            return m_Context.SaveChanges() > 0;
        }

        //名字是否为空
        public bool CheckNameIsEmpty(Expression<Func<T, bool>> whereLambda)
        {
            return m_Context.Set<T>().Any(whereLambda);
        }

        //名字是否存在
        public bool CheckNameExist(Expression<Func<T, bool>> whereLambda)
        {
            return m_Context.Set<T>().Any(whereLambda);
        }
        //检查其他项
        public bool Check(Expression<Func<T, bool>> whereLambda)
        {
            return m_Context.Set<T>().Any(whereLambda);
        }
        //保存
        //public void Save()
        //{
        //    m_Context.SaveChanges();
 
        //}

        public int Count(Expression<Func<T, bool>> predicate)
        {
            return m_Context.Set<T>().Count(predicate);
        }

        public List<T> ToList()
        {
            return m_Context.Set<T>().ToList();
        }

        public T Find(Expression<Func<T, bool>> whereLambda)
        {
            T entity = m_Context.Set<T>().FirstOrDefault<T>(whereLambda);
            return entity;
        }

        public IQueryable<T> FindList(Expression<Func<T, bool>> whereLamba, string orderName, bool isAsc)
        {
            var list = m_Context.Set<T>().Where(whereLamba);
            list = OrderBy(list, orderName, isAsc);
            return list;
        }

        public IQueryable<T> FindList<S>(Expression<Func<T, bool>> whereLambda, bool isAsc, Expression<Func<T, S>> orderLamba)
        {
            var list = m_Context.Set<T>().Where<T>(whereLambda);
            if (isAsc)
            {
                list = list.OrderBy<T, S>(orderLamba);
            }
            else
            {
                list = list.OrderByDescending<T, S>(orderLamba);//降序排列
            }
            return list;
        }




        public IQueryable<T> FindPageList<S>(int pageIndex, int pageSize, out int totalRecordCnt,
    Expression<Func<T, bool>> whereLamdba, bool isAsc, Expression<Func<T, S>> orderLambda)
        {
            var list = m_Context.Set<T>().Where<T>(whereLamdba);
            totalRecordCnt = list.Count();

            if (isAsc)
            {
                list = list.OrderBy<T, S>(orderLambda)
                    .Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize);
            }
            else
            {
                list = list.OrderByDescending<T, S>(orderLambda)
                    .Skip<T>((pageIndex - 1) * pageSize).Take<T>(pageSize);
            }

            return list;
        }



        #region Private Methods
        /// <summary>
        /// 排序
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="source">原IQueryable</param>
        /// <param name="propertyName">排序属性名</param>
        /// <param name="isAsc">是否升序</param>
        /// <returns>排序后的IQueryable</returns>
        private IQueryable<T> OrderBy(IQueryable<T> source, string propertyName, bool isAsc)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source", "不能为空");
            }
            if (string.IsNullOrEmpty(propertyName))
            {
                return source;
            }
            var parameter = Expression.Parameter(source.ElementType);
            var property = Expression.Property(parameter, propertyName);
            if (property == null)
            {
                throw new ArgumentNullException("propertyName", "属性不存在");
            }
            var lambda = Expression.Lambda(property, parameter);
            var methodName = isAsc ? "OrderBy" : "OrderByDescending";
            var resultExpression = Expression.Call(typeof(Queryable), methodName,
                new Type[] { source.ElementType, property.Type }, source.Expression, Expression.Quote(lambda));
            return source.Provider.CreateQuery<T>(resultExpression);
        }
        #endregion
    }