zoukankan html css js c++ java

EntityFramework之领域驱动设计实践（九）（转）

http://www.cnblogs.com/daxnet/archive/2010/07/10/1774706.html

仓储的实现：深入篇

早在年前的时候就已经在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

public interface IRepositoryTransactionContext : IDisposable

```
{ 
```

    IRepository<TEntity> GetRepository<TEntity>()

        where TEntity : EntityObject, IAggregateRoot;

```
    void BeginTransaction(); 
```
```
    void Commit(); 
```
```
    void Rollback(); 
```
```
} 
```

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

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

隐藏行号复制代码？ EdmRepositoryTransactionContext

internal class EdmRepositoryTransactionContext : IRepositoryTransactionContext

```
{ 
```
```
    private ObjectContext objContext; 
```

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

    public EdmRepositoryTransactionContext(ObjectContext objContext)

```
    { 
```
```
        this.objContext = objContext; 
```
```
    } 
```

    #region IRepositoryTransactionContext Members

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

```
 { 
```

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

```
        { 
```

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

```
        } 
```

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

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

```
        return repository; 
```
```
    } 
```
```
    public void BeginTransaction()  
```
```
    {  
```

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

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

        // constructor by Castle Windsor framework.

```
 } 
```
```
    public void Commit() 
```
```
    { 
```
```
        this.objContext.SaveChanges(); 
```
```
    } 
```
```
    public void Rollback() 
```
```
    { 
```

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

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

        // point is stepping out of the using scope.

```
 } 
```
```
    #endregion 
```
```
 
```
```
    #region IDisposable Members 
```
```
    public void Dispose() 
```
```
    { 
```
```
        this.repositoryCache.Clear(); 
```
```
        this.objContext.Dispose(); 
```
```
    } 
```
```
    #endregion 
```
```
} 
```

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实现

internal class NHibernateRepositoryTransactionContext : IRepositoryTransactionContext

```
{ 
```
```
    ITransaction transaction; 
```

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

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

    #region IRepositoryTransactionContext Members

    public IRepository<TEntity> GetRepository<TEntity>()

        where TEntity : EntityObject, IAggregateRoot

```
 { 
```

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

```
        { 
```

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

```
        } 
```

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

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

```
        return repository; 
```
```
    } 
```
```
    public void BeginTransaction() 
```
```
    { 
```

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

```
    } 
```
```
    public void Commit() 
```
```
    { 
```
```
        transaction.Commit(); 
```
```
    } 
```
```
    public void Rollback() 
```
```
    { 
```
```
        transaction.Rollback(); 
```
```
    } 
```
```
    #endregion 
```
```
 
```
```
    #region IDisposable Members 
```
```
    public void Dispose() 
```
```
    { 
```
```
        transaction.Dispose(); 
```

        ISession dbSession = DatabaseSessionFactory.Instance.Session;

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

```
            dbSession.Close(); 
```
```
    } 
```
```
    #endregion 
```
```
} 
```

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

internal class NHibernateRepository<TEntity> : IRepository<TEntity>

    where TEntity : EntityObject, IAggregateRoot

```
{ 
```
```
    ISession session; 
```

    public NHibernateRepository(ISession session)

```
    { 
```
```
        this.session = session; 
```
```
    } 
```

    #region IRepository<TEntity> Members

```
    public void Add(TEntity entity) 
```
```
    { 
```
```
        this.session.Save(entity); 
```
```
    } 
```
```
    public TEntity GetByKey(int id) 
```
```
    { 
```

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

```
    } 
```

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

```
    { 
```

        throw new NotImplementedException();

```
    } 
```
```
    public void Remove(TEntity entity) 
```
```
    { 
```
```
        this.session.Delete(entity); 
```
```
    } 
```
```
    public void Update(TEntity entity) 
```
```
    { 
```

        this.session.SaveOrUpdate(entity);

```
    } 
```
```
    #endregion 
```
```
} 
```

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

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

```
/// <summary> 
```

/// Represents the factory singleton for database session.

```
/// </summary> 
```

internal sealed class DatabaseSessionFactory

```
{ 
```
```
    #region Private Static Fields 
```
```
    /// <summary> 
```

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

```
 /// </summary> 
```

 private static readonly DatabaseSessionFactory databaseSessionFactory = new DatabaseSessionFactory();

```
    #endregion 
```
```
 
```
```
    #region Private Fields 
```
```
    /// <summary> 
```
```
    /// The session factory instance. 
```
```
 /// </summary> 
```

 private ISessionFactory sessionFactory = null;

```
    /// <summary> 
```
```
    /// The session instance. 
```
```
 /// </summary> 
```
```
 private ISession session = null; 
```
```
    #endregion 
```
```
 
```
```
    #region Constructors 
```
```
    /// <summary> 
```

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

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

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

```
 /// </summary> 
```
```
 private DatabaseSessionFactory() 
```
```
    { 
```

        Configuration nhibernateConfig = new Configuration();

```
        nhibernateConfig.Configure(); 
```

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

        sessionFactory = nhibernateConfig.BuildSessionFactory();

```
    } 
```
```
    #endregion 
```
```
 
```
```
    #region Public Properties 
```
```
    /// <summary> 
```

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

```
 /// </summary> 
```

 public static DatabaseSessionFactory Instance

```
    { 
```
```
        get 
```
```
 { 
```

            return databaseSessionFactory;

```
        } 
```
```
    } 
```
```
    /// <summary> 
```

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

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

```
 /// </summary> 
```
```
 public ISession Session 
```
```
    { 
```
```
        get 
```
```
 { 
```
```
            ISession result = session; 
```

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

```
                return result; 
```
```
            return OpenSession(); 
```
```
        } 
```
```
    } 
```
```
    #endregion 
```
```
 
```
```
    #region Public Methods 
```
```
    /// <summary> 
```

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

```
 /// </summary> 
```

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

```
 public ISession OpenSession() 
```
```
    { 
```

        this.session = sessionFactory.OpenSession();

```
        return this.session; 
```
```
    } 
```
```
    #endregion 
```
```
 
```
```
} 
```

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

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

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

```
<castle> 
```
```
  <components> 
```

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

```
    <component id="ObjectContext" 
```

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

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

```
 
```
```
    <component id="GeneralRepository" 
```

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

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

      <objContext>${ObjectContext}</objContext>

```
    </component> 
```
```
 
```
```
    <component id="TransactionContext" 
```

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

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

```
    </component> 
```
```
 
```
```
  </components> 
```
```
</castle> 
```
```
 
```

以下是调用代码：

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

```
[TestMethod] 
```
```
public void TestCreateCustomer() 
```
```
{ 
```

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

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

```
    { 
```
```
        tx.BeginTransaction(); 
```
```
        try 
```
```
 { 
```

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

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

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

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

            customerRepository.Add(customer);

```
            tx.Commit(); 
```
```
        } 
```
```
        catch 
```
```
 { 
```
```
            tx.Rollback(); 
```
```
            throw; 
```
```
        } 
```
```
    } 
```
```
} 
```

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

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

隐藏行号复制代码？ WritePrimitiveTypeProperty

    private void WritePrimitiveTypeProperty(EdmProperty primitiveProperty, CodeGenerationTools code)

```
    { 
```

        MetadataTools ef = new MetadataTools(this);

```
#> 
```
```
    /// <summary> 
```

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

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

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

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

```
    [DataMemberAttribute()] 
```

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

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

```
    { 
```

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

```
        { 
```

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

```
                { 
```
```
#> 
```

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

隐藏行号复制代码？ WriteComplexTypeProperty

    private void WriteComplexTypeProperty(EdmProperty complexProperty, CodeGenerationTools code)

```
    { 
```
```
#> 
```
```
    /// <summary> 
```

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

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

```
    [EdmComplexPropertyAttribute()] 
```

    [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]

```
    [XmlElement(IsNullable=true)] 
```
```
    [SoapElement(IsNullable=true)] 
```
```
    [DataMemberAttribute()] 
```

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

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

```
    { 
```

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

```
        { 
```

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

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

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

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

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

查看全文

相关阅读:
centos go语言开启代理国内镜像
 Docker给MongoDB设置用户密码
 ubuntu镜像一般apt-get源地址都是在国外导致在构建时因为源地址问题导致下载速度极其得慢
 在centos7安装nodejs并升级nodejs到最新版本
 使用express创建简单web服务器
 关于docker的mongo镜像的部署
 Python：函数定义
 Python：if-while-for
Python：运算符
 Python：标准数据类型6种

原文地址：https://www.cnblogs.com/quietwalk/p/2229945.html