用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沒有其餘操做的話，那麼這樣兩個類就完成了。

最後項目截圖：

 

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