代理模式是什么？如何在 C# 中实现代理模式

时间:2020-04-22 清水栞人气:0

代理模式 并不是日常开发工作中常常用到的一种设计模式，也是一种不易被理解的一种设计模式。但是它会广泛的应用在系统框架、业务框架中。

定义

它的定义就如其它同大部分 设计模式 的定义类似，即不通俗也不易懂，而且随便百度一下就能找到 : 为其他对象提供一种代理，以控制对这个对象的访问。代理对象在客户端和目标对象之间起到中介的作用。

每个字都认识，连在一起就看不懂了 by. 某个攻城狮

我们一个词一个词看就明白了。

其他对象

所谓的其它，其实就是你系统中任意一个类型，可以是 UserService、OrderRepository、DataDeletedEventListener、等等。

控制对这个对象的访问

访问其实就是调用这个对象上的方法、访问它的属性、设置它的属性等等，比如

User user = UserService.GetUserById(1); // 访问了 GetUserById 方法
int id = user.Id; // 访问了 Id 属性
Order order = OrderRepository.SelectByUserId(id); // 访问了 SelectByUserId 方法

控制访问 ,控制的本质是包装，外部不再直接使用 其他对象 ，而是使用代理，再由代理来访问 其它对象。我们可以使用一个已有的 List<T> 实现一个 IList<T> ，并在使用 Add 方法时，打印一行日志。

public class LogList<T> : IList<T>
{
  // other code here..
  
  private IList<T> raw; // 这个就 "其它对象"
  
  public EventList(IList<T> raw)
  {
      this.raw = raw; // 通过构造函数，这可以让 EventList 控制对 IList<T> 的访问。
  }
  
  public void Add(T value)
  {
      this.raw.Add(value);
      Console.WriteLine(value);
  }
}

上面就是一个简单的代理模式的例子:
为 IList<T> 提供一种 LogList<T> ，以控制对 IList<T> 的访问。

实现

简单实现

上面 LogList<T> 就是一种简单的实现。

但是你无法对这个类做外部扩展，所有的逻辑都在类型的内部被固定了。

于是我们可以使用下面的方法创建一个可以灵活扩展的 ListProxy<T>

public interface IListInterruption<T>
{
    // other codes
    
    // 执行 IList.Add 时会进入的方法
    void OnAdding(IList<T> list, T addingValue);

    // 执行完 IList.Add 时会进入的方法
    void OnAdded(IList<T> list, T addedValue);

    // other codes

}

// 列表代理类
// 允许外部提供 IListInterruption 来丰富 ListProxy<T> 的逻辑。
public class ListProxy<T> : IList<T>
{
    private readonly IList<T> raw;
    private readonly List<IListInterruption> interruptions;

    public ListProxy(IList<T> raw)
    {
        this.interruptions = new List<IListInterruption>();
        this.raw = raw;
    }

    public void AddInterruption(IListInterruption interruption)
    {
        this.interruptions.Add(interruption);
    }

    public void Add(T value)
    {
        foreach(var item in this.interruptions)
            item.OnAdding(this.raw, value);

        this.raw.Add(value);
        
        foreach(var item in this.interruptions)
            item.OnAdded(this.raw, value);
    }
}

上面的代码实现一个较为灵活的 ProxyList<T> 。

首先看看 IListInterruption。通过实现 IListInterruption 接口，可以向 ProxyList 提供各种各样的功能。

我们可以看一个简单的功能

public class LogListInterruption<T> : IListInterruption<T>
{
    // other codes

    public void OnAdding(IList<T> list, T addingValue)
    {
        Console.WriteLie("Adding : {0}", addingValue);
    }

    // other codes
}

向 ProxyList 添加上述组件，就可以实现在 Add 前打印待添加的值的功能。

List<int> myList = new List<int>();
ProxyList<int> proxy = new ProxyList<int>(myList);
proxy.AddInterruption(new LogListInterruption<int>());
proxy.Add(1);
// >> Adding : 1

这种实现方式可以创建出针对某个类型的代理类，并通过外部给予的 IListInterruption 来丰富代理类功能。

但缺点是，当你无法为所有的类型都创建 Proxy 和 Interruption 。

动态代理类

之前的方法中，我们在编写阶段就已经建立了代理类，被称为静态代理类。

这种方法无法将代理类运用在系统中任何一个我们可能需要的类型上。

于是，动态代理类就来了。

动态代理类依靠编程语言本身的特征，让程序在运行时创建类型，实现接口，添加功能等等。

在 C# 中可以通过两种方式实现运行时创建类型的功能

CodeDom + 运行时编译
Emit

CodeDom 可以用来生成 C# 代码，再利运行时编译，会将C#代码编译为内存中的程序集，最后通过反射访问程序集中的成员。
这种方法的特点就是慢。。。。因为要生成语句，还要编译，生成程序集，最后还要反射，都是大开销，所以慢是可想而知的。

Emit 提供了利用 IL 命令在运行时创建类型、方法，并填充方法内的功能。
毕竟 C# 最终就是编译成 IL 的，所以直接使用 IL 性能当然快无敌了。

这个方式的缺点只有一个 : 学习 IL 。这玩意可不是每个人都愿意去学的。。。

于是，选择一些已经利用 Emit 做好了动态代理类功能的第三方功能库，成为了一个很好的选择。

C# 大环境下，可以用来生成动态代理类的库一般有两个选择 :

PostSharp
Caslte.DynamicProxy

其中 PostSharp 使用了更复杂的技术，不是使用 Emit，而且在编译时，就将代理类所附加的功能放进了目标类型中，你可以通过 Attribute 向任意的方法添加额外的功能。

PostSharp 会在程序编译时，把这些 Attribute 的功能直接编译到方法内部。
这种在编译时就把一切准备好的方法，让 PostSharp 有着最高的运行性能。
但是又傻瓜、又好用的 PostSharp 只有一个缺点 ———— 收费。

Castle.DynamicProxy 是免费的，他是利用 Emit 在程序运行时创建代理类的。
使用 Castle.DynamicProxy 有两个步骤：

编写 Interceptor
将 Interceptor 附加到某个类型或接口上，并得到一个会调用你的 Interceptor 的代理类实例

开发流程很像之前的 LogList 的例子。

相比较 PostSharp 那种一个 Attribute 就搞定一切的模式， Caslte.DynamicProxy 就没有那么方便了。

那么一个显而易见的问题就来了 :
能不能利用 Caslte.DynamicProxy 实现像 PostSharp 那样利用 Attribute 创建代理类的功能呢？

Reface.AppStarter.Proxy

这是基于 Reface.AppStarter 开发的一个功能模块，
使用它，可以利用 Attribute 的方式轻松的创建代理类，并实现 AOP 的功能。

你所要做的，就是创建一个继承于 ProxyAttribute 的特征。

ProxyAttribute 中有三个方法需要重写

OnExecuting ，被标记的方法执行时
OnExecuted ，被标记的方法执行后
OnExecuteError ，被标记的方法执行出现异常后

你可以编写你的逻辑在这三个方法内，并将你的 Attribute 挂载到你需要的类型的方法上即可。

剩下的事情只有两件

向你的 AppModule 添加 ProxyAppModule
为你需要创建代理的类型加上 [Component] 特征

你已经完成了所有工作，
当你利用 Reface.AppStarter 的框架的 IOC / DI 容器创建你的类型时，实际得到的就是代理类，这些代理类会调试你给予的 ProxyAttribute 。

关于 Reface.AppStarter.Proxy 的细节，会在以后的文章中进一步介绍。