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