用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没有其余操做的话，那么这样两个类就完成了。

最后项目截图：

 

在不断的整理，有空就整理一点功能，整个功能实现后会提供源码。