分类导航

程序笔记发布时间：2022-07-21 发布网站：大佬教程 code.js-code.com

大佬教程收集整理的这篇文章主要介绍了（四）.netcore+vue 项目搭建，大佬教程大佬觉得挺不错的，现在分享给大家，也给大家做个参考。

一、各层公用基类

（四）.netcore+vue 项目搭建

public interface IBaseservices<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
    }

View Code

Baseservices.cs

（四）.netcore+vue 项目搭建

public class Baseservices<TEntity> : IBaseservices<TEntity> where TEntity : class, new()
    {
       
        public IBaseDao<TEntity> BaseDal;//通过在子类的构造函数中注入，这里是基类，不用构造函数

        #region Add
        /// <sumMary>
        /// 写入实体数据
        /// </sumMary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public async Task<TEntity> Add(TEntity entity)
        {
            return await BaseDal.Add(entity);
        }



        /// <sumMary>
        /// 批量插入实体(速度快)
        /// </sumMary>
        /// <param name="listEntity">实体集合</param>
        /// <returns>影响行数</returns>
        public async Task<int> Add(List<TEntity> listEntity)
        {
            return await BaseDal.Add(listEntity);
        }

        #endregion

        #region updatE 
        /// <sumMary>
        /// 更新实体数据
        /// </sumMary>
        /// <param name="entity">博文实体类</param>
        /// <returns></returns>
        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
        /// <sumMary>
        /// 根据实体删除一条数据
        /// </sumMary>
        /// <param name="entity">博文实体类</param>
        /// <returns></returns>
        public async Task<bool> delete(TEntity entity)
        {
            return await BaseDal.delete(entity);
        }

        /// <sumMary>
        /// 删除指定ID的数据
        /// </sumMary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        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

        /// <sumMary>
        /// 执行存储过程或自定义sql语句--返回集合
        /// </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)
        {
            return await BaseDal.Query(sql, parms, cmdTypE);

        }


        /// <sumMary>
        /// 自定义语句和存储过程的增删改--返回影响的行数
        /// </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)
        {
            return await BaseDal.Execute(sql, parms, cmdTypE);
        }


        #endregion ORTHER
    }

View Code

IBaseDao.cs

（四）.netcore+vue 项目搭建

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
    }

View Code

BaseDao.cs

（四）.netcore+vue 项目搭建

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

        internal BaseCoreContext Db
        {
            get { return _db; }
            private set { _db = value; }
        }
        public BaseDao(BaseCoreContext mydbcontext)
        {
            this._db = mydbcontext as BaseCoreContext;
            this._dbSet = _db.Set<TEntity>();
        }

        #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;
        }

        public async Task<bool> update(TEntity model, params String[] propertyNames)
        {
            //3.1.1 将对象添加到EF中
            EntityEntry entry = _db.Entry<TEntity>(model);
            //3.1.2 先设置对象的包装状态为 Unchanged
            entry.State = EntityState.Unchanged;
            //3.1.3 循环被修改的属性名数组
            foreach (String propertyName in propertyNames)
            {
                //将每个被修改的属性的状态设置为已修改状态；这样在后面生成的修改语句时，就只为标识为已修改的属性更新
                entry.Property(propertyName).IsModified = true;
            }
            return await _db.SaveChangesAsync() > 0;
        }

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

            //3.2.1 查询要修改的数据
            List<TEntity> listModifing = _db.Set<TEntity>().Where(whereLambda).ToList();
            //3.2.2 获取实体类类型对象
            Type t = typeof(TEntity);
            //3.2.3 获取实体类所有的公共属性
            List<PropertyInfo> propertyInfos = t.GetProperties(BindingFlags.Instance | BindingFlags.PubliC).ToList();
            //3.2.4 创建实体属性字典集合
            Dictionary<String, PropertyInfo> DicPropertys = new Dictionary<String, PropertyInfo>();
            //3.2.5 将实体属性中要修改的属性名 添加到字典集合中  键：属性名  值：属性对象
            propertyInfos.ForEach(p =>
            {
                if (modifiedPropertyNames.Contains(p.Name))
                {
                    DicPropertys.Add(p.Name, p);
                }
            });
            //3.2.6 循环要修改的属性名
            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);
                    }
                }
            }
            //一次性生成sql语句 到数据库执行
            return await _db.SaveChangesAsync() > 0;
        }


        #endregion

        #region deletE
        /// <sumMary>
        /// 根据实体删除一条数据
        /// </sumMary>
        /// <param name="entity">博文实体类</param>
        /// <returns></returns>
        public async Task<bool> delete(TEntity entity)
        {
            //var i = await Task.Run(() => _db.deleteable(entity).ExecuteCommand());
            //return i > 0;
            //return await _db.deleteable(entity).ExecuteCommandHasChangeAsync();
            _db.Set<TEntity>().Attach(entity);
            _db.Set<TEntity>().Remove(entity);
            return await _db.SaveChangesAsync() > 0;
        }

        /// <sumMary>
        /// 删除指定ID的数据
        /// </sumMary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        public async Task<bool> deleteBy(Expression<Func<TEntity, bool>> delWherE)
        {
            //2.1.1 查询要删除的数据
            List<TEntity> listdeleting = _db.Set<TEntity>().Where(delWherE).ToList();
            //2.1.2 将要删除的数据 用删除方法添加到 EF 容器中
            listdeleting.ForEach(u =>
            {
                _db.Set<TEntity>().Attach(u);  //先附加到EF 容器
                _db.Set<TEntity>().Remove(u); //标识为删除状态
            });
            //2.1.3 一次性生成sql语句 到数据库执行删除
            return await _db.SaveChangesAsync() > 0;
        }



        #endregion


        #region SELEct 

        public async Task<TEntity> QueryBy(Expression<Func<TEntity, bool>> whereLambda)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().InSingle(objId));
            //return await _db.Queryable<TEntity>().In(objId).SingleAsync();

            return await _db.Set<TEntity>().Where(whereLambda).AsnoTracking().FirstOrDefaultAsync();
        }

        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereLambda)
        {
            return await _db.Set<TEntity>().Where(whereLambda).AsnoTracking().ToListAsync();
        }

        public async Task<List<TEntity>> Query()
        {
            return await _db.Set<TEntity>().AsnoTracking().ToListAsync();
        }


        #region 排序查询
        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();
            }
        }



        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 分页查询

        public async Task<List<TEntity>> Query<TKey>(Expression<Func<TEntity, bool>> whereLambda, int pageIndex, int pageSize, Expression<Func<TEntity, TKey>> orderByLambda, bool isAsc = true)
        {
            // 分页 一定注意： Skip 之前一定要 OrderBy
            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();
            }
        }


        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>
        /// 执行存储过程或自定义sql语句--返回集合
        /// </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)
        {
            //存储过程（exec getActionUrlId @name,@ID）
            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>
        /// 回滚
        /// </sumMary>
        public void RollBACkChanges()
        {
            var items = _db.ChangeTracker.Entries().ToList();
            items.ForEach(o => o.State = EntityState.Unchanged);
        }

        /// <sumMary>
        /// 自定义语句和存储过程的增删改--返回影响的行数
        /// </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)
        {
            //存储过程（exec getActionUrlId @name,@ID）
            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




    }

View Code

二、以角色为例

新建IRoleservices、Roleservices、RoleController

（四）.netcore+vue 项目搭建

public interface IRoleservices : IBaseservices<SysRole>
    {
        

    }

View Code

（四）.netcore+vue 项目搭建

public class Roleservices : Baseservices<SysRole>, IRoleservices
    {

        IBaseDao<SysRole> _dal;
        public Roleservices(IBaseDao<SysRole> dal)
        {            
            this._dal = dal;
            base.baseDal = dal;
        }
       
    }

View Code

（四）.netcore+vue 项目搭建

 [Route("api/[controller]/[action]")]
    [ApiController]
    public class RoleController : ControllerBase
    {
        readonly IRoleservices _roleservices;
        public RoleController(IRoleservices roleservices)
        {
            _roleservices = roleservices;
        }
       
        [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 = "更新成功";
                    data.response = role?.Id.objToString();
                }
            }

            return data;
        }

       
        [httpdelete]
        public async Task<messageModel<String>> delete(int id)
        {
            var data = new messageModel<String>();
            if (id > 0)
            {
                var userDetail = await _roleservices.QueryBy(a => a.Id == id);
                userDetail.Isdeleted = true;
                data.success = await _roleservices.update(userDetail);
                if (data.success)
                {
                    data.msg = "删除成功";
                    data.response = userDetail?.Id.objToString();
                }
            }

            return data;
        }
    }

View Code

大佬总结

以上是大佬教程为你收集整理的（四）.netcore+vue 项目搭建全部内容，希望文章能够帮你解决（四）.netcore+vue 项目搭建所遇到的程序开发问题。

如果觉得大佬教程网站内容还不错，欢迎将大佬教程推荐给程序员好友。

本图文内容来源于网友网络收集整理提供，作为学习参考使用，版权属于原作者。
如您有任何意见或建议可联系处理。小编QQ：384754419，请注明来意。

标签：list load php sql 排序数据库程序员

上一篇: 对象存储服务MinIO安装部署分布式... 下一篇:用python实现word文档转markdown

猜你在找的程序笔记相关文章

You can't specify target table 'xxx' for update in FROM clause的解决 2022-07-21
【UNIAPP】上传视频，进度条的前台与后端 2022-07-21
十款代码表白特效，一个比一个浪漫！ 2022-07-04
作业3 2022-07-06
linux系统下部署项目访问报404错误的解决方法 2022-05-30
C++带有指针成员的类处理方式详解 2022-06-07
Linux——（1）基本命令 2022-07-21
JavaScript之正则表达式学习笔记 2019-11-07
Redux源码学习笔记 2019-11-07
Webpack学习笔记 2019-11-07