幸福框架：准备抽象NHibernate和EntityFramework，大家给点意见

背景

考虑到目前中小企业应用的主流是ORM，我准备在NHibernate和EntityFramework之间找到一个抽象层，也就是说我准备只支持NHibernate和EntityFramework。

思路

NH和EF都实现了“工作单元”和“主键映射”这两种企业应用模式，而这两种模式其实就是管理一种状态机，如下图：

实现

工作单元接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Happy.Domain
{
    /// <summary>
    /// 工作单元接口。
    /// </summary>
    /// <remarks>
    /// 聚合状态：
    /// <list type="number">
    ///     <item>transient：实例存在于内存中，但不存在于工作单元和数据库中。</item>
    ///     <item>persistent in database：实例存在于数据库中。</item>
    ///     <item>persistent in unitofwork：实例存在于工作单元中。</item>
    ///     <item>detached：实例存在于内存和数据库中，但不存在于工作单元中。</item>
    /// </list>
    /// 合法转换：
    /// <list type="number">
    ///     <item>transient > Save -> persistent in unitofwork，Flush时会生成Insert Sql，场景：从UI层创建实例，执行创建。</item>
    ///     <item>detached -> Update -> persistent in unitofwork，Flush时会生成Update Sql，场景：从UI层重建实例，执行修改（支持离线乐观并发）。</item>
    ///     <item>detached -> Persist -> persistent in unitofwork，Flush时不会生成Sql，场景：将实例从另一个工作单元脱钩，添加到当前工作单元。</item>
    ///     <item>detached -> Delete -> persistent in unitofwork，Flush时会生成Delete Sql，场景：从UI层重建实例，删除记录。</item>
    ///     <item>detached -> Merge -> persistent in unitofwork，Flush时会生成Update Sql，场景：从UI层重建实例，合并到从数据库重建的实例，执行修改（不支持离线乐观并发）。</item>
    ///     <item>persistent in unitofwork -> Evict -> detached，Flush时不会生成Sql，场景：将实例从当前工作单元脱钩，添加到另一个工作单元。</item>
    ///     <item>persistent in unitofwork -> Delete -> persistent in unitofwork，Flush时会生成Delete Sql，场景：从数据库重建实例，删除记录。</item>
    ///     <item>persistent in unitofwork -> Flush -> persistent in database，提交工作单元，会生成SQL，场景：执行完一系列Create、Update和Delete后统一提交，只产生一次数据库往返。</item>
    ///     <item>persistent in database -> Load -> persistent in unitofwork，从数据库重建实例。</item>
    ///     <item>persistent in database -> Refresh -> persistent in unitofwork，从数据库刷新实例，场景：使用存储过程修改了一个实例，使用此方法重新刷新一下。</item>
    /// </list>
    /// </remarks>
    public interface IUnitOfWork : IDisposable
    {
        /// <summary>
        /// 判断<paramref name="item"/>是否 persistent in unitofwork。
        /// </summary>
        bool Contains<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// transient > Save -> persistent in unitofwork，Flush时会生成Insert Sql，场景：从UI层创建实例，执行创建。
        /// </summary>
        void Save<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// detached -> Update -> persistent in unitofwork，Flush时会生成Update Sql，场景：从UI层重建实例，执行修改（支持离线乐观并发）。
        /// </summary>
        void Update<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// detached -> Persist -> persistent in unitofwork，Flush时不会生成Sql，场景：将实例从另一个工作单元脱钩，添加到当前工作单元。
        /// </summary>
        void Persist<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// 执行如下两种转换：
        /// <list type="number">
        ///     <item>detached -> Delete -> persistent in unitofwork，Flush时会生成Delete Sql，场景：从UI层重建实例，删除记录。</item>
        ///     <item>persistent in unitofwork -> Delete -> persistent in unitofwork，Flush时会生成Delete Sql，场景：从数据库重建实例，删除记录。</item>
        /// </list>
        /// </summary>
        void Delete<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// detached -> Merge -> persistent in unitofwork，Flush时会生成Update Sql，场景：从UI层重建实例，合并到从数据库重建的实例，执行修改（不支持离线乐观并发）。
        /// </summary>
        void Merge<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// persistent in unitofwork -> Evict -> detached，Flush时不会生成Sql，场景：将实例从当前工作单元脱钩，添加到另一个工作单元。
        /// </summary>
        void Evict<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// persistent in unitofwork -> Flush -> persistent in database，提交工作单元，会生成SQL，场景：执行完一系列Create、Update和Delete后统一提交，只产生一次数据库往返。
        /// </summary>
        void Flush();

        /// <summary>
        /// persistent in database -> Load -> persistent in unitofwork，从数据库重建实例。
        /// </summary>
        TAggregateRoot Load<TAggregateRoot>(Guid id)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// persistent in database -> Refresh -> persistent in unitofwork，从数据库刷新实例，场景：使用存储过程修改了一个实例，使用此方法重新刷新一下。
        /// </summary>
        void Refresh<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot;

        /// <summary>
        /// 回滚所有自上次提交以后的修改。
        /// </summary>
        void Clear();

        /// <summary>
        /// 清空处于persistent in unitofwork状态的实例。
        /// </summary>
        TRepository GetRepository<TRepository>()
            where TRepository : IRepository;
    }
}

基于EntityFramework的工作单元

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Data;
using System.Data.Entity;
using System.Data.Entity.Infrastructure;

using Microsoft.Practices.ServiceLocation;

using Happy.Domain;
using Happy.DesignByContract;

namespace Happy.EntityFramework
{
    /// <summary>
    /// 基于EntityFramework的工作单元。
    /// </summary>
    public abstract class UnitOfWork : DbContext, IUnitOfWork
    {
        private readonly Dictionary<Type, IRepository> repositories = new Dictionary<Type, IRepository>();

        /// <summary>
        /// 构造方法。
        /// </summary>
        protected UnitOfWork()
        {
        }

        /// <summary>
        /// 构造方法。
        /// </summary>
        protected UnitOfWork(string nameOrConnectionString)
            : base(nameOrConnectionString)
        {
        }

        /// <inheritdoc />
        public bool Contains<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            return this.Entry(item).State != EntityState.Detached;
        }

        /// <inheritdoc />
        public void Save<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            this.Set<TAggregateRoot>().Add(item);
        }

        /// <inheritdoc />
        public void Update<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            this.Entry(item).State = EntityState.Modified;
        }

        /// <inheritdoc />
        public void Persist<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            this.Entry(item).State = EntityState.Unchanged;
        }

        /// <inheritdoc />
        public void Delete<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            this.Entry(item).State = EntityState.Deleted;
        }

        /// <inheritdoc />
        public void Merge<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            var persistItem = this.Set<TAggregateRoot>().Find(item.Id);

            this.Entry(persistItem).CurrentValues.SetValues(item);
        }

        /// <inheritdoc />
        public void Evict<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            this.Entry(item).State = EntityState.Detached;
        }

        /// <inheritdoc />
        public void Flush()
        {
            try
            {
                base.SaveChanges();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                throw new OptimisticConcurrencyException(ex.Message, ex);
            }
        }

        public TAggregateRoot Load<TAggregateRoot>(Guid id)
            where TAggregateRoot : AggregateRoot
        {
            return this.Set<TAggregateRoot>().Find(id);
        }

        public void Refresh<TAggregateRoot>(TAggregateRoot item)
            where TAggregateRoot : AggregateRoot
        {
            item.MustNotNull("item");

            this.Entry(item).Reload();
        }

        /// <inheritdoc />
        public void Clear()
        {
            base.ChangeTracker.Entries()
                              .ToList()
                              .ForEach(entry => entry.State = System.Data.EntityState.Detached);
        }

        /// <inheritdoc />
        public TRepository GetRepository<TRepository>()
            where TRepository : IRepository
        {
            var key = typeof(TRepository);

            if (!repositories.ContainsKey(key))
            {
                var repository = ServiceLocator.Current.GetInstance<TRepository>();
                (repository as IEntityFrameworkRepository).Owner = this;
                repositories[key] = repository;
            }

            return (TRepository)repositories[key];
        }
    }
}

备注

其实我们经常忽略一个关于接口的问题，就是异常本身也是API的一部分，虽然这部分在C#中没有办法显式的表达，等我的朋友实现完了NH版本的工作单元的开发，我们就继续对异常进行抽象。