public void AddExtensionsField()
{
_extensionsFieldInfo = _concreteTarget.AddField("__extensions", FieldAttributes.Private, typeof(object[]));
new AttributeGenerator().AddDebuggerBrowsableAttribute(_extensionsFieldInfo, DebuggerBrowsableState.Never);
_extensionsField = GetFieldExpression(_extensionsFieldInfo);
}
public static MutableFieldInfo AddField(
this MutableType mutableType, string name = null, FieldAttributes attributes = FieldAttributes.Private, Type type = null)
{
name = name ?? "Field_" + ++s_counter;
type = type ?? typeof(int);
return(mutableType.AddField(name, attributes, type));
}
public void AddTypeID(MutableType proxyType, AssembledTypeID typeID)
{
ArgumentUtility.CheckNotNull("proxyType", proxyType);
ArgumentUtility.CheckNotNull("typeID", typeID);
var typeIDField = proxyType.AddField(c_typeIDFieldName, FieldAttributes.Private | FieldAttributes.Static, typeof(AssembledTypeID));
var typeIDExpression = CreateNewTypeIDExpression(
s_assembledTypeIDConstructor, typeID.RequestedType, typeID.Parts, typeof(object), (p, id) => p.GetExpression(id), "GetExpression");
var typeIDFieldInitialization = Expression.Assign(Expression.Field(null, typeIDField), typeIDExpression);
proxyType.AddTypeInitialization(typeIDFieldInitialization);
}
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 CreateField_ThrowsIfAlreadyExist()
{
var field = _mutableType.AddField("Field", FieldAttributes.Private, typeof(int));
Assert.That(
() => _factory.CreateField(_mutableType, "OtherName", field.FieldType, 0),
Throws.Nothing);
Assert.That(
() => _factory.CreateField(_mutableType, field.Name, typeof(string), 0),
Throws.Nothing);
Assert.That(
() => _factory.CreateField(_mutableType, field.Name, field.FieldType, 0),
Throws.InvalidOperationException.With.Message.EqualTo("Field with equal name and signature already exists."));
}
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))));
}
public Tuple <FieldInfo, MethodInfo> CreateInitializationMembers(MutableType mutableType)
{
ArgumentUtility.CheckNotNull("mutableType", mutableType);
var initialization = mutableType.Initialization;
if (initialization.Expressions.Count == 0)
{
return(null);
}
mutableType.AddInterface(typeof(IInitializableObject));
var counter = mutableType.AddField("<tp>_ctorRunCounter", FieldAttributes.Private, typeof(int));
var nonSerializedCtor = MemberInfoFromExpressionUtility.GetConstructor(() => new NonSerializedAttribute());
counter.AddCustomAttribute(new CustomAttributeDeclaration(nonSerializedCtor, new object[0]));
var initializationMethod = mutableType.AddExplicitOverride(s_interfaceMethod, ctx => CreateInitializationBody(ctx, initialization));
return(Tuple.Create <FieldInfo, MethodInfo> (counter, initializationMethod));
}
private Expression AddPublicField(MutableType nextCallProxyType, string name, Type type)
{
var field = nextCallProxyType.AddField(name, FieldAttributes.Public, type);
return(Expression.Field(new ThisExpression(nextCallProxyType), field));
}
private IStorage AddStaticStorage(MutableType mutableType, Type fieldType, string fieldName)
{
var field = mutableType.AddField(fieldName + _counter++, fieldType, FieldAttributes.Private | FieldAttributes.Static);
return(new StaticStorage(field));
}
public void AddFields()
{
var field = _type.AddField("__identifier", FieldAttributes.Public | FieldAttributes.Static, typeof(ConcreteMixinTypeIdentifier));
_identifierField = Expression.Field(null, field);
}