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 = "123",
          FirstName = "Dennis",
          LastName = "Gao",
        };
        Repository.Customer.Insert(customer);
        Repository.Commit();

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

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

需求

假设有一个新的需求：要求在应用层面记录对每个 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> 来完成这一个扩展。