C# ParameterInfo.Count方法代码示例

        internal static object MethodCall(object o, MethodInfo mi, string[] tparams, ParameterInfo[] lpi)
            {
            List<object> passargs = new List<object>();

            for (int i = 0; i < lpi.Count(); i++)
                passargs.Add(ChangeType(tparams[i], lpi[i].ParameterType));

            try
                {
                o = mi.Invoke(o, passargs.ToArray()) ?? "";
                }
            catch (Exception s)
                {
                return string.Format("Error " + s.Message);
                }

            return o;
            }

        public object[] ArgsForParams(ParameterInfo [] prms)
        {
            object [] res = new object [prms.Length];

            for (int i = 0; i < prms.Count (); i++) {
                try {
                    res [i] = Convert.ChangeType (Arguments [i], prms [i].ParameterType);
                } catch (Exception e) {
                    Console.Error.WriteLine ("Exception converting type: '{0}'.", prms [i].ParameterType);
                    Console.Error.WriteLine (e);

                    return null;
                }
            }

            return res;
        }

        /// <summary>
        /// Builds a parameter list given a list of arguments and a list of parameter info
        /// </summary>
        /// <param name="args">A list of Values which will be distributed to the output lists</param>
        /// <param name="pi">An array of parameter info for the method</param>
        /// <param name="end">The end count</param>
        /// <param name="parameters">A parameters List to add to.</param>
        private static void BuildParameterList(FSharpList<Value> args, ParameterInfo[] pi, int end, List<List<object>> parameters)
        {
            //for a static method, the number of parameters
            //will equal the number of arguments on the node
            if (args.Count() == pi.Count())
            {
                //ARGUMENT LOOP
                for (int j = 0; j < end; j++)
                {
                    //create a list to hold each set of arguments
                    var currParams = new List<object>();

                    //PARAMETER LOOP
                    for (int i = 0; i < pi.Count(); i++)
                    {
                        var arg = args[i];

                        //if the value is a list, add the jth item converted
                        //or the last item if i exceeds the count of the list
                        if (arg.IsList)
                        {
                            var lst = (Value.List) arg;
                            var argItem = (j < lst.Item.Count() ? lst.Item[j]: lst.Item.Last());

                            currParams.Add(DynamoTypeConverter.ConvertInput(argItem, pi[i].ParameterType));
                        }
                        else
                            //if the value is not a list,
                            //just add the value
                            currParams.Add(DynamoTypeConverter.ConvertInput(arg, pi[i].ParameterType));
                    }

                    parameters.Add(currParams);
                }
            }
            //for instance methods, the first argument will be the
            //item or list of items which will be the target of invocation
            //in this case, skip parsing the first argument
            else
            {
                //ARGUMENT LOOP
                for (int j = 0; j < end; j++)
                {
                    //create a list to hold each set of arguments
                    var currParams = new List<object>();

                    //PARAMETER LOOP
                    for (int i = 0; i < pi.Count(); i++)
                    {
                        var arg = args[i + 1];

                        //if the value is a list, add the jth item converted
                        //or the last item if i exceeds the count of the list
                        if (arg.IsList)
                        {
                            //var argItem = ((Value.List)arg).Item.Count() < end ? args.Last() : args[j];

                            var lst = (Value.List)arg;
                            var argItem = (j < lst.Item.Count() ? lst.Item[j] : lst.Item.Last());

                            currParams.Add(DynamoTypeConverter.ConvertInput(argItem, pi[i].ParameterType));
                        }
                        else
                            //if the value is not a list,
                            //just add the value
                            currParams.Add(DynamoTypeConverter.ConvertInput(arg, pi[i].ParameterType));
                    }

                    parameters.Add(currParams);
                }
            }
        }

 private bool HasTwoParametersNeeded(ParameterInfo[] parameters, TypeInfo eventArgsType, TypeInfo extraPropertyType)
 {
     return parameters.Count() == 2 &&
            HasOneParameterNeeded(parameters, eventArgsType) &&
            (
               extraPropertyType != null &&
               parameters.ElementAt(1).ParameterType.GetTypeInfo().IsAssignableFrom(extraPropertyType) ||
               parameters.ElementAt(1).ParameterType.GetTypeInfo().IsValueType == false
            );
 }

		/// <summary>
		/// Adds the by suffix.
		/// </summary>
		/// <param name="parameters">The parameters.</param>
		/// <param name="functionName">Name of the function.</param>
		/// <returns></returns>
		internal static string AddBySuffix(ParameterInfo[] parameters, string functionName)
		{
			int paramStart = 0;

			if (parameters.Count() > 0 && parameters.First().Name == "self")
				paramStart = 1;

			for (int paramIndex = paramStart; paramIndex < parameters.Length; paramIndex++) {
				ParameterInfo parameterInfo = parameters[paramIndex];

				if (paramIndex == paramStart)
					functionName += "By_";
				else
					functionName += "_";

				functionName += parameterInfo.Name.ToLower().ToPascalCase();
			}

			return functionName;
		}

 private void TransformParametersIntoNameValueMapper(ParameterInfo[] methodParameters)
 {
     _parametersNameValueMapper = new Dictionary<int, string>();
     for (var i = 0; i < methodParameters.Count(); i++)
     {
         _parametersNameValueMapper.Add(i, methodParameters[i].Name);
     }
 }

        private static void InitializeRequestArray(ILGenerator generator, ParameterInfo[] methodParameters)
        {
            var singleArgumentParameters = methodParameters.Count(x => x.ParameterType != typeof(string[]));

            generator.Emit(OpCodes.Ldc_I4, singleArgumentParameters + 1);

            for (int i = 0; i < methodParameters.Length; i++)
            {
                if (methodParameters[i].ParameterType == typeof(string[]))
                {
                    generator.Emit(OpCodes.Ldarg, i + 1);
                    generator.Emit(OpCodes.Ldlen);
                    generator.Emit(OpCodes.Conv_I4);
                    generator.Emit(OpCodes.Add);
                }
            }

            generator.Emit(OpCodes.Newarr, typeof(string));
            generator.Emit(OpCodes.Stloc_0);
        }

        private void EmitMethodWithParameterCombo(int thissIdx, MethodInfo realMethod, Type[] parameters, MethodBuilder methodBuilder, ParameterInfo[] realParams)
        {
            var gen = methodBuilder.GetILGenerator();
              if (!realMethod.IsStatic)
              {
            // Set 'this' to the result of JishProxy.GetInstance. This allows one
            // class to proxy to methods from different source classes.
            SetReferenceToAppropriateThis(gen, thissIdx);
              }
              for (int i = 0; i < parameters.Length; i++)
              {
            if (IsParamsArray(realParams[i]))
            {
              break;  // Break as this is the last parameter (params must always be last)
            }
            // if (IsParamDelegate(realParams[i])) // TODO: This is in the wrong place
            // {
            // If the param is a delegate it needs to be replaced with a string which
            // will be used to find the 'real' delegate in the jish_internal scope.

            // }
            // Else add standard inline arg
            gen.Emit(OpCodes.Ldarg, i + 1);
              }

              for (int i = parameters.Count(); i < realParams.Length; i++)
              {
            if (IsParamsArray(realParams[i])) break;

            gen.Emit(OpCodes.Ldarg_0);
            gen.Emit(OpCodes.Ldc_I4, thissIdx); // Load the this index into the stack for GetInstance param
            gen.Emit(OpCodes.Ldc_I4, i);
            MethodInfo getLastOptional = typeof (JishProxy).GetMethod("GetOptionalParameterDefaultValue");
            getLastOptional = getLastOptional.MakeGenericMethod(new[] {realParams[i].ParameterType});
            gen.Emit(OpCodes.Callvirt, getLastOptional);
              }
              ParameterInfo last = realParams.Any() ? realParams.Last() : null;
              if (last != null && IsParamsArray(last))
              {
            CovertRemainingParametersToArray(parameters, gen, realParams.Count() - 1, last.ParameterType.GetElementType());
              }
              // Call the real method
              gen.Emit(realMethod.IsStatic ? OpCodes.Call : OpCodes.Callvirt, realMethod);
              gen.Emit(OpCodes.Ret);
        }