动态代理示例(根据博客园BillGan代码增加注释和辅助阅读类)

看了http://www.cnblogs.com/BillGan/archive/2009/12/18/1627112.html?login=1#commentform关于动态代理的示例,觉得理解上有困难,于是根据对示例代码的理解写了一个人工代理实现类和与之对应的Emit动态生成类(从原示例修改),有了这两个类代码的对照,阅读理解都比较容易:

1.人工编写产生代理类(实际中肯定不这样做,本例只是说明动态代理的实现原理)

/// <summary>

/// 人工产生动态的代理类,和类CTypeBuilder通过Emit产生的代理类是一样的

/// 编写本类的目的是帮助理解Emit代码

/// </summary>

public class CProxy_Class : IClass1

{

/// <summary>

/// 被代理对象

/// </summary>

private Object sourceObj;

/// <summary>

/// 拦截器

/// </summary>

private IStandardIntercept intercept;

/// <summary>

/// 创建代理

/// </summary>

/// <param name="targetobj">被代理对象</param>

/// <param name="intercept">拦截器</param>

public CProxy_Class(Object targetobj, IStandardIntercept intercept)

{

this.sourceObj = targetobj;

this.intercept = intercept;

}

/// <summary>

/// 实现接口方法

/// </summary>

/// <param name="a"></param>

/// <param name="b"></param>

public virtual void test(Guid a, Int32 b)

{

MethodInfo mi;//loc0

Object[] oa;//loc1

Invocation inv;//loc2

Type[] ta;//loc3

Type t;//loc4

//获取sourceObj中的当前MethodInfo并存入loc4中

t = sourceObj.GetType();

//获取参数类型数组

ta=new Type[2];

ta[0] = a.GetType();

ta[1] = b.GetType();

mi=t.GetMethod("test", ta);

oa=new Object[2];//参数个数固定为2

oa[0] = a;

oa[1] = b;

inv = new Invocation();

inv.Method = mi;

inv.Proxy = sourceObj;

inv.Arguments = oa;

inv.TargetType = sourceObj.GetType();

intercept.PreProceed(inv);

intercept.Proceed(inv);

intercept.PostProceed(inv);

}

}

2.Emit方式产生动态代理类

public class CTypeBuilder

{

/// <summary>

/// 动态根据被代理对象和拦截器生成代理类实例，本Emit代码和CProxy_Class对应，阅读时请参考CProxy_Class阅读

/// </summary>

/// <typeparam name="T">生成的代理类类型</typeparam>

/// <param name="targetObject">被代理对象（目标对象）</param>

/// <param name="intercept">拦截器</param>

/// <returns>代理类实例/T类型的实例</returns>

public static T Create<T>(T targetObject, IStandardIntercept intercept)

{

Type targetType = typeof(T);

//获取当前AppDomain

AppDomain currentAppDomain = AppDomain.CurrentDomain;

//System.Reflection.AssemblyName 是用来表示一个Assembly的完整名称的

AssemblyName assyName = new AssemblyName();

//为要创建的Assembly定义一个名称（这里忽略版本号，Culture等信息）

assyName.Name = "MyAssemblyFor_" + targetType.Name;

Version vv = new Version(1, 0, 0, 2);

assyName.Version = vv;

//获取AssemblyBuilder

//AssemblyBuilderAccess有Run，Save，RunAndSave三个取值

AssemblyBuilder assyBuilder = currentAppDomain.DefineDynamicAssembly(assyName, AssemblyBuilderAccess.RunAndSave);

//获取ModuleBuilder，提供String参数作为Module名称，随便设一个

ModuleBuilder modBuilder = assyBuilder.DefineDynamicModule("MyModuleFor_" + targetType.Name);

//新类型的名称：随便定一个

String newTypeName = "Proxy_" + targetType.Name;

//新类型的属性：要创建的是Class，而非Interface，Abstract Class等，而且是Public的

TypeAttributes newTypeAttribute = TypeAttributes.Class | TypeAttributes.Public;

//声明要创建的新类型的父类型

Type newTypeParent;

//声明要创建的新类型要实现的接口

Type[] newTypeInterfaces;

//对于基类型是否为接口，作不同处理

if (targetType.IsInterface)

{

newTypeParent = null;

newTypeInterfaces = new Type[] { targetType };

}

else

{

newTypeParent = targetType;

newTypeInterfaces = new Type[0];

}

//得到类型生成器

TypeBuilder typeBuilder = modBuilder.DefineType(newTypeName, newTypeAttribute, newTypeParent, newTypeInterfaces);

//定义字段

FieldBuilder fbuilder_obj = typeBuilder.DefineField("sourceObj", typeof(Object), FieldAttributes.Private);

FieldBuilder fbuilder_intercept = typeBuilder.DefineField("intercept", typeof(IStandardIntercept), FieldAttributes.Private);

#region 创建构造函数

//public CProxy_Class(Object targetobj, IStandardIntercept intercept)

ConstructorBuilder conBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[] { typeof(Object), typeof(IStandardIntercept) });

ILGenerator conIlGen = conBuilder.GetILGenerator();

//this.sourceObj = targetobj;

conIlGen.Emit(OpCodes.Ldarg_0);

conIlGen.Emit(OpCodes.Ldarg_1);

conIlGen.Emit(OpCodes.Stfld, fbuilder_obj);

//this.intercept = intercept;

conIlGen.Emit(OpCodes.Ldarg_0);

conIlGen.Emit(OpCodes.Ldarg_2);

conIlGen.Emit(OpCodes.Stfld, fbuilder_intercept);

conIlGen.Emit(OpCodes.Ret);

#endregion

//以下将为新类型声明方法：新类型应该override基类型的所有virtual方法

//得到基类型的所有方法

MethodInfo[] targetMethods = targetType.GetMethods();

//遍历各个方法，对于Virtual的方法，获取其签名，作为新类型的方法

foreach (MethodInfo targetMethod in targetMethods)

{

//只挑出virtual的方法

if (!targetMethod.IsVirtual)

{

continue;

}

//得到方法的各个参数的类型

ParameterInfo[] paramInfo = targetMethod.GetParameters();

int paramCount = paramInfo.Length;

Type[] paramType = new Type[paramInfo.Length];

for (int i = 0; i < paramInfo.Length; i++)

{

paramType[i] = paramInfo[i].ParameterType;

}

//传入方法签名，得到方法生成器

//实现需要实现的方法.方法的实现就在这里

MethodBuilder methodBuilder = typeBuilder.DefineMethod(targetMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, targetMethod.ReturnType, paramType);

MethodInfo getTypeMI = typeof(object).GetMethod("GetType", new Type[] { });

MethodInfo getMethodMI = typeof(Type).GetMethod("GetMethod", new Type[] { typeof(string), typeof(Type[]) });

//由于要生成的是具体类，所以方法的实现是必不可少的。而方法的实现是通过Emit IL代码来产生的

//得到IL生成器

ILGenerator ilGen = methodBuilder.GetILGenerator();

//定义局部变量

//MethodInfo mi;//loc0

//Object[] oa;//loc1

//Invocation inv;//loc2

//Type[] ta;//loc3

//Type t;//loc4

ilGen.DeclareLocal(typeof(MethodInfo), true); //loc0

ilGen.DeclareLocal(typeof(object[]), true);//loc1

ilGen.DeclareLocal(typeof(Invocation), true);//loc2

ilGen.DeclareLocal(typeof(Type[]), true);//loc3，参数数组

ilGen.DeclareLocal(typeof(Type), true);//loc4

//获取sourceObj中的当前type信息并存入loc4中

//t = sourceObj.GetType();

ilGen.Emit(OpCodes.Nop);

ilGen.Emit(OpCodes.Ldarg_0);

ilGen.Emit(OpCodes.Ldfld, fbuilder_obj);

ilGen.EmitCall(OpCodes.Call, getTypeMI, null);

ilGen.Emit(OpCodes.Stloc, 4);

//获取参数类型数组

//ta = new Type[2];//我在类CProxy_Class中把参数个数paramCount简单的固定为2

ilGen.Emit(OpCodes.Ldc_I4, paramCount);//对于本示例，test方法有两个参数，所以paramCount=2

ilGen.Emit(OpCodes.Newarr, typeof(Type));

ilGen.Emit(OpCodes.Stloc_3);

//循环把所有参数类型放在loc3中，以下的循环实现如下两条语句

//ta[0] = a.GetType();

//ta[1] = b.GetType();

for (int i = 0; i < paramCount; i++)

{

ilGen.Emit(OpCodes.Ldloc_3);

ilGen.Emit(OpCodes.Ldc_I4, i);

ilGen.Emit(OpCodes.Ldarg, (short)(i + 1));//arg0表示this,真正的方法参数从索引1开始

ilGen.Emit(OpCodes.Box, paramType[i]);//不装箱对一些类型的参数会出错

ilGen.EmitCall(OpCodes.Call, getTypeMI, null);

ilGen.Emit(OpCodes.Stelem_Ref);

}

//mi=t.GetMethod("test", ta);

ilGen.Emit(OpCodes.Ldloc, 4);

ilGen.Emit(OpCodes.Ldstr, targetMethod.Name);

ilGen.Emit(OpCodes.Ldloc_3);

ilGen.EmitCall(OpCodes.Call, getMethodMI, null);

ilGen.Emit(OpCodes.Stloc_0);

//获取参数并将其存入object[]类型变量loc1中

//oa=new Object[2];

ilGen.Emit(OpCodes.Ldc_I4, paramCount);

ilGen.Emit(OpCodes.Newarr, typeof(object));

ilGen.Emit(OpCodes.Stloc_1);

//以下循环实现如下两条语句

//oa[0] = a;

//oa[1] = b;

for (int i = 0; i < paramCount; i++)

{

ilGen.Emit(OpCodes.Ldloc_1);

ilGen.Emit(OpCodes.Ldc_I4, i);

ilGen.Emit(OpCodes.Ldarg, (short)(i + 1));//arg0表示this,真正的方法参数从索引1开始

ilGen.Emit(OpCodes.Box, paramType[i]);//不装箱对一些类型的参数会出错

ilGen.Emit(OpCodes.Stelem_Ref);

}

//创建Invocation对象

//inv = new Invocation();

ConstructorInfo InvocationCI = typeof(Invocation).GetConstructor(Type.EmptyTypes);

ilGen.Emit(OpCodes.Newobj, InvocationCI);

ilGen.Emit(OpCodes.Stloc_2);

//给Method值

//inv.Method = mi;拦截器中就是调用该方法

ilGen.Emit(OpCodes.Ldloc_2);

ilGen.Emit(OpCodes.Ldloc_0);

ilGen.EmitCall(OpCodes.Call, typeof(Invocation).GetMethod("set_Method", new Type[] { typeof(MethodInfo) }), null);

//给Target值

//inv.Proxy = sourceObj;//拦截器中拦截调用对象

ilGen.Emit(OpCodes.Ldloc_2);

ilGen.Emit(OpCodes.Ldarg_0);

ilGen.Emit(OpCodes.Ldfld, fbuilder_obj);

ilGen.EmitCall(OpCodes.Call, typeof(Invocation).GetMethod("set_Proxy", new Type[] { typeof(Object) }), null);

//给Arguments值,这个也可以不赋值，由METHOD可以获取到

//inv.Arguments = oa;

ilGen.Emit(OpCodes.Ldloc_2);

ilGen.Emit(OpCodes.Ldloc_1);

ilGen.EmitCall(OpCodes.Call, typeof(Invocation).GetMethod("set_Arguments", new Type[] { typeof(Object[]) }), null);

//给TargetType赋值

//inv.TargetType = sourceObj.GetType();

ilGen.Emit(OpCodes.Ldloc_2);

ilGen.Emit(OpCodes.Ldarg_0);

ilGen.Emit(OpCodes.Ldfld, fbuilder_obj);

ilGen.EmitCall(OpCodes.Call, getTypeMI, null);

ilGen.EmitCall(OpCodes.Call, typeof(Invocation).GetMethod("set_TargetType", new Type[] { typeof(Type) }), null);

//调用拦截器拦截前方法

//intercept.PreProceed(inv);

ilGen.Emit(OpCodes.Ldarg_0);

ilGen.Emit(OpCodes.Ldfld, fbuilder_intercept);

ilGen.Emit(OpCodes.Ldloc_2);

ilGen.Emit(OpCodes.Call, intercept.GetType().GetMethod("PreProceed", new Type[] { typeof(Invocation) }));

//调用自身,改为拦截器的方法后就可以控制方法本身了。

//ilGen.Emit(OpCodes.Ldarg_0);

//for (var i = 1; i <= paramInfo.Length;i++ )

// ilGen.Emit(OpCodes.Ldarg,i);

//ilGen.Emit(OpCodes.Call,targetMethod);

//调用

//intercept.Proceed(inv);

ilGen.Emit(OpCodes.Ldarg_0);

ilGen.Emit(OpCodes.Ldfld, fbuilder_intercept);

ilGen.Emit(OpCodes.Ldloc_2);

ilGen.Emit(OpCodes.Call, intercept.GetType().GetMethod("Proceed", new Type[] { typeof(Invocation) }));

//调用拦截器拦截后方法

//intercept.PostProceed(inv);

ilGen.Emit(OpCodes.Ldarg_0);

ilGen.Emit(OpCodes.Ldfld, fbuilder_intercept);

ilGen.Emit(OpCodes.Ldloc_2);

ilGen.Emit(OpCodes.Call, intercept.GetType().GetMethod("PostProceed", new Type[] { typeof(Invocation) }));

ilGen.Emit(OpCodes.Ret);

}

assyBuilder.Save("CTB.dll");//保存为DLL程序集

Type rt = typeBuilder.CreateType();//创建代理类类型

return (T)Activator.CreateInstance(rt, new object[] { targetObject, intercept });//根据动态产生的代理类类型创建实例并返回

}

}

使用方法:

IClass1 c1=CTypeBuilder.Create<IClass1>(new Class1(), new UserIntercept());

if (c1 != null)

{

c1.test(Guid.NewGuid(), 120);

}

c1 = null;

IClass1 xx = new CProxy_Class(new Class1(), new UserIntercept());

xx.test(Guid.NewGuid(), 110);

xx = null;

示例代码下载