（四）.netcore+vue 项目搭建——EF底层实现

一、各层公用基类

 

 

IBaseServices.cs

public interface IBaseServices<TEntity> where TEntity : class
    {

        #region Add
        /// <summary>
        /// 新增实体
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        Task<TEntity> Add(TEntity entity);
        /// <summary>
        /// 批量新增实体
        /// </summary>
        /// <param name="listEntity">实体集合</param>
        /// <returns>影响行数</returns>
        Task<int> Add(List<TEntity> listEntity);

        #endregion

        #region UPDATE 
        /// <summary>
        /// 更新实体数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task<bool> Update(TEntity entity);

        /// <summary>
        /// 更新实体的指定字段
        /// </summary>
        /// <param name="model"></param>
        /// <param name="propertyNames"></param>
        /// <returns></returns>
        Task<bool> Update(TEntity model, params string[] propertyNames);

        /// <summary>
        /// 根据表达式查询出来的结果集，批量更新指定字段
        /// </summary>
        /// <param name="model"></param>
        /// <param name="whereLambda"></param>
        /// <param name="modifiedPropertyNames"></param>
        /// <returns></returns>
        Task<bool> Update(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames);


        #endregion

        #region DELETE

        /// <summary>
        /// 根据实体删除
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        Task<bool> Delete(TEntity entity);
        /// <summary>
        /// 根据表达式条件删除
        /// </summary>
        /// <param name="delWhere"></param>
        /// <returns></returns>
        Task<bool> DeleteBy(Expression<Func<TEntity, bool>> delWhere);


        #endregion


        #region Select 
        /// <summary>
        /// 根据表达式查询，返回单个实体
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        Task<TEntity> QueryBy(Expression<Func<TEntity, bool>> whereLambda);
        /// <summary>
        /// 根据表达式查询，返回实体列表
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereLambda);
        /// <summary>
        /// 返回实体所有列表
        /// </summary>
        /// <returns></returns>
        Task<List<TEntity>> Query();
        #region 排序查询
        /// <summary>
        /// 根据表达式查询，返回实体集合，并按指定排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="orderLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);


        /// <summary>
        /// 根据表达式查询，返回实体集合，并按指定排序返回指定行数
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="top"></param>
        /// <param name="orderLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int top, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);


        #endregion

        #region 分页查询
        /// <summary>
        /// 按表达式分页查询，并按指定排序，返回实体集合
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="orderByLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true);


        /// <summary>
        /// 按表达式分页查询，并按指定排序，返回分页实体
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="orderByLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        Task<PageModel<TEntity>> QueryPage<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true);


        #endregion

        #endregion


        #region ORTHER
        /// <summary>
        /// 执行存储过程 exec Proc_ @name,返回实体集合
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parms"></param>
        /// <param name="cmdType"></param>
        /// <returns></returns>
        Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);


        /// <summary>
        ///  执行存储过程 exec Proc_ @name,返回影响行数
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parms"></param>
        /// <param name="cmdType"></param>
        /// <returns></returns>
        Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);


        #endregion ORTHER
    }

 

BaseServices.cs

public class BaseServices<TEntity> : IBaseServices<TEntity> where TEntity : class, new()
    {
       
        public IBaseDao<TEntity> BaseDal;

        public BaseServices(IBaseDao<TEntity> dal)
        {
            this.BaseDal = dal;
        }

        #region Add
       
        public async Task<TEntity> Add(TEntity entity)
        {
            return await BaseDal.Add(entity);
        }
        public async Task<int> Add(List<TEntity> listEntity)
        {
            return await BaseDal.Add(listEntity);
        }

        #endregion

        #region UPDATE 
        
        public async Task<bool> Update(TEntity entity)
        {
            return await BaseDal.Update(entity);
        }

        public async Task<bool> Update(TEntity model, params string[] propertyNames)
        {
            return await BaseDal.Update(model, propertyNames);
        }

        public async Task<bool> Update(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames)
        {

            return await BaseDal.Update(model, whereLambda, modifiedPropertyNames);
        }


        #endregion

        #region DELETE
      
        public async Task<bool> Delete(TEntity entity)
        {
            return await BaseDal.Delete(entity);
        }
        
        public async Task<bool> DeleteBy(Expression<Func<TEntity, bool>> delWhere)
        {
            return await BaseDal.DeleteBy(delWhere);
        }

        #endregion


        #region Select 

        public async Task<TEntity> QueryBy(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await BaseDal.QueryBy(whereLambda);
        }

        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await BaseDal.Query(whereLambda);
        }

        public async Task<List<TEntity>> Query()
        {
            return await BaseDal.Query();
        }


        #region 排序查询
        public async Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
        {
            return await BaseDal.Query(whereLambda, orderLambda, isAsc);
        }



        public async Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int top, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
        {
            return await BaseDal.Query(whereLambda, top, orderLambda, isAsc);
        }

        #endregion

        #region 分页查询

        public async Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true)
        {
            return await BaseDal.Query(whereLambda, pageIndex, pageSize, orderByLambda, isAsc);
        }


        public async Task<PageModel<TEntity>> QueryPage<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true)
        {
            return await BaseDal.QueryPage(whereLambda, pageIndex, pageSize, orderByLambda, isAsc);
        }


        #endregion

        #endregion

        #region ORTHER

       
        public async Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
        {
            return await BaseDal.Query(sql, parms, cmdType);

        }
       
        public async Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
        {
            return await BaseDal.Execute(sql, parms, cmdType);
        }


        #endregion ORTHER
    }

 

IBaseDao.cs

public interface IBaseDao<TEntity> where TEntity : class
    {

        #region Add
        Task<TEntity> Add(TEntity entity);

        Task<int> Add(List<TEntity> listEntity);

        #endregion

        #region UPDATE 
        Task<bool> Update(TEntity entity);

        Task<bool> Update(TEntity model, params string[] propertyNames);

        Task<bool> Update(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames);


        #endregion

        #region DELETE


        Task<bool> Delete(TEntity entity);

        Task<bool> DeleteBy(Expression<Func<TEntity, bool>> delWhere);


        #endregion


        #region Select 
       
        Task<TEntity> QueryBy(Expression<Func<TEntity, bool>> whereLambda);
        
        Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereLambda);
       
        Task<List<TEntity>> Query();
        #region 排序查询
        
        Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);


       
        Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int top, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true);


        #endregion

        #region 分页查询
       
        Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true);

       

        Task<PageModel<TEntity>> QueryPage<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true);


        #endregion

        #endregion


        #region ORTHER

       
        Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);

        
        Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text);


        #endregion ORTHER
    }

 

BaseDao.cs

public class BaseDao<TEntity> : IBaseDao<TEntity> where TEntity : class, new()
    {
        private BaseCoreContext _db;

        public BaseDao(BaseCoreContext mydbcontext)
        {
            this._db = mydbcontext as BaseCoreContext;
        }

        #region Add
        /// <summary>
        /// 新增实体
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public async Task<TEntity> Add(TEntity entity)
        {
            _db.Set<TEntity>().Add(entity);
            await _db.SaveChangesAsync();
            return entity;
        }

        /// <summary>
        /// 批量新增实体
        /// </summary>
        /// <param name="listEntity">实体集合</param>
        /// <returns>影响行数</returns>
        public async Task<int> Add(List<TEntity> listEntity)
        {
            await _db.Set<TEntity>().AddRangeAsync(listEntity);
            return await _db.SaveChangesAsync();
        }

        #endregion

        #region UPDATE 
        /// <summary>
        /// 更新实体数据
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity entity)
        {
            _db.Set<TEntity>().Update(entity);
            return await _db.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// 更新实体的指定字段
        /// </summary>
        /// <param name="model"></param>
        /// <param name="propertyNames"></param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity model, params string[] propertyNames)
        {            
            EntityEntry entry = _db.Entry<TEntity>(model);            
            entry.State = EntityState.Unchanged;            
            foreach (string propertyName in propertyNames)
            {                
                entry.Property(propertyName).IsModified = true;
            }
            return await _db.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// 根据表达式查询出来的结果集，批量更新指定字段
        /// </summary>
        /// <param name="model"></param>
        /// <param name="whereLambda"></param>
        /// <param name="modifiedPropertyNames"></param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity model, Expression<Func<TEntity, bool>> whereLambda, params string[] modifiedPropertyNames)
        {
            List<TEntity> listModifing = _db.Set<TEntity>().Where(whereLambda).ToList();            
            Type t = typeof(TEntity);            
            List<PropertyInfo> propertyInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.Public).ToList();            
            Dictionary<string, PropertyInfo> dicPropertys = new Dictionary<string, PropertyInfo>();            
            propertyInfos.ForEach(p =>
            {
                if (modifiedPropertyNames.Contains(p.Name))
                {
                    dicPropertys.Add(p.Name, p);
                }
            });            
            foreach (string propertyName in modifiedPropertyNames)
            {                
                if (dicPropertys.ContainsKey(propertyName))
                {                   
                    PropertyInfo proInfo = dicPropertys[propertyName];                    
                    object newValue = proInfo.GetValue(model, null);                    
                    foreach (TEntity item in listModifing)
                    {                        
                        proInfo.SetValue(item, newValue, null);
                    }
                }
            }
           
            return await _db.SaveChangesAsync() > 0;
        }


        #endregion

        #region DELETE
        
        /// <summary>
        /// 根据实体删除
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public async Task<bool> Delete(TEntity entity)
        {
            _db.Set<TEntity>().Attach(entity);
            _db.Set<TEntity>().Remove(entity);
            return await _db.SaveChangesAsync() > 0;
        }

        /// <summary>
        /// 根据表达式条件删除
        /// </summary>
        /// <param name="delWhere"></param>
        /// <returns></returns>
        public async Task<bool> DeleteBy(Expression<Func<TEntity, bool>> delWhere)
        {
            
            List<TEntity> listDeleting = _db.Set<TEntity>().Where(delWhere).ToList();            
            listDeleting.ForEach(u =>
            {
                _db.Set<TEntity>().Attach(u);  
                _db.Set<TEntity>().Remove(u); 
            });            
            return await _db.SaveChangesAsync() > 0;
        }



        #endregion


        #region Select 

        /// <summary>
        /// 根据表达式查询，返回单个实体
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public async Task<TEntity> QueryBy(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await _db.Set<TEntity>().Where(whereLambda).AsNoTracking().FirstOrDefaultAsync();
        }
        /// <summary>
        /// 根据表达式查询，返回实体列表
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await _db.Set<TEntity>().Where(whereLambda).AsNoTracking().ToListAsync();
        }

        /// <summary>
        /// 返回实体所有列表
        /// </summary>
        /// <returns></returns>
        public async Task<List<TEntity>> Query()
        {
            return await _db.Set<TEntity>().AsNoTracking().ToListAsync();
        }


        #region 排序查询
        /// <summary>
        /// 根据表达式查询，返回实体集合，并按指定排序
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="orderLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
        {
            if (isAsc)
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda).AsNoTracking().ToListAsync();
            }
            else
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda).AsNoTracking().ToListAsync();
            }
        }


        /// <summary>
        /// 根据表达式查询，返回实体集合，并按指定排序返回指定行数
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="top"></param>
        /// <param name="orderLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int top, Expression<Func<TEntity, TKey>> orderLambda, bool isAsc = true)
        {
            if (isAsc)
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderLambda).Take(top).AsNoTracking().ToListAsync();
            }
            else
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderLambda).Take(top).AsNoTracking().ToListAsync();
            }
        }

        #endregion

        #region 分页查询

        /// <summary>
        /// 按表达式分页查询，并按指定排序，返回实体集合
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="orderByLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true)
        {
            if (isAsc)
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderBy(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }
            else
            {
                return await _db.Set<TEntity>().Where(whereLambda).OrderByDescending(orderByLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }
        }

        /// <summary>
        /// 按表达式分页查询，并按指定排序，返回分页实体
        /// </summary>
        /// <typeparam name="TKey"></typeparam>
        /// <param name="whereLambda"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <param name="orderByLambda"></param>
        /// <param name="isAsc"></param>
        /// <returns></returns>
        public async Task<PageModel<TEntity>> QueryPage<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true)
        {
            var rowCount = await _db.Set<TEntity>().Where(whereLambda).CountAsync();
            
            int pageCount = (Math.Ceiling(rowCount.ObjToDecimal() / pageSize.ObjToDecimal())).ObjToInt();

            List<TEntity> list = null;

            if (isAsc)
            {
                list = await _db.Set<TEntity>().OrderBy(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }
            else
            {
                list = await _db.Set<TEntity>().OrderByDescending(orderByLambda).Where(whereLambda).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsNoTracking().ToListAsync();
            }

            return new PageModel<TEntity>() { dataCount = rowCount, pageCount = pageCount, page = pageIndex, PageSize = pageSize, data = list };
        }


        #endregion

        #endregion

        #region ORTHER

        /// <summary>
        /// 执行存储过程 exec Proc_ @name,返回实体集合
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parms"></param>
        /// <param name="cmdType"></param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
        {            
            if (cmdType == CommandType.StoredProcedure)
            {
                StringBuilder paraNames = new StringBuilder();
                foreach (var sqlPara in parms)
                {
                    paraNames.Append($" @{sqlPara},");
                }
                sql = paraNames.Length > 0 ? $"exec {sql} {paraNames.ToString().Trim(',')}" : $"exec {sql} ";
            }

            return await _db.Set<TEntity>().FromSqlRaw(sql).ToListAsync();

        }


        /// <summary>
        ///  执行存储过程 exec Proc_ @name,返回影响行数
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="parms"></param>
        /// <param name="cmdType"></param>
        /// <returns></returns>
        public async Task<int> Execute(string sql, List<SqlParameter> parms, CommandType cmdType = CommandType.Text)
        {
            if (cmdType == CommandType.StoredProcedure)
            {
                StringBuilder paraNames = new StringBuilder();
                foreach (var sqlPara in parms)
                {
                    paraNames.Append($" @{sqlPara},");
                }
                sql = paraNames.Length > 0 ?
                    $"exec {sql} {paraNames.ToString().Trim(',')}" :
                    $"exec {sql} ";
            }

            int ret = await _db.Database.ExecuteSqlRawAsync(sql, parms.ToArray());
            return 0;
        }


        #endregion ORTHER

    }

 

二、以角色操作为例

新建 RoleController

 /// <summary>
    /// 角色管理
    /// </summary>
    [Route("api/[controller]/[action]")]
    [ApiController]
    public class RoleController : ControllerBase
    {
        IBaseServices<SysRole> _roleServices;
        public RoleController(BaseCoreContext mydbcontext)
        {
            _roleServices = new BaseServices<SysRole>(new BaseDao<SysRole>(mydbcontext));
        }
       
        [HttpGet]
        public async Task<MessageModel<PageModel<SysRole>>> Get(int page = 1, string key = "")
        {
            if (string.IsNullOrEmpty(key) || string.IsNullOrWhiteSpace(key))
            {
                key = "";
            }
            int intPageSize = 50;
            var data = await _roleServices.QueryPage(a => a.IsDeleted != true && (a.RoleName != null && a.RoleName.Contains(key)), page, intPageSize, a => a.Id, false);

            return new MessageModel<PageModel<SysRole>>()
            {
                msg = "获取成功",
                success = data.dataCount >= 0,
                response = data
            };

        }
    
        [HttpPost]
        public async Task<MessageModel<string>> Post([FromBody] SysRole role)
        {
            var data = new MessageModel<string>();
            var m = (await _roleServices.Add(role));
            data.success = m.Id > 0;
            if (data.success)
            {
                data.response = m.Id.ObjToString();
                data.msg = "添加成功";
            }
            return data;
        }

  
        [HttpPut]
        public async Task<MessageModel<string>> Put([FromBody] SysRole role)
        {
            var data = new MessageModel<string>();
            if (role != null && role.Id > 0)
            {
                data.success = await _roleServices.Update(role);
                if (data.success)
                {
                    data.msg = "更新成功";
                }
            }
            return data;
        }

       
        [HttpDelete]
        public async Task<MessageModel<string>> Delete(int id)
        {
            var data = new MessageModel<string>();
            if (id > 0)
            {
                var model = await _roleServices.QueryBy(a => a.Id == id);
                model.IsDeleted = true;
                data.success = await _roleServices.Update(model);
                if (data.success)
                {
                    data.msg = "删除成功";
                }
            }
            return data;
        }
    }

 

项目运行起来，测试新增一个角色

 

 

结果成功！

 

 

 

 

 

三、实例化

RoleController的构造函数的参数BaseCoreContext的实例是如何传进来的呢？前面Startup里的services.AddDbContextPool已经实现了注入

RoleController的构造函数里，手动实例化了两个对象，下一章学习依赖注入，由容器来实现实例化，构造函数里只需要注入实例即可使用。

_roleServices = new BaseServices<SysRole>(new BaseDao<SysRole>(mydbcontext));