public ReflectEventDescriptor(Type componentType, EventDescriptor oldReflectEventDescriptor, Attribute[] attributes) : base(oldReflectEventDescriptor, attributes) { this.componentClass = componentType; this.type = oldReflectEventDescriptor.EventType; ReflectEventDescriptor descriptor = oldReflectEventDescriptor as ReflectEventDescriptor; if (descriptor != null) { this.addMethod = descriptor.addMethod; this.removeMethod = descriptor.removeMethod; this.filledMethods = true; } }
/// <summary> /// This constructor takes an existing ReflectEventDescriptor and modifies it by merging in the /// passed-in attributes. /// </summary> public ReflectEventDescriptor(Type componentType, EventDescriptor oldReflectEventDescriptor, Attribute[] attributes) : base(oldReflectEventDescriptor, attributes) { _componentClass = componentType; _type = oldReflectEventDescriptor.EventType; ReflectEventDescriptor desc = oldReflectEventDescriptor as ReflectEventDescriptor; if (desc != null) { _addMethod = desc._addMethod; _removeMethod = desc._removeMethod; _filledMethods = true; } }
/// <devdoc> /// This constructor takes an existing ReflectEventDescriptor and modifies it by merging in the /// passed-in attributes. /// </devdoc> public ReflectEventDescriptor(Type componentType, EventDescriptor oldReflectEventDescriptor, Attribute[] attributes) : base(oldReflectEventDescriptor, attributes) { this.componentClass = componentType; this.type = oldReflectEventDescriptor.EventType; ReflectEventDescriptor desc = oldReflectEventDescriptor as ReflectEventDescriptor; if (desc != null) { this.addMethod = desc.addMethod; this.removeMethod = desc.removeMethod; this.filledMethods = true; } #if DEBUG else if (oldReflectEventDescriptor is DebugReflectEventDescriptor) { this.addMethod = ((DebugReflectEventDescriptor)oldReflectEventDescriptor).addMethod; this.removeMethod = ((DebugReflectEventDescriptor)oldReflectEventDescriptor).removeMethod; this.filledMethods = true; } #endif }
/// <devdoc> /// Static helper API around reflection to get and cache /// events. This does not recurse to the base class. /// </devdoc> private static EventDescriptor[] ReflectGetEvents(Type type) { if (_eventCache == null) { lock (_internalSyncObject) { if (_eventCache == null) { _eventCache = new Hashtable(); } } } EventDescriptor[] events = (EventDescriptor[])_eventCache[type]; if (events != null) { return events; } lock (_internalSyncObject) { events = (EventDescriptor[])_eventCache[type]; if (events == null) { BindingFlags bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance; TypeDescriptor.Trace("Events : Building events for {0}", type.Name); // Get the type's events. Events may have their add and // remove methods individually overridden in a derived // class, but at some point in the base class chain both // methods must exist. If we find an event that doesn't // have both add and remove, we skip it here, because it // will be picked up in our base class scan. // EventInfo[] eventInfos = type.GetEvents(bindingFlags); events = new EventDescriptor[eventInfos.Length]; int eventCount = 0; for (int idx = 0; idx < eventInfos.Length; idx++) { EventInfo eventInfo = eventInfos[idx]; // GetEvents returns events that are on nonpublic types // if those types are from our assembly. Screen these. // if ((!(eventInfo.DeclaringType.IsPublic || eventInfo.DeclaringType.IsNestedPublic)) && (eventInfo.DeclaringType.Assembly == typeof(ReflectTypeDescriptionProvider).Assembly)) { Debug.Fail("Hey, assumption holds true. Rip this assert."); continue; } MethodInfo addMethod = eventInfo.GetAddMethod(); MethodInfo removeMethod = eventInfo.GetRemoveMethod(); if (addMethod != null && removeMethod != null) { events[eventCount++] = new ReflectEventDescriptor(type, eventInfo); } } if (eventCount != events.Length) { EventDescriptor[] newEvents = new EventDescriptor[eventCount]; Array.Copy(events, 0, newEvents, 0, eventCount); events = newEvents; } #if DEBUG foreach(EventDescriptor dbgEvent in events) { Debug.Assert(dbgEvent != null, "Holes in event array for type " + type); } #endif _eventCache[type] = events; } } return events; }
private static EventDescriptor[] ReflectGetEvents(Type type) { if (_eventCache == null) { lock (_internalSyncObject) { if (_eventCache == null) { _eventCache = new Hashtable(); } } } EventDescriptor[] sourceArray = (EventDescriptor[]) _eventCache[type]; if (sourceArray == null) { lock (_internalSyncObject) { sourceArray = (EventDescriptor[]) _eventCache[type]; if (sourceArray != null) { return sourceArray; } BindingFlags bindingAttr = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly; EventInfo[] events = type.GetEvents(bindingAttr); sourceArray = new EventDescriptor[events.Length]; int length = 0; for (int i = 0; i < events.Length; i++) { EventInfo eventInfo = events[i]; if ((eventInfo.DeclaringType.IsPublic || eventInfo.DeclaringType.IsNestedPublic) || (eventInfo.DeclaringType.Assembly != typeof(ReflectTypeDescriptionProvider).Assembly)) { MethodInfo addMethod = eventInfo.GetAddMethod(); MethodInfo removeMethod = eventInfo.GetRemoveMethod(); if ((addMethod != null) && (removeMethod != null)) { sourceArray[length++] = new ReflectEventDescriptor(type, eventInfo); } } } if (length != sourceArray.Length) { EventDescriptor[] destinationArray = new EventDescriptor[length]; Array.Copy(sourceArray, 0, destinationArray, 0, length); sourceArray = destinationArray; } _eventCache[type] = sourceArray; } } return sourceArray; }