现有项目中的orm 并非efcore，而是非主流的npoco，本身没有自带工作单元所以需要自己手撸一个，现记录一下,基于其他orm的工作单元照例实现应该没有什么问题

该实现基于NPOCO，针对其他的ORM实现，所有的实现都基于接口，如需转成其他ORM，只需要将部分实现类重写即可，如UnitOfWorkImpl

实体基类，所有实体继承该类

  1. namespace test.Core
  2. {
  3.     /// <summary>
  4.     /// 实体基类
  5.     /// </summary>
  6.     public class EntityBase
  7.     {
  8.         /// <summary>
  9.         /// 唯一标识
  10.         /// </summary>
  11.         public long Id { get; set; }
  12.  
  13.         public EntityBase()
  14.         {
  15.            // Id = GeneratePrimaryKeyIdHelper.GetPrimaryKeyId();
  16.         }
  17.     }
  18. }

自定义的事务接口实现类

  1. using test.Core;
  2. using NPoco;
  3. using System.Data;
  4.  
  5. namespace test.DAL
  6. {
  7.     internal class DBTransactionImpl : IDBTransaction
  8.     {
  9.         IDatabase db;
  10.  
  11.         public DBTransaction(IDatabase db)
  12.         {
  13.             this.db = db;
  14.             this.db.BeginTransaction();
  15.         }
  16.  
  17.         public virtual void Complete()
  18.         {
  19.             db.CompleteTransaction();
  20.             db = null;
  21.         }
  22.  
  23.         public void Dispose()
  24.         {
  25.             if (db != null)
  26.             {
  27.                 db.AbortTransaction();
  28.             }
  29.         }
  30.  
  31.     }
  32. }

事务接口

  1. using System;
  2.  
  3. namespace test.Core
  4. {
  5.     public interface IDBTransaction : IDisposable
  6.     {
  7.         void Complete();
  8.     }
  9. }

　　

仓储接口：命令类（提交数据的接口，不包含查询的服务）

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq.Expressions;
  4. using System.Text;
  5. using System.Threading.Tasks;
  6. using test.Core;
  7.  
  8. namespace test.IDAL
  9. {
  10.     public interface ICommandBaseRepository
  11.     {
  12.         #region 新增
  13.         /// <summary>
  14.         /// 插入实体
  15.         /// </summary>
  16.         Task<object> InsertAsync<T>(T entity) where T : EntityBase;
  17.  
  18.         /// <summary>
  19.         /// 批量插入实体
  20.         /// </summary>
  21.         Task<bool> InsertBatchAsync<T>(IList<T> entities) where T : EntityBase;
  22.         #endregion
  23.  
  24.         #region 更新
  25.         /// <summary>
  26.         /// 更新单个实体
  27.         /// </summary>
  28.         Task<bool> UpdateAsync<T>(T entity) where T : EntityBase;
  29.  
  30.         /// <summary>
  31.         /// 根据实体更新部分字段
  32.         /// </summary>
  33.         /// <typeparam name="T"></typeparam>
  34.         /// <param name="entity"></param>
  35.         /// <param name="fields"></param>
  36.         /// <returns></returns>
  37.         Task<bool> UpdateAsync<T>(T entity, Expression<Func<T, object>> fields) where T : EntityBase;
  38.  
  39.         /// <summary>
  40.         /// 更新实体的部分字段
  41.         /// </summary>
  42.         /// <param name="entity"></param>
  43.         /// <param name="columns"></param>
  44.         /// <returns></returns>
  45.         Task<bool> UpdateAsync<T>(T entity, IList<string> columns) where T : EntityBase;
  46.  
  47.         /// <summary>
  48.         /// 更新多个实体
  49.         /// </summary>
  50.         /// <param name="entities"></param>
  51.         /// <returns></returns>
  52.         Task<bool> UpdateBatchAsync<T>(IList<T> entities) where T : EntityBase;
  53.  
  54.         /// <summary>
  55.         /// 根据id集合更新多个记录的某个字段
  56.         /// </summary>
  57.         /// <typeparam name="TPrimaryKeyType">主键值类型 long，int等</typeparam>
  58.         /// <typeparam name="TColunmValue">字段值类型 long，int等</typeparam>
  59.         /// <param name="idList">id集合</param>
  60.         /// <param name="column">字段数据，key字段名，value字段值</param>
  61.         /// <returns></returns>
  62.         Task<bool> UpdateSingleFieldByIdsAsync<TPrimaryKeyType, TColunmValue>(IList<TPrimaryKeyType> idList, KeyValuePair<string, TColunmValue> column);
  63.  
  64.         /// <summary>
  65.         /// 保存实体，有则更新，无则新增
  66.         /// </summary>
  67.         /// <param name="entity"></param>
  68.         /// <returns></returns>
  69.         Task<bool> SaveAsync<T>(T entity) where T : EntityBase;
  70.  
  71.         #endregion
  72.  
  73.         #region 删除
  74.  
  75.         /// <summary>
  76.         /// 逻辑删除
  77.         /// </summary>
  78.         /// <param name="id"></param>
  79.         /// <returns></returns>
  80.         Task<bool> SoftDeleteAsync<TPrimaryKeyType>(TPrimaryKeyType id);
  81.  
  82.         /// <summary>
  83.         /// 逻辑删除
  84.         /// </summary>
  85.         /// <param name="id"></param>
  86.         /// <returns></returns>
  87.         Task<bool> SoftDeleteBatchAsync<TPrimaryKeyType>(IList<TPrimaryKeyType> id);
  88.  
  89.         /// <summary>
  90.         /// 删除记录
  91.         /// </summary>
  92.         // Task<bool> DeleteAsync<TPrimaryKeyType>(TPrimaryKeyType id);
  93.  
  94.         /// <summary>
  95.         /// 批量删除记录
  96.         /// </summary>
  97.         //  Task<bool> DeleteBatchAsync<TPrimaryKeyType>(IList<TPrimaryKeyType> idList);
  98.  
  99.         #endregion
  100.  
  101.         #region 事务模块
  102.         /// <summary>
  103.         /// 开始事务（返回事务对象）
  104.         /// </summary>
  105.         /// <returns></returns>
  106.         IDBTransaction BeginDBTransaction();
  107.  
  108.         /// <summary>
  109.         /// 开启事务（不返回事务对象）
  110.         /// </summary>
  111.         /// <returns></returns>
  112.         void BeginNewDBTransaction();
  113.  
  114.         /// <summary>
  115.         /// 提交事务事务
  116.         /// </summary>
  117.         void CompleteDBTransaction();
  118.  
  119.         /// <summary>
  120.         /// 中断结束事务
  121.         /// </summary>
  122.         void AbortDBTransaction();
  123.  
  124.         #endregion
  125.     }
  126. }

　

仓储接口：查询仓储服务

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Threading.Tasks;
  5.  
  6. namespace test.IDAL
  7. {
  8.     public interface IQueryBaseRepository
  9.     {
  10.         /// <summary>
  11.         /// 获得单条数据
  12.         /// </summary>
  13.         /// <typeparam name="TPrimaryKeyType"></typeparam>
  14.         /// <param name="id"></param>
  15.         /// <returns></returns>
  16.         Task<T> GetAsync<T, TPrimaryKeyType>(TPrimaryKeyType id);
  17.  
  18.         /// <summary>
  19.         /// 根据id集合获取多条数据
  20.         /// </summary>
  21.         /// <typeparam name="T"></typeparam>
  22.         /// <typeparam name="TPrimaryKeyType"></typeparam>
  23.         /// <param name="ids"></param>
  24.         /// <returns></returns>
  25.         Task<List<T>> GetListByIdsAsync<T, TPrimaryKeyType>(List<TPrimaryKeyType> ids);
  26.  
  27.         /// <summary>
  28.         /// 根据某个唯一字段列获取单条数据(唯一值)
  29.         /// </summary>
  30.         /// <typeparam name="T"></typeparam>
  31.         /// <typeparam name="TColunmValue"></typeparam>
  32.         /// <param name="column"></param>
  33.         /// <returns></returns>
  34.         Task<T> GetSingleAsync<T, TColunmValue>(KeyValuePair<string, TColunmValue> column);
  35.  
  36.         /// <summary>
  37.         /// 根据主键是否存在记录
  38.         /// </summary>
  39.         Task<bool> ExistsAsync<TPrimaryKeyType>(TPrimaryKeyType id);
  40.  
  41.         /// <summary>
  42.         ///  某个字段是否唯一
  43.         /// </summary>
  44.         /// <typeparam name="TColunmValue"></typeparam>
  45.         /// <param name="column"></param>
  46.         /// <returns>true  唯一  false 不唯一</returns>
  47.         Task<bool> IsUniqueAsync<TColunmValue>(KeyValuePair<string, TColunmValue> column);
  48.  
  49.     }
  50. }

　

工作单元接口

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Text;
  4. using System.Threading.Tasks;
  5. using test.Core;
  6.  
  7. namespace test.IDAL
  8. {
  9.     public interface IUnitOfWork
  10.     {
  11.         /// <summary>
  12.         /// 插入
  13.         /// </summary>
  14.         /// <param name="entity"></param>
  15.         /// <param name="unitofWorkRepository"></param>
  16.         void RegisterInsert(EntityBase entity, ICommandBaseRepository unitofWorkRepository);
  17.  
  18.         /// <summary>
  19.         /// 保存，不支持多个同一类实体（同一个类型实体只能添加一个，否则会异常）
  20.         /// </summary>
  21.         /// <param name="entity"></param>
  22.         /// <param name="unitofWorkRepository"></param>
  23.         void RegisterSave(EntityBase entity, ICommandBaseRepository unitofWorkRepository);
  24.  
  25.         /// <summary>
  26.         /// 更新
  27.         /// </summary>
  28.         /// <param name="entity"></param>
  29.         /// <param name="unitofWorkRepository"></param>
  30.         void RegisterUpdate(EntityBase entity, ICommandBaseRepository unitofWorkRepository);
  31.  
  32.         /// <summary>
  33.         /// 删除
  34.         /// </summary>
  35.         /// <param name="id"></param>
  36.         /// <param name="unitofWorkRepository"></param>
  37.         void RegisterDelete(object id, ICommandBaseRepository unitofWorkRepository);
  38.  
  39.         /// <summary>
  40.         /// 根据字段更新
  41.         /// </summary>
  42.         /// <param name="entity"></param>
  43.         /// <param name="fields"></param>
  44.         /// <param name="unitofWorkRepository"></param>
  45.         void RegisterUpdateByFields(EntityBase entity, IList<string> fields, ICommandBaseRepository unitofWorkRepository);
  46.  
  47.         /// <summary>
  48.         /// 根据id集合更新单个字段
  49.         /// </summary>
  50.         /// <param name="id"></param>
  51.         /// <param name="column"></param>
  52.         /// <param name="unitofWorkRepository"></param>
  53.         void RegisterUpdateSingleFieldByIds(IList<object> id, KeyValuePair<string, object> column, ICommandBaseRepository unitofWorkRepository);
  54.  
  55.         Task CommitAsync();
  56.     }
  57. }

自定义的获取db对象接口，保证一个请求内db是同一个对象即可，可通过依赖注入的addscoped实现

  1. using test.DAL.Repositories;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Text;
  5.  
  6. namespace test.DAL
  7. {
  8.     internal interface IScopeDBFactory
  9.     {
  10.         CustomDatabase GetScopeDb();
  11.     }
  12. }

IScopeDBFactory 实现类，自行实现即可

  1. using MySql.Data.MySqlClient;
  2. using test.Core;
  3. using NPoco;
  4. using NPoco.FluentMappings;
  5. using System;
  6. using System.Collections.Generic;
  7. using System.Data.SqlClient;
  8. using System.Reflection;
  9. using System.Text;
  10.  
  11. namespace test.DAL.Repositories
  12. {
  13.     internal class ScopeDBFactoryImpl : IScopeDBFactory
  14.     {
  15.  
  16.         protected CustomDatabase Db;
  17.         public CustomDatabase GetScopeDb()
  18.         {
  19.         }
  20.  
  21.     }
  22. }

　　

unitofwork 接口实现

　

  1. using test.Core;
  2. using test.DAL;
  3. using test.DAL.Repositories;
  4. using test.IDAL;
  5. using NPoco;
  6. using System;
  7. using System.Collections.Generic;
  8. using System.Linq;
  9. using System.Text;
  10. using System.Threading.Tasks;
  11. using System.Transactions;
  12.  
  13. namespace test.DAL
  14. {
  15.     internal class UnitOfWorkImpl : IUnitOfWork
  16.     {
  17.  
  18.         private Dictionary<ICommandBaseRepository, List<EntityBase>> addedEntities;
  19.         private Dictionary<ICommandBaseRepository, List<EntityBase>> changedEntities;
  20.         private Dictionary<ICommandBaseRepository, List<object>> deletedEntities;
  21.         private Dictionary<ICommandBaseRepository, EntityBase> saveEntity;
  22.  
  23.         private Dictionary<ICommandBaseRepository, List<UpdatePartFieldModel>> changedPartFieldEntityList;
  24.         private Dictionary<ICommandBaseRepository, List<UpdateSingleFieldByIdsModel>> changedPartByIdsEntityList;
  25.  
  26.         private readonly IScopeDBFactory scopeDBFactory;
  27.         public UnitOfWorkImpl(IScopeDBFactory scopeDBFactory)
  28.         {
  29.  
  30.             addedEntities = new Dictionary<ICommandBaseRepository, List<EntityBase>>();
  31.             changedEntities = new Dictionary<ICommandBaseRepository, List<EntityBase>>();
  32.             deletedEntities = new Dictionary<ICommandBaseRepository, List<object>>();
  33.             saveEntity = new Dictionary<ICommandBaseRepository, EntityBase>();
  34.  
  35.             changedPartFieldEntityList = new Dictionary<ICommandBaseRepository, List<UpdatePartFieldModel>>();
  36.             changedPartByIdsEntityList = new Dictionary<ICommandBaseRepository, List<UpdateSingleFieldByIdsModel>>();
  37.             this.scopeDBFactory = scopeDBFactory;
  38.         }
  39.  
  40.         public void RegisterInsert(EntityBase entity, ICommandBaseRepository unitofWorkRepository)
  41.         {
  42.  
  43.             if (!addedEntities.ContainsKey(unitofWorkRepository))
  44.             {
  45.                 addedEntities.Add(unitofWorkRepository, new List<EntityBase>() { entity });
  46.             }
  47.             else
  48.             {
  49.                 List<EntityBase> list = addedEntities[unitofWorkRepository];
  50.                 if (!list.Contains(entity))
  51.                 {
  52.                     addedEntities[unitofWorkRepository].Add(entity);
  53.  
  54.                 }
  55.             }
  56.  
  57.         }
  58.  
  59.         public void RegisterSave(EntityBase entity, ICommandBaseRepository unitofWorkRepository)
  60.         {
  61.  
  62.             if (!saveEntity.ContainsKey(unitofWorkRepository))
  63.             {
  64.                 saveEntity.Add(unitofWorkRepository, entity);
  65.             }
  66.             else
  67.             {
  68.                 throw new Exception("不能重复添加");
  69.             }
  70.  
  71.         }
  72.  
  73.         public void RegisterUpdate(EntityBase entity, ICommandBaseRepository unitofWorkRepository)
  74.         {
  75.  
  76.             if (!changedEntities.ContainsKey(unitofWorkRepository))
  77.             {
  78.                 changedEntities.Add(unitofWorkRepository, new List<EntityBase>() { entity });
  79.             }
  80.             else
  81.             {
  82.                 List<EntityBase> list = changedEntities[unitofWorkRepository];
  83.  
  84.                 if (!list.Contains(entity))
  85.                 {
  86.                     changedEntities[unitofWorkRepository].Add(entity);
  87.  
  88.                 }
  89.             }
  90.         }
  91.  
  92.         public void RegisterUpdateByFields(EntityBase entity, IList<string> fields, ICommandBaseRepository unitofWorkRepository)
  93.         {
  94.             var updatePartModel = new UpdatePartFieldModel();
  95.             updatePartModel.Entity = entity;
  96.             updatePartModel.Fields = fields;
  97.             if (!changedPartFieldEntityList.ContainsKey(unitofWorkRepository))
  98.             {
  99.                 changedPartFieldEntityList.Add(unitofWorkRepository, new List<UpdatePartFieldModel>() { updatePartModel });
  100.             }
  101.             else
  102.             {
  103.                 List<UpdatePartFieldModel> list = changedPartFieldEntityList[unitofWorkRepository];
  104.                 if (!list.Contains(updatePartModel))
  105.                 {
  106.                     changedPartFieldEntityList[unitofWorkRepository].Add(updatePartModel);
  107.                 }
  108.             }
  109.         }
  110.  
  111.         public void RegisterUpdateSingleFieldByIds(IList<object> idList, KeyValuePair<string, object> column, ICommandBaseRepository unitofWorkRepository)
  112.         {
  113.  
  114.             var updateSingleFieldByIdModel = new UpdateSingleFieldByIdsModel();
  115.             updateSingleFieldByIdModel.IdList = idList;
  116.             updateSingleFieldByIdModel.Column = column;
  117.             if (!changedPartByIdsEntityList.ContainsKey(unitofWorkRepository))
  118.             {
  119.                 changedPartByIdsEntityList.Add(unitofWorkRepository, new List<UpdateSingleFieldByIdsModel>() { updateSingleFieldByIdModel });
  120.             }
  121.             else
  122.             {
  123.                 List<UpdateSingleFieldByIdsModel> list = changedPartByIdsEntityList[unitofWorkRepository];
  124.                 if (!list.Contains(updateSingleFieldByIdModel))
  125.                 {
  126.                     changedPartByIdsEntityList[unitofWorkRepository].Add(updateSingleFieldByIdModel);
  127.                 }
  128.             }
  129.         }
  130.  
  131.         public void RegisterDelete(object id, ICommandBaseRepository unitofWorkRepository)
  132.         {
  133.  
  134.             if (!deletedEntities.ContainsKey(unitofWorkRepository))
  135.             {
  136.                 deletedEntities.Add(unitofWorkRepository, new List<object>() { id });
  137.             }
  138.             else
  139.             {
  140.                 List<object> list = deletedEntities[unitofWorkRepository];
  141.                 if (!list.Contains(id))
  142.                 {
  143.                     deletedEntities[unitofWorkRepository].Add(id);
  144.  
  145.                 }
  146.             }
  147.  
  148.         }
  149.  
  150.         /// <summary>
  151.         /// 开启事务
  152.         /// </summary>
  153.         /// <returns></returns>
  154.         private DBTransaction BeginNewDBTransaction(CustomDatabase db)
  155.         {
  156.             var scopeTransaction = new DBTransaction(db);
  157.             return scopeTransaction;
  158.         }
  159.  
  160.         public async Task CommitAsync()
  161.         {
  162.            //获得db对象 一个请求db是同一个
                var db = scopeDBFactory.GetScopeDb();
  163.             using (var scope = BeginNewDBTransaction(db))
  164.             {
  165.                 ///插入新增的实体
  166.                 foreach (var repository in this.addedEntities.Keys)
  167.                 {
  168.                     var entityList = addedEntities[repository];
  169.                     if (entityList.Count > 1)
  170.                     {
  171.                         await repository.InsertBatchAsync(entityList).ConfigureAwait(false);
  172.                     }
  173.                     else
  174.                     {
  175.                         await repository.InsertAsync(entityList[0]).ConfigureAwait(false);
  176.                     }
  177.                 }
  178.  
  179.                 ///保存实体 有则更新 无则删除
  180.                 foreach (var repository in this.saveEntity.Keys)
  181.                 {
  182.                     var entity = saveEntity[repository];
  183.                     await repository.SaveAsync(entity).ConfigureAwait(false);
  184.                 }
  185.  
  186.                 //更新需要修改的实体
  187.                 foreach (var repository in this.changedEntities.Keys)
  188.                 {
  189.                     var entityList = changedEntities[repository];
  190.                     if (entityList.Count > 1)
  191.                     {
  192.                         await repository.UpdateBatchAsync(entityList).ConfigureAwait(false);
  193.                     }
  194.                     else
  195.                     {
  196.                         await repository.UpdateAsync(entityList[0]).ConfigureAwait(false);
  197.                     }
  198.                 }
  199.  
  200.                 ///更新根据字段更新的实体
  201.                 foreach (var repository in this.changedPartFieldEntityList.Keys)
  202.                 {
  203.                     var updateModelList = changedPartFieldEntityList[repository];
  204.                     foreach (var updateModel in updateModelList)
  205.                     {
  206.                         await repository.UpdateAsync(updateModel.Entity, updateModel.Fields).ConfigureAwait(false);
  207.                     }
  208.                 }
  209.  
  210.                 ///更新根据id集合更新的数据实体
  211.                 foreach (var repository in this.changedPartByIdsEntityList.Keys)
  212.                 {
  213.                     var updateModelList = changedPartByIdsEntityList[repository];
  214.                     foreach (var updateModel in updateModelList)
  215.                     {
  216.                         await repository.UpdateSingleFieldByIdsAsync(updateModel.IdList, updateModel.Column).ConfigureAwait(false);
  217.                     }
  218.                 }
  219.  
  220.                 ///删除实体
  221.                 foreach (var repository in this.deletedEntities.Keys)
  222.                 {
  223.                     var entityList = deletedEntities[repository];
  224.                     if (entityList.Count > 1)
  225.                     {
  226.                         await repository.SoftDeleteBatchAsync(entityList).ConfigureAwait(false);
  227.                     }
  228.                     else
  229.                     {
  230.                         await repository.SoftDeleteAsync(entityList[0]).ConfigureAwait(false);
  231.                     }
  232.  
  233.                 }
  234.                 scope.Complete();
  235.                 addedEntities.Clear();
  236.                 changedEntities.Clear();
  237.                 deletedEntities.Clear();
  238.                 saveEntity.Clear();
  239.                 changedPartFieldEntityList.Clear();
  240.                 changedPartByIdsEntityList.Clear();
  241.             }
  242.         }
  243.     }
  244. }

　

  1.  
  2. namespace test.DAL
  3. {
  4.     internal class UpdatePartFieldModel
  5.     {
  6.  
  7.         public EntityBase Entity { get; set; }
  8.  
  9.         public IList<string> Fields { get; set; }
  10.  
  11.     }
  12.  
  13.     internal class UpdateSingleFieldByIdsModel
  14.     {
  15.  
  16.         public IList<object> IdList { get; set; }
  17.  
  18.         public KeyValuePair<string, object> Column { get; set; }
  19.  
  20.     }
  21. }

　　

针对批量删除、批量修改等各种操作，根据各个业务多一层封装UnitOfWork，减少提交工作单元时各种循环，不想要的也可以去掉

以customer业务表为例代码

如下：

  1.  
  2. namespace test.IDAL
  3. {
  4.     public interface ICommandCustomerRepository : ICommandBaseRepository
  5.     {
  6.  
  7.     }
  8. }

客户服务仓储单元接口

  1. namespace test.IDAL
  2. {
  3.     public interface ICustomerUnitOfWork
  4.     {
  5.         void RegisterInsert(CustomerEntity entity);
  6.  
  7.         void RegisterInsertBatch(IList<CustomerEntity> entities);
  8.  
  9.         void RegisterUpdate(CustomerEntity entity);
  10.  
  11.         void RegisterUpdateBatch(IList<CustomerEntity> entities);
  12.  
  13.          void RegisterUpdateByFields(CustomerEntity entity,List<string> fields);
  14.  
  15.         void RegisterUpdateSingleFieldByIds(IList<long> idList, KeyValuePair<string, object> column);
  16.  
  17.         void RegisterDelete(long id);
  18.  
  19.         void RegisterDeleteBatch(IList<long> idList);
  20.  
  21.         Task CommitAsync();
  22.     }
  23. }

　　

客户实体

  1. namespace test.Entity
  2. {
  3.     /// <summary>
  4.     /// 基础数据-客户信息
  5.     /// </summary>
  6.     [MyTableName("Customer")]
  7.     [MyPrimaryKey("Id", AutoIncrement = false)]
  8.     public class CustomerEntity : EntityBase
  9.     {
  10.         /// <summary>
  11.         ///  客户名称
  12.         /// </summary>
  13.         public string Name { get; set; }
  14.  
  15.         /// <summary>
  16.         ///  客户code
  17.         /// </summary>
  18.         ///
  19.         public string Code { get; set; }
  20.  
  21.         /// <summary>
  22.         ///  是否可用 0 否 1是
  23.         /// </summary>
  24.         public bool? IsEnabled { get; set; }
  25.  
  26.         /// <summary>
  27.         ///  邮箱
  28.         /// </summary>
  29.         public string Email { get; set; }
  30.  
  31.         /// <summary>
  32.         ///  传真
  33.         /// </summary>
  34.         public string Fax { get; set; }
  35.  
  36.         /// <summary>
  37.         ///  联系人
  38.         /// </summary>
  39.         public string ContactPerson { get; set; }
  40.  
  41.         /// <summary>
  42.         ///  联系人电话
  43.         /// </summary>
  44.         public string ContactTelphone { get; set; }
  45.  
  46.         /// <summary>
  47.         ///  地址
  48.         /// </summary>
  49.         public string Address { get; set; }
  50.  
  51.         /// <summary>
  52.         ///  备注
  53.         /// </summary>
  54.         public string Remark { get; set; }
  55.  
  56.     }
  57.  
  58. }

　　

客户服务工作单元实现

  1. namespace test.DAL
  2. {
  3.     internal class CustomerUnitOfWorkImpl:ICustomerUnitOfWork , IAutoInject
  4.     {
  5.  
  6.         private readonly IUnitOfWork unitOfWork;
  7.         private readonly ICommandCustomerRepository  commandRepository;
  8.  
  9.         public CustomerUnitOfWorkImpl(ICommandCustomerRepository commandRepository, IUnitOfWork unitOfWork)
  10.         {
  11.             this.commandRepository = commandRepository;
  12.  
  13.             this.unitOfWork = unitOfWork;
  14.         }
  15.  
  16.         public void RegisterInsert(CustomerEntity entity)
  17.         {
  18.             unitOfWork.RegisterInsert(entity, commandRepository);
  19.         }
  20.  
  21.         public void RegisterInsertBatch(IList<CustomerEntity> entities)
  22.         {
  23.             foreach (var entity in entities)
  24.             {
  25.                 unitOfWork.RegisterInsert(entity, commandRepository);
  26.             }
  27.  
  28.         }
  29.  
  30.         public void RegisterUpdate(CustomerEntity entity)
  31.         {
  32.             unitOfWork.RegisterUpdate(entity, commandRepository);
  33.  
  34.         }
  35.  
  36.         public void RegisterUpdateBatch(IList<CustomerEntity> entities)
  37.         {
  38.             foreach (var entity in entities)
  39.             {
  40.                 unitOfWork.RegisterUpdate(entity, commandRepository);
  41.             }
  42.         }
  43.  
  44.         public void RegisterUpdateByFields(CustomerEntity entity, List<string> fields)
  45.         {
  46.             unitOfWork.RegisterUpdateByFields(entity, fields, commandRepository);
  47.         }
  48.  
  49.         public void RegisterUpdateSingleFieldByIds(IList<long> idList, KeyValuePair<string, object> column)
  50.         {
  51.             unitOfWork.RegisterUpdateSingleFieldByIds(idList, column, commandRepository);
  52.         }
  53.  
  54.         public void RegisterDelete(long entity)
  55.         {
  56.             unitOfWork.RegisterDelete(entity, commandRepository);
  57.         }
  58.  
  59.         public void RegisterDeleteBatch(IList<long> entities)
  60.         {
  61.             foreach (var entity in entities)
  62.             {
  63.                 unitOfWork.RegisterDelete(entity, commandRepository);
  64.             }
  65.  
  66.         }
  67.         public async Task CommitAsync()
  68.         {
  69.             await unitOfWork.CommitAsync().ConfigureAwait(false);
  70.         }
  71.     }
  72. }

客户服务接口

  1.  
  2. namespace test.IBLL.Basic
  3. {
  4.     public interface ICommandCustomerService
  5.     {
  6. 	  /// <summary>
  7.         /// 插入单个实体
  8.         /// </summary>
  9.         /// <param name="entity"></param>
  10.         /// <returns></returns>
  11.         Task<HttpResponseResultModel<long>> InsertAsync(CustomerEntity entity,bool isCommit = true);
  12.  
  13.         /// <summary>
  14.         /// 批量插入实体
  15.         /// </summary>
  16.         /// <param name="entityList"></param>
  17.         /// <returns></returns>
  18.         Task<HttpResponseResultModel<bool>> InsertBatchAsync(List<CustomerEntity> entityList,bool isCommit = true);
  19.  
  20.         /// <summary>
  21.         /// 根据主键更新实体
  22.         /// </summary>
  23.         /// <param name="entity"></param>
  24.         /// <returns></returns>
  25.         Task<HttpResponseResultModel<bool>> UpdateAsync(CustomerEntity entity,bool isCommit = true);
  26.  
  27.         /// <summary>
  28.         /// 更新实体的部分字段
  29.         /// </summary>
  30.         /// <param name="entity"></param>
  31.         /// <param name="columns"></param>
  32.         /// <returns></returns>
  33.         Task<HttpResponseResultModel<bool>> UpdateFieldsAsync(CustomerEntity entity, List<string> fields, bool isCommit = true);
  34.  
  35.         /// <summary>
  36.         /// 根据id集合更新某个字段更新
  37.         /// </summary>
  38.         /// <param name="idList"></param>
  39.         /// <param name="column"></param>
  40.         /// <param name="isCommit"></param>
  41.         /// <returns></returns>
  42.         Task<HttpResponseResultModel<bool>> UpdateSingleFieldByIdsAsync(List<long> idList, KeyValuePair<string, object> column, bool isCommit = true);
  43.  
  44.         /// <summary>
  45.         /// 根据主键批量更新实体
  46.         /// </summary>
  47.         /// <param name="entityList">实体集合</param>
  48.         /// <returns></returns>
  49.         Task<HttpResponseResultModel<bool>> UpdateBatchAsync(List<CustomerEntity> entityList,bool isCommit = true);
  50.  
  51.         /// <summary>
  52.         /// 根据根据主键删除
  53.         /// </summary>
  54.         /// <param name="id">主键</param>
  55.         /// <returns></returns>
  56.         Task<HttpResponseResultModel<bool>> DeleteAsync(long id,bool isCommit = true);
  57.  
  58.         /// <summary>
  59.         /// 批量删除 根据主键
  60.         /// </summary>
  61.         /// <param name="idList">主键集合</param>
  62.         /// <returns></returns>
  63.         Task<HttpResponseResultModel<bool>> DeleteBatchAsync(IList<long> idList,bool isCommit = true);
  64.  
  65.         /// <summary>
  66.         /// 保存实体，有则更新，无则新增
  67.         /// </summary>
  68.         /// <param name="entity"></param>
  69.         /// <returns></returns>
  70.         Task<HttpResponseResultModel<bool>> SaveAsync(CustomerEntity entity,bool isCommit = true);
  71.    }
  72. }

　

客户服务接口实现

  1. namespace test.BLL.Basic
  2. {
  3.     internal class CommandCustomerServiceImpl : ICommandCustomerService, IAutoInject
  4.     {
  5.         private readonly ICustomerUnitOfWork unitOfWork;
  6.  
  7.         public CommandCustomerServiceImpl(ICustomerUnitOfWork unitOfWork)
  8.         {
  9.             this.unitOfWork = unitOfWork;
  10.         }
  11.  
  12.         #region 插入
  13.  
  14.         /// <summary>
  15.         /// 插入单个实体
  16.         /// </summary>
  17.         /// <param name="entity"></param>
  18.         /// <returns></returns>
  19.         public async Task<HttpResponseResultModel<long>> InsertAsync(CustomerEntity entity,bool isCommit = true)
  20.         {
  21.             HttpResponseResultModel<long> httpResponseResultModel = new HttpResponseResultModel<long> { IsSuccess = false };
  22.             unitOfWork.RegisterInsert(entity);
  23.             if (isCommit)
  24.             {
  25.                  await  CommitAsync();
  26.             }
  27.             httpResponseResultModel.BackResult = entity.Id;
  28.             httpResponseResultModel.IsSuccess = true;
  29.             return httpResponseResultModel;
  30.         }
  31.  
  32.         /// <summary>
  33.         /// 批量插入实体
  34.         /// </summary>
  35.         /// <param name="entityList"></param>
  36.         /// <returns></returns>
  37.         public async Task<HttpResponseResultModel<bool>> InsertBatchAsync(List<CustomerEntity> entityList,bool isCommit = true)
  38.         {
  39.             HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  40.             unitOfWork.RegisterInsertBatch(entityList);
  41.             if (isCommit)
  42.             {
  43.                 await  CommitAsync();
  44.             }
  45.             httpResponseResultModel.BackResult = true;
  46.             httpResponseResultModel.IsSuccess = true;
  47.             return httpResponseResultModel;
  48.         }
  49.  
  50.         #endregion
  51.  
  52. 	    #region 更新
  53.         /// <summary>
  54.         /// 根据主键更新实体
  55.         /// </summary>
  56.         /// <param name="entity"></param>
  57.         /// <returns></returns>
  58.         public async Task<HttpResponseResultModel<bool>> UpdateAsync(CustomerEntity entity,bool isCommit = true)
  59.         {
  60.             HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  61.             unitOfWork.RegisterUpdate(entity);
  62.             if (isCommit)
  63.             {
  64.                   await  CommitAsync();
  65.             }
  66.             httpResponseResultModel.IsSuccess = true;
  67.             return httpResponseResultModel;
  68.         }
  69.  
  70.         /// <summary>
  71.         /// 批量更新实体
  72.         /// </summary>
  73.         /// <param name="entityList"></param>
  74.         /// <returns></returns>
  75.         public async Task<HttpResponseResultModel<bool>> UpdateBatchAsync(List<CustomerEntity> entityList,bool isCommit = true)
  76.         {
  77.             HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  78.             unitOfWork.RegisterUpdateBatch(entityList);
  79.             if (isCommit)
  80.             {
  81.                 await  CommitAsync();
  82.             }
  83.             httpResponseResultModel.IsSuccess = true;
  84.             return httpResponseResultModel;
  85.         }
  86.  
  87.          /// <summary>
  88.         /// 更新实体的部分字段
  89.         /// </summary>
  90.         /// <param name="entity"></param>
  91.         /// <param name="columns"></param>
  92.         /// <returns></returns>
  93.         public async Task<HttpResponseResultModel<bool>> UpdateFieldsAsync(CustomerEntity entity, List<string> fields, bool isCommit = true)
  94.         {
  95.             HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  96.             unitOfWork.RegisterUpdateByFields(entity, fields);
  97.             if (isCommit)
  98.             {
  99.                  await  CommitAsync();
  100.  
  101.             }
  102.             httpResponseResultModel.IsSuccess = true;
  103.             return httpResponseResultModel;
  104.         }
  105.  
  106.         /// <summary>
  107.         /// 根据id集合更新某个字段更新
  108.         /// </summary>
  109.         /// <param name="idList"></param>
  110.         /// <param name="column"></param>
  111.         /// <param name="isCommit"></param>
  112.         /// <returns></returns>
  113.         public async Task<HttpResponseResultModel<bool>> UpdateSingleFieldByIdsAsync(List<long> idList, KeyValuePair<string, object> column, bool isCommit = true)
  114.         {
  115.             HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  116.             unitOfWork.RegisterUpdateSingleFieldByIds(idList, column);
  117.             if (isCommit)
  118.             {
  119.                  await  CommitAsync();
  120.             }
  121.             httpResponseResultModel.IsSuccess = true;
  122.             return httpResponseResultModel;
  123.         }
  124.  
  125. 		#endregion
  126.  
  127.         #region 删除
  128.  
  129.         /// <summary>
  130.         /// 根据根据主键删除
  131.         /// </summary>
  132.         /// <param name="id">主键</param>
  133.         /// <returns></returns>
  134.         public async Task<HttpResponseResultModel<bool>> DeleteAsync(long id,bool isCommit = true)
  135.         {
  136. 		    HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  137.             unitOfWork.RegisterDelete(id);
  138.             if (isCommit)
  139.             {
  140.                  await  CommitAsync();
  141.             }
  142.              httpResponseResultModel.IsSuccess = true;
  143.             return httpResponseResultModel;
  144. 	   }
  145.  
  146.         /// <summary>
  147.         /// 批量删除 根据主键
  148.         /// </summary>
  149.         /// <param name="idList">主键集合</param>
  150.         /// <returns></returns>
  151.         public async Task<HttpResponseResultModel<bool>> DeleteBatchAsync(IList<long> idList,bool isCommit = true)
  152.         {
  153. 		  HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  154.            unitOfWork.RegisterDeleteBatch(idList);
  155.             if (isCommit)
  156.             {
  157.                 await  CommitAsync();
  158.             }
  159.  
  160.             httpResponseResultModel.IsSuccess = true;
  161.             return httpResponseResultModel;
  162.  
  163. 		}
  164.  
  165.         #endregion
  166.  
  167.         /// <summary>
  168.         /// 保存实体，有则更新，无则新增
  169.         /// </summary>
  170.         /// <param name="entity"></param>
  171.         /// <returns></returns>
  172.         public async Task<HttpResponseResultModel<bool>> SaveAsync(CustomerEntity entity,bool isCommit = true)
  173.         {
  174.             HttpResponseResultModel<bool> httpResponseResultModel = new HttpResponseResultModel<bool> { IsSuccess = false };
  175.  
  176.             return httpResponseResultModel;
  177.         }
  178.  
  179.         #region 事务
  180.  
  181. 		 /// <summary>
  182.         /// 事务
  183.         /// </summary>
  184.         /// <returns></returns>
  185.         public async Task CommitAsync()
  186.         {
  187.             await unitOfWork.CommitAsync().ConfigureAwait(false);
  188.         }
  189. 	     #endregion
  190.  
  191.     }
  192. }

　　

  1. using System.Net;
  2.  
  3. namespace test.Core
  4. {
  5.  
  6.     /// <summary>
  7.     ///  http请求结果类
  8.     /// </summary>
  9.     /// <typeparam name="T"></typeparam>
  10.     public class HttpResponseResultModel<T>
  11.     {
  12.         /// <summary>
  13.         /// http码
  14.         /// </summary>
  15.         public HttpStatusCode HttpStatusCode { get; set; }
  16.  
  17.         /// <summary>
  18.         /// 是否成功
  19.         /// </summary>
  20.         public bool IsSuccess { get; set; }
  21.  
  22.         /// <summary>
  23.         /// 返回结果
  24.         /// </summary>
  25.         public T BackResult { get; set; }
  26.  
  27.         /// <summary>
  28.         /// 错误信息
  29.         /// </summary>
  30.         public string ErrorMessage { get; set; }
  31.  
  32.         /// <summary>
  33.         /// 异常信息
  34.         /// </summary>
  35.         public string ExceptionMessage { get; set; }
  36.     }
  37. }
  没有英汉互译结果
  请尝试网页搜索

  没有英汉互译结果
  请尝试网页搜索

.NET Core 工作单元unitofwork 实现，基于NPOCO的更多相关文章

  1. Asp.Net Core 工作单元 UnitOfWork UOW

    Asp.Net Core 工作单元示例 来自 ABP UOW 去除所有无用特性 代码下载 : 去除所有无用特性版本,原生AspNetCore实现 差不多 2278 行代码: 链接:https://pa ...

  2. .net core2.x - 关于工作单元(UnitOfWork) 模式

    概要:在搭建框架,顺手说下写下,关于unitofwork,可能你理解了,可能你还不理解,可能与不可能不是重点,重点是感兴趣就看看吧. 1.工作单元(unitofowork)是什么(后面简写uow)? ...

  3. ABP官方文档翻译 3.6 工作单元

    工作单元 介绍 ABP中的连接和事务管理 传统的工作单元方法 控制工作单元 UnitOfWork特性 IUnitOfWorkManager 工作单元详情 禁用工作单元 无事务工作单元 一个工作单元方法 ...

  4. ABP框架 - 工作单元

    文档目录 本节内容: 简介 在ABP中管理连接和事务 约定的工作单元 UnitOfWork 特性 IUnitOfWorkManager 工作单元详情 禁用工作单元 非事务性工作单元 工作单元方法调用另 ...

  5. ABP的工作单元

    http://www.aspnetboilerplate.com/Pages/Documents/Unit-Of-Work 工作单元位于领域层.   ABP的数据库连接和事务处理: 1,仓储类 ASP ...

  6. 手工搭建基于ABP的框架 - 工作单元以及事务管理

    一个业务功能往往不只由一次数据库请求(或者服务调用)实现.为了功能的完整性,我们希望如果该功能执行一半时出错,则撤销前面已执行的改动.在数据库层面上,事务管理实现了这种完整性需求.在ABP中,一个完整 ...

  7. 知识全聚集 .Net Core 技术突破 | 简单说说工作单元

    知识全聚集 .Net Core 技术突破 | 简单说说工作单元 教程 01 | 模块化方案一 02 | 模块化方案二 其他教程预览 分库分表项目实战教程 Git地址: https://github.c ...

  8. 工作单元模式(UnitOfWork)学习总结

    工作单元的目标是维护变化的对象列表.使用IUnitOfWorkRepository负责对象的持久化,使用IUnitOfWork收集变化的对象,并将变化的对象放到各自的增删改列表中, 最后Commit, ...

  9. 基于DDD的.NET开发框架 - ABP工作单元(Unit of Work)

    返回ABP系列 ABP是“ASP.NET Boilerplate Project (ASP.NET样板项目)”的简称. ASP.NET Boilerplate是一个用最佳实践和流行技术开发现代WEB应 ...

随机推荐

  1. PAT 1002 A+B for Polynomials (25分)

    题目 This time, you are supposed to find A+B where A and B are two polynomials. Input Specification: E ...

  2. Postman学习宝典（三）

    Postman 入门3 - Newman Newman 官方帮助文档地址 Newman 安装 嗯,它需要安装,因为它不是音乐播放器!Newman是为Postman而生,专门用来运行Postman编写好 ...

  3. centos7 下安装apache mysql php phpmyadmin。

    1 安装mysql yum -y install mariadb-server systemctl start mariadb.service systemctl enable mariadb.ser ...

  4. 静态MAC地址配置案例

    目录导航: 1.静态MAC地址简介 2.组网需求 3.配置思路 4.配置步骤 5.配置文件 1.静态MAC地址简介 返回目录导航 >MAC地址表项是交换机通过报文的源MAC地址学习过程而自动生成 ...

  5. 搞懂：MVVM模型以及VUE中的数据绑定数据劫持发布订阅模式

    搞懂:MVVM模式和Vue中的MVVM模式 MVVM MVVM : model - view - viewmodel的缩写,说都能直接说出来 model:模型,view:视图,view-Model:视 ...

  6. 使用react的一点提醒17/10/26

    1.不直接操作dom 今天在和同学讨论的时候,发现了一些以前没注意的问题. 这段时间自己学习时一直都是用原生js写代码,但是以前在公司经常使用jq,也不知不觉间让我习惯了操作dom的倾向. 使用vue ...

  7. js时间戳转为日期格式的方法

    Date.prototype.Format = function(fmt){ var o = { "M+" : this.getMonth()+1, //月份 "d+&q ...

  8. SpringBoot_自动装配

    SpringBoot SrpingBoot 给人的第一印象就是 简洁,易上手.它是自 Spring 而来为了简化我们开发的,而经历过了 Spring 中繁琐的配置文件,我确实很好奇它到底是怎么帮我们把 ...

  9. ShoneSharp语言(S#)的设计和使用介绍系列（9）— 一等公民“函数“爱炫巧

    ShoneSharp语言(S#)的设计和使用介绍 系列(9)— 一等公民“函数“爱炫巧 作者:Shone 声明:原创文章欢迎转载,但请注明出处,https://www.cnblogs.com/Shon ...

  10. SpringBoot系列——状态机（附完整源码）

    1. 简单介绍状态机 2. 状态机的本质 3. 状态机应用场景 1. 简单介绍状态机 状态机由状态寄存器和组合逻辑电路构成,能够根据控制信号按照预先设定的状态进行状态转移,是协调相关信号动作.完成特定 ...