C# ActionDescriptor.GetParameters方法代码示例

            protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
            {
                var uowParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IUnitOfWork));
                if (uowParam != null)
                {
                    var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute<ConnectionKeyAttribute>();
                    if (connectionKey == null)
                        throw new ArgumentNullException("connectionKey");

                    using (var connection = SqlConnections.NewByKey(connectionKey.Value))
                    using (var uow = new UnitOfWork(connection))
                    {
                        parameters[uowParam.ParameterName] = uow;
                        var result = base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
                        uow.Commit();
                        return result;
                    }
                }

                var cnnParam = actionDescriptor.GetParameters().FirstOrDefault(x => x.ParameterType == typeof(IDbConnection));
                if (cnnParam != null)
                {
                    var connectionKey = controllerContext.Controller.GetType().GetCustomAttribute<ConnectionKeyAttribute>();
                    if (connectionKey == null)
                        throw new ArgumentNullException("connectionKey");

                    using (var cnn = SqlConnections.NewByKey(connectionKey.Value))
                    {
                        parameters[cnnParam.ParameterName] = cnn;
                        return base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
                    }
                }

                return base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
            }

        public bool IsSameAction(ActionDescriptor descriptor)
        {
            var desc = descriptor as ReflectedActionDescriptor;
            if (desc != null)
            {
                bool sameAction = ActionDescriptor.MethodInfo == desc.MethodInfo;
                if (sameAction)
                    return true;
            }
            ParameterDescriptor[] parameters1 = descriptor.GetParameters();

            bool same = descriptor.ControllerDescriptor.ControllerName.Equals(ActionDescriptor.ControllerDescriptor.ControllerName, StringComparison.OrdinalIgnoreCase) &&
                        descriptor.ActionName.Equals(ActionDescriptor.ActionName, StringComparison.OrdinalIgnoreCase) &&
                        (parameters1.Length == _actionParameterDescriptors.Length);

            if (same)
            {
                for (int i = parameters1.Length - 1; i >= 0; i--)
                {
                    if (parameters1[i].ParameterType == _actionParameterDescriptors[i].ParameterType)
                    {
                        continue;
                    }

                    same = false;
                    break;
                }
            }

            return same;
        }

        public bool Invoke(Action invokeMvcPipeline, ActionDescriptor actionDescriptor, ControllerContext controllerContext)
        {
            //IMvcActionInvoker is httpcontext scoped
            var mvcActionInvoker = _mvcActionInvokerResolver();
            mvcActionInvoker.Set(invokeMvcPipeline);

            var actionName = _actionNameProvider.GetName(actionDescriptor);

            //find uniqueId for behavior chain that corresponds to this action call
            var controllerType = controllerContext.Controller.GetType();
            var parameterDescriptors = actionDescriptor.GetParameters();
            var inputParameters = parameterDescriptors.ToDictionary(x => x.ParameterName, x => x.ParameterType);
            var uniqueId = _behaviorChainIdLookup.GetUniqueId(controllerType, actionName, inputParameters);

            //get the behavior chain and invoke it, using this instance of ControllerContext for it
            var arguments = new ServiceArguments();
            //provide controller context to any behaviors that need to get at it
            arguments.Set(typeof(ControllerContext), controllerContext);
            using (var nestedContainer = _container.GetNestedContainer())
            {
                var actionBehavior = nestedContainer.GetInstance<IActionBehavior>(arguments.ToExplicitArgs(), uniqueId.ToString());
                actionBehavior.Invoke();
            }
            return true;
        }

        public IEnumerable<System.Web.Mvc.Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            //if ((controllerContext.Controller is ProductController || controllerContext.Controller is ProductsController) &&
            //    actionDescriptor.ActionName.Equals("ProductList", 
            //    StringComparison.InvariantCultureIgnoreCase))
            if ((actionDescriptor.ControllerDescriptor.ControllerName == "Product" || actionDescriptor.ControllerDescriptor.ControllerName == "Products") &&
                actionDescriptor.ActionName.Equals("ProductList", StringComparison.InvariantCultureIgnoreCase))
            {
                if (controllerContext.RouteData.Values["area"] != null &&
                    (controllerContext.RouteData.Values["area"].ToString() == "Admin" || controllerContext.RouteData.Values["area"].ToString() == "Vendor"))
                {
                    //return new List<System.Web.Mvc.Filter>() { new System.Web.Mvc.Filter(this, FilterScope.Action, 0) };
                }
            }

            if ((actionDescriptor.ControllerDescriptor.ControllerName == "Home") &&
                actionDescriptor.ActionName.Equals("Index",
                StringComparison.InvariantCultureIgnoreCase))
            {
                return new List<System.Web.Mvc.Filter>() { new System.Web.Mvc.Filter(this, FilterScope.Action, 0) };
            }

            var a = actionDescriptor.GetCustomAttributes(true);
            var b = actionDescriptor.GetFilterAttributes(true);
            var c = actionDescriptor.GetParameters();

            return new List<System.Web.Mvc.Filter>();
        }

        protected virtual IDictionary<string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            Dictionary<string, object> parametersDict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            ParameterDescriptor[] parameterDescriptors = actionDescriptor.GetParameters();

            foreach (ParameterDescriptor parameterDescriptor in parameterDescriptors)
            {
                parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
            }
            return parametersDict;
        }

        ///// <summary>
        ///// Provides filters to apply to the specified action.
        ///// </summary>
        ///// <param name="controllerContext">The current controllerContext.</param>
        ///// <param name="actionDescriptor">The action descriptor for the action to provide filters for.</param>
        ///// <returns>
        ///// The filters to apply to the specified action.
        ///// </returns>
        public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            // Actions with a bound parameter of type ODataQueryOptions do not support the query filter
            // The assumption is that the action will handle the querying within the action implementation
            var apiActionDescriptor = actionDescriptor as ApiActionDescriptor;
            if (apiActionDescriptor != null && IsIQueryable(apiActionDescriptor.ReturnType) &&
                !actionDescriptor.GetParameters().Any(parameter => typeof(ODataQueryOptions).IsAssignableFrom(parameter.ParameterType)))
            {
                return new Filter[] { new Filter(QueryFilter, FilterScope.Global, null) };
            }

            return Enumerable.Empty<Filter>();
        }

 protected override IDictionary<string, object> GetParameterValues(ControllerContext cc, ActionDescriptor ad)
 {
     var ps = ad.GetParameters();
     var r = base.GetParameterValues(cc, ad);
     var a = cc.RouteData.Values["args"];
     var arg = (string) (defAct != null ? cc.RouteData.Values["action"] : a);
     var args = !string.IsNullOrEmpty(arg) ? arg.Split('/') : null;
     var rr = new Dictionary<string, object>();
     if (r.Count == 0)
     {
         return rr;
     }
     if (r.Count == 1)
     {
         if (!string.IsNullOrEmpty(arg))
         {
             foreach (var o in r)
             {
                 rr[o.Key] = Convert.ChangeType(arg, ps[0].ParameterType);
             }
         }
         else
         {
             ParseParameters(cc, r, rr);
         }
     }
     else
     {
         if (args != null && args.Length > 0)
         {
             int p = 0;
             foreach (var i in r)
             {
                 if (p >= args.Length)
                 {
                     break;
                 }
                 var par = ps[p];
                 rr[i.Key] = Convert.ChangeType(args[p], par.ParameterType);
                 p++;
             }
         }
         else
         {
             ParseParameters(cc, r, rr);
         }
     }
     return rr;
 }

 /// <summary>
 /// 格式化Action的参数字符串
 /// </summary>
 /// <param name="action"></param>
 /// <returns></returns>
 public static string FormatParams(ActionDescriptor action)
 {
     var param = action.GetParameters();
     var result = new StringBuilder();
     if (param.Length > 0)
     {
         foreach (var item in param)
         {
             result.Append(string.Format("Type:{0}, Name:{1}; ", item.ParameterType, item.ParameterName));
         }
         return result.ToString();
     }
     else
     {
         return null;
     }
 }

        protected override IDictionary<string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor) {
            var directRequest = controllerContext.HttpContext.Items[DirectRequest.DirectRequestKey] as DirectRequest;
            var parametersDict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            ParameterDescriptor[] parameterDescriptors = actionDescriptor.GetParameters();

            if (directRequest == null) {
                throw new NullReferenceException(DirectResources.Common_DirectRequestIsNull);
            }

            if (!directRequest.IsFormPost && directRequest.Data != null) {
                controllerContext.Controller.ValueProvider = new DirectValueProvider(directRequest, parameterDescriptors);
            }

            foreach (ParameterDescriptor parameterDescriptor in parameterDescriptors) {
                parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
            }
            return parametersDict;
        }

        private static string GetSamplePath(RequestContext requestContext, ActionDescriptor action) {
            var urlHelper = new UrlHelper(requestContext);

            var actionNameAttrib = action.GetCustomAttributes(inherit: true).OfType<ActionNameAttribute>().FirstOrDefault();

            // This is tricky because some of the action parameters may not be meant to come from the route.
            // e.g. they could come from a POST body.
            // In that case, they may end up as bogus query string params on the path, which is a bit buggy
            var routeValues = new RouteValueDictionary();
            foreach (ParameterDescriptor param in action.GetParameters()) {
                routeValues.Add(param.ParameterName, GetDefaultValue(param));
            }

            return urlHelper.Action(
                actionNameAttrib != null ? actionNameAttrib.Name : action.ActionName,
                action.ControllerDescriptor.ControllerName.ToLowerInvariant(),
                routeValues);
        }

        protected override IDictionary<string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            var parametersDict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            var parameterDescriptors = actionDescriptor.GetParameters();

            if (_isJsonRequest)
            {
                //ִ��Json������ƴװ
                if (parameterDescriptors.Length == 1)
                    parametersDict[parameterDescriptors[0].ParameterName] = GetJsonParameterValue(controllerContext, parameterDescriptors[0]);
                else
                {
                    foreach (var parameterDescriptor in parameterDescriptors)
                    {
                        //parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
                        parametersDict[parameterDescriptor.ParameterName] = GetJsonDictValue(controllerContext,
                                                                                             parameterDescriptor);
                    }
                }

            }
            else
            {
                foreach (var parameterDescriptor in parameterDescriptors)
                {
                    parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
                }
            }

            return parametersDict;
        }

 /// <summary>
 /// 获取Action的方法签名
 /// </summary>
 /// <param name="descriptor">The descriptor.</param>
 /// <returns></returns>
 private string GetActionSign(ActionDescriptor descriptor)
 {
     return string.Format("{0}({1})", GetActionHttpAttr(descriptor), GetActionParamsString(descriptor.GetParameters()));
 }