C# ParameterInfo.Any方法代码示例

 private bool HasOneParameterNeeded(ParameterInfo[] parameters, TypeInfo eventArgsType)
 {
     return parameters.Any() &&
            parameters.ElementAt(0).ParameterType.GetTypeInfo().IsAssignableFrom(eventArgsType);
 }

 private static bool IsValidCommandHandler(Type commandType, MethodInfo method, ParameterInfo[] parameters, MethodParameterInjector injector)
 {
     if (method.DeclaringType != null && method.DeclaringType.GetProperties().Any(p => IsPropertyAccessor(method, p)))
         return false;
     return parameters.Any(p => p.ParameterType == commandType)
            && parameters.All(p => p.ParameterType == commandType || injector.CanSupply(p.ParameterType));
 }

 /// <summary>
 /// Check if unwrap args is needed. If false, UnwrapArgs/WrapResult become NOP.
 /// The default implementation returns true if there is any [out] params.
 /// </summary>
 /// <param name="parameterInfos">All the parameterinfo.</param>
 /// <returns>true if UnwrapArgs/WrapResult should be performed.</returns>
 protected virtual bool IsUnwrapArgsNeeded(ParameterInfo[] parameterInfos)
 {
     return parameterInfos.Any(p => p.IsOut);
 }

 private static string BuildParameterPath(ParameterInfo[] parameters)
 {
     if(!parameters.Any()) return String.Empty;
     var parameterPath = Path.Combine(parameters.Select(p => $"{{{p.Name}}}").ToArray());
     return $"/{parameterPath}";
 }

        public static void SetEmptyCollectionOnMethodSelect(ParameterInfo[] parameters, ObservableCollection<ControlView> controlViewBindingObject, string guid)
        {
            if (parameters.Any())
            {
                foreach (ParameterInfo mParameter in parameters)
                {
                    int parameterOrder = mParameter.Position;
                    //mParameter.ParameterType

                    GetParameter(controlViewBindingObject, mParameter, parameterOrder, guid);
                }
            }
        }

        public static void SetCollectionOnValue(Value selectedValueObj, ParameterInfo[] parameters, ObservableCollection<ControlView> controlViewBindingObject, string guid)
        {
            if (parameters.Any())
            {
                foreach (ParameterInfo mParameter in parameters)
                {
                    int parameterOrder = mParameter.Position;
                    var paramValue = (from p in selectedValueObj.Param
                                      where p.Order == parameterOrder
                                      select p).First();

                    GetParameter(controlViewBindingObject, mParameter, parameterOrder, guid, paramValue);
                }
            }
        }

        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);
        }