在阅读本文章之前，你可以先阅读：

  • 什么是DDD
  • DDD的实体、值对象、聚合根的基类和接口：设计与实现

仓储封装了基础设施来提供查询和持久化聚合操作。 它们集中提供常见的数据访问功能，从而提供更好的可维护性，并将用于访问数据库的基础结构或技术与领域模型层分离。 创建数据访问层和应用程序的业务逻辑层之间的抽象层。 实现仓储可让你的应用程序对数据存储介质的更改不敏感。

直接访问数据：

  • 重复的代码
  • 难以集中化与数据相关的策略（例如缓存）
  • 编程错误的可能性更高
  • 无法独立于外部依赖项轻松测试业务逻辑

使用仓储优点：

  • 可以通过将业务逻辑与数据或服务访问逻辑分开来提高代码的可维护性和可读性。
  • 可以从许多位置访问数据源，并希望应用集中管理的，一致的访问规则和逻辑。
  • 可以通过自动化进行测试的代码量，并隔离数据层以支持单元测试。
  • 可以使用强类型的业务实体，以便可以在编译时而不是在运行时识别问题。
  • 可以将行为与相关数据相关联。例如，您要计算字段或在实体中的数据元素之间强制执行复杂的关系或业务规则。
  • 应用DDD来简化复杂的业务逻辑。

实现基本的增删改查及事务的提交和回滚

首先，定义接口

  1. /// <summary>
  2. /// IRepository提供应用程序仓储模式基本操作的接口
  3. /// </summary>
  4. public interface IRepository
  5. {
  6.     #region Methods
  7.     void Entry<T>(T t) where T : AggregateRoot;
  8.     void Save();
  9.     T Get<T>(Guid id, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot;
  10.     T Get<T>(Expression<Func<T, bool>> where, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot;
  11.     IQueryable<T> Query<T>(Expression<Func<T, bool>> filter=null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy=null, Func<IQueryable<T>, IQueryable<T>> includes=null) where T : AggregateRoot;
  12.     IQueryable<T> QueryByPage<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot;
  13.     void BeginTransaction();
  14.     void Commit();
  15.     void Rollback();
  16.     #endregion
  17. }

最后，实现以上接口

  1. public class Repository : IDisposable, IRepository
  2. {
  3.     #region Private Fields
  4.     private readonly DbContext context;
  5.     private IDbContextTransaction transaction;
  6.     #endregion
  8.     #region Constructors
  9.     public Repository(DbContext context)
  10.     {
  11.         this.context = context ?? throw new ArgumentNullException(nameof(context));
  12.     }
  13.     #endregion
  15.     #region IRepository<T> Members
  16.     public void Entry<T>(T t) where T : AggregateRoot
  17.     {
  18.         switch (t.AggregateState)
  19.         {
  20.             case AggregateState.Added:
  21.                 context.Entry(t).State = EntityState.Added;
  22.                 break;
  23.             case AggregateState.Deleted:
  24.                 context.Entry(t).State = EntityState.Deleted;
  25.                 break;
  26.             default:
  27.                 context.Entry(t).State = EntityState.Modified;
  28.                 break;
  29.         }
  30.     }
  32.     public void Save()
  33.     {
  34.         context.SaveChanges();
  35.     }
  37.     public T Get<T>(Guid id, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot
  38.     {
  39.         return Get(w => w.Id.Equals(id), includes: includes);
  40.     }
  42.     public T Get<T>(Expression<Func<T, bool>> filter, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot
  43.     {
  44.         return Query(filter, includes: includes).SingleOrDefault();
  45.     }
  47.     public IQueryable<T> Query<T>(Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot
  48.     {
  49.         IQueryable<T> query = context.Set<T>();
  51.         if (filter != null)
  52.         {
  53.             query = query.Where(filter);
  54.         }
  56.         if (includes != null)
  57.         {
  58.             query = includes(query);
  59.         }
  61.         if (orderBy != null)
  62.         {
  63.             query = orderBy(query);
  64.         }
  66.         return query;
  67.     }
  69.     public IQueryable<T> QueryByPage<T>(int pageIndex, int pageSize, Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot
  70.     {
  71.         var query = Query(filter, orderBy, includes)
  72.             .Skip(pageSize * (pageIndex - 1))
  73.             .Take(pageSize);
  75.         return query;
  76.     }
  78.     public void BeginTransaction()
  79.     {
  80.         transaction = context.Database.BeginTransaction();
  81.     }
  83.     public void Rollback()
  84.     {
  85.         transaction.Rollback();
  86.     }
  88.     public void Commit()
  89.     {
  90.         transaction.Commit();
  91.     }
  93.     public void Dispose()
  94.     {
  95.         if (transaction != null)
  96.         {
  97.             transaction.Dispose();
  98.         }
  99.         context.Dispose();
  100.     }
  101.     #endregion
  102. }

为数据库上下文和事务上下文声明类变量：

  1. private readonly DbContext context;
  2. private IDbContextTransaction transaction;

构造函数接受数据库上下文实例：

  1. public Repository(DbContext context)
  2. {
  3.     this.context = context ?? throw new ArgumentNullException(nameof(context));
  4. }

Get分为通过ID查询或过滤条件进行查询，返回序列中的唯一元素：

  1. public T Get<T>(Guid id, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot
  2. {
  3.     return Get(w => w.Id.Equals(id), includes: includes);
  4. }
  5. public T Get<T>(Expression<Func<T, bool>> filter, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot
  6. {
  7.     return Query(filter, includes: includes).SingleOrDefault();
  8. }

Query 方法使用 lambda 表达式来允许调用代码指定筛选条件，使用一列来对结果进行排序，允许调用方为预先加载导航属性列表：

  1. // 代码 Expression<Func<T, bool>> filter 意味着调用方将基于 AggregateRoot 类型提供 lambda 表达式，并且此表达式将返回一个布尔值。
  2. // 代码 Func<IQueryable<T>, IOrderedQueryable<T>> orderBy 也意味着调用方将提供 lambda 表达式。 但在这种情况下，表达式的输入是 AggregateRoot 类型的 IQueryable 对象。 表达式将返回 IQueryable 对象的有序版本。 
  3. // 代码 Func<IQueryable<T>, IQueryable<T>> includes 也意味着调用方将提供 lambda 表达式。 允许预先加载导航属性列表。 
  5. public IQueryable<T> Query<T>(Expression<Func<T, bool>> filter = null, Func<IQueryable<T>, IOrderedQueryable<T>> orderBy = null, Func<IQueryable<T>, IQueryable<T>> includes = null) where T : AggregateRoot
  6. {
  7.     IQueryable<T> query = context.Set<T>();
  9.     if (filter != null)
  10.     {
  11.         query = query.Where(filter);
  12.     }
  14.     if (includes != null)
  15.     {
  16.         query = includes(query);
  17.     }
  19.     if (orderBy != null)
  20.     {
  21.         query = orderBy(query);
  22.     }
  24.     return query;
  25. }

Entry 方法使用 AggregateRoot.AggregateState 来置 context.Entry(t).State 状态，完成增删改

  1. public void Entry<T>(T t) where T : AggregateRoot
  2. {
  3.     switch (t.AggregateState)
  4.     {
  5.         case AggregateState.Added:
  6.             context.Entry(t).State = EntityState.Added;
  7.             break;
  8.         case AggregateState.Deleted:
  9.             context.Entry(t).State = EntityState.Deleted;
  10.             break;
  11.         default:
  12.             context.Entry(t).State = EntityState.Modified;
  13.             break;
  14.     }
  15. }

Save 等其他方法也类似实现。

版权声明：本文为zcqiand原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zcqiand/p/14341891.html