标签：批量 ddc uri lse reading 循环 标识 基于接口 基础
现有项目中的orm 并非efcore，而是非主流的npoco，本身没有自带工作单元所以需要自己手撸一个，现记录一下,基于其他orm的工作单元照例实现应该没有什么问题
该实现基于NPOCO，针对其他的ORM实现，所有的实现都基于接口，如需转成其他ORM，只需要将部分实现类重写即可，如UnitOfWorkImpl
实体基类，所有实体继承该类
namespace test.Core
{
/// <summary>
/// 实体基类
/// </summary>
public class EntityBase
{
/// <summary>
/// 唯一标识
/// </summary>
public long Id { get; set; }
public EntityBase()
{
// Id = GeneratePrimaryKeyIdHelper.GetPrimaryKeyId();
}
}
}
自定义的事务接口实现类
using test.Core;
using NPoco;
using System.Data;
namespace test.DAL
{
internal class DBTransactionImpl : IDBTransaction
{
IDatabase db;
public DBTransaction(IDatabase db)
{
this.db = db;
this.db.BeginTransaction();
}
public virtual void Complete()
{
db.CompleteTransaction();
db = null;
}
public void Dispose()
{
if (db != null)
{
db.AbortTransaction();
}
}
}
}
事务接口
using System;
namespace test.Core
{
public interface IDBTransaction : IDisposable
{
void Complete();
}
}
仓储接口：命令类（提交数据的接口，不包含查询的服务）
using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using test.Core;
namespace test.IDAL
{
public interface ICommandBaseRepository
{
#region 新增
/// <summary>
/// 插入实体
/// </summary>
Task<object> InsertAsync<T>(T entity) where T : EntityBase;
/// <summary>
/// 批量插入实体
/// </summary>
Task<bool> InsertBatchAsync<T>(IList<T> entities) where T : EntityBase;
#endregion
#region 更新
/// <summary>
/// 更新单个实体
/// </summary>
Task<bool> UpdateAsync<T>(T entity) where T : EntityBase;
/// <summary>
/// 根据实体更新部分字段
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="entity"></param>
/// <param name="fields"></param>
/// <returns></returns>
Task<bool> UpdateAsync<T>(T entity, Expression<Func<T, object>> fields) where T : EntityBase;
/// <summary>
/// 更新实体的部分字段
/// </summary>
/// <param name="entity"></param>
/// <param name="columns"></param>
/// <returns></returns>
Task<bool> UpdateAsync<T>(T entity, IList<string> columns) where T : EntityBase;
/// <summary>
/// 更新多个实体
/// </summary>
/// <param name="entities"></param>
/// <returns></returns>
Task<bool> UpdateBatchAsync<T>(IList<T> entities) where T : EntityBase;
/// <summary>
/// 根据id集合更新多个记录的某个字段
/// </summary>
/// <typeparam name="TPrimaryKeyType">主键值类型 long，int等</typeparam>
/// <typeparam name="TColunmValue">字段值类型 long，int等</typeparam>
/// <param name="idList">id集合</param>
/// <param name="column">字段数据，key字段名，value字段值</param>
/// <returns></returns>
Task<bool> UpdateSingleFieldByIdsAsync<TPrimaryKeyType, TColunmValue>(IList<TPrimaryKeyType> idList, KeyValuePair<string, TColunmValue> column);
/// <summary>
/// 保存实体，有则更新，无则新增
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
Task<bool> SaveAsync<T>(T entity) where T : EntityBase;
#endregion
#region 删除
/// <summary>
/// 逻辑删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task<bool> SoftDeleteAsync<TPrimaryKeyType>(TPrimaryKeyType id);
/// <summary>
/// 逻辑删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
Task<bool> SoftDeleteBatchAsync<TPrimaryKeyType>(IList<TPrimaryKeyType> id);
/// <summary>
/// 删除记录
/// </summary>
// Task<bool> DeleteAsync<TPrimaryKeyType>(TPrimaryKeyType id);
/// <summary>
/// 批量删除记录
/// </summary>
// Task<bool> DeleteBatchAsync<TPrimaryKeyType>(IList<TPrimaryKeyType> idList);
#endregion
#region 事务模块
/// <summary>
/// 开始事务（返回事务对象）
/// </summary>
/// <returns></returns>
IDBTransaction BeginDBTransaction();
/// <summary>
/// 开启事务（不返回事务对象）
/// </summary>
/// <returns></returns>
void BeginNewDBTransaction();
/// <summary>
/// 提交事务事务
/// </summary>
void CompleteDBTransaction();
/// <summary>
/// 中断结束事务
/// </summary>
void AbortDBTransaction();
#endregion
}
}
仓储接口：查询仓储服务
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
namespace test.IDAL
{
public interface IQueryBaseRepository
{
/// <summary>
/// 获得单条数据
/// </summary>
/// <typeparam name="TPrimaryKeyType"></typeparam>
/// <param name="id"></param>
/// <returns></returns>
Task<T> GetAsync<T, TPrimaryKeyType>(TPrimaryKeyType id);
/// <summary>
/// 根据id集合获取多条数据
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TPrimaryKeyType"></typeparam>
/// <param name="ids"></param>
/// <returns></returns>
Task<List<T>> GetListByIdsAsync<T, TPrimaryKeyType>(List<TPrimaryKeyType> ids);
/// <summary>
/// 根据某个唯一字段列获取单条数据(唯一值)
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TColunmValue"></typeparam>
/// <param name="column"></param>
/// <returns></returns>
Task<T> GetSingleAsync<T, TColunmValue>(KeyValuePair<string, TColunmValue> column);
/// <summary>
/// 根据主键是否存在记录
/// </summary>
Task<bool> ExistsAsync<TPrimaryKeyType>(TPrimaryKeyType id);
/// <summary>
/// 某个字段是否唯一
/// </summary>
/// <typeparam name="TColunmValue"></typeparam>
/// <param name="column"></param>
/// <returns>true 唯一 false 不唯一</returns>
Task<bool> IsUniqueAsync<TColunmValue>(KeyValuePair<string, TColunmValue> column);
}
}
工作单元接口
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using test.Core;
namespace test.IDAL
{
public interface IUnitOfWork
{
/// <summary>
/// 插入
/// </summary>
/// <param name="entity"></param>
/// <param name="unitofWorkRepository"></param>
void RegisterInsert(EntityBase entity, ICommandBaseRepository unitofWorkRepository);
/// <summary>
/// 保存，不支持多个同一类实体（同一个类型实体只能添加一个，否则会异常）
/// </summary>
/// <param name="entity"></param>
/// <param name="unitofWorkRepository"></param>
void RegisterSave(EntityBase entity, ICommandBaseRepository unitofWorkRepository);
/// <summary>
/// 更新
/// </summary>
/// <param name="entity"></param>
/// <param name="unitofWorkRepository"></param>
void RegisterUpdate(EntityBase entity, ICommandBaseRepository unitofWorkRepository);
/// <summary>
/// 删除
/// </summary>
/// <param name="id"></param>
/// <param name="unitofWorkRepository"></param>
void RegisterDelete(object id, ICommandBaseRepository unitofWorkRepository);
/// <summary>
/// 根据字段更新
/// </summary>
/// <param name="entity"></param>
/// <param name="fields"></param>
/// <param name="unitofWorkRepository"></param>
void RegisterUpdateByFields(EntityBase entity, IList<string> fields, ICommandBaseRepository unitofWorkRepository);
/// <summary>
/// 根据id集合更新单个字段
/// </summary>
/// <param name="id"></param>
/// <param name="column"></param>
/// <param name="unitofWorkRepository"></param>
void RegisterUpdateSingleFieldByIds(IList<object> id, KeyValuePair<string, object> column, ICommandBaseRepository unitofWorkRepository);
Task CommitAsync();
}
}
自定义的获取db对象接口，保证一个请求内db是同一个对象即可，可通过依赖注入的addscoped实现
using test.DAL.Repositories;
using System;
using System.Collections.Generic;
using System.Text;
namespace test.DAL
{
internal interface IScopeDBFactory
{
CustomDatabase GetScopeDb();
}
}
IScopeDBFactory 实现类，自行实现即可
using MySql.Data.MySqlClient;
using test.Core;
using NPoco;
using NPoco.FluentMappings;
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Reflection;
using System.Text;
namespace test.DAL.Repositories
{
internal class ScopeDBFactoryImpl : IScopeDBFactory
{
protected CustomDatabase Db;
public CustomDatabase GetScopeDb()
{
}
}
}
unitofwork 接口实现
using test.Core;
using test.DAL;
using test.DAL.Repositories;
using test.IDAL;
using NPoco;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;
namespace test.DAL
{
internal class UnitOfWorkImpl : IUnitOfWork
{
private Dictionary<ICommandBaseRepository, List<EntityBase>> addedEntities;
private Dictionary<ICommandBaseRepository, List<EntityBase>> changedEntities;
private Dictionary<ICommandBaseRepository, List<object>> deletedEntities;
private Dictionary<ICommandBaseRepository, EntityBase> saveEntity;
private Dictionary<ICommandBaseRepository, List<UpdatePartFieldModel>> changedPartFieldEntityList;
private Dictionary<ICommandBaseRepository, List<UpdateSingleFieldByIdsModel>> changedPartByIdsEntityList;
private readonly IScopeDBFactory scopeDBFactory;
public UnitOfWorkImpl(IScopeDBFactory scopeDBFactory)
{
addedEntities = new Dictionary<ICommandBaseRepository, List<EntityBase>>();
changedEntities = new Dictionary<ICommandBaseRepository, List<EntityBase>>();
deletedEntities = new Dictionary<ICommandBaseRepository, List<object>>();
saveEntity = new Dictionary<ICommandBaseRepository, EntityBase>();
changedPartFieldEntityList = new Dictionary<ICommandBaseRepository, List<UpdatePartFieldModel>>();
changedPartByIdsEntityList = new Dictionary<ICommandBaseRepository, List<UpdateSingleFieldByIdsModel>>();
this.scopeDBFactory = scopeDBFactory;
}
public void RegisterInsert(EntityBase entity, ICommandBaseRepository unitofWorkRepository)
{
if (!addedEntities.ContainsKey(unitofWorkRepository))
{
addedEntities.Add(unitofWorkRepository, new List<EntityBase>() { entity });
}
else
{
List<EntityBase> list = addedEntities[unitofWorkRepository];
if (!list.Contains(entity))
{
addedEntities[unitofWorkRepository].Add(entity);
}
}
}
public void RegisterSave(EntityBase entity, ICommandBaseRepository unitofWorkRepository)
{
if (!saveEntity.ContainsKey(unitofWorkRepository))
{
saveEntity.Add(unitofWorkRepository, entity);
}
else
{
throw new Exception("不能重复添加");
}
}
public void RegisterUpdate(EntityBase entity, ICommandBaseRepository unitofWorkRepository)
{
if (!changedEntities.ContainsKey(unitofWorkRepository))
{
changedEntities.Add(unitofWorkRepository, new List<EntityBase>() { entity });
}
else
{
List<EntityBase> list = changedEntities[unitofWorkRepository];
if (!list.Contains(entity))
{
changedEntities[unitofWorkRepository].Add(entity);
}
}
}
public void RegisterUpdateByFields(EntityBase entity, IList<string> fields, ICommandBaseRepository unitofWorkRepository)
{
var updatePartModel = new UpdatePartFieldModel();
updatePartModel.Entity = entity;
updatePartModel.Fields = fields;
if (!changedPartFieldEntityList.ContainsKey(unitofWorkRepository))
{
changedPartFieldEntityList.Add(unitofWorkRepository, new List<UpdatePartFieldModel>() { updatePartModel });
}
else
{
List<UpdatePartFieldModel> list = changedPartFieldEntityList[unitofWorkRepository];
if (!list.Contains(updatePartModel))
{
changedPartFieldEntityList[unitofWorkRepository].Add(updatePartModel);
}
}
}
public void RegisterUpdateSingleFieldByIds(IList<object> idList, KeyValuePair<string, object> column, ICommandBaseRepository unitofWorkRepository)
{
var updateSingleFieldByIdModel = new UpdateSingleFieldByIdsModel();
updateSingleFieldByIdModel.IdList = idList;
updateSingleFieldByIdModel.Column = column;
if (!changedPartByIdsEntityList.ContainsKey(unitofWorkRepository))
{
changedPartByIdsEntityList.Add(unitofWorkRepository, new List<UpdateSingleFieldByIdsModel>() { updateSingleFieldByIdModel });
}
else
{
List<UpdateSingleFieldByIdsModel> list = changedPartByIdsEntityList[unitofWorkRepository];
if (!list.Contains(updateSingleFieldByIdModel))
{
changedPartByIdsEntityList[unitofWorkRepository].Add(updateSingleFieldByIdModel);
}
}
}
public void RegisterDelete(object id, ICommandBaseRepository unitofWorkRepository)
{
if (!deletedEntities.ContainsKey(unitofWorkRepository))
{
deletedEntities.Add(unitofWorkRepository, new List<object>() { id });
}
else
{
List<object> list = deletedEntities[unitofWorkRepository];
if (!list.Contains(id))
{
deletedEntities[unitofWorkRepository].Add(id);
}
}
}
/// <summary>
/// 开启事务
/// </summary>
/// <returns></returns>
private DBTransaction BeginNewDBTransaction(CustomDatabase db)
{
var scopeTransaction = new DBTransaction(db);
return scopeTransaction;
}
public async Task CommitAsync()
{
//获得db对象 一个请求db是同一个
var db = scopeDBFactory.GetScopeDb();
using (var scope = BeginNewDBTransaction(db))
{
///插入新增的实体
foreach (var repository in this.addedEntities.Keys)
{
var entityList = addedEntities[repository];
if (entityList.Count > 1)
{
await repository.InsertBatchAsync(entityList).ConfigureAwait(false);
}
else
{
await repository.InsertAsync(entityList[0]).ConfigureAwait(false);
}
}
///保存实体 有则更新 无则删除
foreach (var repository in this.saveEntity.Keys)
{
var entity = saveEntity[repository];
await repository.SaveAsync(entity).ConfigureAwait(false);
}
//更新需要修改的实体
foreach (var repository in this.changedEntities.Keys)
{
var entityList = changedEntities[repository];
if (entityList.Count > 1)
{
await repository.UpdateBatchAsync(entityList).ConfigureAwait(false);
}
else
{
await repository.UpdateAsync(entityList[0]).ConfigureAwait(false);
}
}
///更新根据字段更新的实体
foreach (var repository in this.changedPartFieldEntityList.Keys)
{
var updateModelList = changedPartFieldEntityList[repository];
foreach (var updateModel in updateModelList)
{
await repository.UpdateAsync(updateModel.Entity, updateModel.Fields).ConfigureAwait(false);
}
}
///更新根据id集合更新的数据实体
foreach (var repository in this.changedPartByIdsEntityList.Keys)
{
var updateModelList = changedPartByIdsEntityList[repository];
foreach (var updateModel in updateModelList)
{
await repository.UpdateSingleFieldByIdsAsync(updateModel.IdList, updateModel.Column).ConfigureAwait(false);
}
}
///删除实体
foreach (var repository in this.deletedEntities.Keys)
{
var entityList = deletedEntities[repository];
if (entityList.Count > 1)
{
await repository.SoftDeleteBatchAsync(entityList).ConfigureAwait(false);
}
else
{
await repository.SoftDeleteAsync(entityList[0]).ConfigureAwait(false);
}
}
scope.Complete();
addedEntities.Clear();
changedEntities.Clear();
deletedEntities.Clear();
saveEntity.Clear();
changedPartFieldEntityList.Clear();
changedPartByIdsEntityList.Clear();
}
}
}
}
namespace test.DAL
{
internal class UpdatePartFieldModel
{
public EntityBase Entity { get; set; }
public IList<string> Fields { get; set; }
}
internal class UpdateSingleFieldByIdsModel
{
public IList<object> IdList { get; set; }
public KeyValuePair<string, object> Column { get; set; }
}
}
针对批量删除、批量修改等各种操作，根据各个业务多一层封装UnitOfWork，减少提交工作单元时各种循环，不想要的也可以去掉
以customer业务表为例代码
如下：
namespace test.IDAL
{
public interface ICommandCustomerRepository : ICommandBaseRepository
{
}
}
客户服务仓储单元接口
namespace test.IDAL
{
public interface ICustomerUnitOfWork
{
void RegisterInsert(CustomerEntity entity);
void RegisterInsertBatch(IList<CustomerEntity> entities);
void RegisterUpdate(CustomerEntity entity);
void RegisterUpdateBatch(IList<CustomerEntity> entities);
void RegisterUpdateByFields(CustomerEntity entity,List<string> fields);
void RegisterUpdateSingleFieldByIds(IList<long> idList, KeyValuePair<string, object> column);
void RegisterDelete(long id);
void RegisterDeleteBatch(IList<long> idList);
Task CommitAsync();
}
}
客户实体
namespace test.Entity
{
/// <summary>
/// 基础数据-客户信息
/// </summary>
[MyTableName("Customer")]
[MyPrimaryKey("Id", AutoIncrement = false)]
public class CustomerEntity : EntityBase
{
/// <summary>
/// 客户名称
/// </summary>
public string Name { get; set; }
/// <summary>
/// 客户code
/// </summary>
///
public string Code { get; set; }
/// <summary>
/// 是否可用 0 否 1是
/// </summary>
public bool? IsEnabled { get; set; }
/// <summary>
/// 邮箱
/// </summary>
public string Email { get; set; }
/// <summary>
/// 传真
/// </summary>
public string Fax { get; set; }
/// <summary>
/// 联系人
/// </summary>
public string ContactPerson { get; set; }
/// <summary>
/// 联系人电话
/// </summary>
public string ContactTelphone { get; set; }
/// <summary>
/// 地址
/// </summary>
public string Address { get; set; }
/// <summary>
/// 备注
/// </summary>
public string Remark { get; set; }
}
}
客户服务工作单元实现
namespace test.DAL
{
internal class CustomerUnitOfWorkImpl:ICustomerUnitOfWork , IAutoInject
{
private readonly IUnitOfWork unitOfWork;
private readonly ICommandCustomerRepository commandRepository;
public CustomerUnitOfWorkImpl(ICommandCustomerRepository commandRepository, IUnitOfWork unitOfWork)
{
this.commandRepository = commandRepository;
this.unitOfWork = unitOfWork;
}
public void RegisterInsert(CustomerEntity entity)
{
unitOfWork.RegisterInsert(entity, commandRepository);
}
public void RegisterInsertBatch(IList<CustomerEntity> entities)
{
foreach (var entity in entities)
{
unitOfWork.RegisterInsert(entity, commandRepository);
}
}
public void RegisterUpdate(CustomerEntity entity)
{
unitOfWork.RegisterUpdate(entity, commandRepository);
}
public void RegisterUpdateBatch(IList<CustomerEntity> entities)
{
foreach (var entity in entities)
{
unitOfWork.RegisterUpdate(entity, commandRepository);
}
}
public void RegisterUpdateByFields(CustomerEntity entity, List<string> fields)
{
unitOfWork.RegisterUpdateByFields(entity, fields, commandRepository);
}
public void RegisterUpdateSingleFieldByIds(IList<long> idList, KeyValuePair<string, object> column)
{
unitOfWork.RegisterUpdateSingleFieldByIds(idList, column, commandRepository);
}
public void RegisterDelete(long entity)
{
unitOfWork.RegisterDelete(entity, commandRepository);
}
public void RegisterDeleteBatch(IList<long> entities)
{
foreach (var entity in entities)
{
unitOfWork.RegisterDelete(entity, commandRepository);
}
}
public async Task CommitAsync()
{
await unitOfWork.CommitAsync().ConfigureAwait(false);
}
}
}
客户服务接口
namespace test.IBLL.Basic
{
public interface ICommandCustomerService
{
/// <summary>
/// 插入单个实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
Task<HttpResponseResultModel<long>> InsertAsync(CustomerEntity entity,bool isCommit = true);
/// <summary>
/// 批量插入实体
/// </summary>
/// <param name="entityList"></param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> InsertBatchAsync(List<CustomerEntity> entityList,bool isCommit = true);
/// <summary>
/// 根据主键更新实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> UpdateAsync(CustomerEntity entity,bool isCommit = true);
/// <summary>
/// 更新实体的部分字段
/// </summary>
/// <param name="entity"></param>
/// <param name="columns"></param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> UpdateFieldsAsync(CustomerEntity entity, List<string> fields, bool isCommit = true);
/// <summary>
/// 根据id集合更新某个字段更新
/// </summary>
/// <param name="idList"></param>
/// <param name="column"></param>
/// <param name="isCommit"></param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> UpdateSingleFieldByIdsAsync(List<long> idList, KeyValuePair<string, object> column, bool isCommit = true);
/// <summary>
/// 根据主键批量更新实体
/// </summary>
/// <param name="entityList">实体集合</param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> UpdateBatchAsync(List<CustomerEntity> entityList,bool isCommit = true);
/// <summary>
/// 根据根据主键删除
/// </summary>
/// <param name="id">主键</param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> DeleteAsync(long id,bool isCommit = true);
/// <summary>
/// 批量删除 根据主键
/// </summary>
/// <param name="idList">主键集合</param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> DeleteBatchAsync(IList<long> idList,bool isCommit = true);
/// <summary>
/// 保存实体，有则更新，无则新增
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
Task<HttpResponseResultModel<bool>> SaveAsync(CustomerEntity entity,bool isCommit = true);
}
}
客户服务接口实现
namespace test.BLL.Basic
{
internal class CommandCustomerServiceImpl : ICommandCustomerService, IAutoInject
{
private readonly ICustomerUnitOfWork unitOfWork;
public CommandCustomerServiceImpl(ICustomerUnitOfWork unitOfWork)
{
this.unitOfWork = unitOfWork;
}
#region 插入
/// <summary>
/// 插入单个实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task<HttpResponseResultModel<long>> InsertAsync(CustomerEntity entity,bool isCommit = true)
{
HttpResponseResultModel<long> httpResponseResultModel = new HttpResponseResultModel<long> { IsSuccess = false };
unitOfWork.RegisterInsert(entity);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.BackResult = entity.Id;
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
/// <summary>
/// 批量插入实体
/// </summary>
/// <param name="entityList"></param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> InsertBatchAsync(List<CustomerEntity> entityList,bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
unitOfWork.RegisterInsertBatch(entityList);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.BackResult = true;
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
#endregion
#region 更新
/// <summary>
/// 根据主键更新实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> UpdateAsync(CustomerEntity entity,bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
unitOfWork.RegisterUpdate(entity);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
/// <summary>
/// 批量更新实体
/// </summary>
/// <param name="entityList"></param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> UpdateBatchAsync(List<CustomerEntity> entityList,bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
unitOfWork.RegisterUpdateBatch(entityList);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
/// <summary>
/// 更新实体的部分字段
/// </summary>
/// <param name="entity"></param>
/// <param name="columns"></param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> UpdateFieldsAsync(CustomerEntity entity, List<string> fields, bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
unitOfWork.RegisterUpdateByFields(entity, fields);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
/// <summary>
/// 根据id集合更新某个字段更新
/// </summary>
/// <param name="idList"></param>
/// <param name="column"></param>
/// <param name="isCommit"></param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> UpdateSingleFieldByIdsAsync(List<long> idList, KeyValuePair<string, object> column, bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
unitOfWork.RegisterUpdateSingleFieldByIds(idList, column);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
#endregion
#region 删除
/// <summary>
/// 根据根据主键删除
/// </summary>
/// <param name="id">主键</param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> DeleteAsync(long id,bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
unitOfWork.RegisterDelete(id);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
/// <summary>
/// 批量删除 根据主键
/// </summary>
/// <param name="idList">主键集合</param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> DeleteBatchAsync(IList<long> idList,bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
unitOfWork.RegisterDeleteBatch(idList);
if (isCommit)
{
await CommitAsync();
}
httpResponseResultModel.IsSuccess = true;
return httpResponseResultModel;
}
#endregion
/// <summary>
/// 保存实体，有则更新，无则新增
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public async Task<HttpResponseResultModel<bool>> SaveAsync(CustomerEntity entity,bool isCommit = true)
{
HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
return httpResponseResultModel;
}
#region 事务
/// <summary>
/// 事务
/// </summary>
/// <returns></returns>
public async Task CommitAsync()
{
await unitOfWork.CommitAsync().ConfigureAwait(false);
}
#endregion
}
}
using System.Net;
namespace test.Core
{
/// <summary>
/// http请求结果类
/// </summary>
/// <typeparam name="T"></typeparam>
public class HttpResponseResultModel<T>
{
/// <summary>
/// http码
/// </summary>
public HttpStatusCode HttpStatusCode { get; set; }
/// <summary>
/// 是否成功
/// </summary>
public bool IsSuccess { get; set; }
/// <summary>
/// 返回结果
/// </summary>
public T BackResult { get; set; }
/// <summary>
/// 错误信息
/// </summary>
public string ErrorMessage { get; set; }
/// <summary>
/// 异常信息
/// </summary>
public string ExceptionMessage { get; set; }
}
}
.NET Core 工作单元unitofwork 实现，基于NPOCO
标签：批量 ddc uri lse reading 循环 标识 基于接口 基础
原文地址：https://www.cnblogs.com/binbinxu/p/13061726.html
