ASP.net MVC 構建layui管理后台(構造基礎倉儲)<1>

本文章為ASP.net MVC 構建layui管理后台，第一篇。

使用EF+ado.net 實體數據模型模式進行底層的數據庫連接。

 

 

 

 在項目添加一個類庫Model

 

 

 

 

 

 在類庫Model上添加一個ado.net 實體數據模型

 

 

 

 

 

 

 

 

 

 添加成功之后，效果如下

 

 

 

 

 

 

 

按照以上的步驟，已經完成了，對應數據庫的連接，關聯，下面我們來定義數據庫的存儲。

在Model類庫下新建EFDbContext類，用於連接數據庫

 /// <summary>
        /// 連接數據庫
        /// </summary>
        /// <returns></returns>
        public static ZWSDBEntities GetDbContext()
        {
            ZWSDBEntities dbContext = CallContext.GetData("ZWSDBEntities") as ZWSDBEntities;
            if (dbContext == null)
            {
                dbContext = new ZWSDBEntities();
                CallContext.SetData("ZWSDBEntities", dbContext);
            }
            return dbContext;
        }

其中ZWSDBEntities是每個人的可能不一樣，可以在下圖中找

 

 

接下來定義兩個接口IBaseEntityDAL，IBaseEntityService

 /// <summary>
    /// 封裝定義數據操作接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IBaseEntityDAL<T> where T : class
    {
        //! 檢查是否存在持久實體對象
        bool HasInstance(Expression<Func<T, bool>> where);
        bool HasRelevanceInstance<T2>(Expression<Func<T2, bool>> where);

        //! 提取單個對象的方法
        T GetByIntID(int id);
        T GetByStringID(string oid);
        T GetByGuid(Guid oid);
        T GetByLambda(Expression<Func<T, bool>> where);

        //! 根據 id ，提取實例，如果沒有，創建一個新的實例，並執行持久化
        T GetOrCreatePersistence(Guid id);
        //! 根據 id ，提取實例，如果沒有，創建一個新的實例，但不執行持久化
        T GetOrCreateNotPersistence(Guid id);

        //! 添加對象的方法
        void Add(T bo);
        void AddOrUpdate(T bo, bool isForNewObject, ref int returnPoint);

        //! 刪除對象的方法
        void Delete(T bo);
        void DeleteRelevenceObject<T2>(T2 relevanceBo);
        void DeleteRelevenceObjectsByLambda<T2>(Expression<Func<T2, bool>> where);

        //! 更新對象的方法
        void Update(T bo);

        //! 提取對象集合的方法
        IQueryable<T> GetAll();
        IQueryable<T> GetAllOrdered(Expression<Func<T, bool>> order);
        IQueryable<T> GetMany(Expression<Func<T, bool>> where);
        IQueryable<T> GetMany(Expression<Func<T, object>> selector, object val);
        IQueryable<T> GetManyOrdered<TKey>(Expression<Func<T, bool>> where, Expression<Func<T, TKey>> order);
        IQueryable<T> GetAllOrderedPaged<TKey>(Expression<Func<T, TKey>> order, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc);
        //IQueryable<T> GetDataPaging(DataTableModel dataTableModel, ref int dataAmount, string orderProperty, Expression<Func<T, bool>> where = null);
        IQueryable<T> GetAllCommonWay(
            ref int pageAmount,
            ref int boAmount,
            Expression<Func<T, bool>> where = null,
            Expression<Func<T, bool>> order = null,
            bool? isDesc = null,
            int? page = null,
            int? pageSize = null);

        //! 數據處理約束管理方法
        bool CanAdd(Expression<Func<T, bool>> where);

        //! 用於處理一些附加對象的方法
        T2 GetRelevanceObject<T2>(Guid id);
        T2 GetRelevanceObject<T2>(Expression<Func<T2, bool>> where);
        T2 GetRelevanceObjectBySqlQuery<T2>(string SqlQureyString);

        IQueryable<T2> GetRelevanceObjects<T2>(Expression<Func<T2, bool>> where);
        IQueryable<T2> GetRelevanceObjects<T2>(
            Expression<Func<T2, bool>> where = null,
            Expression<Func<T2, bool>> order = null,
            bool? isDesc = null);

        void AddRelevanceObject<T2>(T2 relevanceBo);
        void UpdateRelevanceObject<T2>(T2 relevanceBo);
    }

/// <summary>
    /// 封裝定義數據操作接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public interface IBaseEntityService<T> where T : class
    {
        /// <summary>
        /// 檢查是否存在持久實體對象
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        bool HasInstance(Expression<Func<T, bool>> where);
        bool HasRelevanceInstance<T2>(Expression<Func<T2, bool>> where);


        T GetByIntID(int id);
        /// <summary>
        /// 提取單個對象的方法(ID)
        /// </summary>
        /// <param name="oid">ID</param>
        /// <returns></returns>
        T GetByStringID(string oid);
        /// <summary>
        ///提取單個對象的方法(GID)
        /// </summary>
        /// <param name="oid"></param>
        /// <returns></returns>
        T GetByGuid(Guid oid);
        T GetByLambda(Expression<Func<T, bool>> where);

        //! 根據 id ，提取實例，如果沒有，創建一個新的實例，並執行持久化
        T GetOrCreatePersistence(Guid id);
        //! 根據 id ，提取實例，如果沒有，創建一個新的實例，但不執行持久化
        T GetOrCreateNotPersistence(Guid id);

        //! 添加對象的方法
        void Add(T bo);
        void AddOrUpdate(T bo, bool isForNewObject, params Expression<Func<T, object>>[] updatedProperties);

        //! 刪除對象的方法
        void Delete(T bo);

        void DeleteRelevenceObject<T2>(T2 relevanceBo);
        void DeleteRelevenceObjectsByLambda<T2>(Expression<Func<T2, bool>> where);

        //! 更新對象的方法
        void Update(T bo);

        void Update(T entity, params Expression<Func<T, object>>[] updatedProperties);

        //! 提取對象集合的方法
        IQueryable<T> GetAll();
        IQueryable<T> GetAllOrdered(Expression<Func<T, bool>> order);
        IQueryable<T> GetMany(Expression<Func<T, bool>> where);
        IQueryable<T> GetMany(Expression<Func<T, object>> selector, object val);
        IQueryable<T> GetManyOrdered<TKey>(Expression<Func<T, bool>> where, Expression<Func<T, TKey>> order);

        //! 按照分頁方式提取對象集合的方法
        IQueryable<T> GetAllOrderedPaged(string orderProeprtyName, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc);
        IQueryable<T> GetAllOrderedPaged<TKey>(Expression<Func<T, TKey>> order, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc);

        //IQueryable<T> GetDataPaging(GridPager page, ref int dataAmount, Expression<Func<T, bool>> where = null);
        IQueryable<T> GetManyOrderedPaged<Tkey>(Expression<Func<T, bool>> where, Expression<Func<T, Tkey>> order, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc);
        IQueryable<T> GetManyOrderedByProertyNamePaged(Expression<Func<T, bool>> where, string orderProeprtyName, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc);
        IQueryable<T> GetAllCommonWay(
            ref int pageAmount,
            ref int boAmount,
            Expression<Func<T, bool>> where = null,
            Expression<Func<T, bool>> order = null,
            bool? isDesc = null,
            int? page = null,
            int? pageSize = null);

        //! 數據處理約束管理方法
        bool CanAdd(Expression<Func<T, bool>> where);

        //! 用於處理一些附加對象的方法
        T2 GetRelevanceObject<T2>(Guid id);
        T2 GetRelevanceObject<T2>(Expression<Func<T2, bool>> where);
        T2 GetRelevanceObjectBySqlQuery<T2>(string SqlQureyString);

        IQueryable<T2> GetRelevanceObjects<T2>(Expression<Func<T2, bool>> where);
        IQueryable<T2> GetRelevanceObjects<T2>(
            Expression<Func<T2, bool>> where = null,
            Expression<Func<T2, bool>> order = null,
            bool? isDesc = null);

        IQueryable<T2> GetManyRelevanceObjectsOrderedByProertyNamePaged<T2>(Expression<Func<T2, bool>> where, string orderProeprtyName, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc);

        void AddRelevanceObject<T2>(T2 relevanceBo);
        void UpdateRelevanceObject<T2>(T2 relevanceBo);
    }

兩個操作類，BaseEntityDAL，BaseEntityService

 /// <summary>
    /// 基於 EF CodeFirst 獨立的針對 IBaseEntityService 方法的實現，其實際實現時通過繼承的方式處理
    /// 
    /// 實現基礎操作方法的基類
    /// </summary>
    public abstract class BaseEntityDAL<T> where T : class
    {
        protected readonly DbContext _Context;
        protected readonly IDbSet<T> _DbSet;

        public BaseEntityDAL(DbContext context)
        {
            this._Context = context;
            _DbSet = _Context.Set<T>();
        }

        /// <summary>
        /// 根據條件檢查數據是否已存在
        /// </summary>
        /// <param name="where">Lamda表達式</param>
        /// <returns>true：為不存在</returns>
        public bool HasInstance(Expression<Func<T, bool>> where)
        {
            if (_DbSet.Where(where).FirstOrDefault() == null)
                return true;
            else
                return false;
        }

        public bool HasRelevanceInstance<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2)) as IQueryable<T2>; ;
            if (dbSet.Where(where).FirstOrDefault() != null)
                return true;
            else
                return false;
        }
        public T GetByStringID(string oid)
        {
            return _DbSet.Find(oid);
        }

        public T GetByGuid(Guid oid)
        {
            return _DbSet.Find(oid);
        }

        /// <summary>
        /// 根據Lambda表達式獲取一條數據
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public T GetByLambda(Expression<Func<T, bool>> where)
        {
            try
            {
                return _DbSet.Where(where).FirstOrDefault<T>();
            }
            catch (Exception e)
            {
                return null;
            }
        }


        //根據Guid獲取一條數據，如果該數據不存在將創建一條數據，然后返回
        public T GetOrCreatePersistence(Guid id)
        {
            var fObject = this.GetByGuid(id);
            if (fObject != null)
                return fObject;
            else
            {
                fObject = Activator.CreateInstance<T>();
                this.Add(fObject);
                return fObject;
            }
        }

        public T GetOrCreateNotPersistence(Guid id)
        {
            var fObject = this.GetByGuid(id);
            if (fObject != null)
                return fObject;
            else
            {
                fObject = Activator.CreateInstance<T>();
                return fObject;
            }
        }

        public void Add(T bo)
        {
            _DbSet.Add(bo);
            _Context.SaveChanges();
        }
        public void DelayedAdd(T bo)
        {
            _DbSet.Add(bo);
        }
        public int AllSaveChanges()
        {
            return _Context.SaveChanges();

        }
        public void AddOrUpdate(T bo, bool isForNewObject, ref int returnPoint)
        {
            if (isForNewObject)
            {
                this.Add(bo);
                returnPoint = 1;
            }
            else
            {
                this.Update(bo);
            }
        }
        /// <summary>
        /// 物理刪除
        /// </summary>
        /// <param name="bo"></param>
        public void DeleteEntity(T bo)
        {
            _DbSet.Remove(bo);
            _Context.SaveChanges();
        }
        /// <summary>
        /// 物理刪除
        /// </summary>
        /// <param name="bo"></param>
        public void DeleteByIds(params object[] ids)
        {
            if (ids != null)
            {
                string strIds = string.Join(",", ids);
                _Context.Database.ExecuteSqlCommand(string.Format("delete {0}  where  ID  in ('{1}')  ", typeof(T).Name, strIds));
            }
        }
        /// <summary>
        /// 邏輯刪除(使用時確保表中 含有用於標記邏輯刪除的字段 IsDelete)
        /// </summary>
        /// <param name="bo"></param>
        public void Delete(T bo)
        {
            PropertyInfo[] properties = typeof(T).GetProperties();
            for (int i = properties.Length; i > 0; i--)
            {
                string fn = properties[i - 1].Name;
                PropertyInfo pinfo = typeof(T).GetProperty(fn);
                if ("IsDelete" == fn)
                {
                    pinfo.SetValue(bo, true, null);
                    break;
                }
            }
            _DbSet.Attach(bo);
            _Context.Entry(bo).State = EntityState.Modified;
            _Context.SaveChanges();
        }
        public void DeleteRelevenceObject<T2>(T2 relevanceBo)
        {
            var dbSet = _Context.Set(typeof(T2));
            dbSet.Remove(relevanceBo);
            _Context.SaveChanges();
        }

        public void DeleteRelevenceObjectsByLambda<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2));

            var tempCollection = dbSet as IQueryable<T2>;
            foreach (var item in tempCollection.Where(where))
                dbSet.Remove(item);

            _Context.SaveChanges();
        }

        public void Update(T bo)
        {
            _DbSet.Attach(bo);
            _Context.Entry(bo).State = EntityState.Modified;
            _Context.SaveChanges();
        }

        public IQueryable<T> GetAll()
        {
            return _DbSet as IQueryable<T>;
        }

        //獲取所有數據，根據條件排序
        public IQueryable<T> GetAllOrdered(Expression<Func<T, bool>> order)
        {
            return _DbSet.OrderBy(order);
        }

        public IQueryable<T> GetMany(Expression<Func<T, bool>> where)
        {
            return _DbSet.Where(where) as IQueryable<T>;
        }

        public IQueryable<T> GetMany(Expression<Func<T, object>> selector, object val)
        {
            //var queryBuilder = CustomLinq.Func((selector, val) =>
            //      from c in _DbSet.ToExpandable()
            //      where selector.Expand(c).IndexOf(val) != -1
            //      select c);
            return _DbSet as IQueryable<T>;
        }

        public IQueryable<T> GetManyOrdered<TKey>(Expression<Func<T, bool>> where, Expression<Func<T, TKey>> order)
        {
            return _DbSet.Where(where).OrderBy(order);
        }

        /// <summary>
        /// 分頁獲取數據
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="dataTableModel">表格參數</param>
        /// <param name="dataAmount">總條數</param>
        /// <param name="orderProperty">要排序的對象名稱</param>
        /// <param name="where">搜索條件</param>
        /// <returns></returns>
        //public IQueryable<T> GetDataPaging(DataTableModel dataTableModel, ref int dataAmount, string orderProperty, Expression<Func<T, bool>> where = null)
        //{
        //    var searchResult = _DbSet as IQueryable<T>;
        //    if (where != null)
        //        searchResult = searchResult.Where(where);

        //    dataAmount = searchResult.Count();
        //    var isDesc = dataTableModel.OrderDir == "desc";
        //    searchResult = searchResult.OrderBy(orderProperty, isDesc).Skip(dataTableModel.Start).Take(dataTableModel.Length);
        //    return searchResult;
        //}

        public IQueryable<T> GetAllOrderedPaged<TKey>(Expression<Func<T, TKey>> order, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc)
        {
            var searchResult = _DbSet as IQueryable<T>;
            boAmount = searchResult.Count();
            pageAmount = boAmount / pageSize;
            if (boAmount > pageAmount * pageSize)
                pageAmount = pageAmount + 1;
            return searchResult.OrderBy(order).Skip((page - 1) * pageSize).Take(pageSize);
        }
        public IQueryable<T> GetAllCommonWay(
            ref int pageAmount,
            ref int boAmount,
            Expression<Func<T, bool>> where = null,
            Expression<Func<T, bool>> order = null,
            bool? isDesc = null,
            int? page = null,
            int? pageSize = null)
        {
            pageAmount = 0;
            boAmount = 0;
            var searchResult = _DbSet as IQueryable<T>;


            if (where != null && order != null)
            {
                searchResult = searchResult.Where(where);
                if (isDesc != null)
                    searchResult = searchResult.OrderByDescending(order);
                else
                    searchResult = searchResult.OrderBy(order);
            }
            else
            {
                if (where != null)
                {
                    searchResult = searchResult.Where(where);
                }
                else
                {
                    if (order != null)
                    {
                        if (isDesc != null)
                            searchResult = searchResult.OrderByDescending(order);
                        else
                            searchResult = searchResult.OrderBy(order);
                    }
                }
            }

            boAmount = searchResult.Count();
            if (pageAmount == -1)
            {
                pageAmount = -1;
            }

            if (page != null)
            {
                var p = (int)page;
                var ps = (int)pageSize;
                pageAmount = searchResult.Count() / ps;
                searchResult = searchResult.Skip((p - 1) * ps).Take(ps);
            }

            return searchResult;
        }

        public bool CanAdd(Expression<Func<T, bool>> where)
        {
            var count = _DbSet.Where(where).Count();
            if (count > 0)
                return false;
            else
                return true;
        }

        public T2 GetRelevanceObject<T2>(Guid id)
        {
            var dbSet = _Context.Set(typeof(T2));
            return (T2)dbSet.Find(id);
        }

        public T2 GetRelevanceObjectBySqlQuery<T2>(string SqlQureyString)
        {
            var id = _Context.Database.SqlQuery<Guid>(SqlQureyString).FirstOrDefault();
            if (id != null)
            {
                return GetRelevanceObject<T2>(id);
            }
            else
                return default(T2);
        }

        public T2 GetRelevanceObject<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2)) as IQueryable<T2>;
            return (T2)dbSet.Where(where).FirstOrDefault();
        }

        public IQueryable<T2> GetRelevanceObjects<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2));
            var searchResult = dbSet as IQueryable<T2>;

            return searchResult.Where(where);
        }

        public IQueryable<T2> GetRelevanceObjects<T2>(
            Expression<Func<T2, bool>> where = null,
            Expression<Func<T2, bool>> order = null,
            bool? isDesc = null)
        {
            var dbSet = _Context.Set(typeof(T2));
            var searchResult = dbSet as IQueryable<T2>;
            if (where != null && order != null)
            {
                searchResult = searchResult.Where(where);
                if (isDesc != null)
                    searchResult = searchResult.OrderByDescending(order);
                else
                    searchResult = searchResult.OrderBy(order);
            }
            else
            {
                if (where != null)
                {
                    searchResult = searchResult.Where(where);
                }
                else
                {
                    if (order != null)
                    {
                        if (isDesc != null)
                            searchResult = searchResult.OrderByDescending(order);
                        else
                            searchResult = searchResult.OrderBy(order);
                    }
                }
            }

            return searchResult;
        }


        public void AddRelevanceObject<T2>(T2 relevanceBo)
        {
            var dbSet = _Context.Set(typeof(T2));
            dbSet.Add(relevanceBo);
            _Context.SaveChanges();
        }

        public void UpdateRelevanceObject<T2>(T2 relevanceBo)
        {
            var tempBo = Activator.CreateInstance(typeof(T2));
            tempBo = relevanceBo;
            var dbSet = _Context.Set(typeof(T2));
            dbSet.Attach(tempBo);
            _Context.Entry(tempBo).State = EntityState.Modified;
            _Context.SaveChanges();
        }


        ///// <summary>
        ///// 從緩存中獲取所有數據
        ///// </summary>
        ///// <returns></returns>
        //public ICollection<T> GetAllByCache()
        //{
        //    var key = typeof(T).Name + "List";
        //    var obj = this.GetByCache(key);
        //    if (obj == null)
        //    {
        //        obj = this.GetAll().ToList();
        //        this.SetInCache(key, obj);
        //    }
        //    return obj as ICollection<T>;
        //}
        ///// <summary>
        ///// 從緩存中獲取單個實體
        ///// </summary>
        ///// <param name="id"></param>
        ///// <returns></returns>
        //public T GetByCache(Guid id)
        //{
        //    var key = id.ToString();
        //    var obj = this.GetByCache(key);
        //    if (obj == null)
        //    {
        //        obj = this.GetByGuid(id);
        //        this.SetInCache(key, obj);
        //    }
        //    return obj as T;
        //}

        ///// <summary>
        ///// 移除緩存中的數據（集合）
        ///// </summary>
        //public void RemoveAllCache()
        //{
        //    var key = typeof(T).Name + "List";
        //    this.RemoveCache(key);
        //}
        ///// <summary>
        ///// 移除緩存中的數據（單個實體）
        ///// </summary>
        ///// <param name="id"></param>
        //public void RemoveCache(Guid id)
        //{
        //    var key = id.ToString();
        //    this.RemoveCache(key);
        //}
        /// <summary>
        /// 設置緩存
        /// </summary>
        /// <param name="key"></param>
        /// <param name="val"></param>
        //public void SetInCache(string key, object val)
        //{
        //    CacheHelper.Set(key, val);
        //}
        ///// <summary>
        ///// 從緩存中獲取數據
        ///// </summary>
        ///// <param name="key"></param>
        ///// <returns></returns>
        //public object GetByCache(string key)
        //{
        //    return CacheHelper.Get(key);
        //}
        ///// <summary>
        ///// 從緩存中移除數據
        ///// </summary>
        ///// <param name="key"></param>
        //public void RemoveCache(string key)
        //{
        //    CacheHelper.Remove(key);
        //}
    }

 /// <summary>
    /// 基於 EF CodeFirst 獨立的針對 IBaseEntityService 方法的實現，其實際實現時通過繼承的方式處理
    /// </summary>
    public abstract class BaseEntityService<T> where T : class
    {
        private  readonly DbContext _Context;
        private  readonly IDbSet<T> _DbSet;

        public BaseEntityService(DbContext context)
        {
            this._Context = context;
            _DbSet = _Context.Set<T>();
        }
        /// <summary>
        /// 根據條件判斷是否數據存在
        /// </summary>
        /// <param name="where">判斷條件</param>
        /// <returns></returns>
        public  bool HasInstance(Expression<Func<T, bool>> where)
        {
            if (_DbSet.Where(where).FirstOrDefault() != null)
                return true;
            else
                return false;
        }
        /// <summary>
        /// 根據條件判斷是否數據存在
        /// </summary>
        /// <typeparam name="T2">需要判斷實體</typeparam>
        /// <param name="where">判斷條件</param>
        /// <returns></returns>
        public bool HasRelevanceInstance<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2)) as IQueryable<T2>; ;
            if (dbSet.Where(where).FirstOrDefault() != null)
                return true;
            else
                return false;
        }
        /// <summary>
        /// 根據主鍵ID獲取實體
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T GetByIntID(int id)
        {
            return _DbSet.Find(id);
        }
        /// <summary>
        /// 根據主鍵ID獲取實體
        /// </summary>
        /// <param name="oid"></param>
        /// <returns></returns>
        public T GetByStringID(string oid)
        {
            return _DbSet.Find(oid);
        }
        /// <summary>
        /// 根據主鍵ID獲取實體
        /// </summary>
        /// <param name="oid"></param>
        /// <returns></returns>
        public T GetByGuid(Guid oid)
        {
            return _DbSet.Find(oid);
        }
        /// <summary>
        /// 根據條件獲取實體
        /// </summary>
        /// <param name="where">刷選條件</param>
        /// <returns></returns>
        public T GetByLambda(Expression<Func<T, bool>> where)
        {

            return _DbSet.Where(where).FirstOrDefault<T>();
        }

        public T GetOrCreatePersistence(Guid id)
        {
            var fObject = this.GetByGuid(id);
            if (fObject != null)
                return fObject;
            else
            {
                fObject = Activator.CreateInstance<T>();
                this.Add(fObject);
                return fObject;
            }
        }

        public T GetOrCreateNotPersistence(Guid id)
        {
            var fObject = this.GetByGuid(id);
            if (fObject != null)
                return fObject;
            else
            {
                fObject = Activator.CreateInstance<T>();
                return fObject;
            }
        }
       /// <summary>
       /// 添加數據
       /// </summary>
       /// <param name="bo">實體</param>
        public void Add(T bo)
        {
                _DbSet.Add(bo);
                _Context.SaveChanges();
        }
        /// <summary>
        /// 添加或者更新數據
        /// </summary>
        /// <param name="bo">實體</param>
        /// <param name="isForNewObject">是否新增</param>
        /// <param name="updatedProperties">過濾字段</param>
        public void AddOrUpdate(T bo, bool isForNewObject=true, params Expression<Func<T, object>>[] updatedProperties)
        {
            if (isForNewObject)
            {
                this.Add(bo);
            }
            else
            {
                this.Update(bo,updatedProperties);
            }
        }
        /// <summary>
        /// 刪除數據
        /// </summary>
        /// <param name="bo">實體</param>
        public void Delete(T bo)
        {
            _DbSet.Remove(bo);
            _Context.SaveChanges();
        }

        /// <summary>
        /// 根據stringID刪除數據
        /// </summary>
        /// <param name="id"></param>
        public void Delete(string id)
        {
            _DbSet.Remove(GetByStringID(id));
            _Context.SaveChanges();
        }
        /// <summary>
        /// 根據主鍵ID刪除數據（int）
        /// </summary>
        /// <param name="id"></param>
        public void Delete(int id)
        {
            _DbSet.Remove(GetByIntID(id));
            _Context.SaveChanges();
        }

        //public void DeleteByLambda(Expression<Func<T, bool>> where)
        //{
        //    _DbSet.Delete(where);
        //    _Context.SaveChanges();
        //}
        /// <summary>
        /// 刪除數據
        /// </summary>
        /// <typeparam name="T2"></typeparam>
        /// <param name="relevanceBo"></param>
        public void DeleteRelevenceObject<T2>(T2 relevanceBo)
        {
            var dbSet = _Context.Set(typeof(T2));
            dbSet.Remove(relevanceBo);
            _Context.SaveChanges();
        }
        /// <summary>
        /// 根據刷選添加循環刪除
        /// </summary>
        /// <typeparam name="T2">需要刪除的實體</typeparam>
        /// <param name="where">刪除條件</param>
        public void DeleteRelevenceObjectsByLambda<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2));

            var tempCollection = dbSet as IQueryable<T2>;
            foreach (var item in tempCollection.Where(where))
                dbSet.Remove(item);

            _Context.SaveChanges();
        }
        /// <summary>
        /// 更新實體
        /// </summary>
        /// <param name="bo">實體</param>
        public void Update(T bo)
        {
            _DbSet.Attach(bo);
            _Context.Entry(bo).State = EntityState.Modified;
            _Context.SaveChanges();
        }
        /// <summary>
        /// 更新實體，並過濾不需要更新列
        /// </summary>
        /// <param name="entity">實體</param>
        /// <param name="updatedProperties">過濾不需要更實體數組</param>
        public void Update(T entity, params Expression<Func<T, object>>[] updatedProperties)
        {
            _DbSet.Attach(entity);
            var dbEntityEntry = _Context.Entry(entity);
            _Context.Entry(entity).State = EntityState.Modified;
            if (updatedProperties.Any())
            {
                foreach (var property in updatedProperties)
                {
                    dbEntityEntry.Property(property).IsModified = false;
                }
            }
         
            _Context.SaveChanges();

        }
            /// <summary>
            /// 獲取實體所有信息
            /// </summary>
            /// <returns></returns>
            public IQueryable<T> GetAll()
        {
            return _DbSet as IQueryable<T>;
        }
        /// <summary>
        /// 獲取實體信息並排序
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public IQueryable<T> GetAllOrdered(Expression<Func<T, bool>> order)
        {
            return _DbSet.OrderBy(order);
        }
        /// <summary>
        /// 篩選獲取實體
        /// </summary>
        /// <param name="where"></param>
        /// <returns></returns>
        public IQueryable<T> GetMany(Expression<Func<T, bool>> where)
        {
            return _DbSet.Where(where) as IQueryable<T>;
        }

        public IQueryable<T> GetMany(Expression<Func<T, object>> selector, object val)
        {
            //var queryBuilder = CustomLinq.Func((selector, val) =>
            //      from c in _DbSet.ToExpandable()
            //      where selector.Expand(c).IndexOf(val) != -1
            //      select c);
            return _DbSet as IQueryable<T>;
        }

        public IQueryable<T> GetManyOrdered<TKey>(Expression<Func<T, bool>> where, Expression<Func<T, TKey>> order)
        {
            return _DbSet.Where(where).OrderBy(order);
        }

        public IQueryable<T> GetAllOrderedPaged(string orderProeprtyName, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc)
        {
            var searchResult = _DbSet as IQueryable<T>;
            boAmount = searchResult.Count();
            pageAmount = boAmount / pageSize;
            return searchResult;
        }

        public IQueryable<T> GetAllOrderedPaged<TKey>(Expression<Func<T, TKey>> order, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc)
        {
            var searchResult = _DbSet as IQueryable<T>;
            boAmount = searchResult.Count();
            pageAmount = boAmount / pageSize;
            if (boAmount > pageAmount * pageSize)
                pageAmount = pageAmount + 1;
            return searchResult.OrderBy(order).Skip((page - 1) * pageSize).Take(pageSize);
        }

        public IQueryable<T> GetManyOrderedPaged<Tkey>(Expression<Func<T, bool>> where, Expression<Func<T, Tkey>> order, int page, int pageSize, ref int pageAmount, ref int boAmount, ref bool isDesc)
        {
            var searchResult = _DbSet.Where(where) as IQueryable<T>;
            boAmount = searchResult.Count();
            pageAmount = boAmount / pageSize;
            if (boAmount > pageAmount * pageSize)
                pageAmount = pageAmount + 1;

            if (!isDesc)
                return searchResult.OrderBy(order).Skip((page - 1) * pageSize).Take(pageSize);
            else
                return searchResult.OrderByDescending(order).Skip((page - 1) * pageSize).Take(pageSize);
        }

        ///// <summary>
        ///// 分頁獲取數據
        ///// </summary>
        ///// <param name="page">分頁基礎類</param>
        ///// <param name="dataAmount">輸出總數量</param>
        ///// <param name="where">篩選條件</param>
        ///// <returns></returns>
        //public IQueryable<T> GetDataPaging(GridPager page, ref int dataAmount, Expression<Func<T, bool>> where = null)
        //{
        //    var searchResult = _DbSet as IQueryable<T>;
        //    if (where != null)
        //        searchResult = searchResult.Where(where);
        //    dataAmount = searchResult.Count();
        //    var isDesc = page.order == "desc";
        //    searchResult = searchResult.OrderBy(page.sort, isDesc).Skip(page.thisCount).Take(page.rows);
        //    return searchResult;
        //}

        public IQueryable<T> GetManyOrderedByProertyNamePaged(
            Expression<Func<T, bool>> where,
            string orderProeprtyName,
            int page,
            int pageSize,
            ref int pageAmount,
            ref int boAmount,
            ref bool isDesc
            )
        {
            if (where != null)
            {
                var searchResult = _DbSet.Where(where) as IQueryable<T>;
                boAmount = searchResult.Count();
                pageAmount = boAmount / pageSize;
                if (boAmount > pageAmount * pageSize)
                    pageAmount = pageAmount + 1;

                return searchResult;
            }
            else
            {
                var searchResult = _DbSet as IQueryable<T>;
                boAmount = searchResult.Count();
                pageAmount = boAmount / pageSize;
                if (boAmount > pageAmount * pageSize)
                    pageAmount = pageAmount + 1;

                return searchResult;
            }

        }


        public IQueryable<T> GetAllCommonWay(
            ref int pageAmount,
            ref int boAmount,
            Expression<Func<T, bool>> where = null,
            Expression<Func<T, bool>> order = null,
            bool? isDesc = null,
            int? page = null,
            int? pageSize = null)
        {
            pageAmount = 0;
            boAmount = 0;
            var searchResult = _DbSet as IQueryable<T>;


            if (where != null && order != null)
            {
                searchResult = searchResult.Where(where);
                if (isDesc != null)
                    searchResult = searchResult.OrderByDescending(order);
                else
                    searchResult = searchResult.OrderBy(order);
            }
            else
            {
                if (where != null)
                {
                    searchResult = searchResult.Where(where);
                }
                else
                {
                    if (order != null)
                    {
                        if (isDesc != null)
                            searchResult = searchResult.OrderByDescending(order);
                        else
                            searchResult = searchResult.OrderBy(order);
                    }
                }
            }

            boAmount = searchResult.Count();
            if (pageAmount == -1)
            {
                pageAmount = -1;
            }

            if (page != null)
            {
                var p = (int)page;
                var ps = (int)pageSize;
                pageAmount = searchResult.Count() / ps;
                searchResult = searchResult.Skip((p - 1) * ps).Take(ps);
            }

            return searchResult;
        }

        public bool CanAdd(Expression<Func<T, bool>> where)
        {
            var count = _DbSet.Where(where).Count();
            if (count > 0)
                return false;
            else
                return true;
        }

        public T2 GetRelevanceObject<T2>(Guid id)
        {
            var dbSet = _Context.Set(typeof(T2));
            return (T2)dbSet.Find(id);
        }

        public T2 GetRelevanceObjectBySqlQuery<T2>(string SqlQureyString)
        {
            var id = _Context.Database.SqlQuery<Guid>(SqlQureyString).FirstOrDefault();
            if (id != null)
            {
                return GetRelevanceObject<T2>(id);
            }
            else
                return default(T2);
        }

        public T2 GetRelevanceObject<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2)) as IQueryable<T2>;
            return (T2)dbSet.Where(where).FirstOrDefault();
        }

        public IQueryable<T2> GetRelevanceObjects<T2>(Expression<Func<T2, bool>> where)
        {
            var dbSet = _Context.Set(typeof(T2));
            var searchResult = dbSet as IQueryable<T2>;

            return searchResult.Where(where);
        }

        public IQueryable<T2> GetRelevanceObjects<T2>(
            Expression<Func<T2, bool>> where = null,
            Expression<Func<T2, bool>> order = null,
            bool? isDesc = null)
        {
            var dbSet = _Context.Set(typeof(T2));
            var searchResult = dbSet as IQueryable<T2>;
            if (where != null && order != null)
            {
                searchResult = searchResult.Where(where);
                if (isDesc != null)
                    searchResult = searchResult.OrderByDescending(order);
                else
                    searchResult = searchResult.OrderBy(order);
            }
            else
            {
                if (where != null)
                {
                    searchResult = searchResult.Where(where);
                }
                else
                {
                    if (order != null)
                    {
                        if (isDesc != null)
                            searchResult = searchResult.OrderByDescending(order);
                        else
                            searchResult = searchResult.OrderBy(order);
                    }
                }
            }

            return searchResult;
        }

        public IQueryable<T2> GetManyRelevanceObjectsOrderedByProertyNamePaged<T2>(
            Expression<Func<T2, bool>> where,
            string orderProeprtyName,
            int page,
            int pageSize,
            ref int pageAmount,
            ref int boAmount,
            ref bool isDesc)
        {
            var dbSet = _Context.Set(typeof(T2));

            if (where != null)
            {
                var searchResult = (dbSet as IQueryable<T2>).Where(where) as IQueryable<T2>;
                boAmount = searchResult.Count();
                pageAmount = boAmount / pageSize;
                if (boAmount > pageAmount * pageSize)
                    pageAmount = pageAmount + 1;

                return searchResult;
            }
            else
            {
                var searchResult = dbSet as IQueryable<T2>;
                boAmount = searchResult.Count();
                pageAmount = boAmount / pageSize;
                if (boAmount > pageAmount * pageSize)
                    pageAmount = pageAmount + 1;

                return searchResult;
            }

        }

        public void AddRelevanceObject<T2>(T2 relevanceBo)
        {
            var dbSet = _Context.Set(typeof(T2));
            dbSet.Add(relevanceBo);
            _Context.SaveChanges();
        }

        public void UpdateRelevanceObject<T2>(T2 relevanceBo)
        {
            var tempBo = Activator.CreateInstance(typeof(T2));
            tempBo = relevanceBo;
            var dbSet = _Context.Set(typeof(T2));
            dbSet.Attach(tempBo);
            _Context.Entry(tempBo).State = EntityState.Modified;
            _Context.SaveChanges();
        }



    }

通過以上步驟，一個基本簡單的倉儲完成了。

接下來一般的話，是使用三層Model,DAL,BLL,由於我個人比較懶，直接跳過了DAL層，在BLL層進行業務處理。

新建一個ArticleBLL，對業務的操作。

 public class ArticleBLL : BaseEntityService<ZWStar_Article>, IBaseEntityService<ZWStar_Article>
    {
        public ArticleBLL() : base(EFDbContext.GetDbContext()) { }
    }

 

 

 此刻，基本的倉儲完成，下篇將介紹如果結合layui完成菜單的添加