private void BuildMethod(string methodName, TypeBuilder typeBuilder, MethodInfo method)
{
string wrapperName = GetMethodId(method.Name);
wrapperMethods.Add(wrapperName);
MethodCache.methodLookup[wrapperName] = method;
ParameterInfo[] parameterInfos = method.GetParameters();
Type[] parameterTypes = new Type[parameterInfos.Length];
for (int i = 0; i < parameterInfos.Length; i++)
parameterTypes[i] = parameterInfos[i].ParameterType;
MethodBuilder methodBuilder =
typeBuilder.DefineMethod(methodName,
MethodAttributes.NewSlot | MethodAttributes.Private | MethodAttributes.Virtual |
MethodAttributes.Final | MethodAttributes.HideBySig,
CallingConventions.Standard, method.ReturnType, parameterTypes);
for (int i = 0; i < parameterInfos.Length; i++)
{
}
typeBuilder.DefineMethodOverride(methodBuilder, method);
ILGenerator il = methodBuilder.GetILGenerator();
LocalBuilder paramList = il.DeclareLocal(typeof (ArrayList));
//create param arraylist
ConstructorInfo arrayListCtor = typeof (ArrayList).GetConstructor(new Type[0]);
il.Emit(OpCodes.Newobj, arrayListCtor);
il.Emit(OpCodes.Stloc, paramList);
int j = 0;
ConstructorInfo interceptedParameterCtor = typeof (InterceptedParameter).GetConstructors()[0];
MethodInfo arrayListAddMethod = typeof (ArrayList).GetMethod("Add");
MethodInfo getTypeMethod = typeof (Type).GetMethod("GetType", new Type[1] {typeof (string)});
foreach (ParameterInfo parameter in parameterInfos)
{
il.Emit(OpCodes.Ldloc, paramList);
string paramName = parameter.Name;
if (paramName == null)
{
paramName = "param" + j.ToString();
}
il.Emit(OpCodes.Ldstr, paramName);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Ldstr, parameter.ParameterType.FullName.Replace("&", ""));
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Ldarg, j + 1);
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldind_Ref);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
il.Emit(OpCodes.Box, t);
}
if (parameter.ParameterType.IsValueType)
{
il.Emit(OpCodes.Box, parameter.ParameterType);
}
il.Emit(OpCodes.Ldc_I4, (int) ParameterType.ByVal);
il.Emit(OpCodes.Newobj, interceptedParameterCtor);
il.Emit(OpCodes.Callvirt, arrayListAddMethod);
il.Emit(OpCodes.Pop);
j++;
}
#if NET2
CallInfo callInfo = new CallInfo(wrapperName, method, new ArrayList(), FastCall.GetMethodInvoker(method));
#else
CallInfo callInfo = new CallInfo(wrapperName,method, new ArrayList());
#endif
MethodInfo handleCallMethod = typeof(IAopProxy).GetMethod("HandleFastCall");
int methodNr = MethodCache.AddCallInfo(callInfo, wrapperName);
//il.Emit(OpCodes.Ldc_I4 ,methodNr);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, that); // load the execution target
il.Emit(OpCodes.Ldc_I4, methodNr);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldstr, method.ReturnType.FullName);
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Callvirt, handleCallMethod);
if (method.ReturnType == typeof (void))
{
il.Emit(OpCodes.Pop);
}
else if (method.ReturnType.IsValueType)
{
il.Emit(OpCodes.Unbox, method.ReturnType);
il.Emit(OpCodes.Ldobj, method.ReturnType);
}
j = 0;
MethodInfo get_ItemMethod = typeof (ArrayList).GetMethod("get_Item", new Type[1] {typeof (int)});
foreach (ParameterInfo parameter in parameterInfos)
{
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldarg, j + 1);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Callvirt, get_ItemMethod);
il.Emit(OpCodes.Castclass, typeof (InterceptedParameter));
FieldInfo valueField = typeof (InterceptedParameter).GetField("Value");
il.Emit(OpCodes.Ldfld, valueField);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
{
il.Emit(OpCodes.Unbox, t);
il.Emit(OpCodes.Ldobj, t);
il.Emit(OpCodes.Stobj, t);
}
else
{
il.Emit(OpCodes.Castclass, t);
il.Emit(OpCodes.Stind_Ref);
}
}
j++;
}
il.Emit(OpCodes.Ret);
BuildWrapperMethod(wrapperName, typeBuilder, method);
}
internal static int AddCallInfo(CallInfo callInfo, string methodId)
{
int res = 0;
lock(callInfos.SyncRoot)
{
res = callInfos.Add(callInfo);
callInfoMapper[methodId] = callInfo;
}
return res;
}
private void BuildConstructor(ConstructorInfo constructor, TypeBuilder typeBuilder, IList mixins)
{
string wrapperName = GetMethodId(constructor.Name);
wrapperMethods.Add(wrapperName);
MethodCache.methodLookup[wrapperName] = constructor;
ParameterInfo[] parameters = constructor.GetParameters();
//make proxy ctor param count same as superclass
Type[] parameterTypes = new Type[parameters.Length + 1];
//copy super ctor param types
for (int i = 0; i <= parameters.Length - 1; i++)
{
parameterTypes[i + 1] = parameters[i].ParameterType;
}
parameterTypes[0] = typeof(object);
ConstructorBuilder proxyConstructor =
typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameterTypes);
ILGenerator il = proxyConstructor.GetILGenerator();
proxyConstructor.SetCustomAttribute(DebuggerStepThroughBuilder());
proxyConstructor.SetCustomAttribute(DebuggerHiddenBuilder());
foreach (Type mixinType in mixins)
{
if (mixinType.IsInterface)
{
//ignore interface type mixins , they do not have an impelemntation
}
else
{
// il.EmitWriteLine("setting mixin instance " + mixinType.FullName) ;
il.Emit(OpCodes.Ldarg_0);
ConstructorInfo mixinCtor = (mixinType).GetConstructor(new Type[] {});
il.Emit(OpCodes.Newobj, mixinCtor);
il.Emit(OpCodes.Stfld, GetMixinField(mixinType));
}
}
//associate iproxyaware mixins with this instance
MethodInfo setProxyMethod = typeof(IProxyAware).GetMethod("SetProxy");
foreach (Type mixinType in mixins)
{
if (mixinType.IsInterface)
{
//ignore interface type mixins , they do not have an impelemntation
}
else
{
if (typeof(IProxyAware).IsAssignableFrom(mixinType))
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, GetMixinField(mixinType));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, setProxyMethod);
}
}
}
//--------------------------
LocalBuilder paramList = il.DeclareLocal(typeof(ArrayList));
//create param arraylist
ConstructorInfo arrayListCtor = typeof(ArrayList).GetConstructor(new Type[0]);
il.Emit(OpCodes.Newobj, arrayListCtor);
il.Emit(OpCodes.Stloc, paramList);
ConstructorInfo interceptedParameterCtor = typeof(InterceptedParameter).GetConstructors()[0];
MethodInfo arrayListAddMethod = typeof(ArrayList).GetMethod("Add");
MethodInfo getTypeMethod = typeof(Type).GetMethod("GetType", new Type[1] {
typeof(string)
});
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldstr, "_state");
il.Emit(OpCodes.Ldc_I4, 0);
il.Emit(OpCodes.Ldstr, typeof(object).FullName);
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Ldarg, 0 + 1);
il.Emit(OpCodes.Ldc_I4, (int)ParameterType.ByVal);
il.Emit(OpCodes.Newobj, interceptedParameterCtor);
il.Emit(OpCodes.Callvirt, arrayListAddMethod);
il.Emit(OpCodes.Pop);
int j = 1;
foreach (ParameterInfo parameter in parameters)
{
il.Emit(OpCodes.Ldloc, paramList);
string paramName = parameter.Name;
if (paramName == null)
{
paramName = "param" + j.ToString();
}
il.Emit(OpCodes.Ldstr, paramName);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Ldstr, parameter.ParameterType.FullName.Replace("&", ""));
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Ldarg, j + 1);
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldind_Ref);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
{
il.Emit(OpCodes.Box, t);
}
}
if (parameter.ParameterType.IsValueType)
{
il.Emit(OpCodes.Box, parameter.ParameterType);
}
il.Emit(OpCodes.Ldc_I4, (int)ParameterType.ByVal);
il.Emit(OpCodes.Newobj, interceptedParameterCtor);
il.Emit(OpCodes.Callvirt, arrayListAddMethod);
il.Emit(OpCodes.Pop);
j++;
}
#if NET2
CallInfo callInfo = new CallInfo(wrapperName, constructor, new ArrayList(), FastCall.GetMethodInvoker(constructor));
#else
CallInfo callInfo = new CallInfo(wrapperName, constructor, new ArrayList());
#endif
MethodInfo handleCallMethod = typeof(IAopProxy).GetMethod("HandleFastCall");
int methodNr = MethodCache.AddCallInfo(callInfo, wrapperName);
//il.Emit(OpCodes.Ldc_I4 ,methodNr);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldc_I4, methodNr);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldstr, typeof(void).FullName);
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Callvirt, handleCallMethod);
il.Emit(OpCodes.Pop);
j = 1;
MethodInfo get_ItemMethod = typeof(ArrayList).GetMethod("get_Item", new Type[1] {
typeof(int)
});
foreach (ParameterInfo parameter in parameters)
{
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldarg, j + 1);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Callvirt, get_ItemMethod);
il.Emit(OpCodes.Castclass, typeof(InterceptedParameter));
FieldInfo valueField = typeof(InterceptedParameter).GetField("Value");
il.Emit(OpCodes.Ldfld, valueField);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
{
il.Emit(OpCodes.Unbox, t);
il.Emit(OpCodes.Ldobj, t);
il.Emit(OpCodes.Stobj, t);
}
else
{
il.Emit(OpCodes.Castclass, t);
il.Emit(OpCodes.Stind_Ref);
}
}
j++;
}
il.Emit(OpCodes.Ret);
//--------------
BuildWrapperMethod(wrapperName, typeBuilder, constructor);
}
private void BuildMixinMethod(TypeBuilder typeBuilder, MethodInfo method, FieldBuilder field)
{
if (method.DeclaringType == typeof(IAopProxy))
{
BuildMixinWrapperMethod(method.Name, typeBuilder, method, field);
return;
}
string wrapperName = GetMethodId(method.Name);
wrapperMethods.Add(wrapperName);
MethodCache.methodLookup[wrapperName] = method;
// MethodCache.wrapperMethodLookup[wrapperName] = method;
ParameterInfo[] parameterInfos = method.GetParameters();
Type[] parameterTypes = new Type[parameterInfos.Length];
for (int i = 0; i < parameterInfos.Length; i++)
{
parameterTypes[i] = parameterInfos[i].ParameterType;
}
MethodBuilder methodBuilder =
typeBuilder.DefineMethod(method.Name, MethodAttributes.Public | MethodAttributes.Virtual,
CallingConventions.Standard, method.ReturnType, parameterTypes);
methodBuilder.SetCustomAttribute(DebuggerStepThroughBuilder());
methodBuilder.SetCustomAttribute(DebuggerHiddenBuilder());
for (int i = 0; i < parameterInfos.Length; i++)
{
}
ILGenerator il = methodBuilder.GetILGenerator();
LocalBuilder paramList = il.DeclareLocal(typeof(ArrayList));
//create param arraylist
ConstructorInfo arrayListCtor = typeof(ArrayList).GetConstructor(new Type[0]);
il.Emit(OpCodes.Newobj, arrayListCtor);
il.Emit(OpCodes.Stloc, paramList);
int j = 0;
ConstructorInfo interceptedParameterCtor = typeof(InterceptedParameter).GetConstructors()[0];
MethodInfo arrayListAddMethod = typeof(ArrayList).GetMethod("Add");
MethodInfo getTypeMethod = typeof(Type).GetMethod("GetType", new Type[1] {
typeof(string)
});
foreach (ParameterInfo parameter in parameterInfos)
{
il.Emit(OpCodes.Ldloc, paramList);
string paramName = parameter.Name;
if (paramName == null)
{
paramName = "param" + j.ToString();
}
il.Emit(OpCodes.Ldstr, paramName);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Ldstr, parameter.ParameterType.FullName.Replace("&", ""));
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Ldarg, j + 1);
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldind_Ref);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
{
il.Emit(OpCodes.Box, t);
}
}
if (parameter.ParameterType.IsValueType)
{
il.Emit(OpCodes.Box, parameter.ParameterType);
}
il.Emit(OpCodes.Ldc_I4, (int)ParameterType.ByVal);
il.Emit(OpCodes.Newobj, interceptedParameterCtor);
il.Emit(OpCodes.Callvirt, arrayListAddMethod);
il.Emit(OpCodes.Pop);
j++;
}
#if NET2
CallInfo callInfo = new CallInfo(wrapperName, method, new ArrayList(), FastCall.GetMethodInvoker(method));
#else
CallInfo callInfo = new CallInfo(wrapperName, method, new ArrayList());
#endif
MethodInfo handleCallMethod = typeof(IAopProxy).GetMethod("HandleFastCall");
int methodNr = MethodCache.AddCallInfo(callInfo, wrapperName);
//il.Emit(OpCodes.Ldc_I4 ,methodNr);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, field); // set the execution target to the mixin instance
il.Emit(OpCodes.Ldc_I4, methodNr);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldstr, method.ReturnType.FullName);
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Callvirt, handleCallMethod);
if (method.ReturnType == typeof(void))
{
il.Emit(OpCodes.Pop);
}
else if (method.ReturnType.IsValueType)
{
il.Emit(OpCodes.Unbox, method.ReturnType);
il.Emit(OpCodes.Ldobj, method.ReturnType);
}
j = 0;
MethodInfo get_ItemMethod = typeof(ArrayList).GetMethod("get_Item", new Type[1] {
typeof(int)
});
foreach (ParameterInfo parameter in parameterInfos)
{
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldarg, j + 1);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Callvirt, get_ItemMethod);
il.Emit(OpCodes.Castclass, typeof(InterceptedParameter));
FieldInfo valueField = typeof(InterceptedParameter).GetField("Value");
il.Emit(OpCodes.Ldfld, valueField);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
{
il.Emit(OpCodes.Unbox, t);
il.Emit(OpCodes.Ldobj, t);
il.Emit(OpCodes.Stobj, t);
}
else
{
il.Emit(OpCodes.Castclass, t);
il.Emit(OpCodes.Stind_Ref);
}
}
j++;
}
il.Emit(OpCodes.Ret);
BuildMixinWrapperMethod(wrapperName, typeBuilder, method, field);
}
private void BuildConstructor(ConstructorInfo constructor, TypeBuilder typeBuilder, IList mixins)
{
string wrapperName = GetMethodId(constructor.Name);
wrapperMethods.Add(wrapperName);
MethodCache.methodLookup[wrapperName] = constructor;
ParameterInfo[] parameters = constructor.GetParameters();
//make proxy ctor param count same as superclass
Type[] parameterTypes = new Type[parameters.Length + 1];
//copy super ctor param types
for (int i = 0; i <= parameters.Length - 1; i++)
{
parameterTypes[i + 1] = parameters[i].ParameterType;
}
parameterTypes[0] = typeof (object);
ConstructorBuilder proxyConstructor =
typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameterTypes);
ILGenerator il = proxyConstructor.GetILGenerator();
proxyConstructor.SetCustomAttribute(DebuggerStepThroughBuilder());
proxyConstructor.SetCustomAttribute(DebuggerHiddenBuilder());
foreach (Type mixinType in mixins)
{
if (mixinType.IsInterface)
{
//ignore interface type mixins , they do not have an impelemntation
}
else
{
// il.EmitWriteLine("setting mixin instance " + mixinType.FullName) ;
il.Emit(OpCodes.Ldarg_0);
ConstructorInfo mixinCtor = (mixinType).GetConstructor(new Type[] {});
il.Emit(OpCodes.Newobj, mixinCtor);
il.Emit(OpCodes.Stfld, GetMixinField(mixinType));
}
}
//associate iproxyaware mixins with this instance
MethodInfo setProxyMethod = typeof (IProxyAware).GetMethod("SetProxy");
foreach (Type mixinType in mixins)
{
if (mixinType.IsInterface)
{
//ignore interface type mixins , they do not have an impelemntation
}
else
{
if (typeof (IProxyAware).IsAssignableFrom(mixinType))
{
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, GetMixinField(mixinType));
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Callvirt, setProxyMethod);
}
}
}
//--------------------------
LocalBuilder paramList = il.DeclareLocal(typeof (ArrayList));
//create param arraylist
ConstructorInfo arrayListCtor = typeof (ArrayList).GetConstructor(new Type[0]);
il.Emit(OpCodes.Newobj, arrayListCtor);
il.Emit(OpCodes.Stloc, paramList);
ConstructorInfo interceptedParameterCtor = typeof (InterceptedParameter).GetConstructors()[0];
MethodInfo arrayListAddMethod = typeof (ArrayList).GetMethod("Add");
MethodInfo getTypeMethod = typeof (Type).GetMethod("GetType", new Type[1] {typeof (string)});
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldstr, "_state");
il.Emit(OpCodes.Ldc_I4, 0);
il.Emit(OpCodes.Ldstr, typeof (object).FullName);
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Ldarg, 0 + 1);
il.Emit(OpCodes.Ldc_I4, (int) ParameterType.ByVal);
il.Emit(OpCodes.Newobj, interceptedParameterCtor);
il.Emit(OpCodes.Callvirt, arrayListAddMethod);
il.Emit(OpCodes.Pop);
int j = 1;
foreach (ParameterInfo parameter in parameters)
{
il.Emit(OpCodes.Ldloc, paramList);
string paramName = parameter.Name;
if (paramName == null)
{
paramName = "param" + j.ToString();
}
il.Emit(OpCodes.Ldstr, paramName);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Ldstr, parameter.ParameterType.FullName.Replace("&", ""));
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Ldarg, j + 1);
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldind_Ref);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
il.Emit(OpCodes.Box, t);
}
if (parameter.ParameterType.IsValueType)
{
il.Emit(OpCodes.Box, parameter.ParameterType);
}
il.Emit(OpCodes.Ldc_I4, (int) ParameterType.ByVal);
il.Emit(OpCodes.Newobj, interceptedParameterCtor);
il.Emit(OpCodes.Callvirt, arrayListAddMethod);
il.Emit(OpCodes.Pop);
j++;
}
#if NET2
CallInfo callInfo = new CallInfo(wrapperName,constructor, new ArrayList(), FastCall.GetMethodInvoker(constructor));
#else
CallInfo callInfo = new CallInfo(wrapperName,constructor, new ArrayList());
#endif
MethodInfo handleCallMethod = typeof(IAopProxy).GetMethod("HandleFastCall");
int methodNr = MethodCache.AddCallInfo(callInfo, wrapperName);
//il.Emit(OpCodes.Ldc_I4 ,methodNr);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldc_I4, methodNr);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldstr, typeof (void).FullName);
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Callvirt, handleCallMethod);
il.Emit(OpCodes.Pop);
j = 1;
MethodInfo get_ItemMethod = typeof (ArrayList).GetMethod("get_Item", new Type[1] {typeof (int)});
foreach (ParameterInfo parameter in parameters)
{
if (parameter.ParameterType.FullName.IndexOf("&") >= 0)
{
il.Emit(OpCodes.Ldarg, j + 1);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldc_I4, j);
il.Emit(OpCodes.Callvirt, get_ItemMethod);
il.Emit(OpCodes.Castclass, typeof (InterceptedParameter));
FieldInfo valueField = typeof (InterceptedParameter).GetField("Value");
il.Emit(OpCodes.Ldfld, valueField);
Type t = Type.GetType(parameter.ParameterType.FullName.Replace("&", ""));
if (t.IsValueType)
{
il.Emit(OpCodes.Unbox, t);
il.Emit(OpCodes.Ldobj, t);
il.Emit(OpCodes.Stobj, t);
}
else
{
il.Emit(OpCodes.Castclass, t);
il.Emit(OpCodes.Stind_Ref);
}
}
j++;
}
il.Emit(OpCodes.Ret);
//--------------
BuildWrapperMethod(wrapperName, typeBuilder, constructor);
}
private void BuildMethod(string methodName, TypeBuilder typeBuilder, MethodInfo method)
{
string wrapperName = GetMethodId(method.Name);
wrapperMethods.Add(wrapperName);
MethodCache.methodLookup[wrapperName] = method;
ParameterInfo[] parameterInfos = method.GetParameters();
Type[] parameterTypes = new Type[parameterInfos.Length];
for (int i = 0; i < parameterInfos.Length; i++)
{
parameterTypes[i] = parameterInfos[i].ParameterType;
}
MethodBuilder methodBuilder =
typeBuilder.DefineMethod(methodName,
MethodAttributes.NewSlot | MethodAttributes.Private | MethodAttributes.Virtual |
MethodAttributes.Final | MethodAttributes.HideBySig,
CallingConventions.Standard, method.ReturnType, parameterTypes);
for (int i = 0; i < parameterInfos.Length; i++)
{
}
typeBuilder.DefineMethodOverride(methodBuilder, method);
ILGenerator il = methodBuilder.GetILGenerator();
//--------------------------
LocalBuilder paramList = il.DeclareLocal(typeof(object[]));
//create param object[]
il.Emit(OpCodes.Ldc_I4_S, parameterInfos.Length + 1);
il.Emit(OpCodes.Newarr, typeof(object));
il.Emit(OpCodes.Stloc, paramList);
//-----------------------------------
int j = 0;
foreach (Type parameterType in parameterTypes)
{
//load arr
il.Emit(OpCodes.Ldloc, paramList);
//load index
il.Emit(OpCodes.Ldc_I4, j);
//load arg
il.Emit(OpCodes.Ldarg, j + 1);
//box if needed
if (parameterType.IsByRef)
{
il.Emit(OpCodes.Ldind_Ref);
Type t = parameterType.GetElementType();
if (t.IsValueType)
{
il.Emit(OpCodes.Box, t);
}
}
else if (parameterType.IsValueType)
{
il.Emit(OpCodes.Box, parameterType);
}
il.Emit(OpCodes.Stelem_Ref);
j++;
}
//-----------------------------------
CallInfo callInfo = MethodCache.CreateCallInfo(method, parameterInfos, wrapperName);
MethodInfo handleCallMethod = typeof(IAopProxy).GetMethod("HandleFastCall");
int methodNr = MethodCache.AddCallInfo(callInfo, wrapperName);
//il.Emit(OpCodes.Ldc_I4 ,methodNr);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, that); // load the execution target
il.Emit(OpCodes.Ldc_I4, methodNr);
il.Emit(OpCodes.Ldloc, paramList);
il.Emit(OpCodes.Ldstr, method.ReturnType.FullName);
MethodInfo getTypeMethod = typeof(Type).GetMethod("GetType", new Type[1] {
typeof(string)
});
il.Emit(OpCodes.Call, getTypeMethod);
il.Emit(OpCodes.Callvirt, handleCallMethod);
if (method.ReturnType == typeof(void))
{
il.Emit(OpCodes.Pop);
}
else if (method.ReturnType.IsValueType)
{
il.Emit(OpCodes.Unbox, method.ReturnType);
il.Emit(OpCodes.Ldobj, method.ReturnType);
}
MethodCache.CopyBackRefParams(il, parameterInfos, paramList);
il.Emit(OpCodes.Ret);
BuildWrapperMethod(wrapperName, typeBuilder, method);
}
