用MVC5+EF6+WebApi 做一個考試功能(六) 倉儲模式 打造EF通用倉儲類

前言

年底工作比較忙，年度總結還沒寫，項目要上線，回老家過年各種准備。尤其是給長輩給侄子侄女准備禮物頭都大了。

原來想年前先出一版能用的，我看有點懸了，盡量先把大體功能弄出來，扔掉一些，保證能考試，然后再搞點擴展的東西。

本節主要是做一下EF的封裝，在DDD設計中，有兩個概念不得不提，工作單元模式和倉儲模式。純屬個人理解，不對的地方大家交流。

下面是一張圖來自Microsoft 文檔站點

 

倉儲模式

定義

Repository模式用於通過抽象接口來管理CRUD操作，該接口公開領域實體並隱藏數據庫訪問代碼的實現細節。

為什么

其實定義已經很明確了，就是封裝了一下，讓上一層不知道數據訪問是怎么實現的，為什么要這么做呢？那就又回到了DDD的概念中了，充血模型下更關注業務功能而不是數據持久層怎么實現，以前三層的時候，DAL實際上關注的就是數據怎么取出來，怎么存進去。為了避免重回三層架構的窠臼，DDD中專門把持久化分出去作為一層，這一層與業務之間的分隔就是通過倉儲模式。

一般講，在領域中提供倉儲的接口，即要做什么。具體實現交給持久層，至於持久層是用ADO.NET 還是用ORM框架，數據放在RDBMS、XML、JSON、Cache或者Nosql中，這些都與領域模型無關，領域模型只關心接口，有沒有實現，這樣就保證了領域模型的與數據持久化之間的獨立。

優點

1. 隔離業務與數據持久化，實現關注點分離。
2. 便於自動化的單元測試或者測試驅動的開發
3. 代碼更加規整，可讀性高

參考資料：Why the Repository Pattern

 

工作單元模式

定義

Maintains a list of objects affected by a business transaction and coordinates the writing out of changes and the resolution of concurrency problems.   --P of EAA – Martin Fowler

“工作單元”模式用於將一個或多個操作（通常是數據庫操作）分組到單個事務或“工作單元”中，以便所有操作都可以通過或失敗。 --網友意譯。

 

為什么

工作單元的工作是為了保證業務操作的原子性，也就是一個連貫的業務在提交操作的時候，要么全部成功，要么全部失敗，比如用戶下單操作，要生成訂單，要消減庫存，要派送物流，業務上分析的話，這三個操作是同時完成的，不能分離，要么都成功，要么都失敗。

Entity Framework本身具有這一特性，在一個操作里面，只有調用 db.SaveChanges()時 ,操作才會進行保存，並且是同時成功或者同時失敗，既然EF本身以及有這一功能，為什么還要搞一個工作單元呢？

已經有了存儲模式，當單個實體操作進行增刪改查是沒有問題的，但是當涉及多個實體模型的操作時，就會出現有多個DbContext，大量重復代碼，跨實體操作的代碼無處安放等。

比如一個創建用戶的操作，如下兩個表（這個例子不是很恰當，一般理解下就行）：

注冊用戶的時候，有可能分布填寫信息，最后要添加兩條實體，一條賬號記錄一條用戶信息記錄。

在賬戶倉儲類中，我可以添加一條記錄，在用戶信息倉儲中也可以添加一條記錄。最后無法保證兩條記錄同時成功或者失敗。

實現

public interface IUnitOfWork
    {
        /// <summary>
        /// 命令
        /// </summary>
        /// <param name="commandText"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        int Command(string commandText, IDictionary<string, object> parameters);

        /// <summary>
        /// 事務的提交狀態
        /// </summary>
        bool IsCommited { get; set; }

        /// <summary>
        /// 提交事務
        /// </summary>
        /// <returns></returns>
        void Commit();

        /// <summary>
        /// 回滾事務
        /// </summary>
        void RollBack();
    }

 

本節正文-通用倉儲類實現

發現每次整理來整理去都墨跡的不行，前面介紹倉儲模式和工作單元花了一大堆精力，其實我項目中根本沒用工作單元，原因是項目比較小，如果需要工作單元的地方，在倉儲中自定義一個借口就給解決了。還有就是以前用工作單元+Ioc的模式，除了問題不好調試，為了保證項目進度，先實現功能，然后在重構吧。

 

首先倉儲模式是一個接口和接口的實現，我們在Domain項目中添加IRepository接口，定義內容如下：

public interface IRepository<TEntity> where TEntity : class
    {
        IQueryable<TEntity> All();

        TEntity Single(long id);

        TEntity Single(Expression<Func<TEntity, bool>> predicate);

        TEntity Single(long id, params Expression<Func<TEntity, object>>[] propertySelectors);

        IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> predicate);

        IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> predicate, params Expression<Func<TEntity, object>>[] propertySelectors);

        int Count();

        int Count(Expression<Func<TEntity, bool>> criteria);

        IEnumerable<TEntity> Get<TOrderBy>(Expression<Func<TEntity, bool>> criteria, Expression<Func<TEntity, TOrderBy>> orderBy, int pageIndex, int pageSize, SortOrder sortOrder = SortOrder.Ascending);

        TEntity Delete(long id);

        bool Add(TEntity entity);

        bool Update(TEntity entity);

        int Save(TEntity entity);
    }

接口中定義了增刪改查各種操作，所有的實現都在持久化層，我們這里封裝一下，提供一個通用倉儲類如下：

public class GenericRepository<TEntity> : IRepository<TEntity> where TEntity : EneityOfLongPrimarykey
    {
        private MyDbContext context;

        public GenericRepository()
        {
            context = new MyDbContext();
            // Load navigation properties explicitly (avoid serialization trouble)
            context.Configuration.LazyLoadingEnabled = false;

            // Do NOT enable proxied entities, else serialization fails.
            context.Configuration.ProxyCreationEnabled = false;

            // Because Web API will perform validation, we don't need/want EF to do so
            context.Configuration.ValidateOnSaveEnabled = false;
        }

        public virtual IQueryable<TEntity> All()
        {
            return context.Set<TEntity>().AsQueryable();
        }

        public TEntity Single(long id)
        {
            return All().Single(t => t.Id == id);
        }

        public TEntity Single(long id, params Expression<Func<TEntity, object>>[] propertySelectors)
        {
            return Find(s => s.Id == id, propertySelectors).FirstOrDefault();
        }

        public TEntity Single(Expression<Func<TEntity, bool>> predicate)
        {
            return All().Single(predicate);
        }

        public IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> predicate)
        {
            if (predicate != null)
            {
                return All().Where(predicate).AsNoTracking();
            }
            else
            {
                return All();
            }
        }

        /// <summary>
        /// 取過濾數據，啟用延遲查詢
        /// </summary>
        /// <param name="predicate">過濾條件</param>
        /// <param name="propertySelectors">需要Left Join 的表</param>
        /// <returns></returns>
        public IQueryable<TEntity> Find(Expression<Func<TEntity, bool>> predicate, params Expression<Func<TEntity, object>>[] propertySelectors)
        {
            if (propertySelectors.IsNullOrEmpty())
            {
                return Find(predicate);
            }

            var query = Find(predicate);

            foreach (var propertySelector in propertySelectors)
            {
                query = query.Include(propertySelector);
            }

            return query;
        }

        public int Count()
        {
            return All().Count();
        }

        public int Count(Expression<Func<TEntity, bool>> criteria)
        {
            return All().Count(criteria);
        }

        public IEnumerable<TEntity> Get<TOrderBy>(Expression<Func<TEntity, bool>> criteria, Expression<Func<TEntity, TOrderBy>> orderBy, int pageIndex, int pageSize, SortOrder sortOrder = SortOrder.Ascending)
        {
            if (sortOrder == SortOrder.Ascending)
            {
                return All().OrderBy(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsEnumerable();
            }
            return All().OrderByDescending(orderBy).Skip((pageIndex - 1) * pageSize).Take(pageSize).AsEnumerable();
        }

        public TEntity Delete(long id)
        {
            var entity = Single(id);
            context.Set<TEntity>().Remove(entity);
            context.SaveChanges();
            return entity;
        }

        public bool Add(TEntity entity)
        {
            if (context.Entry<TEntity>(entity).State != EntityState.Detached)
            {
                context.Entry<TEntity>(entity).State = EntityState.Added;
            }
            context.Set<TEntity>().Add(entity);
            return context.SaveChanges() > 0;
        }

        public bool Update(TEntity entity)
        {
            if (context.Entry<TEntity>(entity).State != EntityState.Detached)
            {
                context.Set<TEntity>().Attach(entity);
            }
            context.Entry<TEntity>(entity).State = EntityState.Modified;
            return context.SaveChanges() > 0;
        }

        public int Save(TEntity entity)
        {
            return context.SaveChanges();
        }

    }

 

使用方法：

考試科目的倉儲接口

/// <summary>
    ///   倉儲層接口——ExamSubject
    /// </summary>
    public partial interface IExamSubjectRepository : IRepository<ExamSubject>
    { }

 

考試科目的倉儲接口實現：

using Trump.Domain.Entities;
using Trump.EF.Common;

namespace Trump.EF.Repository
{
    /// <summary>
    ///   倉儲實現——ExamQuestionBizType
    /// </summary>
    public partial class ExamSubjectRepository : GenericRepository<ExamSubject>, IExamSubjectRepository
    { }
}

如果在這個實體模型中，除了CRUD沒有其他操作的話，那么這樣兩個類就完成了。

最后項目截圖：

 

在不斷的整理，有空就整理一點功能，整個功能實現后會提供源碼。