//程序源代码
//模型---------------------------------------------------------------------------------
using System;
using System.Runtime.CompilerServices;
namespace module
{
/// <summary>
/// 拦截器接口
/// </summary>
public interface Intercepter
{
/// <summary>
/// 拦截器最后中调用表示目标对象 methodDelegate.Method.Invoke(methodDelegate.Target, args);
/// </summary>
/// <param name="methodName"></param>
/// <param name="methodDelegate"></param>
/// <param name="args"></param>
/// <returns></returns>
Object Call(String methodName, MulticastDelegate methodDelegate, params Object[] args);
}
/// <summary>
/// 需要动态产生的对象
/// </summary>
public sealed class IStudent_83523988 : IStudent
{
private Intercepter _intercepter;
private delegatechangeNameHandler OnchangeName;
private delegateEqualsHandler OnEquals;
private delegateGetHashCodeHandler OnGetHashCode;
private delegateGetTypeHandler OnGetType;
private delegateToStringHandler OnToString;
public IStudent_83523988(Intercepter intercepter1)
{
this._intercepter = intercepter1;
this.OnchangeName = new delegatechangeNameHandler(this.callBack_OnchangeName);
this.OnToString = new delegateToStringHandler(this.callBack_OnToString);
this.OnEquals = new delegateEqualsHandler(this.callBack_OnEquals);
this.OnGetHashCode = new delegateGetHashCodeHandler(this.callBack_OnGetHashCode);
this.OnGetType = new delegateGetTypeHandler(this.callBack_OnGetType);
}
private void callBack_OnchangeName(string text1)
{
base.changeName(text1);
}
private bool callBack_OnEquals(object obj1)
{
return base.Equals(obj1);
}
private int callBack_OnGetHashCode()
{
return base.GetHashCode();
}
private Type callBack_OnGetType()
{
return base.GetType();
}
private string callBack_OnToString()
{
return base.ToString();
}
public override void changeName(string text1)
{
this._intercepter.Call("changeName", this.OnchangeName, new object[] { text1 });
}
public override bool Equals(object obj1)
{
return (bool)this._intercepter.Call("Equals", this.OnEquals, new object[] { obj1 });
}
public override int GetHashCode()
{
return (int)this._intercepter.Call("GetHashCode", this.OnGetHashCode, new object[0]);
}
/*
public override Type GetType()
{
return (Type)this._intercepter.Call("GetType", this.OnGetType, new object[0]);
}*/
public override string ToString()
{
return (string)this._intercepter.Call("ToString", this.OnToString, new object[0]);
}
private delegate void delegatechangeNameHandler(string s);
private delegate bool delegateEqualsHandler(object obj);
private delegate int delegateGetHashCodeHandler();
private delegate Type delegateGetTypeHandler();
private delegate string delegateToStringHandler();
}
/// <summary>
/// 目标对象
/// </summary>
public class IStudent
{
public virtual void changeName(string newname)
{
Console.WriteLine("名字修改为:" + newname);
}
}
public class test
{
public void TestMethod1()
{
/*
AOP.DynamicProxyBuilder dymProxy = new AOP.DynamicProxyBuilder(typeof(IStudent), new LogIntercepter());
IStudent s = (IStudent)dymProxy.CreateProxyClass();
s.changeName("mxhzmm");
* */
IStudent_83523988 s = new IStudent_83523988(new LogIntercepter());
s.changeName("mxh");
}
}
/// <summary>
/// 拦截器实现类
/// </summary>
public class LogIntercepter : Intercepter
{
public object Call(string methodName, MulticastDelegate methodDelegate, params object[] args)
{
Console.WriteLine("拦截器做了某些处理");
return methodDelegate.Method.Invoke(methodDelegate.Target, args);
}
}
}
//--------------------------------------------------------------------------
//IStudent_83523988 的动态创建
//--------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Reflection.Emit;
namespace AOP
{
/*
public interface Intercepter
{
public Object Call(String methodName, MulticastDelegate methodDelegate, params Object[] args)
{
return methodDelegate.Method.Invoke(methodDelegate.Target, args);
}
}
*/
public interface Intercepter
{
/// <summary>
/// 拦截器最后中调用表示目标对象 methodDelegate.Method.Invoke(methodDelegate.Target, args);
/// </summary>
/// <param name="methodName"></param>
/// <param name="methodDelegate"></param>
/// <param name="args"></param>
/// <returns></returns>
Object Call(String methodName, MulticastDelegate methodDelegate, params Object[] args);
}
public class DynamicProxyBuilder
{
/// <summary>
/// 拦截器
/// </summary>
Intercepter intercepter;
Type m_type_delegate;
/// <summary>
/// 构造器
/// </summary>
/// <param name="t">目标对象</param>
/// <param name="icpt">拦截器</param>
public DynamicProxyBuilder(Type t,Intercepter icpt)
{
try
{
intercepter = icpt;
m_Type = t;
InitModule();
GenerateType();
GenerateMethodDelegateClass();
GentrateMethodDelegateEvent();
GenerateCallBackMethods();
GentrateOverrideMethods();
GenerateConstructor();
m_type_delegate=m_TypeBuilder.CreateType();
m_AssemblyBuilder.Save("DynamicProxy.dll");
}
catch (Exception err)
{
throw err;
}
}
public Object CreateProxyClass()
{
return Activator.CreateInstance(m_type_delegate, intercepter);
}
//assembly-module-(class、interface等)
private ModuleBuilder m_ModuleBuilder;//创建Module
private AssemblyBuilder m_AssemblyBuilder;//创建Assembly
//
/// <summary>
/// 创建一个Assembly,在Assembly中创建一个module
/// module中可以创建类、接口、属性、方法和变量等
/// </summary>
private void InitModule()
{
//
AppDomain domain = AppDomain.CurrentDomain;
AssemblyName asmName = new AssemblyName("DynamicModule");
m_AssemblyBuilder = domain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.RunAndSave);
m_ModuleBuilder = m_AssemblyBuilder.DefineDynamicModule("Module", "DynamicProxy.dll");
}
/// <summary>
/// 被代理类
/// </summary>
private Type m_Type;//被代理类
/// <summary>
/// 代理类构建器
/// </summary>
private TypeBuilder m_TypeBuilder;//代理类
/// <summary>
/// 在module中添加类,在Emit中 类和接口 用Type
/// 通过TypeAttributes制定具体的行为
/// </summary>
private void GenerateType()
{
//用被代理类的名字+"_"+哈希值作为代理类的名字,从被代理类继承一个不可以被继承(TypeAttributes.Sealed)公有(TypeAttributes.Public)的代理类(TypeAttributes.Class)
m_TypeBuilder = m_ModuleBuilder.DefineType(m_Type.Name +"_" + m_Type.GetHashCode().ToString(),
TypeAttributes.Class | TypeAttributes.Public | TypeAttributes.Sealed, m_Type);
//m_TypeBuilder.CreateType();
}
/// <summary>
/// 所有方法的代理
/*
* public sealed class Method_delegate : MulticastDelegate
{
public Method_delegate(object local, IntPtr i);
public override void Invoke(string str);
}
* Invoke参数就是Method的参数
* */
/// </summary>
private TypeBuilder[] m_methodDelegates;
private ConstructorBuilder[] m_constructOfmethodDelegates;
/// <summary>
/// 为每一个方法创建一个代理
/// </summary>
private void GenerateMethodDelegateClass()
{
MethodInfo[] methodInfos = m_Type.GetMethods();//获取被代理类的所有public方法
m_methodDelegates=new TypeBuilder[methodInfos.Length];
m_constructOfmethodDelegates = new ConstructorBuilder[methodInfos.Length];
ConstructorBuilder[] methodDelegateConstructs=new ConstructorBuilder[methodInfos.Length];//构造函数
for (int i = 0; i < m_methodDelegates.Length; i++)
{
//private delegate Type delegateMethodHandler(Type[]) 类似public delegate string delegateChangeNameHandler(string abc);
m_methodDelegates[i] = m_TypeBuilder.DefineNestedType("delegate" + methodInfos[i].Name + "Handler",
TypeAttributes.NestedPrivate | TypeAttributes.Sealed,
typeof(MulticastDelegate));
//在代理里类中创建一个构造函数,构造函数是在执行时管理的
m_constructOfmethodDelegates[i]=m_methodDelegates[i].DefineConstructor(MethodAttributes.Public, CallingConventions.Standard,
new Type[] {typeof(Object),typeof(IntPtr) });
m_constructOfmethodDelegates[i].SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
Type[] argsType = GetParameterTypes(methodInfos[i]);
//定义Invoke方法
m_methodDelegates[i].DefineMethod("Invoke", MethodAttributes.Public, CallingConventions.Standard,
methodInfos[i].ReturnType,//返回值
argsType//函数参数
).SetImplementationFlags(MethodImplAttributes.Runtime | MethodImplAttributes.Managed);
//m_methodDelegates[i]
m_methodDelegates[i].CreateType();
}
}
/// <summary>
/// 代理类中加入intercepter变量
/// </summary>
FieldBuilder m_intercepter;
private FieldBuilder[] m_eventDelegateMethods;
/// <summary>
///为每个方法的delegate生成一个变量
/// 例如:public event delegateChangeNameHandler OnMethodNameEvent;
/// </summary>
private void GentrateMethodDelegateEvent()
{
//在代理类中添加拦截器的变量
m_intercepter = m_TypeBuilder.DefineField("_intercepter", typeof(Intercepter), FieldAttributes.Private);
MethodInfo[] methodInfos = m_Type.GetMethods();
m_eventDelegateMethods = new FieldBuilder[methodInfos.Length];
for (int i = 0; i < methodInfos.Length; i++)
{
m_eventDelegateMethods[i] = m_TypeBuilder.DefineField("On"+methodInfos[i].Name, m_methodDelegates[i], FieldAttributes.Private);
}
}
private MethodBuilder[] m_callBackMethods;
/// <summary>
/// 定义回调函数
/// private Type callBack_OnMethodName(Type[])
/// </summary>
private void GenerateCallBackMethods()
{
MethodInfo[] methodInfos = m_Type.GetMethods();
m_callBackMethods = new MethodBuilder[methodInfos.Length];
for (int i = 0; i < methodInfos.Length; i++)
{
Type[] argsTypes = GetParameterTypes(methodInfos[i]);
m_callBackMethods[i] =
m_TypeBuilder.DefineMethod("callBack_On"+methodInfos[i].Name, MethodAttributes.Private,
CallingConventions.Standard, methodInfos[i].ReturnType, argsTypes);
//方法体
ILGenerator il = m_callBackMethods[i].GetILGenerator();
//this压入堆栈
il.Emit(OpCodes.Ldarg_0);//this指针
//参数压入堆栈
for (int j = 0; j < argsTypes.Length; j++)
{
il.Emit(OpCodes.Ldarg, j + 1);
}
//调用记录方法
il.Emit(OpCodes.Call, methodInfos[i]);
//返回
il.Emit(OpCodes.Ret);
}
}
/// <summary>
/// 重写父类的方法
/// </summary>
private void GentrateOverrideMethods()
{
MethodInfo[] methodInfos = m_Type.GetMethods();
for (int i = 0; i < methodInfos.Length; i++)
{
Type[] argTypes = GetParameterTypes(methodInfos[i]);
MethodBuilder mb = m_TypeBuilder.DefineMethod(methodInfos[i].Name,
MethodAttributes.Public | MethodAttributes.Virtual, CallingConventions.Standard,
methodInfos[i].ReturnType, argTypes);
ILGenerator il = mb.GetILGenerator();
//this指针
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, m_intercepter);
il.Emit(OpCodes.Ldstr, methodInfos[i].Name);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, m_eventDelegateMethods[i]);
LocalBuilder local = il.DeclareLocal(typeof(Object[]));
il.Emit(OpCodes.Ldc_I4, argTypes.Length);
il.Emit(OpCodes.Newarr, typeof(Object));
il.Emit(OpCodes.Stloc, local);
il.Emit(OpCodes.Ldloc, local);
for (int j = 0; j < argTypes.Length; j++)
{
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Ldarg, j + 1);
il.Emit(OpCodes.Box, argTypes[j]);
il.Emit(OpCodes.Stelem_Ref);
il.Emit(OpCodes.Ldloc, local);
}
il.Emit(OpCodes.Call, typeof(Intercepter).GetMethod("Call", new Type[] { typeof(String), typeof(MulticastDelegate), typeof(Object[]) }));
if (methodInfos[i].ReturnType.Equals(typeof(void)))
{
il.Emit(OpCodes.Pop);
}
else
{
il.Emit(OpCodes.Unbox_Any, methodInfos[i].ReturnType);
}
il.Emit(OpCodes.Ret);
}
}
/// <summary>
/// 构造函数构造器
/// </summary>
private ConstructorBuilder m_constructBuilder;
/// <summary>
/// 构建代理类的构造函数
/// </summary>
private void GenerateConstructor()
{
m_constructBuilder = m_TypeBuilder.DefineConstructor(MethodAttributes.Public,
CallingConventions.Standard, new Type[] {typeof(Intercepter)});
ILGenerator il = m_constructBuilder.GetILGenerator();
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Call, m_Type.GetConstructor(new Type[] { }));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Stfld, m_intercepter);
for (int i = 0; i < m_eventDelegateMethods.Length; i++)
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldftn, m_callBackMethods[i]);
il.Emit(OpCodes.Newobj, m_constructOfmethodDelegates[i]);
il.Emit(OpCodes.Stfld, m_eventDelegateMethods[i]);
}
il.Emit(OpCodes.Ret);
}
/// <summary>
/// 返回方法的所有所有参数
/// </summary>
/// <param name="methodInfo1"></param>
/// <returns></returns>
private Type[] GetParameterTypes(MethodInfo methodInfo1)
{
ParameterInfo[] args = methodInfo1.GetParameters();
Type[] argsType=new Type[args.Length];
for (int i = 0; i < args.Length; i++)
{
argsType[i] = args[i].ParameterType;
}
return argsType;
}
}
}