public RemoveEventDecoratorWeaver(IEventTypeBuilder eventTypeBuilder, EventInfo @event, IWeavingSettings weavingSettings)
: base(@event.GetRemoveMethod(), weavingSettings)
{
MethodEndWeaver = new MethodEndWeaver();
MethodScopeWeaver = new RemoveEventDecoratorScopeWeaver(method, weavingSettings);
MethodDefintionWeaver = new RemoveEventMethodSignatureWeaver(eventTypeBuilder, weavingSettings.TypeDefinition);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventMemberDescriptor" /> class.
/// </summary>
/// <param name="ei">The ei.</param>
/// <param name="accessMode">The access mode.</param>
public EventMemberDescriptor(EventInfo ei, InteropAccessMode accessMode = InteropAccessMode.Default)
{
CheckEventIsCompatible(ei, true);
EventInfo = ei;
m_Add = ei.GetAddMethod(true);
m_Remove = ei.GetRemoveMethod(true);
IsStatic = m_Add.IsStatic;
}
public ReflectionEventDescriptor (EventInfo eventInfo) : base (eventInfo.Name, (Attribute[]) eventInfo.GetCustomAttributes (true))
{
_eventInfo = eventInfo;
_componentType = eventInfo.DeclaringType;
_eventType = eventInfo.EventHandlerType;
add_method = eventInfo.GetAddMethod ();
remove_method = eventInfo.GetRemoveMethod ();
}
private void BuildRemover(TypeBuilder typeBuilder, EventInfo contractProperty, EventBuilder builder)
{
var removeMethod = contractProperty.GetRemoveMethod();
if (null != removeMethod)
{
var removeMethodBuilder = new ProxyMethodImplementationStrategy().BuildMethodProxy(typeBuilder, removeMethod);
builder.SetRemoveOnMethod(removeMethodBuilder);
}
}
/// <summary>
/// Tries to create a new StandardUserDataEventDescriptor, returning <c>null</c> in case the method is not
/// visible to script code.
/// </summary>
/// <param name="ei">The EventInfo.</param>
/// <param name="accessMode">The <see cref="InteropAccessMode" /></param>
/// <returns>A new StandardUserDataEventDescriptor or null.</returns>
public static EventMemberDescriptor TryCreateIfVisible(EventInfo ei, InteropAccessMode accessMode)
{
if (!CheckEventIsCompatible(ei, false))
return null;
if (ei.GetVisibilityFromAttributes() ?? (ei.GetAddMethod().IsPublic && ei.GetRemoveMethod().IsPublic))
return new EventMemberDescriptor(ei, accessMode);
return null;
}
/// <summary>
/// Checks if the event is compatible with a standard descriptor
/// </summary>
/// <param name="ei">The EventInfo.</param>
/// <param name="throwException">if set to <c>true</c> an exception with the proper error message is thrown if not compatible.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentException">
/// Thrown if throwException is <c>true</c> and one of this applies:
/// The event is declared in a value type
/// or
/// The event does not have both add and remove methods
/// or
/// The event handler type doesn't implement a public Invoke method
/// or
/// The event handler has a return type which is not System.Void
/// or
/// The event handler has more than MAX_ARGS_IN_DELEGATE parameters
/// or
/// The event handler has a value type parameter or a by ref parameter
/// or
/// The event handler signature is not a valid method according to <see cref="MethodMemberDescriptor.CheckMethodIsCompatible"/>
/// </exception>
public static bool CheckEventIsCompatible(EventInfo ei, bool throwException)
{
if (ei.DeclaringType.IsValueType)
{
if (throwException) throw new ArgumentException("Events are not supported on value types");
return false;
}
if ((ei.GetAddMethod(true) == null) || (ei.GetRemoveMethod(true) == null))
{
if (throwException) throw new ArgumentException("Event must have add and remove methods");
return false;
}
MethodInfo invoke = ei.EventHandlerType.GetMethod("Invoke");
if (invoke == null)
{
if (throwException) throw new ArgumentException("Event handler type doesn't seem to be a delegate");
return false;
}
if (!MethodMemberDescriptor.CheckMethodIsCompatible(invoke, throwException))
return false;
if (invoke.ReturnType != typeof(void))
{
if (throwException) throw new ArgumentException("Event handler cannot have a return type");
return false;
}
ParameterInfo[] pars = invoke.GetParameters();
if (pars.Length > MAX_ARGS_IN_DELEGATE)
{
if (throwException) throw new ArgumentException(string.Format("Event handler cannot have more than {0} parameters", MAX_ARGS_IN_DELEGATE));
return false;
}
foreach (ParameterInfo pi in pars)
{
if (pi.ParameterType.IsValueType)
{
if (throwException) throw new ArgumentException("Event handler cannot have value type parameters");
return false;
}
else if (pi.ParameterType.IsByRef)
{
if (throwException) throw new ArgumentException("Event handler cannot have by-ref type parameters");
return false;
}
}
return true;
}
private EventBuilder ImplementEvent(TypeBuilder typeBuilder, EventInfo eventToImplement, Type targetInterface)
{
var eventBuilder = typeBuilder.DefineEvent(eventToImplement.Name, EventAttributes.None, eventToImplement.EventHandlerType);
var addMethodInfo = eventToImplement.GetAddMethod();
var removeMethodInfo = eventToImplement.GetRemoveMethod();
var addMethodBuilder = ImplementMethod(typeBuilder, addMethodInfo, targetInterface);
var removeMethodBuilder = ImplementMethod(typeBuilder, removeMethodInfo, targetInterface);
eventBuilder.SetAddOnMethod(addMethodBuilder);
eventBuilder.SetRemoveOnMethod(removeMethodBuilder);
return eventBuilder;
}
/// <summary>
/// Implements the event.
/// </summary>
/// <param name="eventToImplement">The event to implement.</param>
/// <param name="targetInterface">The target interface.</param>
/// <returns></returns>
protected override EventBuilder ImplementEvent(EventInfo eventToImplement, Type targetInterface)
{
EventBuilder eventBuilder = this.TypeBuilder.DefineEvent(eventToImplement.Name, EventAttributes.None, eventToImplement.EventHandlerType);
MethodInfo addMethodInfo = eventToImplement.GetAddMethod();
MethodInfo removeMethodInfo = eventToImplement.GetRemoveMethod();
MethodBuilder addMethodBuilder = this.ImplementMethod(addMethodInfo, targetInterface);
MethodBuilder removeMethodBuilder = this.ImplementMethod(removeMethodInfo, targetInterface);
eventBuilder.SetAddOnMethod(addMethodBuilder);
eventBuilder.SetRemoveOnMethod(removeMethodBuilder);
return eventBuilder;
}
/// <summary>
/// Tries to create a new StandardUserDataEventDescriptor, returning <c>null</c> in case the method is not
/// visible to script code.
/// </summary>
/// <param name="ei">The EventInfo.</param>
/// <param name="accessMode">The <see cref="InteropAccessMode" /></param>
/// <returns>A new StandardUserDataEventDescriptor or null.</returns>
public static EventMemberDescriptor TryCreateIfVisible(EventInfo ei, InteropAccessMode accessMode)
{
if (!CheckEventIsCompatible(ei, false))
return null;
MethodInfo addm = ei.GetAddMethod();
MethodInfo remm = ei.GetRemoveMethod();
if (ei.GetVisibilityFromAttributes() ?? ((remm != null && remm.IsPublic) && (addm != null && addm.IsPublic)))
return new EventMemberDescriptor(ei, accessMode);
return null;
}
public ReflectionEvent(EventInfo eventInfo, XmlDocument docs)
{
FullyQualifiedName = String.Concat(eventInfo.DeclaringType.FullName, ".", eventInfo.Name);
if (docs != null) {
XmlNode node = docs.SelectSingleNode ("/Type/Members/Member[@MemberName='" + eventInfo.Name + "']/Docs/summary");
if (node != null) {
Documentation = node.InnerXml;
}
}
// get modifiers
MethodInfo methodBase = null;
try {
methodBase = eventInfo.GetAddMethod(true);
} catch (Exception) {}
if (methodBase == null) {
try {
methodBase = eventInfo.GetRemoveMethod(true);
} catch (Exception) {}
}
if (methodBase != null) {
if (methodBase.IsStatic) {
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly) {
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) { // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
} else if (methodBase.IsFamily) {
modifiers |= ModifierEnum.Protected;
} else if (methodBase.IsPublic) {
modifiers |= ModifierEnum.Public;
} else if (methodBase.IsFamilyOrAssembly) {
modifiers |= ModifierEnum.ProtectedOrInternal;
} else if (methodBase.IsFamilyAndAssembly) {
modifiers |= ModifierEnum.Protected;
modifiers |= ModifierEnum.Internal;
}
} else { // assume public property, if no methodBase could be get.
modifiers = ModifierEnum.Public;
}
returnType = new ReflectionReturnType(eventInfo.EventHandlerType );
}
public ReflectionEvent(EventInfo eventInfo, IClass declaringType) : base(declaringType, eventInfo.Name)
{
this.ReturnType = ReflectionReturnType.Create(this, eventInfo.EventHandlerType, attributeProvider: eventInfo);
// get modifiers
MethodInfo methodBase = null;
try {
methodBase = eventInfo.GetAddMethod(true);
} catch (Exception) {}
if (methodBase == null) {
try {
methodBase = eventInfo.GetRemoveMethod(true);
} catch (Exception) {}
}
ModifierEnum modifiers = ModifierEnum.None;
if (methodBase != null) {
if (methodBase.IsStatic) {
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsAssembly) {
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsPrivate) { // I assume that private is used most and public last (at least should be)
modifiers |= ModifierEnum.Private;
} else if (methodBase.IsFamily || methodBase.IsFamilyOrAssembly) {
modifiers |= ModifierEnum.Protected;
} else if (methodBase.IsPublic) {
modifiers |= ModifierEnum.Public;
} else {
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsFinal) {
modifiers |= ModifierEnum.Sealed;
} else if (methodBase.IsAbstract) {
modifiers |= ModifierEnum.Abstract;
} else if (methodBase.IsVirtual) {
modifiers |= ModifierEnum.Virtual;
}
} else {
// assume public property, if no methodBase could be get.
modifiers = ModifierEnum.Public;
}
this.Modifiers = modifiers;
}
/// <summary>
/// Verifies that two events are equivalent.
/// </summary>
/// <param name="actual">The actual event information.</param>
/// <param name="expected">The expected event information.</param>
/// <param name="isExplicit">A value indicating whether the actual event is implemented explicitly.</param>
public static void AreEquivalent(EventInfo actual, EventInfo expected, bool isExplicit)
{
Assert.That(actual, Is.Not.Null);
Assert.That(expected, Is.Not.Null);
// Check member properties.
AreMembersEquivalent(actual, expected);
// Check event properties.
Assert.That(actual.Attributes, Is.EqualTo(expected.Attributes));
Assert.That(actual.IsMulticast, Is.EqualTo(expected.IsMulticast));
Assert.That(actual.IsSpecialName, Is.EqualTo(expected.IsSpecialName));
// Check event handler type.
AreTypesEquivalent(actual.EventHandlerType, expected.EventHandlerType);
// Check event methods.
InternalAreEquivalent(actual.GetAddMethod(), expected.GetAddMethod(), isExplicit);
InternalAreEquivalent(actual.GetRemoveMethod(), expected.GetRemoveMethod(), isExplicit);
InternalAreEquivalent(actual.GetRaiseMethod(), expected.GetRaiseMethod(), isExplicit);
}
protected EventInfo[] GetEvents_impl(BindingFlags bf, Type reftype)
{
ArrayList l = new ArrayList();
bool match;
MethodAttributes mattrs;
MethodInfo accessor;
initialize();
EventInfo[] events = GetEvents_internal(reftype);
for (int i = 0; i < events.Length; i++)
{
EventInfo c = events [i];
match = false;
accessor = c.GetAddMethod(true);
if (accessor == null)
{
accessor = c.GetRemoveMethod(true);
}
if (accessor == null)
{
continue;
}
mattrs = accessor.Attributes;
if ((mattrs & MethodAttributes.MemberAccessMask) == MethodAttributes.Public)
{
if ((bf & BindingFlags.Public) != 0)
{
match = true;
}
}
else
{
if ((bf & BindingFlags.NonPublic) != 0)
{
match = true;
}
}
if (!match)
{
continue;
}
match = false;
if ((mattrs & MethodAttributes.Static) != 0)
{
if ((bf & BindingFlags.Static) != 0)
{
match = true;
}
}
else
{
if ((bf & BindingFlags.Instance) != 0)
{
match = true;
}
}
if (!match)
{
continue;
}
l.Add(c);
}
EventInfo[] result = new EventInfo [l.Count];
l.CopyTo(result);
return(result);
}
public static MethodInfo?GetRemoveMethod(this EventInfo eventInfo, bool nonPublic)
{
Requires.NotNull(eventInfo, nameof(eventInfo));
return(eventInfo.GetRemoveMethod(nonPublic));
}
static private void AppendEventInfo(StringBuilder builder, Type type, EventInfo info)
{
int propertyStart = builder.Length;
AppendParameterType(builder, info.EventHandlerType);
builder.Append(" ");
builder.Append(info.Name);
builder.Append(" {");
bool gettable = AppendPropertyMethod(builder, type, info.GetAddMethod(), "add");
bool settable = AppendPropertyMethod(builder, type, info.GetRemoveMethod(), "remove");
if (gettable || settable)
{
builder.Append(" }");
builder.Append(Environment.NewLine);
}
else
{
builder.Length = propertyStart;
}
}
/// <summary>
/// Defines an event based on the specified event.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="eventInfo">The event information.</param>
/// <param name="isExplicit">A value indicating whether the specified event should be implemented explicitly.</param>
/// <param name="methodBuilderFactory">The method builder factory function.</param>
/// <returns>The event builder.</returns>
public static void DefineEvent(this TypeBuilder typeBuilder,
EventInfo eventInfo,
bool isExplicit,
Func<MethodInfo, bool, MethodBuilder> methodBuilderFactory)
{
if (typeBuilder == null)
throw new ArgumentNullException("typeBuilder");
if (eventInfo == null)
throw new ArgumentNullException("eventInfo");
if (methodBuilderFactory == null)
throw new ArgumentNullException("methodBuilderFactory");
// Define event.
var eventName = isExplicit ? eventInfo.GetFullName() : eventInfo.Name;
var eventBuilder = typeBuilder.DefineEvent(
eventName,
eventInfo.Attributes,
eventInfo.EventHandlerType);
// Build event add method.
var addMethodInfo = eventInfo.GetAddMethod();
var addMethodBuilder = methodBuilderFactory(addMethodInfo, isExplicit);
eventBuilder.SetAddOnMethod(addMethodBuilder);
// Build event remove method.
var removeMethodInfo = eventInfo.GetRemoveMethod();
var removeMethodBuilder = methodBuilderFactory(removeMethodInfo, isExplicit);
eventBuilder.SetRemoveOnMethod(removeMethodBuilder);
// Build event raise method.
var raiseMethodInfo = eventInfo.GetRaiseMethod();
if (raiseMethodInfo != null)
{
var methodBuilder = methodBuilderFactory(raiseMethodInfo, isExplicit);
eventBuilder.SetRaiseMethod(methodBuilder);
}
}
/// <summary>
/// Throws a <see cref="StaticPublisherEventException"/> if the published event is defined static.
/// </summary>
/// <param name="publishedEvent">The published event.</param>
/// <exception cref="StaticPublisherEventException">Thrown if the published event is defined static.</exception>
private static void ThrowIfEventIsStatic(EventInfo publishedEvent)
{
if (publishedEvent.GetAddMethod().IsStatic || publishedEvent.GetRemoveMethod().IsStatic)
{
throw new StaticPublisherEventException(publishedEvent);
}
}
public StdEventInfo(EventInfo ei)
{
this.ei = ei;
this.name = ei.Name;
this.mi = ei.GetAddMethod();
if (mi == null)
mi = ei.GetRemoveMethod();
// mi will remain null for abstract properties
}
private void detachEventHandler(EventInfo @event, Delegate d, object realButton)
{
@event.GetRemoveMethod().Invoke(realButton, new object[] { d });
}
private void ThrowIfEventIsStatic(EventInfo publishedEvent)
{
if (publishedEvent.GetAddMethod().IsStatic || publishedEvent.GetRemoveMethod().IsStatic)
{
throw new EventBrokerException(String.Format(CultureInfo.CurrentCulture,
Properties.Resources.StaticPublisherNotAllowed, EventName));
}
}
private static void GuardRemoveMethodExists(EventInfo targetEvent)
{
if (targetEvent.GetRemoveMethod() == null)
{
throw new ArgumentException(string.Format("The event '{0}' does not have a public Remove method",
targetEvent.Name));
}
}
public DynamicEvent(EventInfo eventInfo, object instance)
{
_addMethod = new DynamicMethod(eventInfo.GetAddMethod(true), instance);
_removeMethod = new DynamicMethod(eventInfo.GetRemoveMethod(true), instance);
}
private static void MakeEvent(ModuleBuilder builder, EventInfo info, TypeBuilder typeBuilder, Type contextType, bool defaultImp)
{
var tName = info.Name;
var tAddMethod = info.GetAddMethod();
var tRemoveMethod = info.GetRemoveMethod();
var tReturnType = info.EventHandlerType;
var tCallSiteInvokeName = string.Format("Impromptu_Callsite_{1}_{0}", Guid.NewGuid().ToString("N"), tName);
var tCStp = DefineBuilderForCallSite(builder, tCallSiteInvokeName);
var tInvokeIsEvent = "Invoke_IsEvent";
var tInvokeIseventFuncType = tCStp.DefineCallsiteField(tInvokeIsEvent, typeof (bool));
var tInvokeAddAssign = "Invoke_AddAssign";
var tInvokeAddAssignFuncType = tCStp.DefineCallsiteField(tInvokeAddAssign, typeof (object), tReturnType);
var tInvokeSubtractAssign = "Invoke_SubtractAssign";
var tInvokeSubtractAssignFuncType = tCStp.DefineCallsiteField(tInvokeSubtractAssign, typeof (object), tReturnType);
var tAddParamTypes = tRemoveMethod.GetParameters().Select(it => it.ParameterType).ToArray();
var tInvokeAdd = "Invoke_Add";
var tInvokeAddFuncType = tCStp.DefineCallsiteField(tInvokeAdd, typeof (object), tAddParamTypes);
var tRemoveParamTypes = tRemoveMethod.GetParameters().Select(it => it.ParameterType).ToArray();
var tInvokeRemove = "Invoke_Remove";
var tInvokeRemoveFuncType = tCStp.DefineCallsiteField(tInvokeRemove, typeof (object), tRemoveParamTypes);
var tInvokeGet = "Invoke_Get";
var tInvokeGetFuncType = tCStp.DefineCallsiteField(tInvokeGet, typeof (object));
var tInvokeSet = "Invoke_Set";
var tInvokeSetFuncType = tCStp.DefineCallsiteField(tInvokeSet, typeof (object), typeof (object));
var tCallSite = tCStp.CreateType();
var tMp = typeBuilder.DefineEvent(tName, EventAttributes.None, tReturnType);
//AddMethod
var tPublicPrivate = MethodAttributes.Public;
var tAddPrefixName = tAddMethod.Name;
if (!defaultImp) {
tAddPrefixName = String.Format("{0}.{1}", info.DeclaringType.FullName, tAddPrefixName);
tPublicPrivate = MethodAttributes.Private;
}
var tAddBuilder = typeBuilder.DefineMethod(tAddPrefixName,
tPublicPrivate | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot,
typeof (void),
tAddParamTypes);
if (!defaultImp) {
typeBuilder.DefineMethodOverride(tAddBuilder, info.GetAddMethod());
}
foreach (var tParam in tAddMethod.GetParameters()) {
tAddBuilder.DefineParameter(tParam.Position + 1, AttributesForParam(tParam), tParam.Name);
}
var tIlGen = tAddBuilder.GetILGenerator();
var tIsEventField = tCallSite.GetFieldEvenIfGeneric(tInvokeIsEvent);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tIsEventField))) {
tIlGen.EmitDynamicIsEventBinder(CSharpBinderFlags.None, tName, contextType);
tIlGen.EmitCallsiteCreate(tInvokeIseventFuncType);
tIlGen.Emit(OpCodes.Stsfld, tIsEventField);
}
var tSetField = tCallSite.GetFieldEvenIfGeneric(tInvokeSet);
var tGetField = tCallSite.GetFieldEvenIfGeneric(tInvokeGet);
using (tIlGen.EmitBranchTrue(
load => load.EmitInvocation(
target => target.EmitInvocation(
t => t.Emit(OpCodes.Ldsfld, tIsEventField),
i => i.Emit(OpCodes.Ldfld, tIsEventField.FieldType.GetFieldEvenIfGeneric("Target"))
),
invoke => invoke.EmitCallInvokeFunc(tInvokeIseventFuncType),
param => param.Emit(OpCodes.Ldsfld, tIsEventField),
param => param.EmitInvocation(
t => t.Emit(OpCodes.Ldarg_0),
i => i.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod())
)
)
)
) //if IsEvent Not True
{
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSetField))) {
tIlGen.EmitDynamicSetBinderDynamicParams(CSharpBinderFlags.ValueFromCompoundAssignment, tName, contextType, typeof (Object));
tIlGen.EmitCallsiteCreate(tInvokeSetFuncType);
tIlGen.Emit(OpCodes.Stsfld, tSetField);
}
var tAddAssigneField = tCallSite.GetFieldEvenIfGeneric(tInvokeAddAssign);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tAddAssigneField))) {
tIlGen.EmitDynamicBinaryOpBinder(CSharpBinderFlags.None, ExpressionType.AddAssign, contextType, tReturnType);
tIlGen.EmitCallsiteCreate(tInvokeAddAssignFuncType);
tIlGen.Emit(OpCodes.Stsfld, tAddAssigneField);
}
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tGetField))) {
tIlGen.EmitDynamicGetBinder(CSharpBinderFlags.None, tName, contextType);
tIlGen.EmitCallsiteCreate(tInvokeGetFuncType);
tIlGen.Emit(OpCodes.Stsfld, tGetField);
}
tIlGen.Emit(OpCodes.Ldsfld, tSetField);
tIlGen.Emit(OpCodes.Ldfld, tSetField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tSetField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
tIlGen.Emit(OpCodes.Ldsfld, tAddAssigneField);
tIlGen.Emit(OpCodes.Ldfld, tAddAssigneField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tAddAssigneField);
tIlGen.Emit(OpCodes.Ldsfld, tGetField);
tIlGen.Emit(OpCodes.Ldfld, tGetField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tGetField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
tIlGen.EmitCallInvokeFunc(tInvokeGetFuncType);
tIlGen.Emit(OpCodes.Ldarg_1);
tIlGen.EmitCallInvokeFunc(tInvokeAddAssignFuncType);
tIlGen.EmitCallInvokeFunc(tInvokeSetFuncType);
tIlGen.Emit(OpCodes.Pop);
tIlGen.Emit(OpCodes.Ret);
}
var tAddCallSiteField = tCallSite.GetFieldEvenIfGeneric(tInvokeAdd);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tAddCallSiteField))) {
tIlGen.EmitDynamicMethodInvokeBinder(
CSharpBinderFlags.InvokeSpecialName | CSharpBinderFlags.ResultDiscarded,
tAddMethod.Name,
contextType,
tAddMethod.GetParameters(),
Enumerable.Repeat(default(string),
tAddParamTypes.Length));
tIlGen.EmitCallsiteCreate(tInvokeAddFuncType);
tIlGen.Emit(OpCodes.Stsfld, tAddCallSiteField);
}
tIlGen.Emit(OpCodes.Ldsfld, tAddCallSiteField);
tIlGen.Emit(OpCodes.Ldfld, tAddCallSiteField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tAddCallSiteField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
for (var i = 1; i <= tAddParamTypes.Length; i++) {
tIlGen.EmitLoadArgument(i);
}
tIlGen.EmitCallInvokeFunc(tInvokeAddFuncType);
tIlGen.Emit(OpCodes.Pop);
tIlGen.Emit(OpCodes.Ret);
tMp.SetAddOnMethod(tAddBuilder);
var tRemovePrefixName = tRemoveMethod.Name;
if (!defaultImp) {
tRemovePrefixName = String.Format("{0}.{1}", info.DeclaringType.FullName, tRemovePrefixName);
}
//Remove Method
var tRemoveBuilder = typeBuilder.DefineMethod(tRemovePrefixName,
tPublicPrivate | MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.Virtual | MethodAttributes.Final | MethodAttributes.NewSlot,
typeof (void),
tAddParamTypes);
if (!defaultImp) {
typeBuilder.DefineMethodOverride(tRemoveBuilder, info.GetRemoveMethod());
}
foreach (var tParam in tRemoveMethod.GetParameters()) {
tRemoveBuilder.DefineParameter(tParam.Position + 1, AttributesForParam(tParam), tParam.Name);
}
tIlGen = tRemoveBuilder.GetILGenerator();
using (tIlGen.EmitBranchTrue(load => load.Emit(OpCodes.Ldsfld, tIsEventField))) {
tIlGen.EmitDynamicIsEventBinder(CSharpBinderFlags.None, tName, contextType);
tIlGen.EmitCallsiteCreate(tInvokeIseventFuncType);
tIlGen.Emit(OpCodes.Stsfld, tIsEventField);
}
using (tIlGen.EmitBranchTrue(
load => load.EmitInvocation(
target => target.EmitInvocation(
t => t.Emit(OpCodes.Ldsfld, tIsEventField),
i => i.Emit(OpCodes.Ldfld, tIsEventField.FieldType.GetFieldEvenIfGeneric("Target"))
),
invoke => invoke.EmitCallInvokeFunc(tInvokeIseventFuncType),
param => param.Emit(OpCodes.Ldsfld, tIsEventField),
param => param.EmitInvocation(
t => t.Emit(OpCodes.Ldarg_0),
i => i.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod())
)
)
)
) //if IsEvent Not True
{
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSetField))) {
tIlGen.EmitDynamicSetBinderDynamicParams(CSharpBinderFlags.ValueFromCompoundAssignment, tName, contextType, tReturnType);
tIlGen.EmitCallsiteCreate(tInvokeSetFuncType);
tIlGen.Emit(OpCodes.Stsfld, tSetField);
}
var tSubrtractAssignField = tCallSite.GetFieldEvenIfGeneric(tInvokeSubtractAssign);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tSubrtractAssignField))) {
tIlGen.EmitDynamicBinaryOpBinder(CSharpBinderFlags.None, ExpressionType.SubtractAssign, contextType, tReturnType);
tIlGen.EmitCallsiteCreate(tInvokeSubtractAssignFuncType);
tIlGen.Emit(OpCodes.Stsfld, tSubrtractAssignField);
}
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tGetField))) {
tIlGen.EmitDynamicGetBinder(CSharpBinderFlags.None, tName, contextType);
tIlGen.EmitCallsiteCreate(tInvokeGetFuncType);
tIlGen.Emit(OpCodes.Stsfld, tGetField);
}
tIlGen.Emit(OpCodes.Ldsfld, tSetField);
tIlGen.Emit(OpCodes.Ldfld, tSetField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tSetField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
tIlGen.Emit(OpCodes.Ldsfld, tSubrtractAssignField);
tIlGen.Emit(OpCodes.Ldfld, tSubrtractAssignField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tSubrtractAssignField);
tIlGen.Emit(OpCodes.Ldsfld, tGetField);
tIlGen.Emit(OpCodes.Ldfld, tGetField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tGetField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
tIlGen.EmitCallInvokeFunc(tInvokeGetFuncType);
tIlGen.Emit(OpCodes.Ldarg_1);
tIlGen.EmitCallInvokeFunc(tInvokeSubtractAssignFuncType);
tIlGen.EmitCallInvokeFunc(tInvokeSetFuncType);
tIlGen.Emit(OpCodes.Pop);
tIlGen.Emit(OpCodes.Ret);
}
var tRemoveCallSiteField = tCallSite.GetFieldEvenIfGeneric(tInvokeRemove);
using (tIlGen.EmitBranchTrue(gen => gen.Emit(OpCodes.Ldsfld, tRemoveCallSiteField))) {
tIlGen.EmitDynamicMethodInvokeBinder(
CSharpBinderFlags.InvokeSpecialName | CSharpBinderFlags.ResultDiscarded,
tRemoveMethod.Name,
contextType,
tRemoveMethod.GetParameters(),
Enumerable.Repeat(default(string),
tRemoveParamTypes.Length));
tIlGen.EmitCallsiteCreate(tInvokeRemoveFuncType);
tIlGen.Emit(OpCodes.Stsfld, tRemoveCallSiteField);
}
tIlGen.Emit(OpCodes.Ldsfld, tRemoveCallSiteField);
tIlGen.Emit(OpCodes.Ldfld, tRemoveCallSiteField.FieldType.GetFieldEvenIfGeneric("Target"));
tIlGen.Emit(OpCodes.Ldsfld, tRemoveCallSiteField);
tIlGen.Emit(OpCodes.Ldarg_0);
tIlGen.Emit(OpCodes.Call, typeof (ActLikeProxy).GetProperty("Original").GetGetMethod());
tIlGen.Emit(OpCodes.Ldarg_1);
tIlGen.EmitCallInvokeFunc(tInvokeRemoveFuncType);
tIlGen.Emit(OpCodes.Pop);
tIlGen.Emit(OpCodes.Ret);
tMp.SetRemoveOnMethod(tRemoveBuilder);
}
/// <summary>
/// Defines an event based on the specified event.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="eventInfo">The event information.</param>
/// <param name="isExplicit">A value indicating whether the specified event should be implemented explicitly.</param>
/// <param name="methodBuilderFactory">The method builder factory function.</param>
/// <returns>The event builder.</returns>
public static void DefineEvent(this TypeBuilder typeBuilder,
EventInfo eventInfo,
bool isExplicit,
Func<MethodInfo, bool, MethodBuilder> methodBuilderFactory)
{
if (typeBuilder == null)
throw new ArgumentNullException("typeBuilder");
if (eventInfo == null)
throw new ArgumentNullException("eventInfo");
if (methodBuilderFactory == null)
throw new ArgumentNullException("methodBuilderFactory");
// Define event.
var eventName = isExplicit ? eventInfo.GetFullName() : eventInfo.Name;
var eventBuilder = typeBuilder.DefineEvent(
eventName,
eventInfo.Attributes,
eventInfo.EventHandlerType);
// Build event add method.
var addMethodInfo = eventInfo.GetAddMethod();
var addMethodBuilder = methodBuilderFactory(addMethodInfo, isExplicit);
eventBuilder.SetAddOnMethod(addMethodBuilder);
// Build event remove method.
var removeMethodInfo = eventInfo.GetRemoveMethod(true);
var removeMethodBuilder = methodBuilderFactory(removeMethodInfo, isExplicit);
eventBuilder.SetRemoveOnMethod(removeMethodBuilder);
// Build event raise method.
var raiseMethodInfo = eventInfo.GetRaiseMethod(true);
if (raiseMethodInfo != null)
{
var methodBuilder = methodBuilderFactory(raiseMethodInfo, isExplicit);
eventBuilder.SetRaiseMethod(methodBuilder);
}
// Build event other methods.
var otherMethodInfos = eventInfo.GetOtherMethods(true);
// Mono returns null in case no other methods are defined.
if (otherMethodInfos != null)
{
foreach (var otherMethodInfo in otherMethodInfos)
{
var methodBuilder = methodBuilderFactory(otherMethodInfo, isExplicit);
eventBuilder.AddOtherMethod(methodBuilder);
}
}
}
public static MethodInfo?GetRemoveMethod(this EventInfo eventInfo, bool nonPublic)
{
ArgumentNullException.ThrowIfNull(eventInfo);
return(eventInfo.GetRemoveMethod(nonPublic));
}
private void AddEvent(EventInfo @event, IProxyGenerationHook hook)
{
var addMethod = @event.GetAddMethod(true);
var removeMethod = @event.GetRemoveMethod(true);
MetaMethod adder = null;
MetaMethod remover = null;
if (addMethod != null)
{
adder = AddMethod(addMethod, hook, false);
}
if (removeMethod != null)
{
remover = AddMethod(removeMethod, hook, false);
}
if (adder == null && remover == null)
{
return;
}
events[@event] = new MetaEvent(@event.Name,
@event.DeclaringType, @event.EventHandlerType, adder, remover, EventAttributes.None);
}
private void CreateEvent(Type aType, Classifier aCls, EventInfo anEvent, PdOOM.BasePackage aPckg, ref AttributeTable aAttrTable, ref MethodTable aMthTable, ref InfluenceTable aInfTable)
{
if (!LZ.Reverse.Info._bVBNet)
{
bool flag;
bool flag2;
if (aType.GetField(anEvent.Name, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.DeclaredOnly) != null)
{
flag = false;
flag2 = false;
}
else
{
flag = true;
flag2 = true;
}
if (flag)
{
PdOOM.Attribute anObject = (PdOOM.Attribute) aCls.CreateObject(0x18112065, "", -1, true);
anObject.Stereotype = "Event";
try
{
anObject.Name = anObject.Code = anEvent.Name;
}
catch (COMException)
{
if (LZ.Reverse.Info._bDebug)
{
LZ.Reverse.Info.Write(new string[] { "*** exception while naming the event \"{1}\" on the type \"{0}\"", aType.FullName, anEvent.Name });
}
}
Type eventHandlerType = anEvent.EventHandlerType;
this.ProcessType(eventHandlerType, false);
TypeMapping mapping = TypeMapping.Retrieve(eventHandlerType);
anObject.DataType = mapping.Name;
if (!mapping.Delegate && LZ.Reverse.Info._bDebug)
{
LZ.Reverse.Info.Write(new string[] { "*** invalid delegate mapping for \"{0}\"", eventHandlerType.FullName });
}
MethodInfo addMethod = anEvent.GetAddMethod(true);
anObject.Visibility = GetMethodVisibility(addMethod);
if (flag2)
{
aInfTable.Add(addMethod, anObject, "EventAdd");
addMethod = anEvent.GetRemoveMethod(true);
aInfTable.Add(addMethod, anObject, "EventRemove");
}
}
if (!flag2)
{
MethodInfo aMethod = anEvent.GetAddMethod(true);
aMthTable.Add(aMethod);
aMethod = anEvent.GetRemoveMethod(true);
aMthTable.Add(aMethod);
}
}
}
private void Initialize()
{
assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(
a => a.FullName.StartsWith("Microsoft.WindowsAzure.ServiceRuntime"));
// If we are runing within a worker role Microsoft.WindowsAzure.ServiceRuntime should already be loaded
if (assembly == null)
{
const string msg1 = "Microsoft.WindowsAzure.ServiceRuntime is not loaded. Trying to load it with Assembly.LoadWithPartialName().";
logger.Warn(ErrorCode.AzureServiceRuntime_NotLoaded, msg1);
// Microsoft.WindowsAzure.ServiceRuntime isn't loaded. We may be running within a web role or not in Azure.
// Trying to load by partial name, so that we are not version specific.
// Assembly.LoadWithPartialName has been deprecated. Is there a better way to load any version of a known assembly?
#pragma warning disable 618
assembly = Assembly.LoadWithPartialName("Microsoft.WindowsAzure.ServiceRuntime");
#pragma warning restore 618
if (assembly == null)
{
const string msg2 = "Failed to find or load Microsoft.WindowsAzure.ServiceRuntime.";
logger.Error(ErrorCode.AzureServiceRuntime_FailedToLoad, msg2);
throw new OrleansException(msg2);
}
}
roleEnvironmentType = assembly.GetType("Microsoft.WindowsAzure.ServiceRuntime.RoleEnvironment");
stoppingEvent = roleEnvironmentType.GetEvent("Stopping");
stoppingEventAdd = stoppingEvent.GetAddMethod();
stoppingEventRemove = stoppingEvent.GetRemoveMethod();
roleInstanceType = assembly.GetType("Microsoft.WindowsAzure.ServiceRuntime.RoleInstance");
DeploymentId = (string) roleEnvironmentType.GetProperty("DeploymentId").GetValue(null);
if (string.IsNullOrWhiteSpace(DeploymentId))
throw new OrleansException("DeploymentId is null or whitespace.");
currentRoleInstance = roleEnvironmentType.GetProperty("CurrentRoleInstance").GetValue(null);
if (currentRoleInstance == null)
throw new OrleansException("CurrentRoleInstance is null.");
InstanceId = currentRoleInstance.Id;
UpdateDomain = currentRoleInstance.UpdateDomain;
FaultDomain = currentRoleInstance.FaultDomain;
instanceEndpoints = currentRoleInstance.InstanceEndpoints;
role = currentRoleInstance.Role;
RoleName = role.Name;
}
static MethodBuilder BuildEventRemoveMethod(TypeBuilder type, Type viewType, EventInfo eventInfo)
{
var removeBuilder = BuildMethod(
type,
"remove",
eventInfo.Name,
typeof(void),
new [] { eventInfo.EventHandlerType });
var il = removeBuilder.GetILGenerator();
EmitILForEachView(viewType, il,
() =>
{
// Call the original remove method
var originalRemoveMethod = eventInfo.GetRemoveMethod();
il.EmitCall(OpCodes.Callvirt, originalRemoveMethod, null);
});
// Return control
il.Emit(OpCodes.Ret);
return removeBuilder;
}
private static bool ShouldReserveName(EventInfo member)
{
bool hasNonPrivate = false;
MethodInfo miAdd = member.GetAddMethod();
if (miAdd != null)
{
hasNonPrivate |= ShouldReserveName(miAdd, false);
}
MethodInfo miRemove = member.GetRemoveMethod();
if (miRemove != null)
{
hasNonPrivate |= ShouldReserveName(miRemove, false);
}
return hasNonPrivate;
}
/// <summary> method checks to see if the class implements addPropertyChangeListener
/// </summary>
/// <returns>
///
/// </returns>
protected internal virtual bool checkBean()
{
bool add = false;
bool remove = false;
eventPropertyChanged = OBJECT_CLASS.GetEvent("PropertyChanged");
if (eventPropertyChanged == null)
{
return false;
}
delegateType = eventPropertyChanged.EventHandlerType;
addListener = eventPropertyChanged.GetAddMethod();
removeListener = eventPropertyChanged.GetRemoveMethod();
return delegateType != null && addListener != null && removeListener != null;
/*
MethodInfo[] methd = INFO.getMethodDescriptors();
for (int idx = 0; idx < methd.Length; idx++)
{
MethodInfo desc = methd[idx];
if (desc.Name.Equals(Constants.PCS_ADD) && checkParameter(desc))
{
// check the parameter
add = true;
}
if (desc.Name.Equals(Constants.PCS_REMOVE) && checkParameter(desc))
{
// check the parameter
remove = true;
}
}
if (add && remove)
{
getUtilMethods();
return true;
}
else
{
return false;
}
*/
}
public override System.Reflection.MethodInfo GetRemoveMethod(bool nonPublic)
{
return(_innerEventInfo.GetRemoveMethod(nonPublic));
}
public static MethodInfo?GetRemoveMethod(this EventInfo eventInfo)
{
ArgumentNullException.ThrowIfNull(eventInfo, nameof(eventInfo));
return(eventInfo.GetRemoveMethod());
}
/// <summary>Writes XML documenting an event.</summary>
/// <param name="writer">XmlWriter to write on.</param>
/// <param name="eventInfo">Event to document.</param>
private void WriteEvent(XmlWriter writer, EventInfo eventInfo)
{
string memberName = MemberID.GetMemberID(eventInfo);
string name = eventInfo.Name;
string interfaceName = null;
int lastIndexOfDot = name.LastIndexOf('.');
if (lastIndexOfDot != -1)
{
//this is an explicit interface implementation. if we don't want
//to document them, get out of here quick...
if (!this.rep.DocumentExplicitInterfaceImplementations) return;
interfaceName = name.Substring(0, lastIndexOfDot);
lastIndexOfDot = interfaceName.LastIndexOf('.');
if (lastIndexOfDot != -1)
name = name.Substring(lastIndexOfDot + 1);
//check if we want to document this interface.
ImplementsInfo implements = null;
MethodInfo adder = eventInfo.GetAddMethod(true);
if (adder != null)
{
implements = implementations[adder.ToString()];
}
if (implements == null)
{
MethodInfo remover = eventInfo.GetRemoveMethod(true);
if (remover != null)
{
implements = implementations[remover.ToString()];
}
}
if (implements != null) return;
}
writer.WriteStartElement("event");
writer.WriteAttributeString("name", name);
writer.WriteAttributeString("id", memberName);
writer.WriteAttributeString("access", GetMethodAccessValue(eventInfo.GetAddMethod(true)));
writer.WriteAttributeString("contract", GetMethodContractValue(eventInfo.GetAddMethod(true)));
Type t = eventInfo.EventHandlerType;
writer.WriteAttributeString("type", MemberID.GetTypeName(t));
writer.WriteAttributeString("valueType", t.IsValueType.ToString().ToLower());
bool inherited = eventInfo.DeclaringType != eventInfo.ReflectedType;
if (inherited)
{
writer.WriteAttributeString("declaringType", MemberID.GetDeclaringTypeName(eventInfo));
}
if (interfaceName != null)
{
writer.WriteAttributeString("interface", interfaceName);
}
if (eventInfo.IsMulticast)
{
writer.WriteAttributeString("multicast", "true");
}
if (inherited)
{
WriteInheritedDocumentation(writer, memberName, eventInfo.DeclaringType);
}
else
{
WriteEventDocumentation(writer, memberName, true);
}
WriteCustomAttributes(writer, eventInfo);
if (implementations != null)
{
ImplementsInfo implements = null;
MethodInfo adder = eventInfo.GetAddMethod(true);
if (adder != null)
{
implements = implementations[adder.ToString()];
}
if (implements == null)
{
MethodInfo remover = eventInfo.GetRemoveMethod(true);
if (remover != null)
{
implements = implementations[remover.ToString()];
}
}
if (implements != null)
{
writer.WriteStartElement("implements");
MemberInfo InterfaceMethod = (MemberInfo)implements.InterfaceMethod;
EventInfo InterfaceEvent =
InterfaceMethod.DeclaringType.GetEvent(InterfaceMethod.Name.Substring(4));
writer.WriteAttributeString("name", InterfaceEvent.Name);
writer.WriteAttributeString("id", MemberID.GetMemberID(InterfaceEvent));
writer.WriteAttributeString("interface", implements.InterfaceType.Name);
writer.WriteAttributeString("interfaceId", MemberID.GetMemberID(implements.InterfaceType));
writer.WriteAttributeString("declaringType", implements.InterfaceType.FullName.Replace('+', '.'));
writer.WriteEndElement();
}
}
writer.WriteEndElement();
}
private void OverrideEvent(EventInfo @event, int count)
{
MethodBuilder addMethod = OverrideEventMethod(@event.GetAddMethod(), count);
MethodBuilder removeMethod = OverrideEventMethod(@event.GetRemoveMethod(), count);
AddEventDefinition(@event, addMethod, removeMethod);
}
