public void CreateInstanceInitializationMembers()
{
_mutableType.AddInitialization(ctx => Expression.Constant("blub"));
_mutableType.AddInitialization(ctx => ctx.InitializationSemantics);
var result = _builder.CreateInitializationMembers(_mutableType);
var counter = (MutableFieldInfo)result.Item1;
var initMethod = (MutableMethodInfo)result.Item2;
// Interface added.
Assert.That(_mutableType.AddedInterfaces, Is.EqualTo(new[] { typeof(IInitializableObject) }));
// Field added.
Assert.That(_mutableType.AddedFields, Is.EqualTo(new[] { counter }));
Assert.That(counter.Name, Is.EqualTo("<tp>_ctorRunCounter"));
Assert.That(counter.FieldType, Is.SameAs(typeof(int)));
Assert.That(counter.AddedCustomAttributes.Single().Type, Is.SameAs(typeof(NonSerializedAttribute)));
// Initialization method added.
var methodAttributes = MethodAttributes.Private | MethodAttributes.Virtual | MethodAttributes.NewSlot | MethodAttributes.HideBySig;
Assert.That(_mutableType.AddedMethods, Is.EqualTo(new[] { initMethod }));
Assert.That(initMethod.DeclaringType, Is.SameAs(_mutableType));
Assert.That(initMethod.Name, Is.EqualTo("Remotion.TypePipe.Implementation.IInitializableObject.Initialize"));
Assert.That(initMethod.Attributes, Is.EqualTo(methodAttributes));
Assert.That(initMethod.ReturnType, Is.SameAs(typeof(void)));
var parameters = initMethod.GetParameters();
Assert.That(parameters, Has.Length.EqualTo(1));
Assert.That(parameters[0].ParameterType, Is.SameAs(typeof(InitializationSemantics)));
var interfaceMethod = NormalizingMemberInfoFromExpressionUtility.GetMethod((IInitializableObject obj) => obj.Initialize(0));
Assert.That(initMethod.AddedExplicitBaseDefinitions, Is.EqualTo(new[] { interfaceMethod }));
var expectedBody = Expression.Block(typeof(void), Expression.Constant("blub"), initMethod.ParameterExpressions[0]);
ExpressionTreeComparer.CheckAreEqualTrees(expectedBody, initMethod.Body);
}
public void DefineTypeFacets()
{
var typeInitializer = _mutableType.AddTypeInitializer(ctx => Expression.Empty());
var instanceInitialization = ExpressionTreeObjectMother.GetSomeExpression();
_mutableType.AddInitialization(ctx => instanceInitialization);
var customAttribute = CustomAttributeDeclarationObjectMother.Create();
_mutableType.AddCustomAttribute(customAttribute);
var @interface = typeof(IDisposable);
_mutableType.AddInterface(@interface);
var field = _mutableType.AddField();
var constructor = _mutableType.AddConstructor();
var method = _mutableType.AddMethod();
var property = _mutableType.AddProperty();
var event_ = _mutableType.AddEvent();
using (_mockRepository.Ordered())
{
var context = PopulateContext(_generator, 2);
_typeBuilderMock.Expect(mock => mock.SetParent(_mutableType.BaseType));
_memberEmitterMock.Expect(mock => mock.AddConstructor(context, typeInitializer));
_initializationBuilderMock.Expect(mock => mock.CreateInitializationMembers(_mutableType)).Return(_fakeInitializationMembers);
_proxySerializationEnablerMock.Expect(mock => mock.MakeSerializable(_mutableType, _fakeInitializationMethod));
_typeBuilderMock.Expect(mock => mock.SetCustomAttribute(customAttribute));
_typeBuilderMock.Expect(mock => mock.AddInterfaceImplementation(@interface));
_memberEmitterMock.Expect(mock => mock.AddField(context, field));
_initializationBuilderMock.Expect(
mock => mock.WireConstructorWithInitialization(constructor, _fakeInitializationMembers, _proxySerializationEnablerMock));
_memberEmitterMock.Expect(mock => mock.AddConstructor(context, constructor));
_memberEmitterMock.Expect(mock => mock.AddMethod(context, method));
SetupExpectationsForAccessors(_memberEmitterMock, _mutableType.AddedMethods.Except(new[] { method }));
_memberEmitterMock.Expect(mock => mock.AddProperty(context, property));
_memberEmitterMock.Expect(mock => mock.AddEvent(context, event_));
}
_mockRepository.ReplayAll();
_generator.DefineTypeFacets();
_mockRepository.VerifyAll();
}
public void AddInitializations(List <Type> mixinTypes)
{
ArgumentUtility.CheckNotNull("mixinTypes", mixinTypes);
Assertion.IsNotNull(_extensionsField, "AddExtensionsField must be called first.");
Assertion.IsNotNull(_extensionsInitializedField, "AddFields must be called first.");
Assertion.IsNotNull(_firstField, "AddFields must be called first.");
Assertion.IsNotNull(_nextCallProxy, "AddNextCallProxy must be called first.");
Assertion.IsNotNull(_mixinArrayInitializerField, "AddFields must be called first.");
Assertion.IsNotNull(_extensionsInitializedField, "AddFields must be called first.");
_initializationMethod = _concreteTarget.AddMethod(
"__InitializeMixins",
MethodAttributes.Private,
parameters: new[] { new ParameterDeclaration(typeof(bool), "isDeserialization") },
bodyProvider: ctx => ImplementMixinInitalizationMethod(ctx, mixinTypes));
_concreteTarget.AddInitialization(
ctx => Expression.Call(
ctx.This,
_initializationMethod,
Expression.Equal(ctx.InitializationSemantics, Expression.Constant(InitializationSemantics.Deserialization))));
}