TinyFrame升级之七：重构Repository和Unit Of Work

首先，重构的想法来源于以下文章：Correct use of Repository and Unit Of Work patterns in ASP.NET MVC,因为我发现在我的框架中，对UnitOfWork使用了错误的设计方法，同时感谢一下文章：Generically Implementing the Unit of Work & Repository Pattern with Entity Framework in MVC & Simplifying Entity Graphs,我的重构设计参考了它。

下面来说说我的具体重构方式。

在原来的代码中，我的Repository<T>泛型继承自IRepository<T>并且在增删改查代码中做了如下处理：

  public virtual void Insert(T entity)
        {
            try
            {
                if (entity == null)
                    throw new ArgumentException("实体类为空");
                DbSet.Add(entity);
                context.SaveChanges();
            }
            catch (DbEntityValidationException dbex)
            {
                var msg = string.Empty;
                foreach(var validationErrors in dbex.EntityValidationErrors)
                    foreach(var validateionError in validationErrors.ValidationErrors)
                        msg+=string.Format("Property:{0} Error:{1}",validateionError.PropertyName,validateionError.ErrorMessage);

                var fail = new Exception(msg,dbex);
                throw fail;
            }
        }

最关键的地方是，我添加了“Context.SaveChanges”方法，这就直接导致UnitOfWork的规则失效。UnitOfWork出现的本身是为了提供事务提交支持。这样直接在Repository中提交，直接导致UnitOfWork功能废弃。

还有个地方就是在前台，通过Autofac注册完毕后，我是这么用的：

public BookService(IUnitOfWork unitOfWork
           , IBook bookRepository
           , IBookType bookTypeRepository
           , IBookPlace bookPlaceRepository
           , ICacheManager cacheManager
           , ILoggerService logger
           )
       {
           this.unitOfWork = unitOfWork;
           this.bookRepository = bookRepository;
           this.bookTypeRepository = bookTypeRepository;
           this.bookPlaceRepository = bookPlaceRepository;
           this.cacheManager = cacheManager;
           this.logger = logger;
       }

       private readonly IUnitOfWork unitOfWork;
       private readonly IBook bookRepository;
       private readonly IBookType bookTypeRepository;
       private readonly IBookPlace bookPlaceRepository;
       private readonly ICacheManager cacheManager;
       private readonly ILoggerService logger;

这样做的话，当以后我们有表删除或者新增的时候，我们不得不维护这样的列表。这完全不符合OO设计原则。

但是如果引入UnitOfWork的话，内部利用Hashtable等实现对Respository的指向，那么在界面我们只要这样写就可以了：

public BookService(
             IUnitOfWork unitOfWork
           , ICacheManager cacheManager
           , ILoggerService logger
           )
       {
           this.unitOfWork = unitOfWork;
           this.cacheManager = cacheManager;
           this.logger = logger;
       }

       private readonly IUnitOfWork unitOfWork;
       private readonly ICacheManager cacheManager;
       private readonly ILoggerService logger;

使用的时候，直接这样实例化就行了：

var bookPlaceRepository = unitOfWork.Repository<BookPlace>();

这样做完全不用顾虑有新表的添加删除了。代码根本就不用动。

所以，综上两点，UnitOfWork的引入为了解决以下问题：

1.提供全局事务支持。

2.提供对Repository模型的指向。以便于松耦合绑定。

下面是代码重构部分：

IUnitOfWork接口部分：

using System;
using TinyFrame.Data.DataRepository;
using TinyFrame.Data.DomainModel;

namespace TinyFrame.Unitofwork
{
    public interface IUnitOfWork
    {
        void Commit();
        IRepository<T> Repository<T>() where T : class;

        void Dispose(bool disposing);
        void Dispose();
    }
}

实现部分比较简单，利用Hashtable来保存对Repository的指向：

using System;
using System.Data.Entity;
using TinyFrame.Data.DataRepository;
using TinyFrame.Data.DomainModel;
using TinyFrame.Data.DataContext;
using System.Collections;

namespace TinyFrame.Unitofwork
{
    public class UnitOfWork : IUnitOfWork
    {
        public UnitOfWork(IDbContext dbContext)
        {
            this.dbContext = dbContext;
        }

        private readonly IDbContext dbContext;
        private bool disposed;
        private Hashtable repositorys;

        public void Commit()
        {
            dbContext.SaveChanges();
        }

        public IRepository<T> Repository<T>() where T:class
        {
            if (repositorys == null)
                repositorys = new Hashtable();

            var type = typeof(T).Name;

            if (!repositorys.ContainsKey(type))
            {
                var repositoryType = typeof(Repository<>);
                var repositoryInstance = Activator.CreateInstance(repositoryType.MakeGenericType(typeof(T)), dbContext);
                repositorys.Add(type, repositoryInstance);
            }
            return (IRepository<T>)repositorys[type];
        }

        #region Dispose method
        public virtual void Dispose(bool disposing)
        {
            if (!disposed)
                if (disposing)
                    dbContext.Dispose();
            disposed = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }
        #endregion
    }
}

第17行，保持对DbContext的引用，以便于进行提交操作。

第26行，Repository<T>泛型方法，以便于动态返回仓储模型。

需要注意的是，在Repository<T>的实现中，不要再增删改查里面再添加 DbContext.SaveChanges方法，首先是没意义，其次是完全不符合Repository和UnitOfWork的做法。

最后附图一张，表明我对Repository和UnitOfWork的理解：

本章源码下载：

点击这里下载

备份下载地址