private MethodBuilder CreateMethodOverride(MethodBuilder delegateMethod)
{
string methodName =
_explicitImplementation
? _methodToOverride.DeclaringType.Name + "." + _methodToOverride.Name
: _methodToOverride.Name;
MethodBuilder methodBuilder =
_typeBuilder.DefineMethod(
methodName,
_explicitImplementation ? ExplicitImplementationAttributes : ImplicitImplementationAttributes);
var paramMapper = new MethodOverrideParameterMapper(_methodToOverride);
paramMapper.SetupParameters(methodBuilder, _targetInterfaceParameterMapper);
methodBuilder.SetReturnType(paramMapper.GetReturnType());
methodBuilder.SetParameters(_methodParameters.Select(pi => paramMapper.GetParameterType(pi.ParameterType)).ToArray());
if (_explicitImplementation)
{
_typeBuilder.DefineMethodOverride(methodBuilder, _methodToOverride);
}
int paramNum = 1;
foreach (ParameterInfo pi in _methodParameters)
{
methodBuilder.DefineParameter(paramNum++, pi.Attributes, pi.Name);
}
ILGenerator il = methodBuilder.GetILGenerator();
LocalBuilder methodReturn = il.DeclareLocal(typeof(IMethodReturn));
LocalBuilder ex = il.DeclareLocal(typeof(Exception));
LocalBuilder parameterArray = il.DeclareLocal(typeof(object[]));
LocalBuilder inputs = il.DeclareLocal(typeof(VirtualMethodInvocation));
// Create instance of VirtualMethodInvocation
il.Emit(OpCodes.Ldarg_0); // target object
// If we have a targetField, that means we're building a proxy and
// should use it as the target object. If we don't, we're building
// a type interceptor and should leave the this pointer as the
// target.
if (_targetField != null)
{
il.Emit(OpCodes.Ldfld, _targetField);
}
// If we have a generic method, we want to make sure we're using the open constructed generic method
// so when a closed generic version of the method is invoked the actual type parameters are used
il.Emit(
OpCodes.Ldtoken,
_methodToOverride.IsGenericMethodDefinition
? _methodToOverride.MakeGenericMethod(paramMapper.GenericMethodParameters)
: _methodToOverride);
if (_methodToOverride.DeclaringType.IsGenericType)
{
// if the declaring type is generic, we need to get the method from the target type
il.Emit(OpCodes.Ldtoken, _targetInterface);
il.Emit(OpCodes.Call, MethodBaseMethods.GetMethodForGenericFromHandle);
}
else
{
il.Emit(OpCodes.Call, MethodBaseMethods.GetMethodFromHandle); // target method
}
EmitLoadConstant(il, _methodParameters.Length);
il.Emit(OpCodes.Newarr, typeof(object)); // object[] parameters
if (_methodParameters.Length > 0)
{
il.Emit(OpCodes.Stloc, parameterArray);
for (int i = 0; i < _methodParameters.Length; ++i)
{
il.Emit(OpCodes.Ldloc, parameterArray);
EmitLoadConstant(il, i);
EmitLoadArgument(il, i);
Type elementType = paramMapper.GetParameterType(_methodParameters[i].ParameterType);
if (elementType.IsByRef)
{
elementType = paramMapper.GetElementType(_methodParameters[i].ParameterType);
il.Emit(OpCodes.Ldobj, elementType);
}
EmitBox(il, elementType);
il.Emit(OpCodes.Stelem_Ref);
}
il.Emit(OpCodes.Ldloc, parameterArray);
}
il.Emit(OpCodes.Newobj, VirtualMethodInvocationMethods.VirtualMethodInvocation);
il.Emit(OpCodes.Stloc, inputs);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, _proxyInterceptionPipelineField);
il.Emit(OpCodes.Ldloc, inputs);
// Put delegate reference onto the stack
il.Emit(OpCodes.Ldarg_0);
MethodInfo callTarget = delegateMethod;
if (callTarget.IsGenericMethod)
{
callTarget = delegateMethod.MakeGenericMethod(paramMapper.GenericMethodParameters);
}
il.Emit(OpCodes.Ldftn, callTarget);
il.Emit(OpCodes.Newobj, InvokeInterceptionBehaviorDelegateMethods.InvokeInterceptionBehaviorDelegate);
// And call the pipeline
il.Emit(OpCodes.Call, InterceptionBehaviorPipelineMethods.Invoke);
il.Emit(OpCodes.Stloc, methodReturn);
// Was there an exception?
Label noException = il.DefineLabel();
il.Emit(OpCodes.Ldloc, methodReturn);
il.EmitCall(OpCodes.Callvirt, IMethodReturnMethods.GetException, null);
il.Emit(OpCodes.Stloc, ex);
il.Emit(OpCodes.Ldloc, ex);
il.Emit(OpCodes.Ldnull);
il.Emit(OpCodes.Ceq);
il.Emit(OpCodes.Brtrue_S, noException);
il.Emit(OpCodes.Ldloc, ex);
if (ReflectionHelper.ExceptionDispatchInfoCaptureMethod != null &&
ReflectionHelper.ExceptionDispatchInfoThrowMethod != null)
{
il.EmitCall(OpCodes.Call, ReflectionHelper.ExceptionDispatchInfoCaptureMethod, null);
il.EmitCall(OpCodes.Callvirt, ReflectionHelper.ExceptionDispatchInfoThrowMethod, null);
}
else
{
il.Emit(OpCodes.Throw);
}
il.MarkLabel(noException);
// Unpack any ref/out parameters
if (_methodParameters.Length > 0)
{
int outputArgNum = 0;
for (paramNum = 0; paramNum < _methodParameters.Length; ++paramNum)
{
ParameterInfo pi = _methodParameters[paramNum];
if (pi.ParameterType.IsByRef)
{
// GetOrDefault the original parameter value - address of the ref or out
EmitLoadArgument(il, paramNum);
// GetOrDefault the value of this output parameter out of the Outputs collection
il.Emit(OpCodes.Ldloc, methodReturn);
il.Emit(OpCodes.Callvirt, IMethodReturnMethods.GetOutputs);
EmitLoadConstant(il, outputArgNum++);
il.Emit(OpCodes.Callvirt, IListMethods.GetItem);
EmitUnboxOrCast(il, paramMapper.GetElementType(pi.ParameterType));
// And store in the caller
il.Emit(OpCodes.Stobj, paramMapper.GetElementType(pi.ParameterType));
}
}
}
if (MethodHasReturnValue)
{
il.Emit(OpCodes.Ldloc, methodReturn);
il.EmitCall(OpCodes.Callvirt, IMethodReturnMethods.GetReturnValue, null);
EmitUnboxOrCast(il, paramMapper.GetReturnType());
}
il.Emit(OpCodes.Ret);
return(methodBuilder);
}
private MethodBuilder CreateDelegateImplementation()
{
string methodName = CreateMethodName("DelegateImplementation");
MethodBuilder methodBuilder = _typeBuilder.DefineMethod(methodName,
MethodAttributes.Private | MethodAttributes.HideBySig);
List <LocalBuilder> outOrRefLocals = new List <LocalBuilder>();
var paramMapper = new MethodOverrideParameterMapper(_methodToOverride);
paramMapper.SetupParameters(methodBuilder, _targetInterfaceParameterMapper);
methodBuilder.SetReturnType(typeof(IMethodReturn));
// Adding parameters
methodBuilder.SetParameters(typeof(IMethodInvocation), typeof(GetNextInterceptionBehaviorDelegate));
// Parameter
methodBuilder.DefineParameter(1, ParameterAttributes.None, "inputs");
// Parameter
methodBuilder.DefineParameter(2, ParameterAttributes.None, "getNext");
methodBuilder.SetCustomAttribute(new CustomAttributeBuilder(CompilerGeneratedAttributeMethods.CompilerGeneratedAttribute, new object[0]));
ILGenerator il = methodBuilder.GetILGenerator();
if (_targetField != null)
{
// forwarding implementation
Label done = il.DefineLabel();
LocalBuilder ex = il.DeclareLocal(typeof(Exception));
LocalBuilder baseReturn = null;
LocalBuilder parameters = null;
if (MethodHasReturnValue)
{
baseReturn = il.DeclareLocal(paramMapper.GetReturnType());
}
LocalBuilder retval = il.DeclareLocal(typeof(IMethodReturn));
il.BeginExceptionBlock();
// Call the target method
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldfld, _targetField);
if (_methodParameters.Length > 0)
{
parameters = il.DeclareLocal(typeof(IParameterCollection));
il.Emit(OpCodes.Ldarg_1);
il.EmitCall(OpCodes.Callvirt, IMethodInvocationMethods.GetArguments, null);
il.Emit(OpCodes.Stloc, parameters);
for (int i = 0; i < _methodParameters.Length; ++i)
{
il.Emit(OpCodes.Ldloc, parameters);
EmitLoadConstant(il, i);
il.EmitCall(OpCodes.Callvirt, IListMethods.GetItem, null);
Type parameterType = paramMapper.GetParameterType(_methodParameters[i].ParameterType);
if (parameterType.IsByRef)
{
Type elementType = parameterType.GetElementType();
LocalBuilder refShadowLocal = il.DeclareLocal(elementType);
outOrRefLocals.Add(refShadowLocal);
EmitUnboxOrCast(il, elementType);
il.Emit(OpCodes.Stloc, refShadowLocal);
il.Emit(OpCodes.Ldloca, refShadowLocal);
}
else
{
EmitUnboxOrCast(il, parameterType);
}
}
}
MethodInfo callTarget = _methodToOverride;
if (callTarget.IsGenericMethod)
{
callTarget = _methodToOverride.MakeGenericMethod(paramMapper.GenericMethodParameters);
}
il.Emit(OpCodes.Callvirt, callTarget);
if (MethodHasReturnValue)
{
il.Emit(OpCodes.Stloc, baseReturn);
}
// Generate the return value
il.Emit(OpCodes.Ldarg_1);
if (MethodHasReturnValue)
{
il.Emit(OpCodes.Ldloc, baseReturn);
EmitBox(il, paramMapper.GetReturnType());
}
else
{
il.Emit(OpCodes.Ldnull);
}
EmitLoadConstant(il, _methodParameters.Length);
il.Emit(OpCodes.Newarr, typeof(object));
if (_methodParameters.Length > 0)
{
LocalBuilder outputArguments = il.DeclareLocal(typeof(object[]));
il.Emit(OpCodes.Stloc, outputArguments);
int outputArgNum = 0;
for (int i = 0; i < _methodParameters.Length; ++i)
{
il.Emit(OpCodes.Ldloc, outputArguments);
EmitLoadConstant(il, i);
Type parameterType = paramMapper.GetParameterType(_methodParameters[i].ParameterType);
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
il.Emit(OpCodes.Ldloc, outOrRefLocals[outputArgNum++]);
EmitBox(il, parameterType);
}
else
{
il.Emit(OpCodes.Ldloc, parameters);
EmitLoadConstant(il, i);
il.Emit(OpCodes.Callvirt, IListMethods.GetItem);
}
il.Emit(OpCodes.Stelem_Ref);
}
il.Emit(OpCodes.Ldloc, outputArguments);
}
il.Emit(OpCodes.Callvirt, IMethodInvocationMethods.CreateReturn);
il.Emit(OpCodes.Stloc, retval);
il.BeginCatchBlock(typeof(Exception));
il.Emit(OpCodes.Stloc, ex);
// Create an exception return
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldloc, ex);
il.EmitCall(OpCodes.Callvirt, IMethodInvocationMethods.CreateExceptionMethodReturn, null);
il.Emit(OpCodes.Stloc, retval);
il.EndExceptionBlock();
il.MarkLabel(done);
il.Emit(OpCodes.Ldloc, retval);
il.Emit(OpCodes.Ret);
}
else
{
// exception-throwing implementation
il.Emit(OpCodes.Ldarg_1);
il.EmitCall(OpCodes.Call, BuildAdditionalInterfaceNonImplementedExceptionMethod, null);
il.EmitCall(OpCodes.Callvirt, IMethodInvocationMethods.CreateExceptionMethodReturn, null);
il.Emit(OpCodes.Ret);
}
return(methodBuilder);
}
