EntityFramework中使用Repository装饰器

铺垫

通常在使用 EntityFramework 时，我们会封装出 IRepository 和 IUnitOfWork 接口，前者负责 CRUD 操作，后者负责数据提交 Commit。

   public interface IRepository<T>
       where T : class
   {
     IQueryable<T> Query();

     void Insert(T entity);

     void Update(T entity, params Expression<Func<T, object>>[] modifiedPropertyLambdas);

     void Delete(T entity);
   }

   public interface IUnitOfWork
   {
     void Commit();
   }

然后，通过使用 Unity IoC 容器来注册泛型接口与实现类型。

       Func<IUnityContainer> factory = () =>
       {
         return new UnityContainer()
           .RegisterType(typeof(IRepository<>), typeof(Repository<>), new ContainerControlledLifetimeManager())
           .RegisterType<IUnitOfWork, UnitOfWork>(new ContainerControlledLifetimeManager())
           .RegisterType<DbContext, MyDBContext>(new ContainerControlledLifetimeManager())
           .RegisterType<DbContextAdapter>(new ContainerControlledLifetimeManager())
           .RegisterType<IObjectSetFactory, DbContextAdapter>(new ContainerControlledLifetimeManager())
           .RegisterType<IObjectContext, DbContextAdapter>(new ContainerControlledLifetimeManager());
       };

进而使与数据库相关的操作在 Bisuness Logic 中呈现的非常简单。

例如，通过一系列封装，我们可以达到如下效果：

         Customer customer = new Customer()
         {
           ID = "",
           FirstName = "Dennis",
           LastName = "Gao",
         };
         Repository.Customer.Insert(customer);
         Repository.Commit();

查询操作也是一句话搞定：

 Customer customer = Repository.Customer.Query().SingleOrDefault(c => c.ID == "");

需求

假设有一个新的需求：要求在应用层面记录对每个 Table 的 CRUD 的次数。

这时，有几种办法：

1. 应用程序的 Business Logic 中自己记录，比如调用 Update() 操作后记录。
2. 使用 AOP 模式，在调用 CRUD 方法时注入计数器。
3. 修改 Repository<T> 实现，在每个方法中嵌入计数器。
4. 继承 Repository<T> 类，在衍生类中嵌入计数器。
5. 使用装饰器模式封装 Repository<T>，在新的 RepositoryDecorator<T> 类中嵌入计数器。

考虑到前三种方法均需要改动已有代码，主要是涉及的修改太多，所有没有尝试采用。

方法 4 则要求修改 Repository<T> 的实现，为 CRUD 方法添加 virtual 关键字以便扩展。

方法 5 不需要修改 Repository<T> 的实现，对已有代码的改动不大。

综上所述，我们选择了方法 5。

Repository 装饰器基类实现

为便于以后的扩展，创建一个装饰器的抽象类。

   public abstract class RepositoryDecorator<T> : IRepository<T>
      where T : class
   {
     private readonly IRepository<T> _surrogate;

     protected RepositoryDecorator(IRepository<T> surrogate)
     {
       _surrogate = surrogate;
     }

     protected IRepository<T> Surrogate
     {
       get { return _surrogate; }
     }

     #region IRepository<T> Members

     public virtual IQueryable<T> Query()
     {
       return _surrogate.Query();
     }

     public virtual void Insert(T entity)
     {
       _surrogate.Insert(entity);
     }

     public virtual void Update(T entity, params Expression<Func<T, object>>[] modifiedPropertyLambdas)
     {
       _surrogate.Update(entity, modifiedPropertyLambdas);
     }

     public virtual void Delete(T entity)
     {
       _surrogate.Delete(entity);
     }

     #endregion
   }

可以看到，RepositoryDecorator<T> 类型仍然实现了 IRepository<T> 接口，对外使用没有任何变化。

实现需求

我们定义一个 CountableRepository<T> 类用于封装 CRUD 计数功能，其继承自 RepositoryDecorator<T> 抽象类。

   public class CountableRepository<T> : RepositoryDecorator<T>
      where T : class
   {
     public CountableRepository(IRepository<T> surrogate)
       : base(surrogate)
     {
     }

     public override IQueryable<T> Query()
     {
       PerformanceCounter.CountQuery<T>();
       return base.Query();
     }

     public override void Insert(T entity)
     {
       PerformanceCounter.CountInsert<T>();
       base.Insert(entity);
     }

     public override void Update(T entity, params Expression<Func<T, object>>[] modifiedPropertyLambdas)
     {
       PerformanceCounter.CountUpdate<T>();
       base.Update(entity, modifiedPropertyLambdas);
     }

     public override void Delete(T entity)
     {
       PerformanceCounter.CountDelete<T>();
       base.Delete(entity);
     }
   }

我们在 override 方法中，添加了 CRUD 的计数功能。这里的代码简写为：

 PerformanceCounter.CountQuery<T>();

对原有代码的修改则是需要注册新的 CountableRepository<T> 类型。

       Func<IUnityContainer> factory = () =>
       {
         return new UnityContainer()
           .ReplaceBehaviorExtensionsWithSafeExtension()
           .RegisterType(typeof(IRepository<>), typeof(Repository<>), new ContainerControlledLifetimeManager())
           .RegisterType(typeof(CountableRepository<>), new ContainerControlledLifetimeManager())
           .RegisterType<IUnitOfWork, UnitOfWork>(new ContainerControlledLifetimeManager())
           .RegisterType<DbContext, MyDBContext>(new ContainerControlledLifetimeManager())
           .RegisterType<DbContextAdapter>(new ContainerControlledLifetimeManager())
           .RegisterType<IObjectSetFactory, DbContextAdapter>(new ContainerControlledLifetimeManager())
           .RegisterType<IObjectContext, DbContextAdapter>(new ContainerControlledLifetimeManager());
       };

扩展应用

既然有了抽象基类 RepositoryDecorator<T> ，我们可以从其设计衍生多个特定场景的 Repository 。

比如，当我们需要为某个 Table 的 Entity 添加缓存功能时，我们可以定制一个 CachableRepository<T> 来完成这一个扩展。