C# MethodBase.GetParametersCached方法代码示例

        public static ParameterAssignment Bind(MethodBase method, string parameter, Expression expression)
        {
            // NB: This overload is needed for the compiler to emit factory calls;
            //     we can't emit a `ldtoken` instruction to obtain a ParameterInfo.

            ContractUtils.RequiresNotNull(method, nameof(method));
            ContractUtils.RequiresNotNull(parameter, nameof(parameter));

            var parameterInfo = default(ParameterInfo);

            foreach (var candidate in method.GetParametersCached())
            {
                if (candidate.Name == parameter)
                {
                    parameterInfo = candidate;
                    break;
                }
            }

            if (parameterInfo == null)
            {
                throw Error.ParameterNotDefinedForMethod(parameter, method.Name);
            }

            return Bind(parameterInfo, expression);
        }

 private static bool IsCompatible(MethodBase m, Expression[] args)
 {
     ParameterInfo[] parms = m.GetParametersCached();
     if (parms.Length != args.Length)
         return false;
     for (int i = 0; i < args.Length; i++)
     {
         Expression arg = args[i];
         ContractUtils.RequiresNotNull(arg, "argument");
         Type argType = arg.Type;
         Type pType = parms[i].ParameterType;
         if (pType.IsByRef)
         {
             pType = pType.GetElementType();
         }
         if (!TypeUtils.AreReferenceAssignable(pType, argType) &&
             !(TypeUtils.IsSameOrSubclass(typeof(LambdaExpression), pType) && pType.IsAssignableFrom(arg.GetType())))
         {
             return false;
         }
     }
     return true;
 }

        /// <summary>
        /// Emits arguments to a call, and returns an array of write-backs that
        /// should happen after the call. For emitting dynamic expressions, we
        /// need to skip the first parameter of the method (the call site).
        /// </summary>
        private List<WriteBack> EmitArguments(MethodBase method, IArgumentProvider args, int skipParameters)
        {
            ParameterInfo[] pis = method.GetParametersCached();
            Debug.Assert(args.ArgumentCount + skipParameters == pis.Length);

            var writeBacks = new List<WriteBack>();
            for (int i = skipParameters, n = pis.Length; i < n; i++)
            {
                ParameterInfo parameter = pis[i];
                Expression argument = args.GetArgument(i - skipParameters);
                Type type = parameter.ParameterType;

                if (type.IsByRef)
                {
                    type = type.GetElementType();

                    WriteBack wb = EmitAddressWriteBack(argument, type);
                    if (wb != null)
                    {
                        writeBacks.Add(wb);
                    }
                }
                else
                {
                    EmitExpression(argument);
                }
            }
            return writeBacks;
        }

        private static ParameterInfo[] GetParametersForValidation(MethodBase method, ExpressionType nodeKind) {
            ParameterInfo[] pis = method.GetParametersCached();

            if (nodeKind == ExpressionType.Dynamic) {
                pis = pis.RemoveFirst(); // ignore CallSite argument
            }
            return pis;
        }

            /// <summary>
            /// Marks child expressions representing arguments bound to parameters of
            /// the specified <paramref name="method"/> as ByRef values if needed.
            /// </summary>
            /// <param name="method">
            /// The method containing the parameters bound to the arguments held by
            /// child expressions tracked by this rewriter.
            /// </param>
            /// <param name="startIndex">
            /// The index of the child expression representing the first argument. This
            /// value is typically 0 for static methods and 1 for instance methods.
            /// </param>
            internal void MarkRefArgs(MethodBase method, int startIndex)
            {
                var parameters = method.GetParametersCached();

                for (int i = 0, n = parameters.Length; i < n;  i++)
                {
                    if (parameters[i].ParameterType.IsByRef)
                    {
                        MarkRef(startIndex + i);
                    }
                }
            }

 public static ReadOnlyCollection<ParameterAssignment> GetParameterBindings(MethodBase method, IEnumerable<Expression> expressions)
 {
     return GetParameterBindings(method.GetParametersCached(), expressions);
 }

 public static void ValidateParameterBindings(MethodBase method, ReadOnlyCollection<ParameterAssignment> argList, bool extensionMethod = false)
 {
     ValidateParameterBindings(method, method.GetParametersCached(), argList, extensionMethod);
 }