/// <summary>
/// Builds an intercepted method based on the specified method.
/// </summary>
/// <param name="methodInfo">The method information.</param>
/// <param name="isExplicit">A value indicating whether the specified method should be implemented explicitly.</param>
/// <returns>The intercepted method builder.</returns>
private MethodBuilder BuildInterceptedMethod(MethodInfo methodInfo, bool isExplicit)
{
var isOverride = IsOverrideMember(methodInfo);
if (isOverride && !methodInfo.CanOverride())
throw new InvalidOperationException(String.Format(Resources.MethodNotOverridable, methodInfo.Name));
// Define method.
var methodBuilder = _typeBuilder.DefineMethod(methodInfo, isExplicit, isOverride);
// Define generic parameters.
var genericParameterTypes = methodBuilder.DefineGenericParameters(methodInfo);
// Define parameters.
methodBuilder.DefineParameters(methodInfo, genericParameterTypes);
// Only define method override if method is implemented explicitly and is an override.
if (isExplicit && isOverride)
_typeBuilder.DefineMethodOverride(methodBuilder, methodInfo);
// Implement method.
var ilGenerator = methodBuilder.GetILGenerator();
// Load arguments.
var parameterTypes = methodInfo.MapGenericParameterTypes(genericParameterTypes);
var parametersLocalBuilder = ilGenerator.NewArray(typeof (object), parameterTypes.Length);
LoadArguments(ilGenerator, parameterTypes, parametersLocalBuilder);
// Load invocation handler.
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(OpCodes.Ldfld, _invocationHandlerFieldInfo);
// Load proxy object.
ilGenerator.Emit(OpCodes.Ldarg_0);
// Get method information constructor.
var methodInfoConstructorInfo = GetMethodInfoConstructor(methodInfo, genericParameterTypes);
// Create and load method information.
ilGenerator.Emit(OpCodes.Ldarg_0);
ilGenerator.Emit(isOverride ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
ilGenerator.Emit(OpCodes.Newobj, methodInfoConstructorInfo);
// Load parameters.
ilGenerator.Emit(OpCodes.Ldloc, parametersLocalBuilder);
// Call invocation handler method.
ilGenerator.EmitCall(InvocationHandlerInvokeMethodInfo);
// Restore by reference arguments.
RestoreByReferenceArguments(ilGenerator, parameterTypes, parametersLocalBuilder);
// Handle return value.
var returnType = methodInfo.MapGenericReturnType(genericParameterTypes);
if (returnType.IsVoid())
ilGenerator.Emit(OpCodes.Pop);
else
ilGenerator.EmitUnbox(returnType);
ilGenerator.Emit(OpCodes.Ret);
return methodBuilder;
}
/// <inheritdoc/>
public Type CreateType(MethodInfo methodInfo)
{
if (methodInfo == null)
throw new ArgumentNullException("methodInfo");
// Define type.
var typeBuilder = _typeRepository.DefineType("MethodInfo", typeof (MethodInfoBase));
// Define generic parameters.
var genericParameterTypes = typeBuilder.DefineGenericParameters(methodInfo.GetGenericArguments());
// Define method information static field.
var methodFieldInfo = typeBuilder.DefineField(
"TargetMethod",
typeof (MethodInfo),
FieldAttributes.Private | FieldAttributes.Static | FieldAttributes.InitOnly);
// Build type initializer.
BuildTypeInitializer(typeBuilder, methodInfo, genericParameterTypes, methodFieldInfo);
// Build constructor.
BuildConstructor(typeBuilder, methodFieldInfo);
// Build base invoke method only for non abstract and overrideable methods.
if (!methodInfo.IsAbstract && methodInfo.CanOverride())
BuildInvokeMethod(typeBuilder, methodInfo, genericParameterTypes, false);
// Build virtual invoke method.
BuildInvokeMethod(typeBuilder, methodInfo, genericParameterTypes, true);
return typeBuilder.CreateType();
}
