C# Type.GetEvent方法代码示例

        private static bool ProcessEventParameters(WorkflowParameterBindingCollection parameters, IMethodMessage message, Type interfaceType, string operation)
        {
            bool isKnownSignature = false;
            if (parameters == null)
                return isKnownSignature;

            EventInfo eventInfo = interfaceType.GetEvent(operation);
            MethodInfo methodInfo = eventInfo.EventHandlerType.GetMethod("Invoke");
            int index = 0;

            foreach (ParameterInfo formalParameter in methodInfo.GetParameters())
            {
                if ((typeof(ExternalDataEventArgs).IsAssignableFrom(formalParameter.ParameterType)))
                {
                    if (index == 1)
                        isKnownSignature = true;
                }

                if (parameters.Contains(formalParameter.Name))
                {
                    WorkflowParameterBinding binding = parameters[formalParameter.Name];
                    binding.Value = message.Args[index];
                }
                index++;
            }
            return isKnownSignature;
        }

 private static void SetMemberValue(object control, Type type, string member, object value)
 {
     PropertyInfo propertyInfo = type.GetProperty(member);
     if (propertyInfo != null)
     {
         SetPropertyValue(control, value, propertyInfo);
     }
     else
     {
         EventInfo eventInfo = type.GetEvent(member);
         if (eventInfo != null)
         {
             switch (eventInfo.EventHandlerType.FullName)
             {
                 case "System.EventHandler":
                     eventInfo.AddEventHandler(control, new EventHandler((sender, e) =>
                                                                         {
                                                                             (value as LuaFunc).Invoke(new LuaValue[] { new LuaUserdata(sender), new LuaUserdata(e) });
                                                                         }));
                     break;
                 case "System.Windows.Forms.TreeViewEventHandler":
                     eventInfo.AddEventHandler(control, new TreeViewEventHandler((sender, e) =>
                                                                                 {
                                                                                     (value as LuaFunc).Invoke(new LuaValue[] { new LuaUserdata(sender), new LuaUserdata(e) });
                                                                                 }));
                     break;
                 default:
                     throw new NotImplementedException(eventInfo.EventHandlerType.FullName + " type not implemented.");
             }
         }
     }
 }

 private static EventInfo GetEventInfo(Type type, string name)
 {
     if ((s_cbmTdpBridge != null) && IsFrameworkType(type))
     {
         Type typeToUseForCBMBridge = GetTypeToUseForCBMBridge(type);
         if (s_cbmTdpBridge.HasEvent(typeToUseForCBMBridge, name))
         {
             return type.GetEvent(name);
         }
         return null;
     }
     if (GetReflectionType(type).GetEvent(name) != null)
     {
         return type.GetEvent(name);
     }
     return null;
 }

            public object Get(string name, object instance, Type type, params object[] arguments)
            {
                var ei = type.GetEvent(name, PropertyFilter);
                if (ei == null) return NoResult;
                return !CanBind(ei) ? NoResult : ei;

                //Type eventHelper = typeof(EventHelper<>);
                //Type actualHelper = eventHelper.MakeGenericType(ei.EventHandlerType);
            }

		public ReflectionEventDescriptor (Type componentType, EventDescriptor oldEventDescriptor, Attribute[] attrs) : base (oldEventDescriptor, attrs)
		{
			_componentType = componentType;
			_eventType = oldEventDescriptor.EventType;

			EventInfo event_info = componentType.GetEvent (oldEventDescriptor.Name);
			add_method = event_info.GetAddMethod ();
			remove_method = event_info.GetRemoveMethod ();
		}

            public object Get(string name, object instance, Type type, params object[] arguments)
            {
                EventInfo ei = type.GetEvent(name);
                if (ei == null) return NoResult;
                if (!CanBind(ei)) return NoResult;

                //Type eventHelper = typeof(EventHelper<>);
                //Type actualHelper = eventHelper.MakeGenericType(ei.EventHandlerType);
                return ei;
            }

        internal static EventInfo GetEventInfo(Type type, string eventName,
            DynamicFunction f, string scriptVirtualPath) {

            EventInfo eventInfo = type.GetEvent(eventName);

            // If it doesn't match an event name, just ignore it
            if (eventInfo == null)
                return null;

            return eventInfo;
        }

		public static EventInfo FindEvent(Type instanceType, String eventName)
		{
			EventInfo info;

			do
			{
				info = instanceType.GetEvent(eventName, NuGenBinding.Instance);
				instanceType = instanceType.BaseType;
			} while (info == null && instanceType != _objectType);

			return info;
		}

            public object Set(string name, object instance, Type type, object value, params object[] arguments)
            {
                EventInfo ei = type.GetEvent(name);
                if (ei == null) return NoResult;
                if (!CanBind(ei)) return NoResult;

                if (!(value is RemoveDelegate))
                  EventHelper.AssignEvent(ei, instance, (IInvokable)value);
                else
                  EventHelper.RemoveEvent(ei, instance, (IInvokable)value);

                return value;
            }

        public TeamFoundationHostWrapper(ITeamFoundationContextManager teamFoundationHostObject)
        {
            _teamFoundationHostObject = teamFoundationHostObject;
            _teamFoundationHostObject.ContextChanged += delegate(object sender, ContextChangedEventArgs args)
                {
                    if (ContextChanged != null)
                        ContextChanged(sender, args);
                };

            _teamFoundationHostObject.ContextChanging += delegate(object sender, ContextChangingEventArgs args)
                {
                    if (ContextChanging != null)
                        ContextChanging(sender, args);
                };

            _teamFoundationHostObjectType = _teamFoundationHostObject.GetType();
            _commandHandlerField = new Lazy<FieldInfo>(() => _teamFoundationHostObjectType.GetField("m_commandHandler", BindingFlags.NonPublic | BindingFlags.Instance));
            _promptForServerAndProjectsMethod = new Lazy<MethodInfo>(() => _teamFoundationHostObjectType.GetMethod("PromptForServerAndProjects", BindingFlags.Public | BindingFlags.Instance));

            var connectingEventInfo = _teamFoundationHostObjectType.GetEvent("Connecting", BindingFlags.Public | BindingFlags.Instance);
            var connectingEventHandlerConstructor = connectingEventInfo.EventHandlerType.GetConstructor(new[] { typeof(object), typeof(IntPtr) });
            var connectingEventHandler = (Delegate)connectingEventHandlerConstructor.Invoke(new object[]
                {
                    this, typeof (TeamFoundationHostWrapper).GetMethod("TeamFoundationHostConnecting", BindingFlags.NonPublic | BindingFlags.Instance).MethodHandle.GetFunctionPointer()
                });

            connectingEventInfo.AddEventHandler(_teamFoundationHostObject, connectingEventHandler);

            var connectionCompletedEventInfo = _teamFoundationHostObjectType.GetEvent("ConnectionCompleted", BindingFlags.Public | BindingFlags.Instance);
            var connectionCompletedEventHandlerConstructor = connectionCompletedEventInfo.EventHandlerType.GetConstructor(new[] { typeof(object), typeof(IntPtr) });
            var connectionCompletedEventHandler = (Delegate)connectionCompletedEventHandlerConstructor.Invoke(new object[]
                {
                    this, typeof (TeamFoundationHostWrapper).GetMethod("TeamFoundationHostConnectionCompleted", BindingFlags.NonPublic | BindingFlags.Instance).MethodHandle.GetFunctionPointer()
                });

            connectionCompletedEventInfo.AddEventHandler(_teamFoundationHostObject, connectionCompletedEventHandler);
        }

        private static void WireToDefaultEvent(Parameter parameter, Type type, DependencyObject source, PropertyInfo property)
        {
            var defaults = IoC.Get<IConventionManager>()
                .GetElementConvention(type);

            if (defaults == null)
                throw new CaliburnException(
                    "Insuficient information provided for wiring action parameters.  Please set interaction defaults for " + type.FullName
                    );

            var eventInfo = type.GetEvent(defaults.EventName);

            if (property == null)
                parameter.Wire(source, eventInfo, () => defaults.GetValue(source));
            else parameter.Wire(source, eventInfo, () => property.GetValue(source, null));
        }

		static EventInfo FindEvent (Type wrapperType, Type objectType, string name)
		{
			EventInfo info;

			if (wrapperType != null) {
				info = wrapperType.GetEvent (name, flags);
				if (info != null)
					return info;
			}

			info = objectType.GetEvent (name, flags);
			if (info != null)
				return info;

			throw new ArgumentException ("Invalid event name " + objectType.Name + "." + name);
		}

        public ReflectionHelper(Type workItemTestType)
        {
            enqueueWorkItemMethod = workItemTestType.GetMethod("EnqueueWorkItem");

            unitTestHarnessProperty = workItemTestType.GetProperty("UnitTestHarness");

            var unitTestHarnessType = unitTestHarnessProperty.PropertyType;

            dispatcherStackProperty = unitTestHarnessType.GetProperty("DispatcherStack");

            var dispatcherStackType = dispatcherStackProperty.PropertyType;

            pushWorkItemMethod = dispatcherStackType.GetMethod("Push");
            popWorkItemMethod = dispatcherStackType.GetMethod("Pop");

            compositeWorkItemType = pushWorkItemMethod.GetParameters()[0].ParameterType;
            compositeWorkItemExceptionEvent = compositeWorkItemType.GetEvent("UnhandledException");
        }

 private static bool ProcessEventParameters(WorkflowParameterBindingCollection parameters, IMethodMessage message, Type interfaceType, string operation)
 {
     bool flag = false;
     if (parameters != null)
     {
         MethodInfo method = interfaceType.GetEvent(operation).EventHandlerType.GetMethod("Invoke");
         int index = 0;
         foreach (ParameterInfo info3 in method.GetParameters())
         {
             if (typeof(ExternalDataEventArgs).IsAssignableFrom(info3.ParameterType) && (index == 1))
             {
                 flag = true;
             }
             if (parameters.Contains(info3.Name))
             {
                 WorkflowParameterBinding binding = parameters[info3.Name];
                 binding.Value = message.Args[index];
             }
             index++;
         }
     }
     return flag;
 }

 internal static EventInfo getEvent(Type type, string name)
 {
     return type.GetEvent(name, BindingFlags.Public | BindingFlags.Instance);
 }