public Expression VisitNewDelegate(NewDelegateExpression node)
{
ArgumentUtility.CheckNotNull("node", node);
var constructorInfo = node.Type.GetConstructor(new[] { typeof(object), typeof(IntPtr) });
if (node.Method.IsStatic)
{
_ilGenerator.Emit(OpCodes.Ldnull);
}
else
{
_childExpressionEmitter(node.Target);
}
if (node.Method.IsVirtual)
{
_ilGenerator.Emit(OpCodes.Dup);
_ilGenerator.Emit(OpCodes.Ldvirtftn, node.Method);
}
else
{
_ilGenerator.Emit(OpCodes.Ldftn, node.Method);
}
_ilGenerator.Emit(OpCodes.Newobj, constructorInfo);
return(node);
}
public void Initialization_StaticMethod()
{
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => StaticMethod());
var expression = new NewDelegateExpression(typeof(Action), null, method);
Assert.That(expression.Target, Is.Null);
}
public void SetUp()
{
_nonVirtualInstanceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => Method(7, null));
_delegateType = typeof(Func <int, object, string>);
_target = ExpressionTreeObjectMother.GetSomeExpression(_nonVirtualInstanceMethod.DeclaringType);
_expression = new NewDelegateExpression(_delegateType, _target, _nonVirtualInstanceMethod);
}
public void VisitNewDelegate_Static()
{
var delegateType = typeof(Action);
var delegateCtor = delegateType.GetConstructors().Single();
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod(() => DomainType.StaticMethod());
var expression = new NewDelegateExpression(delegateType, null, method);
_ilGeneratorMock.Setup(mock => mock.Emit(OpCodes.Ldnull)).Verifiable();
_ilGeneratorMock.Setup(mock => mock.Emit(OpCodes.Ldftn, expression.Method)).Verifiable();
_ilGeneratorMock.Setup(mock => mock.Emit(OpCodes.Newobj, delegateCtor)).Verifiable();
_emitter.VisitNewDelegate(expression);
_ilGeneratorMock.Verify();
}
public void VisitNewDelegate()
{
var delegateType = typeof(Action);
var delegateCtor = delegateType.GetConstructors().Single();
var targetExpression = ExpressionTreeObjectMother.GetSomeExpression(typeof(DomainType));
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((DomainType obj) => obj.Method());
var expression = new NewDelegateExpression(delegateType, targetExpression, method);
_childExpressionEmitterMock.Setup(mock => mock.EmitChildExpression(expression.Target)).Verifiable();
_ilGeneratorMock.Setup(mock => mock.Emit(OpCodes.Ldftn, expression.Method)).Verifiable();
_ilGeneratorMock.Setup(mock => mock.Emit(OpCodes.Newobj, delegateCtor)).Verifiable();
var result = _emitter.VisitNewDelegate(expression);
_childExpressionEmitterMock.Verify();
_ilGeneratorMock.Verify();
Assert.That(result, Is.SameAs(expression));
}
public void VisitNewDelegate_Virtual()
{
var delegateType = typeof(Action);
var delegateCtor = delegateType.GetConstructors().Single();
var method = NormalizingMemberInfoFromExpressionUtility.GetMethod((BaseType obj) => obj.VirtualMethod());
var targetExpression = ExpressionTreeObjectMother.GetSomeExpression(typeof(DomainType));
var expression = new NewDelegateExpression(delegateType, targetExpression, method);
_childExpressionEmitterMock.Expect(mock => mock.EmitChildExpression(expression.Target));
_ilGeneratorMock.Expect(mock => mock.Emit(OpCodes.Dup));
_ilGeneratorMock.Expect(mock => mock.Emit(OpCodes.Ldvirtftn, expression.Method));
_ilGeneratorMock.Expect(mock => mock.Emit(OpCodes.Newobj, delegateCtor));
_emitter.VisitNewDelegate(expression);
_childExpressionEmitterMock.VerifyAllExpectations();
_ilGeneratorMock.VerifyAllExpectations();
}
public void Prepare(MutableType mutableType, EventInfo eventInfo)
{
var eventType = eventInfo.EventHandlerType;
var eventInvoke = eventType.GetMethod("Invoke");
var original = Expression.Field(
new ThisExpression(mutableType),
mutableType.GetField(eventInfo.Name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public));
var broker = Expression.Field(
new ThisExpression(mutableType),
mutableType.AddField(eventInfo.Name + "Broker", eventType));
var addMethod = mutableType.GetOrAddMutableMethod(eventInfo.GetAddMethod(true));
var removeMethod = mutableType.GetOrAddMutableMethod(eventInfo.GetRemoveMethod(true));
var parameters = eventInvoke.GetParameters().Select(ParameterDeclaration.CreateEquivalent);
var invokeMethod = mutableType.AddMethod(
"invoke_" + eventInfo.Name,
MethodAttributes.Private,
eventInvoke.ReturnType,
parameters,
ctx => Expression.Call(broker, eventInvoke, ctx.Parameters.Cast <Expression>()));
var invokeDelegate = new NewDelegateExpression(eventType, new ThisExpression(mutableType.UnderlyingSystemType), invokeMethod);
addMethod.SetBody(
ctx => Expression.Block(
Expression.IfThen(
Expression.Equal(broker, Expression.Constant(null, eventType)),
Expression.Call(ctx.This, new NonVirtualCallMethodInfoAdapter(addMethod.UnderlyingSystemMethodInfo), invokeDelegate)),
Expression.Assign(
broker,
Expression.Convert(Expression.Call(null, s_combineMethod, new Expression[] { broker, ctx.Parameters.Single() }), eventType))));
removeMethod.SetBody(
ctx => Expression.Block(
Expression.IfThen(
Expression.Equal(broker, Expression.Constant(null, eventType)),
Expression.Call(ctx.This, new NonVirtualCallMethodInfoAdapter(addMethod.UnderlyingSystemMethodInfo), invokeDelegate)),
Expression.Assign(
broker,
Expression.Convert(Expression.Call(null, s_combineMethod, new Expression[] { broker, ctx.Parameters.Single() }), eventType))));
}
