关于.NET动态代理的介绍和应用简介

　　引言

　　假如现在我们有这样在这个示例中我将使用尽可能简单的逻辑实现所有功能需求，这将更突出我们所要解决的核心问题。例子是一个简单计算器类：

public class calculator
{
　public int add(int x, int y) { return x + y; }
}

　　这个类再简单不过了，不过若你将它想象为一个可能更复杂的业务处理类的时候，你将面临除了核心功能实现之外的更多处理细节，比如说：权限控制、审计日志、性能监测、缓冲处理、事务环境等等。为简单起见，我们首先为该类增加记录日志的功能，该功能要求将对每个方法的调用和处理结果输出到console中，如下：

public class calculator
{
　public int add(int x, int y)
　{
　　console.write("add({0},{1})", x, y);
　　int result = x + y;
　　console.writeline(" = {0}", result);
　　return result;
　}
}

　　再简单不过了，对吧？现在我们需要为该方法实现性能监测，如下：

public class calculator
{
　public int add(int x, int y)
　{
　　console.write("add({0},{1})", x, y);
　　datetime timebegin = system.datetime.now;
　　int result = x + y;
　　timespan timeinter =system.datetime.now-timebegin;
　　console.write(" [{0}] ", timeinter);
　　console.writeline(" = {0}", result);
　　return result;
　}
}

　　此时你已经感觉到，虽然我们实现了所需的功能，但是在一个方法中堆叠了处理各类事宜的不同代码。虽然在这个简单例子中不会感觉有什么不爽，但是请你想象一下如果我们将为该类添加第二个方法时会发生什么事情：

public class calculator
{
　public int add(int x, int y)
　{
　　console.write("add({0},{1})", x, y);
　　datetime timebegin = system.datetime.now;
　　int result = x + y;
　　timespan timeinter =system.datetime.now-timebegin;
　　console.write(" [{0}] ", timeinter);
　　console.writeline(" = {0}", result);
　　return result;
　}
　public int subtract(int x, int y)
　{
　　console.write("subtract({0},{1})", x, y);
　　datetime timebegin = system.datetime.now;
　　int result = x - y;
　　timespan timeinter =system.datetime.now-timebegin;
　　console.write(" [{0}] ", timeinter);
　　console.writeline(" = {0}", result);
　　return result;
　}
}

　　在两个方法中已经明显出现重复代码了，这可不是一个好的解决办法——想想一下如果我们的计算器有10个方法呢？如果我们还有类似于计算器类的另外数十个类呢？如果我们还有更多的方法级功能要实现呢（权限控制、事务管理……）？在企业级应用开发中，这可是一个经常会遇的问题。为清楚起见，我们将问题分解成两部分，首要的问题是代码职责混淆，其次则是同样的代码逻辑反复多次——这些问题都将导致开发管理、代码编写与维护的各种困难。

　　方案一：自己手动编写代理解决

　　1、首先 我们定义接口icalculator：

using system;
namespace proxy
{
　public interface icalculator
　{
　　int add(int x, int y);
　　int subtract(int x, int y);
　}
}

　　2、具体实现一个接口：

using system;
namespace proxy
{
　public class calculator:icalculator
　{
　　public virtual int add(int x, int y)
　　{
　　　int result = x + y;
　　　return result;
　　}
　　public virtual int subtract(int x, int y)
　　{
　　　int result = x - y;
　　　return result;
　　}
　}
}

　　3、编写增加日志和性能检测功能的代理类

　　增加记录日志的功能，即功能要求将对每个方法的调用和处理结果输出到console；增加性能监测。

　　有两种实现方式 ，注释了其中的一种

using system;
namespace proxy
{
　// /// <summary>
　// /// calproxy 的摘要说明。
　// /// </summary>
　// public class calproxy:icalculator
　// {
　// private calculator _calculator;
　// public calproxy()
　// {
　// this._calculator=new calculator();
　// }
　// private datetime timebegin = system.datetime.now;
　// private void predosomething(int x, int y)
　// {
　// timebegin = system.datetime.now;
　// console.write("number({0},{1})\n", x, y);
　// }
　// //实现add
　// public virtual int add(int x, int y)
　// {
　// this.predosomething(x,y);
　// int result = this._calculator.add(x,y);
　// this.postdosomething(result);
　// return result;
　// }
　// //实现sub
　// public virtual int subtract(int x, int y)
　// {
　// this.predosomething(x,y);
　// int result = this._calculator.subtract(x,y);
　// this.postdosomething(result);
　// return result;
　// }
　// private void postdosomething(int result)
　// {
　// timespan timeinter =system.datetime.now-timebegin;
　// console.write(" 运行时间[{0}]\n ", timeinter);
　// console.writeline(" 运行结果= {0}\n", result);
　// }
　// }
　/// <summary>
　/// calproxy 的摘要说明。
　/// </summary>

　public class calproxy:calculator
　{
　　public calproxy()
　　{}
　　private datetime timebegin = system.datetime.now;
　　private void predosomething(int x, int y)
　　{
　　　timebegin = system.datetime.now;
　　　console.write("number({0},{1})\n", x, y);
　　}
　　//实现add
　　public override int add(int x, int y)
　　{
　　　this.predosomething(x,y);
　　　int result = base.add(x,y);
　　　this.postdosomething(result);
　　　return result;
　　}
　　//实现sub
　　public override int subtract(int x, int y)
　　{
　　　this.predosomething(x,y);
　　　int result = base.subtract(x,y);
　　　this.postdosomething(result);
　　　return result;
　　}
　　private void postdosomething(int result)
　　{
　　　timespan timeinter =system.datetime.now-timebegin;
　　　console.write(" 运行时间[{0}]\n ", timeinter);
　　　console.writeline(" 运行结果= {0}\n", result);
　　}
　}
}

　　4、外界的调用方式

icalculator ical=new proxy.calproxy();

ical.add(5,3);

ical.subtract(7,2);

　　运行程序的结果：

number(5,3)

　　运行时间[00:00:02.0156250]

　　运行结果= 8

　　number(7,2)

　　运行时间[00:00:03]

　　运行结果= 5

　　方案二：通过使用castle.dynamicproxy，实现iinterceptor解决

　　步骤1，2与解决问题

　　3、实现standardinterceptor，增加日志和性能监测功能

　　standardinterceptor是接口iinterceptor的一个实现类，我们实现standardinterceptor

using system;
using system.collections;
using castle.dynamicproxy;

namespace proxy
{
　/// <summary>
　/// proxyinterceptor 拦截器 实现了日志和性能监测
　/// </summary>

　public class proxyinterceptor:standardinterceptor
　{
　　private system.datetime timebegin=system.datetime.now;
　　public proxyinterceptor()
　　{}
　　protected override void postproceed(iinvocation invocation, ref object returnvalue, params object[] arguments)
　　{
　　　timespan timeinter =system.datetime.now-timebegin;
　　　console.write(" 运行时间[{0}]\n ", timeinter);
　　　console.writeline(" 运行结果= {0}\n", returnvalue);
　　　base.postproceed(invocation, ref returnvalue, arguments);
　　}
　　protected override void preproceed(iinvocation invocation, params object[] args)
　　{
　　　console.write("number({0},{1})\n", args[0], args[1]);
　　　timebegin=system.datetime.now;
　　　base.preproceed(invocation, args);
　　}
　　public override object intercept(iinvocation invocation, params object[] args)
　　{
　　　preproceed(invocation, args);
　　　object retvalue = invocation.proceed( args );
　　　postproceed(invocation, ref retvalue, args);
　　　return retvalue;
　　}
　}
}

　　4、使用castle.dynamicproxy调用

proxygenerator generator = new proxygenerator();
object proxy = generator.createclassproxy(typeof(calculator), new proxyinterceptor());
icalculator icalcastle=proxy as icalculator;
icalcastle.add(5,3);
icalcastle.subtract(7,2);

　　实现过程：首先通过代码生成完成一个代理类，该代理类继承自要织入的类。然后在代理类中覆盖要拦截的方法，并在覆盖的方法中封装invocation对象，并传给用户传入的intercepter对象的intercept方法。在intercept方法依次调用intercepter的preprocess,通过invocation传入的delegate指向的回调函数，intercepter的postprocess方法，从而达到拦截的目的。

　　意义

　　在aop领域 可以将日志，事务，缓存等附加功能用此实现。