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); }