C# MethodInfo.GetParameterTypes方法代码示例

 public void AssertValidMethod(MethodInfo method)
 {
     if (method.ReturnType != preBuildContextType
         || method.GetParameterTypes().SingleOrDefaultIfMore() != preBuildContextType)
     {
         throw new InvalidMethodSignature(GetType(), method, preBuildContextType);
     }
 }

        internal static void GenerateMethodForDelegateCall(this TypeBuilder dynamicType, MethodInfo method, FieldBuilder field, MethodInfo onUnhandledException)
        {
            var il = dynamicType.CreateMethod(method);

            // the target object has a property or field that matches the signature we're looking for.
            // let's use that.

            var delegateType = WrappedDelegate.GetFuncOrActionType(method.GetParameterTypes(), method.ReturnType);

            il.LoadThis();
            il.LoadField(field);
            for (var i = 0; i < method.GetParameterTypes().Length; i++) {
                il.LoadArgument(i + 1);
            }
            il.CallVirutal(delegateType.GetMethod("Invoke"));
            il.Return();
        }

        internal static bool IsDelegateAssignableFromMethod(this Type delegateType, MethodInfo methodInfo) {
            if (delegateType == null || methodInfo == null) {
                return false;
            }

            // are the return types the same?
            if (methodInfo.ReturnType != delegateType.GetDelegateReturnType() && !methodInfo.ReturnType.IsAssignableFrom(delegateType.GetDelegateReturnType())) {
                return false;
            }

            if (!delegateType.GetDelegateParameterTypes().SequenceEqual(methodInfo.GetParameterTypes(), AssignableTypeComparer.Instance)) {
                return false;
            }
            return true;
        }

        [System.Security.SecuritySafeCritical]  // auto-generated
        public virtual void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
        {
            if (methodInfo == null)
                throw new ArgumentNullException("methodInfo");

            if (!(opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj)))
                throw new ArgumentException(Environment.GetResourceString("Argument_NotMethodCallOpcode"), "opcode");

            Contract.EndContractBlock();

            int stackchange = 0;
            int tk = GetMethodToken(methodInfo, optionalParameterTypes, false);

            EnsureCapacity(7);
            InternalEmit(opcode);

            // Push the return value if there is one.
            if (methodInfo.ReturnType != typeof(void))
                stackchange++;
            // Pop the parameters.
            Type[] parameters = methodInfo.GetParameterTypes();
            if (parameters != null)
                stackchange -= parameters.Length;

            // Pop the this parameter if the method is non-static and the
            // instruction is not newobj.
            if (!(methodInfo is SymbolMethod) && methodInfo.IsStatic == false && !(opcode.Equals(OpCodes.Newobj)))
                stackchange--;
            // Pop the optional parameters off the stack.
            if (optionalParameterTypes != null)
                stackchange -= optionalParameterTypes.Length;
            UpdateStackSize(opcode, stackchange);

            RecordTokenFixup();
            PutInteger4(tk);
        }

        internal static void GenerateMethodForDirectCall(this TypeBuilder dynamicType, MethodInfo method, FieldBuilder backingField, MethodInfo instanceMethod, MethodInfo onUnhandledException)
        {
            var il = dynamicType.CreateMethod(method);
            // the target object has a method that matches.
            // let's use that.

            var hasReturn = method.ReturnType != typeof(void);
            var hasOue = onUnhandledException != null;

            var exit = il.DefineLabel();
            var setDefaultReturn = il.DefineLabel();

            var ret = hasReturn ? il.DeclareLocal(method.ReturnType) : null;
            var exc = hasOue ? il.DeclareLocal(typeof(Exception)) : null;

            il.BeginExceptionBlock();

            il.LoadThis();
            il.LoadField(backingField);

            var imTypes = instanceMethod.GetParameterTypes();
            var dmTypes = method.GetParameterTypes();

            for (var i = 0; i < dmTypes.Length; i++)
            {
                il.LoadArgument(i + 1);

                // if the types are assignable,
                if (imTypes[i].IsAssignableFrom(dmTypes[i]))
                {
                    // it assigns straight across.
                }
                else
                {
                    // it doesn't, we'll ducktype it.
                    if (dmTypes[i].GetTypeInfo().IsPrimitive)
                    {
                        // box it first?
                        il.Emit(OpCodes.Box, dmTypes[i]);
                    }
                    il.Call(AsMethod.MakeGenericMethod(imTypes[i]));
                }
            }

            // call the actual method implementation
            il.CallVirtual(instanceMethod);

            if (hasReturn)
            {
                // copy the return value in the return
                // check to see if we need to ducktype the return value here.
                if (method.ReturnType.IsAssignableFrom(instanceMethod.ReturnType))
                {
                    // it can store it directly.
                }
                else
                {
                    // it doesn't assign directly, let's ducktype it.
                    if (instanceMethod.ReturnType.GetTypeInfo().IsPrimitive)
                    {
                        il.Emit(OpCodes.Box, instanceMethod.ReturnType);
                    }
                    il.Call(AsMethod.MakeGenericMethod(method.ReturnType));
                }
                il.StoreLocation(ret);
            }
            else
            {
                // this method isn't returning anything.
                if (instanceMethod.ReturnType != typeof(void))
                {
                    // pop the return value because the generated method is void and the
                    // method we called actually gave us a result.
                    il.Emit(OpCodes.Pop);
                }
            }
            il.Emit(OpCodes.Leave_S, exit);

            il.BeginCatchBlock(typeof(Exception));
            if (hasOue)
            {
                // we're going to call the handler.
                il.StoreLocation(exc.LocalIndex);
                il.LoadArgument(0);
                il.Emit(OpCodes.Ldstr, instanceMethod.ToSignatureString());
                il.LoadLocation(exc.LocalIndex);
                il.Call(onUnhandledException);
                il.Emit(OpCodes.Leave_S, setDefaultReturn);
            }
            else
            {
                // suppress the exception quietly
                il.Emit(OpCodes.Pop);
                il.Emit(OpCodes.Leave_S, setDefaultReturn);
            }
            il.EndExceptionBlock();

            // if we can't return the appropriate value, we're returning default(T)
            il.MarkLabel(setDefaultReturn);
            SetDefaultReturnValue(il, method.ReturnType);
//.........这里部分代码省略.........

 internal static ILGenerator CreateMethod(this TypeBuilder dynamicType, MethodInfo method)
 {
     return dynamicType.CreateMethod(method.Name, method.ReturnType, method.GetParameterTypes());
 }

        [System.Security.SecuritySafeCritical]  // auto-generated
        public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
        {
            if (methodInfo == null)
                throw new ArgumentNullException(nameof(methodInfo));

            if (!(opcode.Equals(OpCodes.Call) || opcode.Equals(OpCodes.Callvirt) || opcode.Equals(OpCodes.Newobj)))
                throw new ArgumentException(Environment.GetResourceString("Argument_NotMethodCallOpcode"), nameof(opcode));

            if (methodInfo.ContainsGenericParameters)
                throw new ArgumentException(Environment.GetResourceString("Argument_GenericsInvalid"), nameof(methodInfo));

            if (methodInfo.DeclaringType != null && methodInfo.DeclaringType.ContainsGenericParameters)
                throw new ArgumentException(Environment.GetResourceString("Argument_GenericsInvalid"), nameof(methodInfo));
            Contract.EndContractBlock();

            int tk;
            int stackchange = 0;

            tk = GetMemberRefToken(methodInfo, optionalParameterTypes);

            EnsureCapacity(7);
            InternalEmit(opcode);

            // Push the return value if there is one.
            if (methodInfo.ReturnType != typeof(void))
                stackchange++;
            // Pop the parameters.
            stackchange -= methodInfo.GetParameterTypes().Length;
            // Pop the this parameter if the method is non-static and the
            // instruction is not newobj.
            if (!(methodInfo is SymbolMethod) && methodInfo.IsStatic == false && !(opcode.Equals(OpCodes.Newobj)))
                stackchange--;
            // Pop the optional parameters off the stack.
            if (optionalParameterTypes != null)
                stackchange -= optionalParameterTypes.Length;
            UpdateStackSize(opcode, stackchange);

            PutInteger4(tk);
        }

		static bool MethodMatch (MethodInfo candidate, MethodInfo method)
		{
			if (candidate.Name != method.Name)
				return false;

			if (!HasExtensionAttribute (candidate))
				return false;

			var parameters = method.GetParameterTypes ();

			if (parameters.Length != candidate.GetParameters ().Length)
				return false;

			if (method.IsGenericMethod) {
				if (!candidate.IsGenericMethod)
					return false;

				if (candidate.GetGenericArguments ().Length != method.GetGenericArguments ().Length)
					return false;

				candidate = candidate.MakeGenericMethodFrom (method);
			}

			if (!TypeMatch (candidate.ReturnType, method.ReturnType))
				return false;

			var candidate_parameters = candidate.GetParameterTypes ();

			if (candidate_parameters [0] != GetComparableType (parameters [0]))
				return false;

			for (int i = 1; i < candidate_parameters.Length; ++i)
				if (!TypeMatch (candidate_parameters [i], parameters [i]))
					return false;

			return true;
		}

 public virtual void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes)
 {
     if (methodInfo == null)
     {
         throw new ArgumentNullException("methodInfo");
     }
     if ((!opcode.Equals(OpCodes.Call) && !opcode.Equals(OpCodes.Callvirt)) && !opcode.Equals(OpCodes.Newobj))
     {
         throw new ArgumentException(Environment.GetResourceString("Argument_NotMethodCallOpcode"), "opcode");
     }
     int stackchange = 0;
     int num2 = this.GetMethodToken(methodInfo, optionalParameterTypes, false);
     this.EnsureCapacity(7);
     this.InternalEmit(opcode);
     if (methodInfo.ReturnType != typeof(void))
     {
         stackchange++;
     }
     Type[] parameterTypes = methodInfo.GetParameterTypes();
     if (parameterTypes != null)
     {
         stackchange -= parameterTypes.Length;
     }
     if ((!(methodInfo is SymbolMethod) && !methodInfo.IsStatic) && !opcode.Equals(OpCodes.Newobj))
     {
         stackchange--;
     }
     if (optionalParameterTypes != null)
     {
         stackchange -= optionalParameterTypes.Length;
     }
     this.UpdateStackSize(opcode, stackchange);
     this.RecordTokenFixup();
     this.PutInteger4(num2);
 }

        public override void EmitCall(OpCode opcode, MethodInfo methodInfo, Type[] optionalParameterTypes) {
            int         tk;
            int         stackchange = 0;

            if (methodInfo == null)
                throw new ArgumentNullException("methodInfo");

            if (methodInfo.ContainsGenericParameters)
                throw new ArgumentException(Environment.GetResourceString("Argument_GenericsInvalid"), "methodInfo");

            if (methodInfo.DeclaringType != null && methodInfo.DeclaringType.ContainsGenericParameters)
                throw new ArgumentException(Environment.GetResourceString("Argument_GenericsInvalid"), "methodInfo");

            tk = GetMemberRefToken(methodInfo, optionalParameterTypes);

            EnsureCapacity(7);
            InternalEmit(opcode);

            // The opcode must be one of call, callvirt, or newobj.
            BCLDebug.Assert(opcode.Equals(OpCodes.Call) ||
                            opcode.Equals(OpCodes.Callvirt) ||
                            opcode.Equals(OpCodes.Newobj),
                            "Unexpected opcode passed to EmitCall.");
            
            // Push the return value if there is one.
            if (methodInfo.ReturnType != typeof(void))
                stackchange++;
            // Pop the parameters.
            stackchange -= methodInfo.GetParameterTypes().Length;
            // Pop the this parameter if the method is non-static and the
            // instruction is not newobj.
            if (!(methodInfo is SymbolMethod) && methodInfo.IsStatic == false && !(opcode.Equals(OpCodes.Newobj)))
                stackchange--;
            // Pop the optional parameters off the stack.
            if (optionalParameterTypes != null)
                stackchange -= optionalParameterTypes.Length;
            UpdateStackSize(opcode, stackchange);

            m_length = PutInteger4(tk, m_length, m_ILStream);
        }

        private static Setter CreateSetter(MethodInfo method)
        {
            var dm = CreateDynamicSetterMethod();

            Type returnType = method.GetParameterTypes()[0];
            ILGenerator il = dm.GetILGenerator();
            il.DeclareLocal(returnType);

            il.Emit(OpCodes.Ldarg_1);
            EmitHelper.UnboxOrCast(il, returnType);
            il.Emit(OpCodes.Stloc_0);

            il.Emit(OpCodes.Ldarg_0);
            EmitHelper.UnboxOrCast(il, method.DeclaringType);
            il.Emit(OpCodes.Ldloc_0);

            if (method.IsFinal)
                il.Emit(OpCodes.Call, method);
            else
                il.Emit(OpCodes.Callvirt, method);

            il.Emit(OpCodes.Ret);

            return dm.CreateDelegate(typeof(Setter)) as Setter;
        }

 private static MethodBuilder DefineExplicitInterfaceMethod(this TypeBuilder typeBuilder, MethodInfo method)
 {
     var builder = typeBuilder.DefineMethod($"{method.DeclaringType.FullName}.{method.Name}",
         MethodAttributes.Private | MethodAttributes.Final | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual,
         method.CallingConvention, method.ReturnType, method.GetParameterTypes().ToArray());
     if (method.IsGenericMethod)
     {
         builder.DefineGeneric(method);
     }
     typeBuilder.DefineMethodOverride(builder, method);
     return builder;
 }

 private static MethodBuilder DefineOverrideMethod(this TypeBuilder typeBuilder, MethodInfo method)
 {
     var builder = typeBuilder.DefineMethod(method.Name, method.GetAttributes(), method.CallingConvention, method.ReturnType, method.GetParameterTypes().ToArray());
     if (method.IsGenericMethod)
     {
         return builder.DefineGeneric(method);
     }
     return builder;
 }

        private static void MethodIntercept(ILGenerator ilGenerator, MethodInfo methodInfo, IInterceptor[] interceptors, LocalBuilder[] local,
            bool[] boolean, Action<ILGenerator> method)
        {
            var methodInterceptors = interceptors.GetMethodInterceptor();
            if (!methodInterceptors.Any())
            {
                method(ilGenerator);
                return;
            }
            var invocationType = InternalDynamicTypeProvider.CreateType<IMethodInvocation>();
            var returnParameterType = InternalDynamicTypeProvider.CreateType<IReturnParameter>();

            var parameterType = InternalDynamicTypeProvider.CreateType<IParameter>();
            var setParameters = invocationType.GetMethod("set_Parameters");
            var setParameterValue = parameterType.GetMethod("set_Value");
            var getParameterValue = parameterType.GetMethod("get_Value");
            var setParameterName = parameterType.GetMethod("set_Name");
            var setParameterInfo = parameterType.GetMethod("set_ParameterInfo");
            var getParameterName = typeof(ParameterInfo).GetMethod("get_Name");
            var getCurrentParameter = typeof(InterceptorExtends).GetMethod("GetCurrentParameter");

            var setReturnParameter = invocationType.GetMethod("set_ReturnParameter");
            var getReturnValue = returnParameterType.GetMethod("get_Value");
            var setReturnType = returnParameterType.GetMethod("set_ReturnType");
            var setReturnValue = returnParameterType.GetMethod("set_Value");
            var returnParameterLocal = ilGenerator.DeclareLocal(returnParameterType);
            var getReturnType = typeof(MethodInfo).GetMethod("get_ReturnType");
            var setInterceptedMethod = invocationType.GetMethod("set_InterceptedMethod");
            var setInterceptedType = invocationType.GetMethod("set_InterceptedType");
            var setInterceptedInstance = invocationType.GetMethod("set_InterceptedInstance");
            var getExecutedHandled = invocationType.GetMethod("get_ExecutedHandled");
            var getGetMethodInterceptor = typeof(InterceptorExtends).GetMethod("GetMethodInterceptor");
            var getGetExecutedMethodInterceptor = typeof(InterceptorExtends).GetMethod("GetExecutedMethodInterceptor");
            var onMethodExecuting = typeof(IMethodInterceptor).GetMethod("OnMethodExecuting");
            var onMethodExecuted = typeof(IMethodInterceptor).GetMethod("OnMethodExecuted");
            var interceptorLocal = ilGenerator.DeclareLocal(typeof(IMethodInterceptor[]));
            var executedInterceptorLocal = ilGenerator.DeclareLocal(typeof(IMethodInterceptor[]));


            var parametersLocal = ilGenerator.DeclareLocal(typeof(IParameter[]));
         


            var invocationLocal = ilGenerator.DeclareLocal(invocationType);
            var endLable = ilGenerator.DefineLabel();
            ilGenerator.LoadLocal(local[0]).Call(getGetMethodInterceptor).StoreLocal(interceptorLocal);
            ilGenerator.LoadLocal(local[0]).Call(getGetExecutedMethodInterceptor).StoreLocal(executedInterceptorLocal);
            ilGenerator.New(invocationType.GetConstructor(Type.EmptyTypes)).StoreLocal(invocationLocal);
            ilGenerator.LoadLocal(invocationLocal).LoadLocal(local[1]).Callvirt(setInterceptedMethod);
            ilGenerator.LoadLocal(invocationLocal).LoadLocal(local[2]).Callvirt(setInterceptedType);
            ilGenerator.LoadLocal(invocationLocal).This().Callvirt(setInterceptedInstance);
            ilGenerator.New(returnParameterType.GetConstructor(Type.EmptyTypes)).StoreLocal(returnParameterLocal);
            if (boolean[0]) ilGenerator.LoadLocal(returnParameterLocal).LoadLocal(local[1]).Callvirt(getReturnType).Callvirt(setReturnType);
            else ilGenerator.LoadLocal(returnParameterLocal).Typeof(typeof(void)).Callvirt(setReturnType);
            ilGenerator.LoadLocal(invocationLocal).LoadLocal(returnParameterLocal).Callvirt(setReturnParameter);

            ilGenerator.NewArray(typeof(IParameter), methodInfo.GetParameters().Length).StoreLocal(parametersLocal);
            ilGenerator.ForEach(methodInfo.GetParameterTypes(), (il, arg, i) =>
            {
                var argLocal = ilGenerator.DeclareLocal(parameterType);
                ilGenerator.New(parameterType.GetConstructor(Type.EmptyTypes)).StoreLocal(argLocal);
                ilGenerator.LoadLocal(argLocal).LoadArgument(i + 1).Box(arg).Callvirt(setParameterValue);
                ilGenerator.LoadLocal(argLocal).LoadLocal(local[1]).LoadInt(i).Call(getCurrentParameter).Callvirt(setParameterInfo);
                ilGenerator.LoadLocal(argLocal).LoadLocal(local[1]).LoadInt(i).Call(getCurrentParameter).Callvirt(getParameterName).Callvirt(setParameterName);
                ilGenerator.LoadLocal(parametersLocal).LoadInt(i).LoadLocal(argLocal).SetArrayItemRef();
            });
            ilGenerator.LoadLocal(invocationLocal).LoadLocal(parametersLocal).Callvirt(setParameters);

            ilGenerator.ForEach(methodInterceptors, (_, interceptor, index) =>
            _.LoadLocal(interceptorLocal).LoadArrayItem(index).LoadLocal(invocationLocal)
            .Callvirt(onMethodExecuting).LoadLocal(invocationLocal).Callvirt(getExecutedHandled).False(endLable));

            ilGenerator.ForEach(methodInfo.GetParameterTypes(), (il, arg, i) =>
            {
                ilGenerator.LoadLocal(parametersLocal).LoadArrayItem(i).Callvirt(getParameterValue).UnBox(arg).StroeArgument(i + 1);
            });
            method(ilGenerator);


            if (boolean[0]) ilGenerator.LoadLocal(returnParameterLocal).LoadLocal(local[3]).Callvirt(setReturnValue);
            ilGenerator.ForEach(methodInterceptors.OrderBy(i => i.ExecutedOrder), (_, interceptor, index) =>
            _.LoadLocal(executedInterceptorLocal).LoadArrayItem(index).LoadLocal(invocationLocal).
            Callvirt(onMethodExecuted).LoadLocal(invocationLocal).Callvirt(getExecutedHandled).False(endLable));
            ilGenerator.MarkLabelFor(endLable);
            if (boolean[0]) ilGenerator.LoadLocal(returnParameterLocal).Callvirt(getReturnValue).StoreLocal(local[3]);
        }

 private static bool MethodMatch(MethodInfo candidate, MethodInfo method)
 {
     if (candidate.Name != method.Name || !HasExtensionAttribute(candidate))
     {
         return false;
     }
     var parameters = method.GetParameterTypes();
     if (parameters.Length != candidate.GetParameters().Length)
     {
         return false;
     }
     else if (method.IsGenericMethod)
     {
         if (!candidate.IsGenericMethod || candidate.GetGenericArguments().Length != method.GetGenericArguments().Length)
         {
             return false;
         }
         candidate = candidate.MakeGenericMethodFrom(method);
     }
     if (!TypeMatch(candidate.ReturnType, method.ReturnType))
     {
         return false;
     }
     var candidate_parameters = candidate.GetParameterTypes();
     if (candidate_parameters[0] != GetComparableType(parameters[0]))
     {
         return false;
     }
     for (int index = 1; index < candidate_parameters.Length; ++index)
     {
         if (!TypeMatch(candidate_parameters[index], parameters[index]))
         {
             return false;
         }
     }
     return true;
 }