public void WireConstructorWithInitialization(
MutableConstructorInfo constructor,
Tuple <FieldInfo, MethodInfo> initializationMembers,
IProxySerializationEnabler proxySerializationEnabler)
{
ArgumentUtility.CheckNotNull("constructor", constructor);
ArgumentUtility.CheckNotNull("proxySerializationEnabler", proxySerializationEnabler);
if (initializationMembers == null || proxySerializationEnabler.IsDeserializationConstructor(constructor))
{
return;
}
// We cannot protect the decrement with try-finally because the this pointer must be initialized before entering a try block.
// Using *IncrementAssign and *DecrementAssign results in un-verifiable code (emits stloc.0).
constructor.SetBody(
ctx =>
{
var initilizationMethod = initializationMembers.Item2;
var counter = Expression.Field(ctx.This, initializationMembers.Item1);
var one = Expression.Constant(1);
var zero = Expression.Constant(0);
return(Expression.Block(
Expression.Assign(counter, Expression.Add(counter, one)),
constructor.Body,
Expression.Assign(counter, Expression.Subtract(counter, one)),
Expression.IfThen(
Expression.Equal(counter, zero),
Expression.Call(ctx.This, initilizationMethod, Expression.Constant(InitializationSemantics.Construction)))));
});
}
public void SetUp()
{
_proxy = MutableTypeObjectMother.Create();
_addedCtor = _proxy.AddConstructor();
_tracker = new ProxyTypeModificationTracker(_proxy, new[] { _addedCtor.Body });
}
public void RegisterWith(IEmittableOperandProvider emittableOperandProvider, MutableConstructorInfo constructor)
{
ArgumentUtility.CheckNotNull("emittableOperandProvider", emittableOperandProvider);
ArgumentUtility.CheckNotNull("constructor", constructor);
emittableOperandProvider.AddMapping(constructor, _constructorBuilder);
}
public void Initialization()
{
var declaringType = MutableTypeObjectMother.Create();
var attributes = (MethodAttributes)7 | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName;
var parameters = ParameterDeclarationObjectMother.CreateMultiple(2);
var body = ExpressionTreeObjectMother.GetSomeExpression(typeof(void));
var ctor = new MutableConstructorInfo(declaringType, attributes, parameters.AsOneTime(), body);
Assert.That(ctor.DeclaringType, Is.SameAs(declaringType));
Assert.That(ctor.MutableDeclaringType, Is.SameAs(declaringType));
Assert.That(ctor.Name, Is.EqualTo(".ctor"));
var actualParameters = ctor.GetParameters();
Assert.That(actualParameters, Has.Length.EqualTo(2));
CustomParameterInfoTest.CheckParameter(actualParameters[0], ctor, 0, parameters[0].Name, parameters[0].Type, parameters[0].Attributes);
CustomParameterInfoTest.CheckParameter(actualParameters[1], ctor, 1, parameters[1].Name, parameters[1].Type, parameters[1].Attributes);
Assert.That(ctor.MutableParameters, Is.EqualTo(actualParameters));
var paramExpressions = ctor.ParameterExpressions;
Assert.That(paramExpressions, Has.Count.EqualTo(2));
Assert.That(paramExpressions[0], Has.Property("Name").EqualTo(parameters[0].Name).And.Property("Type").SameAs(parameters[0].Type));
Assert.That(paramExpressions[1], Has.Property("Name").EqualTo(parameters[1].Name).And.Property("Type").SameAs(parameters[1].Type));
Assert.That(ctor.Body, Is.SameAs(body));
}
public void AddMapping(MutableConstructorInfo mappedConstructor, ConstructorInfo emittableConstructor)
{
ArgumentUtility.CheckNotNull("mappedConstructor", mappedConstructor);
ArgumentUtility.CheckNotNull("emittableConstructor", emittableConstructor);
AddMapping(_mappedConstructors, mappedConstructor, emittableConstructor);
}
private void AdaptDeserializationConstructor(MutableConstructorInfo constructor, Tuple <string, FieldInfo>[] serializedFieldMapping)
{
constructor
.SetBody(
ctx => Expression.Block(
typeof(void),
new[] { ctx.PreviousBody }.Concat(BuildFieldDeserializationExpressions(ctx.This, ctx.Parameters[0], serializedFieldMapping))));
}
public void SetUp()
{
_delegateProviderMock = new Mock <IDelegateProvider> (MockBehavior.Strict);
_provider = new EmittableOperandProvider(_delegateProviderMock.Object);
_mutableType = MutableTypeObjectMother.Create();
_mutableGenericParameter = MutableGenericParameterObjectMother.Create();
_mutableField = MutableFieldInfoObjectMother.Create();
_mutableConstructor = MutableConstructorInfoObjectMother.Create();
_mutableMethod = MutableMethodInfoObjectMother.Create();
_emittableType = ReflectionObjectMother.GetSomeType();
}
public NextCallProxy(
MutableType type,
MutableConstructorInfo constructor,
TargetClassDefinition targetClassDefinition,
INextCallMethodGenerator nextCallMethodGenerator)
{
ArgumentUtility.CheckNotNull("type", type);
ArgumentUtility.CheckNotNull("constructor", constructor);
ArgumentUtility.CheckNotNull("targetClassDefinition", targetClassDefinition);
ArgumentUtility.CheckNotNull("nextCallMethodGenerator", nextCallMethodGenerator);
_type = type;
_constructor = constructor;
_targetClassDefinition = targetClassDefinition;
_nextCallMethodGenerator = nextCallMethodGenerator;
}
public void AddConstructor(CodeGenerationContext context, MutableConstructorInfo constructor)
{
ArgumentUtility.CheckNotNull("context", context);
ArgumentUtility.CheckNotNull("constructor", constructor);
var parameterTypes = GetParameterTypes(constructor);
var ctorBuilder = context.TypeBuilder.DefineConstructor(constructor.Attributes, constructor.CallingConvention, parameterTypes);
ctorBuilder.RegisterWith(context.EmittableOperandProvider, constructor);
DefineParameters(ctorBuilder, constructor);
DefineCustomAttributes(ctorBuilder, constructor);
var bodyBuildAction = CreateBodyBuildAction(context, ctorBuilder, constructor.ParameterExpressions, constructor.Body);
context.PostDeclarationsActionManager.AddAction(bodyBuildAction);
}
public void AddMapping(MutableConstructorInfo mappedConstructor, ConstructorInfo emittableConstructor)
{
_emittableOperandProvider.AddMapping(mappedConstructor, emittableConstructor);
}
public ConstructorInfo GetGeneratedConstructor(MutableConstructorInfo mutableConstructor)
{
return((ConstructorInfo)GetGeneratedMember(mutableConstructor));
}
public void SetUp()
{
_constructor = MutableConstructorInfoObjectMother.Create(parameters: ParameterDeclarationObjectMother.CreateMultiple(2));
}
private void WireAndAddConstructor(
IMemberEmitter member, CodeGenerationContext context, MutableConstructorInfo constructor, Tuple <FieldInfo, MethodInfo> initializationMembers)
{
_initializationBuilder.WireConstructorWithInitialization(constructor, initializationMembers, _proxySerializationEnabler);
member.AddConstructor(context, constructor);
}
public static void ModifyConstructor(MutableConstructorInfo mutableConstructor)
{
mutableConstructor.SetBody(ctx => ExpressionTreeObjectMother.GetSomeExpression(typeof(void)));
}
