# dapper-net

**Repository Path**: ausions/dapper-net

## Basic Information

- **Project Name**: dapper-net
- **Description**: dapper-net
- **Primary Language**: C#
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 0
- **Created**: 2024-05-30
- **Last Updated**: 2026-02-12

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# dapper-net

### 介绍
dapper-net是一款简单的orm框架。




### 使用说明

# dapper-net

### 介绍
dapper-net是一款简单的orm框架。




### 使用说明

##### AllSelectColumn(支持泛型)
###### 查询全部列
select  a,b,c from user
###### 实现接口
ISelectColumn
###### 构造函数
isDistinct：是否去重
excludes：排除列，当字段特别多但是查询的列很多少量列不需要查询出来的时候使用
 public AllSelectColumn(bool isDistinct = false)
 public AllSelectColumn(string[] excludes, bool isDistinct = false)
###### 例子
--查询除了某些公共列的所有数据
var userInfos = _repository.GetList(new AllSelectColumn(CommonExcludeEntityUtils.exclude_four),new EqualsWhere().Add("Code", code));
CommonExcludeEntityUtils  针对业务定义的常用排除的列这个可以针对业务来排除
```csharp
 public static readonly string[] exclude_one = new string[5] { "Id", "Code", "Status", "ModifyTime", "CreateTime" };

 public static readonly string[] exclude_two = new string[7] { "Id", "Platform", "ShopCode", "Code", "Status", "ModifyTime", "CreateTime" };

 public static readonly string[] exclude_three = new string[4] { "Id", "Status", "ModifyTime", "CreateTime" };

 public static readonly string[] exclude_four = new string[6] { "Id", "Platform", "ShopCode", "Status", "ModifyTime", "CreateTime" };

 public static string[] ConcatByExCludeOne(string[] array)
 {
     return array.Concat(exclude_one).ToArray();
 }

 public static string[] ConcatByExCludeTwo(string[] array)
 {
     return array.Concat(exclude_two).ToArray();
 }
```

#### UpdateColumn(支持泛型)
 更新指定的列,构建下面更新语句标红的地方
update user set a=1,b=2 where 1=1
##### 实现接口
IUpdateColumn
##### 构造函数
UpdateColumn(IDictionary<string, string> columns)
```csharp
    sql  set a=1
```
```csharp
 IDictionary<string, string> columns   键值对  key 代表字段名，value 代表字段的值
```
##### 方法
###### set a=1
```csharp
Set(string column, object value, string columnNick = "")
Set<T>(Expression<Func<T, object>> columnExpression, object value, string columnNick = "") 
```
```csharp
    sql  set a=1
```
###### set a+=1
```csharp
Increase(string column, int value, string columnNick = "")
Increase<T>(string column, int value, string columnNick = "")
```
```csharp
  sql  set a+=1
```
###### set a-=1
```csharp
Reduce(string column, int value, string columnNick = "")
Reduce<T>(string column, int value, string columnNick = "")
```
```csharp
 sql  set a-=1
```



columnNick  列昵称 优先已这个昵称为主
column 列名
value 值

#### EqualsWhere(支持泛型)
相等查询条件
select * from where code=1
##### 实现接口
IWhere
##### 构造函数
EqualsWhere()
EqualsWhere(IDictionary<string, string> dic)
    sql  where code =1
##### 方法
###### code=1
```csharp
Add(string key ,string value)
Add<T>(Expression<Func<T, object>> columnExpression, object value)
```
  添加相等条件    and code =1
#### ComplexWhere（支持泛型）
复杂查询条件组合

##### 实现接口
IWhere
##### 构造函数
ComplexWhere()
##### 方法
###### column>'2025-05-08'|column>='2025-05-08' (时间|数值)
```csharp
Gt(string column, object value, bool isEquals = false, string columnNick = "")
Gt<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object value, bool isEquals = false, string columnNick = "")
```
###### column<'2025-05-08'|column<='2025-05-08'(时间|数值)
```csharp
Lt(string column, object value, bool isEquals = false, string columnNick = "")
Lt<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object value, bool isEquals = false, string columnNick = "")
```
isEquals  :控制是否相等
###### column=1
```csharp
Eq(string column, object value, string columnNick = "")
Eq<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object value, string columnNick = "")
```
###### column='2025-05-05' （时间）
```csharp
EqDate(string column, DateTime value, string columnNick = "")
EqDate<TEntity>(Expression<Func<TEntity, object>> expressionColumn, DateTime value, string columnNick = "") 
```
###### column!=1
```csharp
NotEq(string column, object value, string columnNick = "")
NotEq<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object value, string columnNick = "")
```
###### column like '%value%'
```csharp
Like(string column, object value, string columnNick = "")
Like<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object value, string columnNick = "")
```
###### column like 'value%'
```csharp
RightLike(string column, object value, string columnNick = "")
RightLike<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object value, string columnNick = "")
```
###### column in ('a','b')  (数值|字符)
```csharp
In(string column, object[] values, string columnNick = "")
In<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object[] values, string columnNick = "")
```
###### column in ('a','b') 数值
```csharp
In(string column, int[] values, string columnNick = "")
In<TEntity>(Expression<Func<TEntity, object>> expressionColumn, int[] values, string columnNick = "")
```
###### column not in ('a','b') (数值|字符)
```csharp
NotIn(string column, object[] values, string columnNick = "")
NotIn<TEntity>(Expression<Func<TEntity, object>> expressionColumn, object[] values, string columnNick = "")
```
column not in (1,5) (数值)
```csharp
NotIn(string column, int[] values, string columnNick = "")
NotIn<TEntity>(Expression<Func<TEntity, object>> expressionColumn, int[] values, string columnNick = "")
```
##### OrderBy（支持泛型）
###### 构造函数
OrderBy(string field)
默认正序 asc
```csharp
OrderBy(string field, OrderByConditionType type)
OrderBy(string[] fields, OrderByConditionType type)
```
field：字段
type：序列化类型

#### Attribute 属性标签
##### Column
字段映射
###### 构造函数
ColumnAttribute(string columnName) 
 columnName：数据库字段名
###### 例子
        /// <summary>
        /// 主键ID
        /// </summary>
        [Column("id")]
        public int Id { get; set; }
##### EnumColumn
枚举字段列，可自动映射string类型和int类型且可以定义string的数据
###### 构造函数
```csharp
 EnumColumnAttribute(string columnName,DbType dbType)
```
    columnName：数据库字段名
    dbType:数据库类型如果设置为string 则走枚举转换 转化是通过枚举上DbAlias来进行转化存进数据库的时候直接存储“test”
注意：默认值类型枚举会自动转化成int和不是int

###### 例子
        /// <summary>
        /// 
        /// </summary>
        [EnumColumn("user_type", DbType.String)]
        public UserType UserType { get; set; }


        public enum UserType
        {
            [DbAlias("test")]
            AB = 0,
            CD = 1,
        }
#### Table
表名映射
##### 构造函数
TableAttribute(string tableName) 
 tableName：数据库表名
##### 例子
 [Table("every_day_category")]
 public class EveryDayCategoryEntity

##### Code
唯一字符串code标签,标记了这个会当做系统的唯一code来处理 会根据这个code有一些优化查询编辑等逻辑，每个表中只有一个
###### 构造函数
CodeAttribute() 
###### 例子
        /// <summary>
        /// code
        /// </summary>
        [Code]
        [Column("code")]
        public string Code { get; set; }
##### Key
主键标识
###### 构造函数
KeyAttribute() 
###### 例子
        [Key]
        [Column("id")]
        public int Id { get; set; }
##### IgnoreUpdate
忽略更新，默认会不更新这个字段
###### 构造函数
IgnoreUpdateAttribute() 
###### 例子
        /// <summary>
        /// 创建时间
        /// </summary>
        [Column("create_time")]
        [IgnoreUpdate]
        [InsertTimeAutoGenrate]
        public DateTime CreateTime { get; set; }

##### InsertTimeAutoGenrate
添加的时候默认自动生成当前时间，如果传值了则按照传值优先
###### 构造函数
InsertTimeAutoGenrateAttribute() 
###### 例子
        /// <summary>
        /// 创建时间
        /// </summary>
        [Column("create_time")]
        [IgnoreUpdate]
        [InsertTimeAutoGenrate]
        public DateTime CreateTime { get; set; }
##### IgnoreInsert
忽略添加，默认会不更新这个字段
###### 构造函数
IgnoreInsertAttribute() 
###### 例子
        /// <summary>
        /// 修改时间
        /// </summary>
        [Column("modify_time")]
        [IgnoreInsert]
        [UpdateTimeAutoGenrate]
        public DateTime? ModifyTime { get; set; }


##### UpdateTimeAutoGenrate
编辑的时候默认自动生成当前时间，如果传值了则按照传值优先
###### 构造函数
UpdateTimeAutoGenrateAttribute() 
###### 例子
        /// <summary>
        /// 修改时间
        /// </summary>
        [Column("modify_time")]
        [IgnoreInsert]
        [UpdateTimeAutoGenrate]
        public DateTime? ModifyTime { get; set; }


#### 查询
##### 单个查询
查询都是建议指定列的，不建议使用*

        public void Get()
        {
            var where= new ComplexWhere<Test>();
            where.Eq(a=>a.Id, "1");
            //sql: select id,test_name from test where id=1
            var res = repository.Get(new SelectColumn(new string[] { "ID","TestName"}),dic.ToEqualsWhere());
            Assert.Pass();

        }

##### 查询多条


        public void GetList()
        {
            var where= new ComplexWhere<Test>();
            where.Eq(a=>a.Id, "1");
            //sql: select test_name from test where id=1
            var res = repository.GetList(new SelectColumn(new string[] { "TestName" }),where);
            Assert.Pass();
        }

查询前多少条

        public void GetTopList()
        {
            var where= new ComplexWhere<Test>();
            where.Eq(a=>a.Id, "1");
            //sql: select test_name from test where id=1 limit 10
            var res = repository.GetTopList(10,new SelectColumn(new string[] { "TestName" }),where);
            Assert.Pass();
        }


##### 分页查询

        public void GetListPage()
        {
            ComplexWhere simpleWhere = new ComplexWhere();
            simpleWhere.Gt("sort", 0);
            // 排除某个字段
            AllSelectColumn allSelectColumnCondition = new AllSelectColumn(new string[] { "Sort" });

            ///根据某个字段排序
            var orderBy = new OrderBy("sort", OrderByConditionType.Desc);
            //sql :SELECT `id` as Id,`test_name` as TestName FROM test  WHERE  `sort` > 0    order by sort desc LIMIT 0,10;
            //     SELECT COUNT(1)  FROM `test`   WHERE  `sort` > 0 
            var categorys = repository.GetPageList(allSelectColumnCondition, simpleWhere, pageNumber: 1, rowsPerPage: 10, order: orderBy);
            Assert.Pass();
        }

##### 获取总数

        public void GetRecordCount()
        {
            ComplexWhere simpleWhere = new ComplexWhere();
            simpleWhere.Gt("sort", 0);
           
            //sql : SELECT COUNT(1)  FROM `test`   WHERE  `sort` > 0 
            var reponse = repository.RecordCount(simpleWhere);
            Assert.Pass();
        }
#### 新增
##### 单个插入

        public void Insert()
        {

            var res = repository.Insert(new Test()
            {
               
                TestName = "test",
                Sort = 1

            });
            Assert.Pass();
        }

##### 批量插入


        public void BatchInsert()
        {
            var insert = new List<Test>();
            insert.Add(new Test()
            {
                TestName = "batchTest"
            });

            insert.Add(new Test()
            {

                TestName = "batchTest"
            });
            //排除columns 列
            var excludeColumns = new List<string>() { "Sort" };

            //singleBatchCount 单次批量插入数量
            //delayDefaultSleepMillSeconds 默认延迟毫秒
            //delayMaxCount 最大延迟数量
            //delayOverCountSleepMillSeconds 超过了最大延迟的数量时增加延迟毫秒
            var res = repository.BatchInsert(insert);
            Assert.Pass();
        }
#### 修改
##### 简单实体更新

        public void Update()
        {
            //条件
            var update = new UpdateWhere(new string[] { "Id","Sort" });
            //实体及读取数据
            var res = repository.Update(new Test()
            {
                TestName = "updaeTest",
                Id = 1,
                Sort=0

            }, update);
            // sql: update test set TestName='updaeTest' where Id=1 and sort=0
            Assert.Pass();
        }

##### 更新指定列

        public void UpdateByColumn()
        {
            var where= new ComplexWhere<Test>();
            where.Eq(a=>a.Id, "1");
            var column = new Dictionary<string, string>();
            column.Add("test_name", "1");
            //sql: update test set TestName='updaeTest' where Id=1
            var res = repository.Update(column.ToSimpleUpdateColumn(), where);
            Assert.Pass();
        }
#### 删除
##### 简单删除

        public void SimpleDelete()
        {
             //sql id=1 
            var where= new ComplexWhere<Test>();
            where.Eq(a=>a.Id, "1");
            var res = repository.Delete(dic.ToEqualsWhere());
            Assert.Pass();
        }

##### 复杂条件删除

        public void CompleyDelete()
        {
            var where = new ComplexWhere();
            //sql id=1
            where.Eq("Id", 1);
            // sql id>10
            where.Gt("id", 10);
            // sql id<10
            where.Lt("Id", 10);
            // sql id!=10
            where.NotEq("Id", 10);
            // sql id!=10
            where.NotEq("Id", 10);
            // sql id in (10,20)
            where.In("Id", new int[] { 10, 20 });
            //sql id LIKE CONCAT('%',test,'%') 
            where.Like("TestName", "test");

            //另外一种写法,都是可以的
            //sql id=1 and name='test'
            where.Eq("Id", 1).Eq("Name", "test");
            var res = repository.Delete(where);
            Assert.Pass();
        }
##### 根据条件跟新指定字段
int Update(IUpdateColumn column, IWhere where)
   sql  update user set=a where 1=1
IUpdateColumn  指定列
IWhere    条件
```csharp
 _repository.Update(new UpdateColumn()
                         .Set("LastLoginTime", DateTime.Now)
                         , new EqualsWhere().Add("Code", code));
```
###### 扩展
int UpdateByCode(IUpdateColumn updateColumn, string code);
   根据指定条件code 来更新字段
```csharp
 sql update user x=1  where code=code
```
#### 高级保存
##### 单个保存
描述：保存逻辑主要是根据条件来查询是否存在这个数据如果存在则更新没有则新增
###### 例子
例子中查询条件是查询用户是否在指定记录时间是否有记录如果没有则新增有则更新
所以他的底层逻辑会是

第一步
先通过 select 1 from EveryDayRecordEntity where UserCode='' and RecordYear=2026 and RecordMonth=1 and RecordDay=1 and Pattern=1 status=1 查询出是否有数据

第二步
如果有则执行更新语句
update EveryDayRecordEntity  set love=1 where  UserCode='' and RecordYear=2026 and RecordMonth=1 and RecordDay=1 and Pattern=1 status=1  
注意： 更新字段必须指定需要更新那个字段其他字段可以不更新 所以.AddUpdateInclude<EveryDayRecordEntity>(new Columns<EveryDayRecordEntity>(a => a.Love));  就是指定更新的字段

如果没有则新增 新增则默认是新增所有的字段  
```csharp
 var entity = new EveryDayRecordEntity()
 {
     UserCode = request.UserCode,
     RecordYear = request.Year,
     RecordDay = request.Day,
     RecordMonth = request.Month,
     Pattern = request.Mode,
     RecordDate = PareseDate(request.Year, request.Month, request.Day)
 };
var updateColumn = new SaveUpdateIncluedeColumn();
updateColumn.AddUpdateInclude<EveryDayRecordEntity>(new Columns<EveryDayRecordEntity>(a => a.Love));
var columns = new Columns<EveryDayRecordEntity>(a => a.RecordYear, a => a.RecordMonth, a => a.RecordDay, a => a.UserCode, a => a.Pattern, a => a.Status);
var where = new UpdateWhere().Add<EveryDayRecordEntity>(columns);
_repository.Save(entity, where, updateColumn);
```

##### 批量保存

描述：批量保存是和单个保存逻辑类似也是先通过查询哪些数据有哪些数据没有有的数据则更新没有的数据则新增
###### 例子

例子中查询条件是查询用户是否在指定记录时间是否有记录如果没有则新增有则更新

第一步
所以他的底层逻辑会是先查询出 UpdateWhereColumn 条件带的字段的所有数据
先通过 select UserCode，RecordDate from EveryDayRecordEntity where UserCode='' and RecordDate='2026-02-16' 查询出是否有数据

第二步
获取到数据后将UserCode，RecordDate  生成一个hashcode 作为一个唯一值code 来区分谁是更新的

第三步
然后将由两个集合装上哪些是需要批量更新的哪些是批量新增的  新增的走批量新增，更新的走批量更新
更新目前是根据CASE when的字段来做的处理保存

注意：目前是根据多个字段来做的唯一判断，后期可能会优化根据一个唯一的ID来做更新（例如：Id,Code）

如果没有则新增 新增则默认是新增所有的字段  
```csharp
var list = new List<EveryDayRecordEntity>();
getWxStepReponseItems = getWxStepReponseItems.OrderBy(a => a.Time).ToList();
foreach (var item in getWxStepReponseItems)
{
    if (request.Time == item.Time)
    {
        continue;
    }
    //减少数据量
    if (item.step <= 0)
    {
        continue;
    }

    list.Add(new EveryDayRecordEntity()
    {

        RecordYear = item.Time.Year,
        RecordMonth = item.Time.Month,
        RecordDay = item.Time.Day,
        RecordDate = item.Time,
        UserCode = request.UserCode,
        Pattern = PeriodPatternEnum.Menstrual,
        SportWxStep = item.step
    });
}
var reponse = await _repository.BatchSave(new BatchSaveRequest<EveryDayRecordEntity>()
{
    Entity = list,
    UpdateColumn = new Columns<EveryDayRecordEntity>(a => a.SportWxStep),
    UpdateWhereColumn = new Columns<EveryDayRecordEntity>(a => a.UserCode, a => a.RecordDate),
    UpdateWhere = new ComplexWhere<EveryDayRecordEntity>().Eq(a => a.UserCode, request.UserCode).Gt(a => a.RecordDate, getWxStepReponseItems.FirstOrDefault().Time, true)
       .Lt(a => a.RecordDate, getWxStepReponseItems.LastOrDefault().Time, true)
});

await _every_day_record_detail_service.SaveStepList(request, getWxStepReponseItems);
return reponse;
```



#### 高级查询
##### 连表查询（查询主表的code）案例一
案例介绍：连表查询当前用户现在在开放的房间房间号，因为用户的信息在house_user_info表中，然而房间状态在house表中，所以这里需要连接查询将房号先查询出来，然后根据房号在去查询对应的用户信息
详解：这个就是靠本来的查询来查询数据的，但是针对字段列比较多的时候可能会出现比较麻烦列写错的情况，这里有地方将优化列的创建
        /// <summary>
        /// 获取当前正在进行中的房间号
        /// </summary>
        /// <returns></returns>
        public IList<string> GetCurrentHouseCodeByUserCode(string userCode)
        {
            //连表查询仓储
            
            var multReponsitroy = new SimpleJoinQueryRepositroy();
            string sql = "select  h.house_code as HouseCode from house h left join house_user_info on u on h.code=u.house_code where u.user_code=@userCode and h.house_status=@houseStatus ";
            var data = multReponsitroy.Query<string>("", sql,
                new { userCode = userCode, houseStatus = HouseStatusEnum.Open.ToInt() }
            );
            if (!data.Any())
            {
                return new List<string>();
            }
            return data.ToList();
        }
##### 连表查询(分页查询)
案例介绍：分页查询用户参与了开房的房间
        public PageReponse<HouseEntity> GetHousePageList(GetHouseRecordPageRequest request)
        {
            //连表查询仓储

            var multReponsitroy = new SimpleJoinQueryRepositroy();
            //判断是否使用了关联采购单关联表的查询          
            var joinCondition = new JoinPageQueryConditionRequest(request.PageNumber, request.RowsPerPage);
            var buildWhere = " and u.user_code=@userCode order by h.id desc";

            string orderBy = "order by h.id desc";
            joinCondition.AppendOrderBy(orderBy);

            string columns = "distinct h.code as Code,h.house_number as HouseNumber,h.house_status,h.settle_is_win,h.settle_score,h.create_time";
            joinCondition.AppendColumn(columns);

            joinCondition.AppendMainTable(" house h inner join house_user_info u on h.code=u.house_codeode ");

            joinCondition.SetParamter(new { userCode = request.UserCode });

            var data = multReponsitroy.PageQuery<HouseEntity>("", joinCondition);
            return data;
        }

打印sql 

###### JoinPageQueryConditionRequest 解析
new JoinPageQueryConditionRequest(request.PageNumber, request.RowsPerPage);  初始化的时候需要传入页数和页码。
AppendMainWhere 添加主表条件
AppendSideWhere 添副连接条件
AppendColumn  添加列
AppendOrderBy  添加排序规则
AppendMainTable 添加主表连接查询
AppendSideTable添加副连接查询
SetParamter  设置参数
PrintSql 打印sql
语句的颜色来介绍我们设置参数的位置
###### 语句一
语句一比较简单就是一个主表
AppendColumn  
AppendMainTable 
AppendMainWhere 
AppendOrderBy
```csharp
select  distinct h.id,h.code as Code,h.house_number as HouseNumber,h.house_status,h.settle_is_win,h.settle_score,h.create_time  from    house h inner join house_user_info u on h.code=u.house_code   where 1=1  and code='232323'  order by h.id desc limit 0,10
```


### 项目扩展
#### 针对通用Task任务扩展
##### 实现功能
针对同用户的task任务进行状态设置任务执行任务查询等逻辑
由于框架支持可以直接填写指定的字段名称则可以和容易的写一些例如基础字段非常确定的通用业务.

```csharp
public interface ITaskBusinessService
{
    Task SetTaskErrorStatus(SetTaskErrorStatusRequest request);

    Task<int> SetTaskStatus(SetTaskStatusRequest request, bool isClearErrorMsg = true);

    Task RunningTaskStatus(string taskCode);

    Task SuccessTaskStatus(string taskCode, long executeTime, bool isContinue);

    Task SuccessTaskStatus(string taskCode, string taskReponseId, long executeTime, bool isContinue);

    Task FailedTaskStatus(string taskCode, TaskErrorCodeEnum errorCode, long executeTime, string errorDetailMessage, bool isContinue);

    Task AddTask(string taskCode, AbsTaskParamRequest param, object taskType, TaskTriggerTypeEnum task, ITaskTriggerValue taskTriggerValue, string userCode, string taskDetailType = "");

    Task SaveTask(string taskCode, AbsTaskParamRequest param, object taskType, TaskTriggerTypeEnum taskTriggerType, ITaskTriggerValue taskTriggerValue, string userCode, string taskDetailType = "", TaskStatusEnum taskStatusEnum = TaskStatusEnum.None);

    Task CloseTask(string taskCode);

    Task<IList<GetTaskListReponse>> GetTaskList(object taskType, IColumns columns, TaskStatusEnum[] taskStatusEnum = null, TaskTriggerTypeEnum[] taskTriggerTypes = null);


    Task<GetTaskDetailReponse> GetTask(string taskCode, IColumns columns);


    Task AddTask(string taskCode, AbsTaskParamRequest param, object taskType, TaskTriggerTypeEnum task, ITaskTriggerValue taskTriggerValu, string responseId, string userCode, string taskDetailType = "");

    Task ExecuteTask(string taskCode, Action action, bool isContinue = false);

    Task<string> ExecuteAndAddTask(string taskCode, AbsTaskParamRequest request, object taskType, TaskTriggerTypeEnum task, ITaskTriggerValue taskTriggerValu, Func<Task<string>> action, string userCode, bool isContinue = false);

    Task<PageReponse<GetTaskRecordPageReponse>> GetTaskPage(GetTaskRecordPageRequest request, IColumns column = null);

    Task<bool> ExistTask(string taskCode, string userCode);

    Task<bool> LogicalDeleteTask(GetTaskCodeRequest request);
}
```

```csharp
/// <summary>
/// 任务业务服务
/// </summary>
/// <typeparam name="TEntity"></typeparam>
public class TaskBusinessService<TEntity> : ITaskBusinessService<TEntity>, IService where TEntity : TaskBusinessEntity, IEntity
{
    private TaskBusinessRepository<TEntity> _base_task_reponsitory;

    public TaskBusinessService()
    {
        _base_task_reponsitory = ServiceLocator.INSTANCE.GetSafeService<TaskBusinessRepository<TEntity>>();

    }
    public virtual async Task SetTaskErrorStatus(SetTaskErrorStatusRequest request)
    {
        await _base_task_reponsitory.SetTaskErrorStatus(request);
    }

    public virtual async Task<int> SetTaskStatus(SetTaskStatusRequest request, bool isClearErrorMsg = false)
    {
        return await _base_task_reponsitory.SetTaskStatus(request, isClearErrorMsg);
    }

    public virtual async Task RunningTaskStatus(string taskCode)
    {
        await _base_task_reponsitory.RunningTaskStatus(taskCode);

    }

    public virtual async Task SuccessTaskStatus(string taskCode, long executeTime, bool isContinue)
    {
        await _base_task_reponsitory.SuccessTaskStatus(taskCode, executeTime, isContinue);

    }

    public virtual async Task SuccessTaskStatus(string taskCode, string taskReponseId, long executeTime, bool isContinue)
    {
        await _base_task_reponsitory.SuccessTaskStatus(taskCode, taskReponseId, executeTime, isContinue);

    }

    public virtual async Task FailedTaskStatus(string taskCode, TaskErrorCodeEnum errorCode, long executeTime, string errorDetailMessage, bool isContinue)
    {
        await _base_task_reponsitory.FailedTaskStatus(taskCode, errorCode, executeTime, errorDetailMessage, isContinue);

    }

    public async Task AddTask(string taskCode, AbsTaskParamRequest param, object taskType, TaskTriggerTypeEnum task, ITaskTriggerValue taskTriggerValue, string userCode, string taskDetailType = "")
    {
        await _base_task_reponsitory.AddTask(taskCode, param, taskType, task, taskTriggerValue, userCode, taskDetailType: taskDetailType);
    }

    public async Task AddTask(string taskCode, AbsTaskParamRequest param, object taskType, TaskTriggerTypeEnum task, ITaskTriggerValue taskTriggerValue, string responseId, string userCode, string taskDetailType = "")
    {
        await _base_task_reponsitory.AddTask(taskCode, param, taskType, task, taskTriggerValue, responseId, taskDetailType: taskDetailType);
    }


    public async Task CloseTask(string taskCode)
    {

        await _base_task_reponsitory.CloseTask(taskCode);
    }

    public async Task SaveTask(string taskCode, AbsTaskParamRequest param, object taskType, TaskTriggerTypeEnum taskTriggerType, ITaskTriggerValue taskTriggerValue, string userCode, string taskDetailType = "", TaskStatusEnum taskStatusEnum = TaskStatusEnum.None)
    {

        await _base_task_reponsitory.SaveTask(taskCode, param, taskType, taskTriggerType, taskTriggerValue, userCode, taskDetailType: taskDetailType, taskStatusEnum: taskStatusEnum);
    }

    public async Task<IList<GetTaskListReponse>> GetTaskList(object taskType, IColumns columns, TaskStatusEnum[] taskStatusEnum = null, TaskTriggerTypeEnum[] taskTriggerTypes = null)
    {
        var tasks = await _base_task_reponsitory.GetTaskList(taskType, columns, taskStatusEnum, taskTriggerTypes);

        return tasks.ToList();
    }

    public async Task<GetTaskDetailReponse> GetTask(string taskCode, IColumns columns)
    {
        var tasks = await _base_task_reponsitory.GetTask(taskCode, columns);
        return tasks;
    }

    public async Task<bool> ExistTask(string taskCode,string userCode)
    {
        var tasks = await _base_task_reponsitory.ExistTask(taskCode, userCode);
        return tasks;
    }

    public async Task ExecuteTask(string taskCode, Action action, bool isContinue = false)
    {
        var watch = new Stopwatch();
        try
        {

            watch.Start();
            action.Invoke();
            await _base_task_reponsitory.SuccessTaskStatus(taskCode, watch.ElapsedMilliseconds, false);
            watch.Stop();
        }
        catch (Exception ex)
        {
            watch.Stop();
            await _base_task_reponsitory.FailedTaskStatus(taskCode, TaskErrorCodeEnum.SystemError, watch.ElapsedMilliseconds, ex.Message, isContinue);
        }
    }

    public async Task<string> ExecuteAndAddTask(string taskCode, AbsTaskParamRequest request, object taskType, TaskTriggerTypeEnum task, ITaskTriggerValue taskTriggerValue, Func<Task<string>> action, string userCode, bool isContinue = false)
    {
        var watch = new Stopwatch();
        try
        {
            var entity = await _base_task_reponsitory.GetTask(taskCode, new Columns(new string[] { "TaskCode", "TaskReponseId" }));
            if (entity != null)
            {
                //优先创建
                return entity.TaskReponseId;
            }
            else
            {
                await _base_task_reponsitory.AddTask(taskCode, request, taskType, task, taskTriggerValue, userCode);
            }

            var responseId = await action.Invoke();
            await _base_task_reponsitory.SuccessTaskStatus(taskCode, responseId == null ? "" : responseId, watch.ElapsedMilliseconds, isContinue);
            return responseId;
        }
        catch (Exception ex)
        {
            watch.Stop();
            await _base_task_reponsitory.FailedTaskStatus(taskCode, TaskErrorCodeEnum.SystemError, watch.ElapsedMilliseconds, ex.Message, isContinue);
            return "";
        }
    }

    public async Task<string> TimeOnceExecuteAndAddTask(AbsTaskParamRequest request, object taskType, Func<Task<string>> action, string userCode, double hour)
    {
        string taskCode = string.Empty;
        var watch = new Stopwatch();
        try
        {
            //这种是优先先查有没有这个数据 有就使用原有的
            var type = taskType.ToAliasName();
            var endTime = DateTime.Now;
            var startTime = endTime.AddHours(-hour);

            var entity = await _base_task_reponsitory.GetTask(userCode, type, new Columns(new string[] { "TaskCode", "TaskReponseId" }), startTime, endTime);
            if (entity != null)
            {
                taskCode = entity.TaskCode;
                //优先创建
                return entity.TaskReponseId;
            }
            else
            {
                taskCode = EntityIdGenerateUtils.CodeGenerate();
                await _base_task_reponsitory.AddTask(taskCode, request, taskType, TaskTriggerTypeEnum.Immediately, null, userCode);
            }

            var responseId = await action.Invoke();
            await _base_task_reponsitory.SuccessTaskStatus(taskCode, responseId == null ? "" : responseId, watch.ElapsedMilliseconds, false);
            return responseId;
        }
        catch (Exception ex)
        {
            watch.Stop();
            await _base_task_reponsitory.FailedTaskStatus(taskCode, TaskErrorCodeEnum.SystemError, watch.ElapsedMilliseconds, ex.Message, false);
            return "";
        }
    }



    public async Task<string> ExecuteAndAddTask(string taskCode, AbsTaskParamRequest request, object taskType, TaskTriggerTypeEnum task, ITaskTriggerValue taskTriggerValue, Func<ExecuteAndAddTaskParamCheckReponse, Task<bool>> paramCheckExecuteAction, Func<Task<string>> action, string userCode, bool isContinue = false)
    {
        var watch = new Stopwatch();
        try
        {
            var entity = await _base_task_reponsitory.GetTask(taskCode, new Columns(new string[] { "TaskCode", "TaskReponseId", "TaskReponseId", "TaskStatus", "TaskEndTime" }));
            if (entity != null)
            {
                var isExcute = await paramCheckExecuteAction.Invoke(new ExecuteAndAddTaskParamCheckReponse()
                {
                    TaskCode = taskCode,
                    TaskEndTime = entity.TaskEndTime,
                    ReponseId = entity.TaskReponseId,
                    TaskStatus = entity.TaskStatus
                });
                if (!isExcute)
                {
                    //优先创建
                    return entity.TaskReponseId;
                }
            }
            else
            {
                await _base_task_reponsitory.AddTask(taskCode, request, taskType, task, taskTriggerValue, userCode);
            }
            var responseId = await action.Invoke();
            await _base_task_reponsitory.SuccessTaskStatus(taskCode, responseId == null ? "" : responseId, watch.ElapsedMilliseconds, isContinue);
            return responseId;
        }
        catch (Exception ex)
        {
            watch.Stop();
            await _base_task_reponsitory.FailedTaskStatus(taskCode, TaskErrorCodeEnum.SystemError, watch.ElapsedMilliseconds, ex.Message, isContinue);
            return "";
        }
    }

    public async Task<PageReponse<GetTaskRecordPageReponse>> GetTaskPage(GetTaskRecordPageRequest request, IColumns column = null)
    {
        return await _base_task_reponsitory.GetTaskPage(request, column: column);
    }

    public async Task<bool> LogicalDeleteTask(GetTaskCodeRequest request)
    {

        return await _base_task_reponsitory.LogicalDeleteTask(request);
    }
```

部分仓储层
```csharp
public async Task<PageReponse<GetTaskRecordPageReponse>> GetTaskPage(GetTaskRecordPageRequest request, IColumns column = null)
{
    if (column == null)
    {
        column = new Columns(new string[] { "TaskCode", "TaskStatus", "CreateTime", "TaskEndTime", "TaskParam" });
    }
    var selectColumn = new SelectColumn(column);
    var where = new ComplexWhere();
    if (request.TaskStatus != null && request.TaskStatus.Any())
    {
        where.In("TaskStatus", request.TaskStatus.Select(a => a.ToDbAliasName()).ToArray
            ());
    }
    if (request.TaskTriggerTypes != null && request.TaskTriggerTypes.Any())
    {
        where.In("TaskTriggerType", request.TaskTriggerTypes.Select(a => a.ToDbAliasName()).ToArray
           ());
    }

    where.Eq("TaskType", request.TaskType);

    where.Eq("TaskCreateUserId", request.UserCode);
    where.Eq("Status", (int)DeleteStatusEnum.Normal);
    var data = await _reponsitory.GetPageList(selectColumn, where, request.PageNumber, request.RowsPerPage,order:new OrderBy("create_time", OrderByConditionType.Desc));

    var rows = data.Rows.Maps<TEntity, GetTaskRecordPageReponse>();

    return data.ConverEntitys(rows);
}
```