BaseQuery今生

上篇我介绍了,BaseQuery的前世.这里我介绍以下BaseQuery的今生.

轮子造好怎么用?

1.添加包源地址

https://www.myget.org/F/basequery/api/v3/index.json

2.新建一个.Net6 WebAPI项目

3.引用Nuget

dotnet add package BaseQuery

4.具体使用

    /// <summary>
    /// 仓储接口
    /// </summary>
    /// <typeparam name="T">实体</typeparam>
    /// <typeparam name="C">新增参数</typeparam>
    /// <typeparam name="U">修改参数</typeparam>
    /// <typeparam name="R">查询参数</typeparam>
    public interface IRepository<T, C, U, R> where T : BaseEntity, new()
        where R : class, new()
    {
        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        Task<int> InsertAsync(C data);

        /// <summary>
        /// 新增
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        Task<int> InsertAsync(IEnumerable<C> data);

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        Task<int> UpdateAsync(U data);

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        Task<int> UpdateAsync(IEnumerable<U> data);

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        Task<int> DeleteAsync(T data);

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        Task<int> DeleteAsync(IEnumerable<T> data);

        /// <summary>
        /// [单表]获取实体
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        Task<T> GetEntityAsync(R input);

        /// <summary>
        /// [单表]获取实体集合
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetEntityListAsync(R input);

        /// <summary>
        /// [单表]获取分页实体集合
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        Task<IEnumerable<T>> GetPageEntityListAsync(PageEntity<R> input);
    }

只需要封装一个仓储.基础的查询就不用写了

    /// <summary>
    /// 基础仓储
    /// </summary>
    /// <typeparam name="T">实体参数</typeparam>
    /// <typeparam name="C">新增参数</typeparam>
    /// <typeparam name="U">修改参数</typeparam>
    /// <typeparam name="R">读取参数</typeparam>
    public class BaseRepository<T, C, U, R> : BaseDynamicExpression<T, R>, IRepository<T, C, U, R>
        where T : BaseEntity, new()
        where R : class, new()
    {
        protected readonly ISqlSugarClient _db;

        public BaseRepository(ISqlSugarClient db)
        {
            _db = db;
        }

        /// <summary>
        /// 新增
        /// </summary>
        /// <returns></returns>
        public async Task<int> InsertAsync(C input)
        {

            return await _db.Insertable<T>(input.MapTo<C, T>()).ExecuteCommandAsync();
        }

        /// <summary>
        /// 新增
        /// </summary>
        /// <returns></returns>
        public async Task<int> InsertAsync(IEnumerable<C> input)
        {
            return await _db.Insertable<T>(input.MapTo<C, T>()).ExecuteCommandAsync();
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <returns></returns>
        public async Task<int> UpdateAsync(U input)
        {
            return await _db.Updateable<T>(input.MapTo<U, T>()).ExecuteCommandAsync();
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <returns></returns>
        public async Task<int> UpdateAsync(IEnumerable<U> input)
        {
            return await _db.Updateable<T>(input.MapTo<U, T>()).ExecuteCommandAsync();
        }

        /// <summary>
        /// 修改
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<int> UpdateAsync(Expression<Func<T, bool>> input)
        {
            return await _db.Updateable<T>(input).ExecuteCommandAsync();
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public async Task<int> DeleteAsync(IEnumerable<T> data)
        {
            return await _db.Deleteable<T>(data).ExecuteCommandAsync();
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public async Task<int> DeleteAsync(T data)
        {
            return await _db.Deleteable<T>(data).ExecuteCommandAsync();
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<int> DeleteAsync(Expression<Func<T, bool>> input)
        {
            return await _db.Deleteable<T>(input).ExecuteCommandAsync();
        }

        /// <summary>
        /// [单表]获取集合
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<IEnumerable<T>> GetEntityListAsync(R input)
        {
            return await this.GetSqlSugarExpression(input).ToListAsync();
        }

        /// <summary>
        /// [单表]获取单个
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<T> GetEntityAsync(R input)
        {
            return await this.GetSqlSugarExpression(input).FirstAsync();
        }

        /// <summary>
        /// [单表]获取分页
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<IEnumerable<T>> GetPageEntityListAsync(PageEntity<R> input)
        {
            var res = this.GetSqlSugarExpression(input.Data);

            if (!string.IsNullOrEmpty(input.OrderField))
                res.OrderBy(input.OrderField);

            return await res.ToPageListAsync(input.PageIndex, input.PageSize, input.Total);
        }

        /// <summary>
        /// 获取SqlSugar的表达式目录树
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        private ISugarQueryable<T> GetSqlSugarExpression(R input)
        {
            var res = GetExpression(input);
            return _db.Queryable<T>().WhereIF(res.Condition, res.Expression);
        }
    }

重点在这里

        /// <summary>
        /// [单表]获取集合
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<IEnumerable<T>> GetEntityListAsync(R input)
        {
            return await this.GetSqlSugarExpression(input).ToListAsync();
        }

        /// <summary>
        /// [单表]获取单个
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<T> GetEntityAsync(R input)
        {
            return await this.GetSqlSugarExpression(input).FirstAsync();
        }

        /// <summary>
        /// [单表]获取分页
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<IEnumerable<T>> GetPageEntityListAsync(PageEntity<R> input)
        {
            var res = this.GetSqlSugarExpression(input.Data);

            if (!string.IsNullOrEmpty(input.OrderField))
                res.OrderBy(input.OrderField);

            return await res.ToPageListAsync(input.PageIndex, input.PageSize, input.Total);
        }

        /// <summary>
        /// 获取SqlSugar的表达式目录树
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        private ISugarQueryable<T> GetSqlSugarExpression(R input)
        {
            var res = GetExpression(input);
            return _db.Queryable<T>().WhereIF(res.Condition, res.Expression);
        }

举例实现

只需要这样简单的继承一下.基础的增删改查就不用重复的写了.

    /// <summary>
    /// 学校仓储
    /// </summary>
    public interface ISchoolRepository : IRepository<SchoolEntity, SchoolAddInput, SchoolModifyInput, SchoolQueryInput>
    {

    }

    /// <summary>
    /// 学校仓储
    /// </summary>
    public class SchoolRepository : BaseRepository<SchoolEntity, SchoolAddInput, SchoolModifyInput, SchoolQueryInput>, ISchoolRepository
    {
        public SchoolRepository(ISqlSugarClient db) : base(db)
        {

        }
    }

规范

以Name为例

 public string Name { get; set; }

相等(=):查询实体的字段名称和类型必须和对应实体属性一致

查询实体属性: public string Name

小于(<):查询实体的字段后缀要加上LessThan

查询实体属性: public int IdLessThan

小于等于(<=):查询实体的字段后缀要加上LessThanOrEqual

查询实体属性: public int IdLessThanOrEqual

大于(>):查询实体的字段后缀要加上GreaterThan

查询实体属性: public int IdGreaterThan

大于等于(>=):查询实体的字段后缀要加上GreaterThanOrEqual

查询实体属性: public int IdGreaterThanOrEqual

不等于(<>/!=):查询实体的字段后缀要加上NotEqual

查询实体属性: public int IdNotEqual { get; set; }
public string NameNotEqual

模糊(Contains):类型相同,并且在名称相同的基础上,查询实体的字段后缀要加上Contains

查询实体属性: public string NameContains

StartsWith

public string NameStartsWith

EndsWith

public string NameEndsWith

集合(IN): 以下三选一

public List Name_Contains { get; set; }
public string[] Name_Contains { get; set; }
public IEnumerable Name_Contains

思想:

约定大约配置

定义:系统，类库，框架假定其合理的默认值，而非要求提供不必要的配置。在大部分情况下，使用框架提供的默认值会让项目运行的更快。
这里我理解的只有两个字-那就是规范.大家都去遵守某种规范,那么这种规范也就成了默认值,减少了很多成本.;体现在字段的命名上面.减少配置.用通俗易懂的规范.

封装

所谓的封装,无非就是减少变化,把不变的部分合理的封装成公用的,把变化转移到上层.使下层更加稳定.这里我有一些感慨,程序稳定性和逻辑的复杂度以及工作量的大小大多数情况下和封装有紧密的联系. 不要写重复的代码.只要是看到大量重复 类似的代码.那这个就是代码坏掉的味道 那就要想办法去适当的改造. 不要让代码成为垃圾堆,你去堆一下我去堆一下的.这样下去终有一天会让你加班到崩溃.垃圾要进行垃圾分类.同样代码也需要分类.

posted @ 2022-04-04 12:14 Bug专员阅读(172) 评论(0) 收藏举报

刷新页面返回顶部

永远不要停止学习的脚步

BaseQuery今生

轮子造好怎么用?

1.添加包源地址

2.新建一个.Net6 WebAPI项目

3.引用Nuget

4.具体使用

举例实现

规范

思想:

公告