幸福框架：准備抽象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版本的工作單元的開發，我們就繼續對異常進行抽象。