BaseService

最新推荐文章于 2024-06-21 17:15:27 发布
最新推荐文章于 2024-06-21 17:15:27 发布
阅读量116 收藏
点赞数 1
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37758989/article/details/136639196
版权 
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Threading.Tasks;
using Api.Contact;
using Api.Models;
using Api.Service.DB;
using Api.Service.SqlSugar;
using SqlSugar;

namespace Api.Service
{
    public class BaseService<TEntity>  where TEntity : class, new()
    {
        internal SqlSugarClient Db { get; }
        internal SimpleClient<TEntity> EntityDb { get; }

        public BaseService()
        {
            DbContext.Init(BaseDBConfig.ConnectionString);
            var context = DbContext.GetDbContext();
            Db = context.Db;
            EntityDb = context.GetEntityDB<TEntity>(Db);
        }


        #region Query
        /// <summary>
        /// 根据ID查询数据
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public async Task<TEntity> QueryById(int id)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().InSingle(objId));
            return await Db.Queryable<TEntity>().In(id).SingleAsync();
        }
        /// <summary>
        /// 根据ID查询一条数据
        /// </summary>
        /// <param name="id">id（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <param name="useCache">是否使用缓存</param>
        /// <returns>数据实体</returns>
        public async Task<TEntity> QueryById(int id, bool useCache = false)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().WithCacheIF(blnUseCache).InSingle(objId));
            return await Db.Queryable<TEntity>().WithCacheIF(useCache).In(id).SingleAsync();
        }

        /// <summary>
        /// 根据ID列表查询数据集合
        /// </summary>
        /// <param name="Ids">id列表（必须指定主键特性 [SugarColumn(IsPrimaryKey=true)]），如果是联合主键，请使用Where条件</param>
        /// <returns>数据实体列表</returns>
        public async Task<List<TEntity>> QueryByIds(int[] Ids)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().In(lstIds).ToList());
            return await Db.Queryable<TEntity>().In(Ids).ToListAsync();
        }

        /// <summary>
        /// 查询所有数据
        /// </summary>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query()
        {
            //return await Task.Run(() => _entityDb.GetList());
            return await Db.Queryable<TEntity>().ToListAsync();
        }

        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="strWhere">条件</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(string strWhere)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToList());
            return await Db.Queryable<TEntity>().WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToListAsync();
        }

        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="whereExpression">whereExpression</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression)
        {
            //return await Task.Run(() => _entityDb.GetList(whereExpression));
            return await Db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression).ToListAsync();
        }

        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="orderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, string orderByFileds)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).ToList());
            return await Db.Queryable<TEntity>().WhereIF(whereExpression != null, whereExpression)
                .OrderByIF(!string.IsNullOrWhiteSpace(orderByFileds), orderByFileds).ToListAsync();
        }

        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="orderByExpression">排序表达式</param>
        /// <param name="isAsc">是否正序</param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression,
            Expression<Func<TEntity, object>> orderByExpression, bool isAsc = true)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().OrderByIF(orderByExpression != null, orderByExpression, isAsc ? OrderByType.Asc : OrderByType.Desc).WhereIF(whereExpression != null, whereExpression).ToList());
            return await Db.Queryable<TEntity>()
                .WhereIF(whereExpression != null, whereExpression)
                .OrderByIF(orderByExpression != null, orderByExpression, isAsc ? OrderByType.Asc : OrderByType.Desc)
                .ToListAsync();
        }

        /// <summary>
        /// 查询数据列表
        /// </summary>
        /// <param name="where">条件</param>
        /// <param name="orderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(string where, string orderByFileds)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToList());
            return await Db.Queryable<TEntity>()
                .WhereIF(!string.IsNullOrEmpty(where), where)
                .OrderByIF(!string.IsNullOrEmpty(orderByFileds), orderByFileds)
                .ToListAsync();
        }

        /// <summary>
        /// 查询前N条数据
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="top">前N条</param>
        /// <param name="orderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(
            Expression<Func<TEntity, bool>> whereExpression,
            int top,
            string orderByFileds)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).Take(intTop).ToList());
            return await Db.Queryable<TEntity>()
                .WhereIF(whereExpression != null, whereExpression)
                .OrderByIF(!string.IsNullOrEmpty(orderByFileds), orderByFileds)
                .Take(top).ToListAsync();
        }

        /// <summary>
        /// 查询前N条数据
        /// </summary>
        /// <param name="where">条件</param>
        /// <param name="top">前N条</param>
        /// <param name="orderByFileds">排序字段，如name asc,age desc</param>
        /// <returns>数据列表</returns>
        public async Task<List<TEntity>> Query(string where, int top, string orderByFileds)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).Take(intTop).ToList());
            return await Db.Queryable<TEntity>()
                .WhereIF(!string.IsNullOrEmpty(where), where)
                .OrderByIF(!string.IsNullOrEmpty(orderByFileds), orderByFileds)
                .Take(top).ToListAsync();
        }


        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="pageIndex">页码</param>
        /// <param name="pageSize">数据量</param>
        /// <param name="orderByFileds">排序方式，如name asc,age desc</param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query(Expression<Func<TEntity, bool>> whereExpression, int pageIndex,
            int pageSize, string orderByFileds)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(whereExpression != null, whereExpression).ToPageList(intPageIndex, intPageSize));
            return await Db.Queryable<TEntity>()
                .WhereIF(whereExpression != null, whereExpression)
                .OrderByIF(!string.IsNullOrEmpty(orderByFileds), orderByFileds)
                .ToPageListAsync(pageIndex, pageSize);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="where">条件</param>
        /// <param name="pageIndex">页码</param>
        /// <param name="pageSize">数据量</param>
        /// <param name="orderByFileds">排序方式，如name asc,age desc</param>
        /// <returns></returns>
        public async Task<List<TEntity>> Query(string where, int pageIndex, int pageSize, string orderByFileds)
        {
            //return await Task.Run(() => _db.Queryable<TEntity>().OrderByIF(!string.IsNullOrEmpty(strOrderByFileds), strOrderByFileds).WhereIF(!string.IsNullOrEmpty(strWhere), strWhere).ToPageList(intPageIndex, intPageSize));
            return await Db.Queryable<TEntity>()
                .WhereIF(!string.IsNullOrEmpty(where), where)
                .OrderByIF(!string.IsNullOrEmpty(orderByFileds), orderByFileds)
                .ToPageListAsync(pageIndex, pageSize);
        }

        /// <summary>
        /// 分页查询
        /// </summary>
        /// <param name="whereExpression">条件表达式</param>
        /// <param name="pageIndex">页码（下标0）</param>
        /// <param name="pageSize">页大小</param>
        /// <param name="orderByFileds">排序字段，如name asc,age desc</param>
        /// <returns></returns>
        public async Task<PageModel<TEntity>> QueryPage(Expression<Func<TEntity, bool>> whereExpression, int pageIndex = 1, int pageSize = 10, string orderByFileds = null)
        {
            RefAsync<int> totalCount = 0;
            var list = await Db.Queryable<TEntity>()

                .OrderByIF(!string.IsNullOrEmpty(orderByFileds), orderByFileds).WhereIF(whereExpression != null, whereExpression)
                .ToPageListAsync(pageIndex, pageSize, totalCount);

            int pageCount = Math.Ceiling(totalCount.ObjToDecimal() / pageSize.ObjToDecimal()).ObjToInt();
            return new PageModel<TEntity>
            {
                DataCount = totalCount,
                PageCount = pageCount,
                PageIndex = pageIndex,
                PageSize = pageSize,
                Data = list
            };
        }


        public async Task<int> QueryCount(Expression<Func<TEntity, bool>> whereExpression)
        {
            var count = await Db.Queryable<TEntity>()
                .WhereIF(whereExpression != null, whereExpression)
                .CountAsync();

            return count;
        }

        #endregion

        #region Add

        /// <summary>
        /// 添加
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public async Task<int> Add(TEntity entity)
        {
            //var i = await Task.Run(() => _db.Insertable(entity).ExecuteReturnBigIdentity());
            返回的i是long类型,这里你可以根据你的业务需要进行处理
            //return (int)i;

            var insert = Db.Insertable(entity);
            return await insert.ExecuteReturnIdentityAsync();

        }

        /// <summary>
        /// 写入实体数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <param name="insertColumns">指定只插入列</param>
        /// <returns>返回自增量列</returns>
        public async Task<int> Add(TEntity entity, Expression<Func<TEntity, object>> insertColumns = null)
        {
            var insert = Db.Insertable(entity);
            if (insertColumns == null)
            {
                return await insert.ExecuteReturnIdentityAsync();
            }

            return await insert.InsertColumns(insertColumns).ExecuteReturnIdentityAsync();
        }


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

        #region Delete

        /// <summary>
        /// 删除指定ID的数据
        /// </summary>
        /// <param name="id">主键ID</param>
        /// <returns></returns>
        public async Task<bool> DeleteById(int id)
        {
            //var i = await Task.Run(() => _db.Deleteable<TEntity>(id).ExecuteCommand());
            //return i > 0;
            return await Db.Deleteable<TEntity>(id).ExecuteCommandHasChangeAsync();
        }

        /// <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();
        }


        /// <summary>
        /// 删除指定ID集合的数据(批量删除)
        /// </summary>
        /// <param name="ids">主键ID集合</param>
        /// <returns></returns>
        public async Task<bool> DeleteByIds(int[] ids)
        {
            //var i = await Task.Run(() => _db.Deleteable<TEntity>().In(ids).ExecuteCommand());
            //return i > 0;
            return await Db.Deleteable<TEntity>().In(ids).ExecuteCommandHasChangeAsync();
        }
        #endregion

        #region Update

        /// <summary>
        /// 更新实体数据
        /// </summary>
        /// <param name="entity">实体类</param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity entity)
        {
            这种方式会以主键为条件
            //var i = await Task.Run(() => _db.Updateable(entity).ExecuteCommand());
            //return i > 0;
            //这种方式会以主键为条件
            return await Db.Updateable(entity).ExecuteCommandHasChangeAsync();
        }

        /// <summary>
        /// 更新实体数据
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="where">条件</param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity entity, string where)
        {
            //return await Task.Run(() => _db.Updateable(entity).Where(strWhere).ExecuteCommand() > 0);
            return await Db.Updateable(entity).Where(where).ExecuteCommandHasChangeAsync();
        }


        /// <summary>
        /// 更新实体数据
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="columns">更新的列</param>
        /// <param name="ignoreColumns">跳过的列</param>
        /// <param name="where">条件</param>
        /// <returns></returns>
        public async Task<bool> Update(TEntity entity, List<string> columns = null, List<string> ignoreColumns = null, string where = "")
        {
            //IUpdateable<TEntity> up = await Task.Run(() => _db.Updateable(entity));
            //if (lstIgnoreColumns != null && lstIgnoreColumns.Count > 0)
            //{
            //    up = await Task.Run(() => up.IgnoreColumns(it => lstIgnoreColumns.Contains(it)));
            //}
            //if (lstColumns != null && lstColumns.Count > 0)
            //{
            //    up = await Task.Run(() => up.UpdateColumns(it => lstColumns.Contains(it)));
            //}
            //if (!string.IsNullOrEmpty(strWhere))
            //{
            //    up = await Task.Run(() => up.Where(strWhere));
            //}
            //return await Task.Run(() => up.ExecuteCommand()) > 0;

            IUpdateable<TEntity> up = Db.Updateable(entity);
            if (ignoreColumns != null && ignoreColumns.Count > 0)
            {
                up = up.IgnoreColumns(ignoreColumns.ToArray());
            }
            if (columns != null && columns.Count > 0)
            {
                up = up.UpdateColumns(columns.ToArray());
            }
            if (!string.IsNullOrEmpty(where))
            {
                up = up.Where(where);
            }
            return await up.ExecuteCommandHasChangeAsync();
        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="sql">SQL</param>
        /// <param name="parameters">参数</param>
        /// <returns></returns>
        public async Task<bool> Update(string sql, SugarParameter[] parameters = null)
        {
            //return await Task.Run(() => _db.Ado.ExecuteCommand(strSql, parameters) > 0);
            return await Db.Ado.ExecuteCommandAsync(sql, parameters) > 0;
        }

        /// <summary>
        /// 更新实体数据
        /// </summary>
        /// <param name="entityList">实体类</param>
        /// <returns></returns>
        public async Task<bool> Update(List<TEntity> entityList)
        {
            //这种方式会以主键为条件
            var i = await Db.Updateable(entityList).ExecuteCommandAsync();
            return i > 0;
        }
        #endregion
    }
}

雾里°
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
java泛型BaseDao与BaseService
04-07
java泛型BaseDao与BaseService
BaseService:Goland服务的基本代码
04-01
基本服务 Goland服务的基本代码
纳税服务系统【抽取BaseService、条件查询】
3y
06-08 459
抽取BaseService 到目前为止，我们已经写了三个模块的开发了。我们已经抽取过了BaseAction、BaseDao，我们这次来看看我们的Service接口。 UserService /** * created by ozc on 2017/5/23. */ public interface UserService { //新增 void save(Use...
基于JPA封装的BaseService
ぃ慕容ぅ
09-11 3942
JPA-快速开始 我们将通过一个简单的 Demo 来阐述 BaseService 的强大功能，在此之前，我们假设您已经： 拥有 Java 开发环境以及相应 IDE 熟悉 Spring Boot 熟悉 Maven 配置 在 xxxService 类上继承BaseService： @Service public class TestService extends BaseService<M...
BaseService代码示例
lud
12-23 423
public interface BaseService<T> { /** * 方法功能说明：@1.列表查询 * 创建时间：2018年5月24日 下午5:38:13 --lud */ List<T> queryList(T t); /** * 方法功能说明：@1.分页查询 * 创建时间：2018年6月4日 下午2:36:21 --lud */ Page<T> quer.
抽取BaseDao和BaseService
WannaRunning的博客
12-17 1160
目录 抽取BaseDao 定义BaseDao接口 定义BaseDaoImpl类 业务Dao基于BaseDao的的实现方式 抽取BaseService 定义BaseService接口 定义抽象的BaseServiceImpl类 业务service基于BaseService的实现（第一种方式）： 业务service基于BaseService的实现（第二种方式）： 抽取BaseDao...
BaseService和其实现类
weixin_44619313的博客
05-08 4392
BaseService和其实现类 开发工具与关键技术：Eclipse、java 作者：梁添荣 撰写时间：2020-05-08 在service层，我们经常会写基本的增删查改方法，但有很多模块都有类似的写法，所以，抽取常用的增删查改BaseService接口，再实现该接口为BaseServiceImpl，通过service层的实现类继承BaseServiceImpl，就有了各个增删查改的方法了，只...
万能BaseMapper，BaseService，BaseController模板（偷懒专用）
weixin_45873488的博客
12-23 5302
1.目录结构（后期利用工具也能实现，建议前期自己编写，储存用作模板） 2.创建BaseMapper接口 package com.liu.base; import org.apache.ibatis.annotations.Param; import java.io.Serializable; import java.util.List; import java.util.Map; /** * @author root * @create 2020-12-21 15:28 * 封装一些mappe
万能模板(封装) BaseMapper，BaseService，BaseController
赵博林
12-26 1975
目录结构（后期利用工具也能实现，建议前期自己编写，储存用作模板） 创建BaseMapper接口 package com.liu.base; import org.apache.ibatis.annotations.Param; import java.io.Serializable; import java.util.List; import java.util.Map; /** * @author root * @create 2020-12-21 15:28 * 封装一些map..
Mybatis BaseService范类
zhanzhenguang的博客
03-22 2245
1.接口类@Servicepublic interface BaseService&lt;T&gt; { Long generatePrimaryKey(); T selectOne(T record); T selectByPrimaryKey(Object key);     int insert(T record);        int insertSelective(T recor...
基于Mybatis和BaseService的批量操作(MySql)
tplina的博客
02-21 1336
1.通用Mapper import tk.mybatis.mapper.common.Mapper; import tk.mybatis.mapper.common.MySqlMapper; /** * 基础mapper,实现增删改查,分页等基本功能 * * @param &lt;T&gt; 泛型参数 * @author lw * @since 2019年2月14日 13:48:1...
XXF.BaseService.DistributedCache-BSF-DistributedCache.zip
12-10
.net 分布式缓存中间件 方便实现缓存的分布式，集群，负载均衡，故障自动转移，并兼容多种缓存存储的分布式缓存中间件。 用于解决分布式架构中的分布式缓存环节。
xmljava系统源码-iuap-pap-baseservice:iuap快速开发体系中的后台支持部分，通过与iuap前端开发框架结合,可快速
06-06
iuap-pap-baseservice框架属于iuap快速开发体系中的后台支持部分，通过与iuap前端开发框架结合,可快速的实现一套业务表单系统开发. 特性 集成图形化快速建模工具—— 快速启动业务表单开发 简化单表/主子表CRUD服务...
S-mall-ssm:小小商城系统，JavaWEB项目，基于SSM，仿天猫页面，功能齐全，实现了自动处理关联查询的通用Mapper、抽象 BaseService 类、注解鉴权、参数注解校验等
05-13
实现了 BaseService 类对 Service 层进行抽象。通过拦截器实现了方法级粒度的鉴权，通过AOP实现了参数校验。 演示： 可自行注册账号，或使用后台查看权限账号 demo 密码 demo （后台入口登陆后显示） 兄弟项目： 本...
c# winform修改控件数字类型运行输入null
可达鸭的博客
06-17 216
在winform里，对于一个text控件，有时候想给他添加控制变成数字类型，仅允许输入数字，使用上面的代码；但是会发现，用户输入框输入数字后，delete会变成0，无法设置null值。只要在properties里面修改一下属性即可。
C# 使用Vector256写了一个简单的帮助类Vector256Helper
最新发布
ftfmatlab的博客
06-21 319
当数据量大的时候用普通代码计算非常耗时，这里简单利用simd加速处理。
.NET C#基础：While & do-while
2401_82584055的博客
06-17 475
只要指定的布尔表达式保持 true，do-while 语句就会运行语句或语句块。由于此表达式在每次循环执行后计算，因此 do-while 循环至少执行一次。
C# —— 枚举
lu2023_8_6的博客
06-17 848
枚举是一个特殊的存在// 它是一个被命名的整形常量的集合// 一般用来表示 状态 类型 等等Boss, // 1。
BaseService的批量删除
04-25
答：对于BaseService的批量删除操作，可以先根据传入的id列表查询到需要删除的所有对象，然后再对这些对象进行删除操作。具体实现可以参考如下代码： ```java public void batchDelete(List<Long> ids) { List<T> ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值