之所以学习DynamicProxy的原因有两个：一是在2005年第一期《程序员》杂志中的一篇文章《动态代理的前世今生》，另外就是对wayfarer的《让僵冷的翅膀飞起来》系列文章的讨论。这两方面都把我引向了对动态代理的学习。《动态代理的前世今生》一文是针对Java来写的，读了好几遍还是无法理解某些细节，只知道动态代理技术是很多新技术的基础，包括AOP。于是自己找来了网上的开源项目Castle's DynamicProxy for .net（Code Project上有文章介绍，但不很详细），花了些时间读读源代码，总算有所了解。不过要想深入学习，就要透彻的掌握IL以及通过Reflection动态生成程序集的技术，这不是我想要的，于是就此打住。通过对DynamicProxy的学习，对其中的关键技术总算了解了一二，写出来与大家分享。
DynamicProxy（无特殊说明的化，都指Castle's DynamicProxy for .net中的DynamicProxy技术）是建立在动态程序集生成技术的基础之上的，也就是说程序在运行时动态生成IL代码并被编译执行。这方面的内容我就不说了，感兴趣可以找相关资料，我只说说DynamicProxy如何利用动态编译技术实现所需操作的。
先说说DynamicProxy是如何实现代码拦截的（有些象AOP的横切，其实另一个开源项目Aspect#就是建立在DynamicProxy这个特性基础上的）。假设我们有编写好的一个类：
public class SimpleClass
{
public virtual int DoSomething1()
{
SomeDelay(50);
Console.WriteLine("The return value of DoSomething1 is : {0}", 100);
return 100;
}
public virtual int DoSomething2()
{
SomeDelay(60);
Console.WriteLine("The return value of DoSomething2 is : {0}", 200);
return 200;
}
private void SomeDelay(int t)
{
Thread.Sleep(t);
}
}
该类有两个virtual方法DoSomething1与DoSomething2。现在要求不改变原有类的基础上为这个两个虚拟方法添加计时功能。其实我们可以非常容易的实现该功能，那就是继承SimpleClass，并为子类添加计时功能，代码如下：
public class DerivedSimpleClass : SimpleClass
{
public override int DoSomething1()
{
DateTime begin = DateTime.Now;
//调用父类代码
int result = base.DoSomething1();
DateTime end = DateTime.Now;
TimeSpan t = end - begin;
Console.WriteLine("Time used: {0}\n", t.Milliseconds);
return result;
}
public override int DoSomething2()
{
DateTime begin = DateTime.Now;
//调用父类代码
int result = base.DoSomething2();
DateTime end = DateTime.Now;
TimeSpan t = end - begin;
Console.WriteLine("Time used: {0}\n", t.Milliseconds);
return result;
}
}
我想，很多人已经开始对这段代码产生反感了。毕竟它里面存在了大量的重复代码，而这些重复代码又与原来的系统没有任何关系。那么我们能否将这些代码抽取出来，在必要的时候"插入"到SimpleClass中呢？让我们来看看动态代理是如何实现此功能的。
首先动态代理会动态生成一个Proxy对象，Proxy对象继承自SimpleClass（这也是为什么只有virtual方法才能被Intercept），生成出来的代码大体如下（经过大量简化和修改并只保留了DoSomething1方法。对此感兴趣的化，可以在Debug模式下反编译动态生成出来的GeneratedAssembly.dll文件）：
using System;
using System.Reflection;
public class CProxyTypeSimpleClass : SimpleClass
{
// 通过委派机制实现回调
public delegate int delegateForDoSomething1();
public delegateForDoSomething1 callableForDoSomething1 =
new delegateForDoSomething1(callback__DoSomething1);
// 在此结合构造函数，并利用依赖注入技术实现自定义的拦截
public IInterceptor _interceptor;
public CProxyTypeSimpleClass(IInterceptor interceptor)
{
this._interceptor = interceptor;
}
//将对父类DoSomething1方法的调用封装到一个新方法中
public virtual int callback__DoSomething1()
{
base.DoSomething1();
}
// 复写DoSomething1方法，允许被拦截
public override int DoSomething1()
{
/**//* 以下为示意性代码
* MethodInfo m = ldtoke currentMethod;
* object proxy = this;
* IInvocation invocation =
* ObtainInvocationFor(callableForDoSomething1, proxy, m);
* return (int) _interceptor.Intercept( invocation )
*/
}
}
在仔细研究这段代码之前，让我们先看一个拦截器的实现：
namespace Castle.DynamicProxy
{
using System;
[Serializable]
public class StandardInterceptor : IInterceptor
{
public StandardInterceptor(){}
protected virtual void PreProceed(IInvocation invocation, params object[] args){}
protected virtual void PostProceed(IInvocation invocation, ref object returnValue, params object[] args){}
public virtual object Intercept(IInvocation invocation, params object[] args)
{
PreProceed(invocation, args);
object retValue = invocation.Proceed( args );
PostProceed(invocation, ref retValue, args);
return retValue;
}
}
}
这个拦截器使用了典型的模板方法模式，注意观察Intercept方法，其中的PreProceed与PostProceed方法是虚函数，可以在子类中被覆写。现在让我们看看DynamicProxy到底是如何工作的：
首先，动态代理CProxyTypeSimpleClass继承自SimpleClass并将原有代码进行"转移"，下面的代码演示了父类DoSomething1方法被转移到了callback__DoSomething1方法中，腾出来的DoSomething1方法用来进行"拦截"操作。
public class CProxyTypeSimpleClass : SimpleClass
{
// 将对父类DoSomething1方法的调用封装到一个新方法中
public virtual int callback__DoSomething1()
{
base.DoSomething1();
}
// 复写DoSomething1方法，允许被拦截
public override int DoSomething1()
{
……
}
}
拦截器必须实现IInterceptor接口。我们上面看到的StandardInterceptor便是一个拦截器。IInterceptor接口非常简单，仅有一个方法，其定义如下：
public interface IInterceptor
{
object Intercept( IInvocation invocation, params object[] args );
}
那么拦截器与代理之间到底是如何工作的呢？我们用下面的图来说明调用步骤：
（1）DoSomething1调用Interceptor的Intercept方法，并传递相关参数。参数有两个，一个是IInvocation类型参数invocation，我们现在不用去关心IInvocation是什么，只要知道它里面包含了一个指向callback_DoSomething1的委派就行了（其实是一个ICallable类型的对象，现在我们不必过多的去关心它）。另外一个参数是object[] args，提供对callback_DoSomething1调用时所需的参数。
在CProxyTypeSimpleClass示意性代码中，我们可以看到的
// 通过委派机制实现回调
public delegate int delegateForDoSomething1();
public delegateForDoSomething1 callableForDoSomething1 =
new delegateForDoSomething1(callback__DoSomething1);
便是为回调作准备的。在DoSomething1()方法中，将委派callableForDoSomething1封装到了一个IInvocation对象里面：
* IInvocation invocation =
* ObtainInvocationFor(callableForDoSomething1, proxy, m);
（2）在真正的调用前，允许用户插入自己的代码。用户甚至可以改变调用参数args的值。
（3）利用回调机制，调用真正的DoSomething1代码。首先拦截器会从IInvocation对象中解出指向callback_DoSomething1的委派callableForDoSomething1；然后进行调用。于是CProxyTypeSimpleClass的callback_DoSomething1被调用，进而转去调用base.DoSomething1()，于是SimpleClass的DoSomething1便被调用执行。
（4）在实际代码调用完成后，调用PostProceed方法。用户可以在此方法中拦截返回的结果"ref object returnValue"，甚至可以改变调用结果的值。下面是StandardInterceptor类中PostProceed方法的定义：
protected virtual void PostProceed(IInvocation invocation, ref object returnValue, params object[] args){}
由此可见，我们在没有修改SimpleClass的基础上，通过动态代理实现了方法调用的拦截，并插入了一部分自定义的代码。
下面我们来分析一下DynamicProxy中的"依赖注入机制"。其实动态代理的一个迷人的地方就在于我们可以动态更换拦截器，而不用修改任何原有代码。设想我们现在不统计方法运行时间了，而是对方法调用次数进行累加计数。我们可以非常方便的通过更换Interceptor实现这个功能而没有必要每次都重新写代码。在DynamicProxy动态生成的代码中我们可以看到类似代码如下：
// 在此结合构造函数，并利用依赖注入技术实现自定义的拦截
public IInterceptor _interceptor;
public CProxyTypeSimpleClass(IInterceptor interceptor)
{
this._interceptor = interceptor;
}
可以看到DynamicProxy为我们生成了一个构造函数，允许在实例化代理对象时指定一个具体的拦截器。这样"依赖"便被"注入"到CProxyTypeSimpleClass类中。
这篇文章先写到这里，在后续的文章中，我将继续深入介绍DynamicProxy的功能细节，包括Mixins技术和IInvocation接口。
附：
1、"Castle's DynamicProxy for .net"的源代码可以从http://www.castleproject.org/下载到。
2、本篇文章的完整代码下载：http://files.cnblogs.com/zhenyulu/DynamicProxy.rar