C# Delegate.GetType方法代码示例

        public static Delegate Transcribe(Type sourceEventHandlerType, Delegate destinationEventHandler)
        {
            if (destinationEventHandler == null)
                throw new ArgumentNullException("destinationEventHandler");
            if (destinationEventHandler.GetType() == sourceEventHandlerType)
                return destinationEventHandler; // already OK

            var sourceArgs = VerifyStandardEventHandler(sourceEventHandlerType);
            var destinationArgs = VerifyStandardEventHandler(destinationEventHandler.GetType());
            var name = "_wrap" + Interlocked.Increment(ref methodIndex);
            var paramTypes = new Type[sourceArgs.Length + 1];

            paramTypes[0] = destinationEventHandler.GetType();
            for (int i = 0; i < sourceArgs.Length; i++)
            {
                paramTypes[i + 1] = sourceArgs[i].ParameterType;
            }

            var dynamicMethod = new DynamicMethod(name, null, paramTypes);
            var invoker = paramTypes[0].GetMethod("Invoke");
            var ilGenerator = dynamicMethod.GetILGenerator();
            ilGenerator.Emit(OpCodes.Ldarg_0);
            ilGenerator.Emit(OpCodes.Ldarg_1);
            ilGenerator.Emit(OpCodes.Ldarg_2);

            if (!destinationArgs[1].ParameterType.IsAssignableFrom(sourceArgs[1].ParameterType))
            {
                ilGenerator.Emit(OpCodes.Castclass, destinationArgs[1].ParameterType);
            }
            ilGenerator.Emit(OpCodes.Call, invoker);
            ilGenerator.Emit(OpCodes.Ret);

            return dynamicMethod.CreateDelegate(sourceEventHandlerType, destinationEventHandler);
        }

			public DelegateEntry delegateEntry; // next delegate in the invocation list

			// A DelegateEntry holds information about a delegate that is part
			// of an invocation list of a multicast delegate.
			public DelegateEntry (Delegate del, string targetLabel)
			{
				type = del.GetType().FullName;
				assembly = del.GetType().Assembly.FullName;
				target = targetLabel;
				targetTypeAssembly = del.Method.DeclaringType.Assembly.FullName;
				targetTypeName = del.Method.DeclaringType.FullName;
				methodName = del.Method.Name;
			}

        static public void OnListenerAdding(string eventType, Delegate listenerBeingAdded)
        {
            if (!eventTable.ContainsKey(eventType))
            {
                eventTable.Add(eventType, null);
            }

            Delegate d = eventTable[eventType];
            if (d != null && d.GetType() != listenerBeingAdded.GetType())
            {
                throw new ListenerException(string.Format("Attempting to add listener with inconsistent signature for event type {0}. Current listeners have type {1} and listener being added has type {2}", eventType, d.GetType().Name, listenerBeingAdded.GetType().Name));
            }
        }

		public static Func<object[], Delegate, object> MakeFuncCaller(Delegate delg)
		{
			var argsParam = Expression.Parameter(typeof(object[]));
			var delegateParam = Expression.Parameter(typeof(Delegate));

			var invoke = delg.GetType().GetMethod("Invoke");
			var hasReturn = invoke.ReturnType != typeof(void);
			var locals = invoke.GetParameters().Select(
				p => Expression.Variable(p.ParameterType.IsByRef ? p.ParameterType.GetElementType() : p.ParameterType))
				.ToArray();
			var assignments = Expression.Block(
				invoke.GetParameters().Select((p, i) =>
					Expression.Assign(
						locals[i],
						Expression.Convert(
							Expression.ArrayIndex(argsParam, Expression.Constant(i)), locals[i].Type)))
					.Concat(new Expression[] { Expression.Empty() }));

			Expression call = Expression.Call(
				Expression.Convert(delegateParam, delg.GetType()),
				invoke, locals);
			var resultVar = hasReturn
				? (Expression)Expression.Variable(invoke.ReturnType)
				: Expression.Constant(null, typeof(object));
			if (hasReturn)
				call = Expression.Assign(resultVar, call);

			var byrefAssignments = Expression.Block(
				invoke.GetParameters()
				.Select((p, i) => new { Type = p.ParameterType, Index = i })
				.Where(data => data.Type.IsByRef)
				.Select(data => Expression.Assign(
					Expression.ArrayAccess(argsParam, Expression.Constant(data.Index)),
					Expression.Convert(locals[data.Index], typeof(object))))
				.Concat(new Expression[] { Expression.Empty() })
				.ToArray());

			var callerBlock = Expression.Block(locals,
				assignments,
				call,
				byrefAssignments,
				Expression.Convert(resultVar, typeof(object)));

			if (hasReturn)
				callerBlock = Expression.Block(new[] { (ParameterExpression)resultVar }, callerBlock);

			var callerLambda = Expression.Lambda<Func<object[], Delegate, object>>(callerBlock, argsParam, delegateParam);
			return callerLambda.Compile();
		}

        public static Delegate CreateDelegate(Delegate dlg)
        {
            if (dlg == null)
                throw new ArgumentNullException ();
            if (dlg.Target != null)
                throw new ArgumentException ();
            if (dlg.Method == null)
                throw new ArgumentException ();

            get_runtime_types ();

            var ret_type = dlg.Method.ReturnType;
            var param_types = dlg.Method.GetParameters ().Select (x => x.ParameterType).ToArray ();

            var dynamic = new DynamicMethod (Guid.NewGuid ().ToString (), ret_type, param_types, typeof (object), true);
            var ig = dynamic.GetILGenerator ();

            LocalBuilder retval = null;
            if (ret_type != typeof (void))
                retval = ig.DeclareLocal (ret_type);

            ig.Emit (OpCodes.Call, wait_for_bridge_processing_method);

            var label = ig.BeginExceptionBlock ();

            for (int i = 0; i < param_types.Length; i++)
                ig.Emit (OpCodes.Ldarg, i);
            ig.Emit (OpCodes.Call, dlg.Method);

            if (retval != null)
                ig.Emit (OpCodes.Stloc, retval);

            ig.Emit (OpCodes.Leave, label);

            bool  filter = Debugger.IsAttached || !JNIEnv.PropagateExceptions;
            if (filter) {
                ig.BeginExceptFilterBlock ();

                ig.Emit (OpCodes.Call, mono_unhandled_exception_method);
                ig.Emit (OpCodes.Ldc_I4_1);
                ig.BeginCatchBlock (null);
            } else {
                ig.BeginCatchBlock (typeof (Exception));
            }

            ig.Emit (OpCodes.Dup);
            ig.Emit (OpCodes.Call, exception_handler_method);

            if (filter)
                ig.Emit (OpCodes.Throw);

            ig.EndExceptionBlock ();

            if (retval != null)
                ig.Emit (OpCodes.Ldloc, retval);

            ig.Emit (OpCodes.Ret);

            return dynamic.CreateDelegate (dlg.GetType ());
        }

		public WeakDelegate(Delegate callback)
            : base(callback.Target)
        {
            methodname = callback.Method.Name;
            type = callback.GetType();
            rm = new ResourceManager("Strings", Assembly.GetExecutingAssembly());
        }

		void IEventDispatcher.Unsubscribe(Delegate receiver)
		{
			if (receiver is Action)
				Unsubscribe((Action)receiver);
			else
				throw new ArgumentException(string.Format("Type {0} doesn't match event type {1}. Make sure that all subscribers have the same signature.", receiver.GetType().Name, Event.GetType().Name));
		}

        // Check to see if the given delegate is a legal handler for this type.
        //  It either needs to be a type that the registering class knows how to
        //  handle, or a RoutedEventHandler which we can handle without the help
        //  of the registering class.
        internal bool IsLegalHandler(Delegate handler)
        {
            Type handlerType = handler.GetType();

            return ((handlerType == HandlerType) ||
                (handlerType == typeof(RoutedEventHandler)));
        }

        /// <summary>
        /// Adds a class handler to the manager.
        /// </summary>
        /// <param name="classType">The type for which the handler is defined; must be a supertype of the manager's owner type.</param>
        /// <param name="handler">A delegate which represents the class handler to add to the type.</param>
        /// <param name="handledEventsToo">A value indicating whether the handler should receive events which have already been handled by other handlers.</param>
        public void AddHandler(Type classType, Delegate handler, Boolean handledEventsToo)
        {
            if (classType != this.ownerType && !this.ownerType.IsSubclassOf(classType))
                throw new ArgumentException(PresentationStrings.ClassTypeMustBeSubclassOfOwnerType.Format(classType.Name, ownerType.Name));

            if (routedEvent.DelegateType != handler.GetType())
                throw new ArgumentException(PresentationStrings.HandlerTypeMismatch.Format(handler.Method.Name, routedEvent.DelegateType.Name), "handler");

            lock (handlers)
            {
                var ordinalByType     = (short)0;
                var ordinalWithinType = ordinal++;

                var currentType = this.ownerType;
                while (currentType != classType)
                {
                    ordinalByType++;
                    currentType = currentType.BaseType;
                }

                var metadata = new RoutedEventHandlerMetadata(handler, ordinalByType, ordinalWithinType, handledEventsToo);
                handlers.Add(metadata);

                if (!sortSuspended)
                {
                    Sort();
                }
            }
        }

        public static Delegate Remove (Delegate a, Delegate b) {
          CodeContract.Ensures(((object)a) == null && ((object)b) == null ==> ((object)result) == null);
          CodeContract.Ensures(((object)a) == null && ((object)b) != null ==> ((object)result) == null);
          CodeContract.Ensures(((object)a) != null && ((object)b) == null ==> ((object)result) == (object)a);
          CodeContract.Ensures(((object)a) != null && ((object)b) != null ==> ((object)result) != null && result.GetType() == a.GetType() && Owner.Same(result, a));

          return default(Delegate);
        }

		public EventForwarder(Delegate realDelegate)
		{
			this.realDelegate = realDelegate;

			Type type = realDelegate.GetType();
			MethodInfo proxyMethod = typeof(EventForwarder).GetMethod("ForwardEvent" + realDelegate.Method.GetParameters().Length);
			proxyDelegate = Delegate.CreateDelegate(type, this, proxyMethod);
		}

        public ReflectionDetourNotifier(HookFactory hookFactory, Delegate targetDelegate)
        {
            _targetDelegate = targetDelegate;
            _hookDelegate = GenerateInterceptor(targetDelegate);

            Hook = hookFactory(Marshal.GetFunctionPointerForDelegate(_targetDelegate),
                Marshal.GetFunctionPointerForDelegate(_hookDelegate));
            _detour = Hook.CreateDetour(_targetDelegate.GetType());
        }

        private Delegate GenerateInterceptor(Delegate targetDelegate)
        {
            Type delegateType = targetDelegate.GetType();
            MethodInfo mi = delegateType.GetMethod("Invoke");
            ParameterExpression[] parameters = (from p in mi.GetParameters()
                                                select Expression.Parameter(p.ParameterType, p.Name)).ToArray();

            var builder = new InterceptorFuncBuilder(this);
            return builder.CreateLambdaBody(parameters, delegateType, mi);
        }

        public bool IsMatch(Delegate action)
        {
            if (action == null) return false;

            if (action.Target != TargetWeakReference.Target) return false;
            if (action.GetType() != ActionType) return false;
            if (action.Method != Method) return false;

            return true;
        }

        public HostCall(string name, Delegate function)
        {
            m_Method = function.GetType().GetMethod("Invoke");
            if (m_Method.ReturnType != typeof(double))
                throw new ArgumentException("Required return type for delegate is double");

            m_Name = name;
            m_Function = function;
            var parameters = Method.GetParameters();
            m_ParameterList = new object[parameters.Length];
        }