public AddEventDecoratorWeaver(IEventTypeBuilder eventTypeBuilder, EventInfo @event, IWeavingSettings weavingSettings) : base(@event.GetAddMethod(), weavingSettings) { MethodEndWeaver = new MethodEndWeaver(); MethodScopeWeaver = new AddEventDecoratorScopeWeaver(method, weavingSettings); MethodDefintionWeaver = new AddEventMethodSignatureWeaver(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 static bool IsMatchedTo(this EventInfo firstEvent, EventInfo secondEvent) { if (firstEvent.IsNull() || !firstEvent.Name.Equals(secondEvent.Name) || firstEvent.EventHandlerType != secondEvent.EventHandlerType) { return false; } return firstEvent.GetAddMethod().IsMatchedTo(secondEvent.GetAddMethod()); }
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 (); }
/// <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; }
private void BuildAdder(TypeBuilder typeBuilder, EventInfo contractProperty, EventBuilder builder) { var addMethod = contractProperty.GetAddMethod(); if (null != addMethod) { var addMethodBuilder = new ProxyMethodImplementationStrategy().BuildMethodProxy(typeBuilder, addMethod); builder.SetAddOnMethod(addMethodBuilder); } }
/// <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; }
/// <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; }
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; }
public MvxEventHandlerEventInfoTargetBinding(object target, EventInfo targetEventInfo) : base(target) { _targetEventInfo = targetEventInfo; // addMethod is used because of error: // "Attempting to JIT compile method '(wrapper delegate-invoke) <Module>:invoke_void__this___UIControl_EventHandler (MonoTouch.UIKit.UIControl,System.EventHandler)' while running with --aot-only." // see https://bugzilla.xamarin.com/show_bug.cgi?id=3682 var addMethod = _targetEventInfo.GetAddMethod(); addMethod.Invoke(target, new object[] {new EventHandler(HandleEvent)}); }
Event LoadEvent(System.Reflection.EventInfo refEvent) { Event eventObject = new Event { Name = refEvent.Name, IsStatic = refEvent.GetAddMethod().IsStatic, EventHandlerType = GetTypeFullName(refEvent.EventHandlerType), Attributes = refEvent.Attributes, }; return(eventObject); }
/// <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; }
public MBeanInternalNotificationInfo(EventInfo eventInfo, IMBeanInfoFactory factory) { _handlerType = eventInfo.GetAddMethod().GetParameters()[0].ParameterType; _handlerGenericArgument = _handlerType.GetGenericArguments()[0]; if (_handlerType.GetGenericTypeDefinition() == typeof(EventHandler<>) && (typeof(Notification).IsAssignableFrom(_handlerGenericArgument) || typeof(NotificationEventArgs).IsAssignableFrom(_handlerGenericArgument))) { _notifInfo = factory.CreateMBeanNotificationInfo(eventInfo, _handlerType); } else { throw new NotCompliantMBeanException(eventInfo.DeclaringType.AssemblyQualifiedName); } _eventInfo = eventInfo; }
/// <summary> /// Hack for compatibility RabbitMQ.Client library between 3.4.x and 3.5.x versions /// ConnectionShutdownEventHandler replaced by Eventhandler<ShutdownEventArgs> - https://github.com/rabbitmq/rabbitmq-dotnet-client/commit/84ca5552a338a86c9af124331adca230accf3be3 /// using reflection for understand, what type of delegate we must use for IConnection.ConnectionShutdown: /// - EventHandler<ShutdownEventArgs> for 3.5.x version /// - ConnectionShutdownEventHandler for 3.4.x and early version /// </summary> private void PrepareConnectionShutdownEventHandler() { System.Reflection.EventInfo connectionShutdownEventInfo = typeof(IConnection).GetEvent("ConnectionShutdown"); _connectionShutdownEventAddMethod = connectionShutdownEventInfo.GetAddMethod(); Type delegateType = connectionShutdownEventInfo.EventHandlerType; System.Reflection.MethodInfo shutdownAmqpMethodInfo = null; if (delegateType.IsConstructedGenericType && delegateType.GetGenericTypeDefinition() == typeof(EventHandler <>)) { shutdownAmqpMethodInfo = typeof(RabbitMQ).GetMethod("ShutdownAmqp35", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); } else { shutdownAmqpMethodInfo = typeof(RabbitMQ).GetMethod("ShutdownAmqp", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance); } _connectionShutdownEventHandler = shutdownAmqpMethodInfo.CreateDelegate(delegateType, this); }
/// <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); }
public EventDetail(RootDetail parent, EventInfo ei) : base(parent, ei) { _name = ei.Name; _visibility = VisibilityUtil.GetVisibilityFor(ei.GetAddMethod(true)); _category = "event"; CodeStringBuilder csb = new CodeStringBuilder(); AppendAttributesDeclaration(csb); csb.Mode = AppendMode.Html; csb.AppendVisibility(_visibility); csb.AppendText(" "); csb.Mode = AppendMode.Both; csb.AppendKeyword("event "); csb.AppendType(ei.EventHandlerType); csb.AppendText(" "); csb.AppendText(ei.Name); _declaration = csb.ToString(); _declarationHtml = csb.ToHtmlString(); }
private static void GuardAddMethodExists(EventInfo targetEvent) { if(targetEvent.GetAddMethod() == null) { throw new ArgumentException(string.Format("The event '{0}' does not have a public Add method", targetEvent.Name)); } }
private static EventInfo GetParentDefinition(EventInfo ev) { Contract.Requires(ev != null); // note that this only works for RuntimeMethodInfo MethodInfo add = ev.GetAddMethod(true); RuntimeMethodInfo rtAdd = add as RuntimeMethodInfo; if (rtAdd != null) { rtAdd = rtAdd.GetParentDefinition(); if (rtAdd != null) return rtAdd.DeclaringType.GetEvent(ev.Name); } return null; }
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> /// 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>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 Delegate attachEventHandler(EventInfo @event, string methodName, object realButton) { MethodInfo method = GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance); Delegate d = Delegate.CreateDelegate(@event.EventHandlerType, this, method); @event.GetAddMethod().Invoke(realButton, new object[] { d }); return d; }
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); }
public CompiledEventScope(SymInfo si, EventInfo ei, CompiledScope declaringType) { this.si = si; this.ei = ei; string[] args = declaringType.TemplateArguments; if (args != null) { generic_args = new List<string>(); generic_args.AddRange(args); } if (generic_args != null) { //TypeScope ts = declaringType.instances[ei.EventHandlerType.GenericParameterPosition]; this.sc = CompiledScope.get_type_instance(ei.EventHandlerType, declaringType.instances); } else this.sc = TypeTable.get_compiled_type(ei.EventHandlerType); if (si.name == null) AssemblyDocCache.AddDescribeToComplete(this.si, ei); this.si.name = ei.Name; this.si.description = this.ToString(); this.topScope = declaringType; MethodInfo acc_mi = ei.GetAddMethod(true); is_static = acc_mi.IsStatic; if (acc_mi.IsPrivate) { this.acc_mod = access_modifer.private_modifer; this.si.acc_mod = access_modifer.private_modifer; } else if (acc_mi.IsFamily || acc_mi.IsFamilyOrAssembly) { this.acc_mod = access_modifer.protected_modifer; this.si.acc_mod = access_modifer.protected_modifer; } else if (acc_mi.IsFamilyAndAssembly || acc_mi.IsAssembly) { this.acc_mod = access_modifer.internal_modifer; this.si.acc_mod = access_modifer.internal_modifer; } //this.si.describe += "\n"+AssemblyDocCache.GetDocumentation(ei.DeclaringType.Assembly,"E:"+ei.DeclaringType.FullName+"."+ei.Name); }
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; } }
public override System.Reflection.MethodInfo GetAddMethod(bool nonPublic) { return(_innerEventInfo.GetAddMethod(nonPublic)); }
void OutlineEvent (EventInfo ei) { MethodBase accessor = ei.GetAddMethod (true); o.Write (GetMethodVisibility (accessor)); o.Write ("event "); o.Write (FormatType (ei.EventHandlerType)); o.Write (" "); o.Write (ei.Name); o.Write (";"); }
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 int GetIcon(EventInfo eventinfo) { if (eventinfo.GetAddMethod(true) != null) { return EventIndex + GetIcon(eventinfo.GetAddMethod(true)) - MethodIndex; } return EventIndex; }
public static Type GetEventHandlerType(EventInfo eventInfo) { if (eventInfo == null) { throw new ArgumentNullException("eventInfo"); } MethodInfo addMethod = eventInfo.GetAddMethod(true); if (addMethod != null) { ParameterInfo[] parameters = addMethod.GetParameters(); Type superClass = typeof(Delegate); for (int i = 0; i < parameters.Length; i++) { Type parameterType = parameters[i].ParameterType; if (IsSubclassOf(parameterType, superClass)) { return parameterType; } } } return null; }
// Utility method for use with the AddButton<event>Handler API methods. protected void AddButtonEventHandler(EventInfo Event, Action<object> Handler) { Delegate d = Delegate.CreateDelegate(Event.EventHandlerType, Handler.Target, Handler.Method); MethodInfo addHandler = Event.GetAddMethod(); addHandler.Invoke(this.Button, new object[] { d }); }
void WriteEventSignatureCS (EventInfo mi) { WriteMethodAttributesCS ( mi.GetAddMethod ().Attributes, false); output.WriteString (CSharpName (mi.EventHandlerType)); output.WriteString (" "); output.WriteString (mi.Name); output.WriteString (";"); }