private void ImplementIntroducedEvent(Expression implementer, EventIntroductionDefinition introducedEvent) { var interfaceEvent = introducedEvent.InterfaceMember; var implementingEvent = introducedEvent.ImplementingMember; var visibility = introducedEvent.Visibility; var addMethod = ImplementIntroducedMethod(implementer, interfaceEvent.GetAddMethod(), implementingEvent.AddMethod, visibility); var removeMethod = ImplementIntroducedMethod(implementer, interfaceEvent.GetRemoveMethod(), implementingEvent.RemoveMethod, visibility); var name = GetIntroducedMemberName(visibility, interfaceEvent); var @event = _concreteTarget.AddEvent(name, EventAttributes.None, addMethod, removeMethod); _attributeGenerator.AddIntroducedMemberAttribute(@event, interfaceEvent, implementingEvent); _attributeGenerator.ReplicateAttributes(implementingEvent, @event); }
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 static MutableEventInfo AddEvent2( this MutableType mutableType, string name = null, EventAttributes attributes = EventAttributes.None, MutableMethodInfo addMethod = null, MutableMethodInfo removeMethod = null, MutableMethodInfo raiseMethod = null) { name = name ?? "Event_" + ++s_counter; var handlerMethod = addMethod ?? removeMethod; var handlerType = handlerMethod != null?handlerMethod.GetParameters().Single().ParameterType : typeof(Action); addMethod = addMethod ?? MutableMethodInfoObjectMother.Create(mutableType, "Adder", parameters: new[] { ParameterDeclarationObjectMother.Create(handlerType) }); removeMethod = removeMethod ?? MutableMethodInfoObjectMother.Create(mutableType, "Adder", parameters: new[] { ParameterDeclarationObjectMother.Create(handlerType) }); return(mutableType.AddEvent(name, attributes, addMethod, removeMethod, raiseMethod)); }
public void CreateEvent_Providers_ThrowsIfAlreadyExists() { var factory = new EventFactory(new MethodFactory(new RelatedMethodFinder())); Func <MethodBodyCreationContext, Expression> bodyProvider = ctx => Expression.Empty(); var event_ = _mutableType.AddEvent("Event", typeof(Action), addBodyProvider: bodyProvider, removeBodyProvider: bodyProvider); Assert.That( () => factory.CreateEvent(_mutableType, "OtherName", event_.EventHandlerType, 0, bodyProvider, bodyProvider, null), Throws.Nothing); Assert.That( () => factory.CreateEvent(_mutableType, event_.Name, typeof(Action <int>), 0, bodyProvider, bodyProvider, null), Throws.Nothing); Assert.That( () => factory.CreateEvent(_mutableType, event_.Name, event_.EventHandlerType, 0, bodyProvider, bodyProvider, null), Throws.InvalidOperationException.With.Message.EqualTo("Event with equal name and signature already exists.")); }
public static MutableEventInfo AddEvent( this MutableType mutableType, string name = null, Type handlerType = null, MethodAttributes accessorAttributes = MethodAttributes.Public, Func <MethodBodyCreationContext, Expression> addBodyProvider = null, Func <MethodBodyCreationContext, Expression> removeBodyProvider = null, Func <MethodBodyCreationContext, Expression> raiseBodyProvider = null) { name = name ?? "Event_" + ++s_counter; handlerType = handlerType ?? typeof(Action); if (addBodyProvider == null) { addBodyProvider = ctx => Expression.Empty(); } if (removeBodyProvider == null) { removeBodyProvider = ctx => Expression.Empty(); } return(mutableType.AddEvent(name, handlerType, accessorAttributes, addBodyProvider, removeBodyProvider, raiseBodyProvider)); }