EntityFramework之领域驱动设计实践【仓储深入实现】

早在年前的时候就已经在CSAI博客发表了上一篇文章：《仓储的实现：基础篇》。苦于日夜奔波于工作与生活之间，一直没有能够抽空继续探讨仓储的实现细节，也让很多关注EntityFramework和领域驱动设计的朋友们备感失望。

闲话不多说，现在继续考虑，如何让仓储的操作在相同的事物处理上下文中进行。DDD引入仓储模式，其目的之一就是能够通过仓储隐藏对象持久化的技术细节，使得领域模型变得更为“纯净”。由此可见，仓储的实现是需要基础结构层的组件支持的，表现为对数据库的操作。在传统的关系型数据库操作中，事务处理是一个很重要的概念，虽然从目前某些大型项目看，事务处理会降低效率，但它保证了数据的完整性。关系型数据库仍然是目前数据持久化机制的主流，事务处理的实现还是很有必要的。

为了迎合仓储模式，就需要对经典的ObjectContext使用方式作一些调整。比如，原本我们可以非常简单地使用using (EntitiesContainer ec = new EntitiesContainer())语句来界定LINQ to Entities的操作范围，并使用ObjectContext的SaveChanges成员方法提交事务，而在引入了仓储的实现中，就不能继续采用这种经典的使用方式。这让EntityFramework看上去变得很奇怪，也很牵强，我相信很多网友会批评我的做法，因为我把问题复杂化了。

其实，这应该是关注点不同罢了。关注EntityFramework的开发人员，自然觉得经典的调用方式简单明了，而从DDD的角度看呢？只能把关注点放在仓储上，而把EntityFramework当成是仓储的一种技术选型（当然从DDD角度讲，我们完全可以不选择EntityFramework，而去选择其它技术）。所以本文暂且抛开EntityFramework，继续在上文的基础上，讨论仓储的实现。

前面提到，仓储的实现需要考虑事务处理，而且根据DDD的经验，针对每一个聚合根，都需要有个仓储对其进行持久化以及对象重新组装等操作。为此，我的想法是，将仓储操作“界定”在某一个事务处理上下文（Context）中，仓储的实例是由Context获得的，这有点像EntityFramework中ObjectContext与EntityObject的关系那样。由于仓储是来自于transaction context，所以它知道目前处于哪个事务上下文中。我定义的这个transaction context如下：

隐藏行号 复制代码 ？Transaction Context

1. public interface IRepositoryTransactionContext : IDisposable
   

2. {
   

3.     IRepository<TEntity> GetRepository<TEntity>()
   

4.         where TEntity : EntityObject, IAggregateRoot;
   

5.     void BeginTransaction();
   

6.     void Commit();
   

7.     void Rollback();
   

8. }
   

上面第三行代码定义了一个接口方法，这个方法的主要作用就是返回一个针对指定聚合根实体的仓储实例。剩下那三行代码就很明显了，那是标准的transaction操作：启动事务、提交事务以及回滚事务。

在设计上，可以根据需要，选择合适的技术来实现IRepositoryTransactionContext。我们现在讨论的是EntityFramework，所以我将给出EntityFramework的具体实现。当然，如果你不选用EntityFramework，而是用NHibernate实现数据持久化，这样的设计同样能够使你达到目的。以下是基于EntityFramework的实现：EdmRepositoryTransactionContext的伪代码。

隐藏行号 复制代码 ？EdmRepositoryTransactionContext

1. internal class EdmRepositoryTransactionContext : IRepositoryTransactionContext
   

2. {
   

3.     private ObjectContext objContext;
   

4.     private Dictionary<Type, object> repositoryCache = new Dictionary<Type, object>();
   

6.     public EdmRepositoryTransactionContext(ObjectContext objContext)
   

7.     {
   

8.         this.objContext = objContext;
   

9.     }
   

11.     #region IRepositoryTransactionContext Members
    

13.     public IRepository<TEntity> GetRepository<TEntity>() where TEntity : EntityObject, IAggregateRoot
    

14.     {
    

15.         if (repositoryCache.ContainsKey(typeof(TEntity)))
    

16.         {
    

17.             return (IRepository<TEntity>)repositoryCache[typeof(TEntity)];
    

18.         }
    

19.         IRepository<TEntity> repository = new EdmRepository<TEntity>(this.objContext);
    

20.         this.repositoryCache.Add(typeof(TEntity), repository);
    

21.         return repository;
    

22.     }
    

24.     public void BeginTransaction() 
    

25.     { 
    

26.         // We do not need to begin a transaction here because the object context,
    

27.         // which would handle the transaction, was created and injected into the
    

28.         // constructor by Castle Windsor framework.
    

29.     }
    

31.     public void Commit()
    

32.     {
    

33.         this.objContext.SaveChanges();
    

34.     }
    

36.     public void Rollback()
    

37.     {
    

38.         // We also do not need to perform the rollback operation because
    

39.         // entity framework will handle this for us, just when the execution
    

40.         // point is stepping out of the using scope.
    

41.     }
    

43.     #endregion
    

45.     #region IDisposable Members
    

47.     public void Dispose()
    

48.     {
    

49.         this.repositoryCache.Clear();
    

50.         this.objContext.Dispose();
    

51.     }
    

53.     #endregion
    

54. }
    

EdmRepositoryTransactionContext被定义为internal，这个设计是合理的，因为Domain层是不需要知道事务上下文的具体实现，它将会被IoC/DI容器注入到Domain层中（本系列文章采用Castle Windsor框架）。在EdmRepositoryTransactionContext的构造函数中，它需要EntityFramework的ObjectContext对象来初始化实例。同样，由于IoC/DI的使用，我们在代码中也是不需要去创建这个ObjectContext的，交给Castle Windsor就OK了。第13行的GetRepository方法简单地采用了Dictionary对象来实现缓存仓储实例的效果，当然这种做法还有待改进。

EdmRepositoryTransactionContext是不需要BeginTransaction的，我们将方法置空，因为EntityFramework的事务会由ObjectContext来管理，同理，Rollback也被置空。

EdmRepository的实现就比较显而易见了，请参见上文。

此外，我们还可以针对NHibernate实现仓储模式，只需要实现IRepositoryTransactionContext和IRepository接口即可，比如：

隐藏行号 复制代码 ？NHibernateRepositoryTransactionContext实现

1. internal class NHibernateRepositoryTransactionContext : IRepositoryTransactionContext
   

2. {
   

3.     ITransaction transaction;
   

4.     Dictionary<Type, object> repositoryCache = new Dictionary<Type, object>();
   

6.     public ISession Session { get { return DatabaseSessionFactory.Instance.Session; } }
   

8.     #region IRepositoryTransactionContext Members
   

10.     public IRepository<TEntity> GetRepository<TEntity>() 
    

11.         where TEntity : EntityObject, IAggregateRoot
    

12.     {
    

13.         if (repositoryCache.ContainsKey(typeof(TEntity)))
    

14.         {
    

15.             return (IRepository<TEntity>)repositoryCache[typeof(TEntity)];
    

16.         }
    

17.         IRepository<TEntity> repository = new NHibernateRepository<TEntity>(this.Session);
    

18.         this.repositoryCache.Add(typeof(TEntity), repository);
    

19.         return repository;
    

20.     }
    

22.     public void BeginTransaction()
    

23.     {
    

24.         transaction = DatabaseSessionFactory.Instance.Session.BeginTransaction();
    

25.     }
    

27.     public void Commit()
    

28.     {
    

29.         transaction.Commit();
    

30.     }
    

32.     public void Rollback()
    

33.     {
    

34.         transaction.Rollback();
    

35.     }
    

37.     #endregion
    

39.     #region IDisposable Members
    

41.     public void Dispose()
    

42.     {
    

43.         transaction.Dispose();
    

44.         ISession dbSession = DatabaseSessionFactory.Instance.Session;
    

45.         if (dbSession != null && dbSession.IsOpen)
    

46.             dbSession.Close();
    

47.     }
    

49.     #endregion
    

50. }
    

隐藏行号 复制代码 ？NHibernateRepository实现

1. internal class NHibernateRepository<TEntity> : IRepository<TEntity>
   

2.     where TEntity : EntityObject, IAggregateRoot
   

3. {
   

4.     ISession session;
   

6.     public NHibernateRepository(ISession session)
   

7.     {
   

8.         this.session = session;
   

9.     }
   

11.     #region IRepository<TEntity> Members
    

13.     public void Add(TEntity entity)
    

14.     {
    

15.         this.session.Save(entity);
    

16.     }
    

18.     public TEntity GetByKey(int id)
    

19.     {
    

20.         return (TEntity)this.session.Get(typeof(TEntity), id);
    

21.     }
    

23.     public IEnumerable<TEntity> FindBySpecification(Func<TEntity, bool> spec)
    

24.     {
    

25.         throw new NotImplementedException();
    

26.     }
    

28.     public void Remove(TEntity entity)
    

29.     {
    

30.         this.session.Delete(entity);
    

31.     }
    

33.     public void Update(TEntity entity)
    

34.     {
    

35.         this.session.SaveOrUpdate(entity);
    

36.     }
    

38.     #endregion
    

39. }
    

在NHibernateRepositoryTransactionContext中使用了一个DatabaseSessionFactory的类，该类主要用于管理NHibernate的Session对象，具体实现如下（该实现已被用于我的Apworks应用开发框架原型中）：

隐藏行号 复制代码 ？DatabaseSessionFactory实现

1. /// <summary>
   

2. /// Represents the factory singleton for database session.
   

3. /// </summary>
   

4. internal sealed class DatabaseSessionFactory
   

5. {
   

6.     #region Private Static Fields
   

7.     /// <summary>
   

8.     /// The singleton instance of the database session factory.
   

9.     /// </summary>
   

10.     private static readonly DatabaseSessionFactory databaseSessionFactory = new DatabaseSessionFactory();
    

11.     #endregion
    

13.     #region Private Fields
    

14.     /// <summary>
    

15.     /// The session factory instance.
    

16.     /// </summary>
    

17.     private ISessionFactory sessionFactory = null;
    

18.     /// <summary>
    

19.     /// The session instance.
    

20.     /// </summary>
    

21.     private ISession session = null;
    

22.     #endregion
    

24.     #region Constructors
    

25.     /// <summary>
    

26.     /// Privately constructs the database session factory instance, configures the
    

27.     /// NHibernate framework by using the assemblies listed in the configured spaces(paths)
    

28.     /// that are decorated by <see cref="EntityVisibleAttribute"/>.
    

29.     /// </summary>
    

30.     private DatabaseSessionFactory()
    

31.     {
    

32.         Configuration nhibernateConfig = new Configuration();
    

33.         nhibernateConfig.Configure();
    

34.         nhibernateConfig.AddAssembly(typeof(IAggregateRoot).Assembly);
    

35.         sessionFactory = nhibernateConfig.BuildSessionFactory();
    

36.     }
    

37.     #endregion
    

39.     #region Public Properties
    

40.     /// <summary>
    

41.     /// Gets the singleton instance of the database session factory.
    

42.     /// </summary>
    

43.     public static DatabaseSessionFactory Instance
    

44.     {
    

45.         get
    

46.         {
    

47.             return databaseSessionFactory;
    

48.         }
    

49.     }
    

51.     /// <summary>
    

52.     /// Gets the singleton instance of the session. If the session has not been
    

53.     /// initialized or opened, it will return a newly opened session from the session factory.
    

54.     /// </summary>
    

55.     public ISession Session
    

56.     {
    

57.         get
    

58.         {
    

59.             ISession result = session;
    

60.             if (result != null && result.IsOpen)
    

61.                 return result;
    

62.             return OpenSession();
    

63.         }
    

64.     }
    

65.     #endregion
    

67.     #region Public Methods
    

68.     /// <summary>
    

69.     /// Always opens a new session from the session factory.
    

70.     /// </summary>
    

71.     /// <returns>The newly opened session.</returns>
    

72.     public ISession OpenSession()
    

73.     {
    

74.         this.session = sessionFactory.OpenSession();
    

75.         return this.session;
    

76.     }
    

77.     #endregion
    

79. }
    

简单小结一下。通过上面的例子可以看到，仓储的实现是不能依赖于任何技术细节的，因为领域模型并不关心技术问题。这并不是DDD一书中怎么说，我们就得怎么做。事实上的确如此，因为DDD的思想，使得我们应该把关注点放在业务分析与领域建模上，而仓储实现的分离正是这一思想的具体表现形式。不管怎么样，采用其它的手段也罢，我们还是应该遵循“将关注点放在领域”这一宗旨。

接下来看如何在领域层结合IoC框架使用仓储。仍然以Castle Windsor为例。配置文件如下（超长部分我用省略号去掉了）：

 

隐藏行号 复制代码 ？Castle Windsor配置

1. <castle>
   

2.   <components>
   

3.     <!-- Object Context for Entity Data Model -->
   

4.     <component id="ObjectContext"
   

5.                service="System.Data.Objects.ObjectContext, System.Data.Entity, Version=4.0.0.0,......" 
   

6.                type="EasyCommerce.Domain.Model.EntitiesContainer, EasyCommerce.Domain"/>
   

8.     <component id="GeneralRepository"
   

9.                service="EasyCommerce.Domain.IRepository`1[[EasyCommerce.Domain.Model.Customer, ......"
   

10.                type="EasyCommerce.Infrastructure.Repositories.EdmRepositories.EdmRepository`1[[EasyCo......">
    

11.       <objContext>${ObjectContext}</objContext>
    

12.     </component>
    

14.     <component id="TransactionContext"
    

15.                service="EasyCommerce.Domain.IRepositoryTransactionContext, EasyCommerce.Domain......"
    

16.                type="EasyCommerce.Infrastructure.Repositories.EdmRepositories.EdmRepositoryTransactionContext, ...">
    

17.     </component>
    

19.   </components>
    

20. </castle>
    

以下是调用代码：

隐藏行号 复制代码 ？调用方代码

1. [TestMethod]
   

2. public void TestCreateCustomer()
   

3. {
   

4.     IWindsorContainer container = new WindsorContainer(new XmlInterpreter());
   

5.     using (IRepositoryTransactionContext tx = container.GetService<IRepositoryTransactionContext>())
   

6.     {
   

7.         tx.BeginTransaction();
   

8.         try
   

9.         {
   

10.             Customer customer = Customer.CreateCustomer("daxnet", "12345",
    

11.                 new Name { FirstName = "Sunny", LastName = "Chen" },
    

12.                 new Address(), new Address(), DateTime.Now.AddYears(-29));
    

14.             IRepository<Customer> customerRepository = tx.GetRepository<Customer>();
    

15.             customerRepository.Add(customer);
    

17.             tx.Commit();
    

18.         }
    

19.         catch
    

20.         {
    

21.             tx.Rollback();
    

22.             throw;
    

23.         }
    

24.     }
    

25. }
    

 

测试结果及数据库数据结果：

 

 

【注意】：在使用NHibernate的仓储实现时，由于NHibernate的延迟加载特性，需要将实体的属性设置为virtual，以便由NHibernate产生Proxy Class进而实现延迟加载；但是由EntityFramework自动生成的源代码并不会将实体属性设置为virtual，而采用partial class也无法解决这个问题。因此需要在代码生成技术上做文章。我的做法是，针对edmx产生一个基于T4的代码生成模板，然后修改这个模板，分别在WritePrimitiveTypeProperty和WriteComplexTypeProperty方法中的适当位置加上virtual关键字：

隐藏行号 复制代码 ？WritePrimitiveTypeProperty

1.     private void WritePrimitiveTypeProperty(EdmProperty primitiveProperty, CodeGenerationTools code)
   

2.     {
   

3.         MetadataTools ef = new MetadataTools(this);
   

4. #>
   

6.     /// <summary>
   

7.     /// <#=SummaryComment(primitiveProperty)#>
   

8.     /// </summary><#=LongDescriptionCommentElement(primitiveProperty, 1)#>
   

9.     [EdmScalarPropertyAttribute(EntityKeyProperty=<#=code.CreateLiteral(ef.IsKey(primitiveProperty))#>, 

10. IsNullable=<#=code.CreateLiteral(ef.IsNullable(primitiveProperty))#>)]
    

11.     [DataMemberAttribute()]
    

12.     <#=code.SpaceAfter(NewModifier(primitiveProperty))#><#=Accessibility.ForProperty(primitiveProperty)#> virtual

13.  <#=code.Escape(primitiveProperty.TypeUsage)#> <#=code.Escape(primitiveProperty)#>
    

14.     {
    

15.         <#=code.SpaceAfter(Accessibility.ForGetter(primitiveProperty))#>get
    

16.         {
    

17. <#+             if (ef.ClrType(primitiveProperty.TypeUsage) == typeof(byte[]))
    

18.                 {
    

19. #>
    

20.             return StructuralObject.GetValidValue(<#=code.FieldName(primitiveProperty)#>);
    

隐藏行号 复制代码 ？WriteComplexTypeProperty

1.     private void WriteComplexTypeProperty(EdmProperty complexProperty, CodeGenerationTools code)
   

2.     {
   

3. #>
   

5.     /// <summary>
   

6.     /// <#=SummaryComment(complexProperty)#>
   

7.     /// </summary><#=LongDescriptionCommentElement(complexProperty, 1)#>
   

8.     [EdmComplexPropertyAttribute()]
   

9.     [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
   

10.     [XmlElement(IsNullable=true)]
    

11.     [SoapElement(IsNullable=true)]
    

12.     [DataMemberAttribute()]
    

13.     <#=code.SpaceAfter(NewModifier(complexProperty))#><#=Accessibility.ForProperty(complexProperty)#> virtual 

14. <#=MultiSchemaEscape(complexProperty.TypeUsage, code)#><#=code.Escape(complexProperty)#>
    

15.     {
    

16.         <#=code.SpaceAfter(Accessibility.ForGetter(complexProperty))#>get
    

17.         {
    

18.             <#=code.FieldName(complexProperty)#> = GetValidValue(<#=code.FieldName(complexProperty)#>, 

19. "<#=complexProperty.Name#>", 

20. false, <#=InitializedTrackingField(complexProperty, code)#>);
    

21.             <#=InitializedTrackingField(complexProperty, code)#> = true;
    

始终坚持一个原则：不要在生成的代码上直接修改，一是工作量巨大，另一方面就是，代码是自动生成的，今后模型修改了，代码将会重新生成。