protected virtual InferredAction GetInferredAction(ControllerDescriptor controllerDescriptor, string actionName) {
     return InferredActions.Current
         .Where(inferred => inferred.Controller == controllerDescriptor.ControllerType)
         .Where( inferred =>
             string.Equals(inferred.ActionName, actionName, StringComparison.CurrentCultureIgnoreCase))
         .FirstOrDefault();
 }

 /// <summary>
 /// Конструктор, сохраняет нужные данные
 /// </summary>
 /// <param name="methodInfo">данные о вызываемом action'е</param>
 /// <param name="actionName">имя action'а</param>
 /// <param name="controllerDescriptor">дескриптор контроллера</param>
 public TaskAsyncActionDescriptor(
     MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor)
 {
     _methodInfo = methodInfo;
     _actionName = actionName;
     _controllerDescriptor = controllerDescriptor;
 }

        public virtual ActionDescriptor FindAction(ControllerContext controllerContext,
		                                           ControllerDescriptor controllerDescriptor, string actionName)
        {
            // Todo we may want convention here.
            //if (controllerContext.HttpContext.Request.HttpMethod != Verbs.Post)
            //{
            //    return null;
            //}
            var controllerName = controllerContext.RouteData.Values["controller"].ToString().ToLowerInvariant();
            var service = _Registry.GetService(controllerName);
            if (service == null)
            {
                return null;
            }
            var commandAction = service.FindAction(actionName);
            if (commandAction == null || !commandAction.IsCommand())
            {
                return null;
            }
            var commandDescriptor = _Locator.GetInstance<ReflectedCommand>();
            commandDescriptor.SetActionName(actionName);
            commandDescriptor.SetControllerDescriptor(controllerDescriptor);
            commandDescriptor.SetAction(commandAction);
            return commandDescriptor;
        }

        protected override ActionDescriptor FindAction(
			ControllerContext controllerContext, 
			ControllerDescriptor controllerDescriptor, 
			string actionName)
        {
            var action = base.FindAction(controllerContext, controllerDescriptor, actionName);
            if (action != null)
            {
                return action;
            }

            if (typeof(CqrsController).IsAssignableFrom(controllerDescriptor.ControllerType))
            {
                //TODO: cache command types?
                var messagesAssembly = Assembly.Load(new AssemblyName("ECom.Messages"));
                var commandTypes = messagesAssembly.GetTypes()
                                    .Where(t => typeof(ICommand).IsAssignableFrom(t))
                                    .Select(t => new { Name = t.Name, Type = t });

                var command = commandTypes.FirstOrDefault(c => c.Name.Equals(actionName, StringComparison.InvariantCultureIgnoreCase));

                if (command != null)//we have a command action but the action itself is not declared
                {
                    //fallback to cqrs controller generic command action
                    var actionInfo = controllerDescriptor.ControllerType.GetMethod("SubmitCommand").MakeGenericMethod(command.Type);

                    if (actionInfo != null)
                    {
                        return new ReflectedActionDescriptor(actionInfo, actionName, controllerDescriptor);
                    }
                }
            }

            return null;
        }

        internal ReflectedActionDescriptor(MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethod)
        {
            if (methodInfo == null)
            {
                throw new ArgumentNullException("methodInfo");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
            }
            if (controllerDescriptor == null)
            {
                throw new ArgumentNullException("controllerDescriptor");
            }

            if (validateMethod)
            {
                string failedMessage = VerifyActionMethodIsCallable(methodInfo);
                if (failedMessage != null)
                {
                    throw new ArgumentException(failedMessage, "methodInfo");
                }
            }

            MethodInfo = methodInfo;
            _actionName = actionName;
            _controllerDescriptor = controllerDescriptor;
        }

        protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            var method = controllerContext.HttpContext.Request.HttpMethod;

            var actionDescriptor = controllerDescriptor.FindAction(controllerContext, method);
            return actionDescriptor;
        }

        /// <summary>
        /// Gets the action descriptor and caches it
        /// </summary>
        /// <param name="controllerContext"></param>
        /// <param name="controllerDescriptor"></param>
        /// <param name="actionName"></param>
        /// <returns></returns>
        protected ReflectedActionDescriptor GetActionDescriptor(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            var found = _descriptorCache.GetOrAdd(
                controllerDescriptor.UniqueId,
                s => new ReflectedActionDescriptor(
                    controllerContext.Controller.GetType().GetMethods()
                        .First(x => x.Name == actionName &&
                                    x.GetCustomAttributes(typeof(NonActionAttribute), false).Any() == false),
                    actionName,
                    controllerDescriptor));

            //check if the action name matches, it won't if the user has changed the action name in umbraco, if this occurs we need to refresh the cache
            if (!found.ActionName.InvariantEquals(actionName))
            {
                var newDescriptor = new ReflectedActionDescriptor(
                    controllerContext.Controller.GetType().GetMethods()
                        .First(x => x.Name == actionName &&
                                    x.GetCustomAttributes(typeof (NonActionAttribute), false).Any() == false),
                    actionName,
                    controllerDescriptor);

                _descriptorCache.TryUpdate(controllerDescriptor.UniqueId, newDescriptor, found);

                found = newDescriptor;
            }

            return found;
        }

        protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            var ad = base.FindAction(controllerContext, controllerDescriptor, actionName);

            //now we need to check if it exists, if not we need to return the Index by default
            if (ad == null)
            {
                if (controllerContext.RouteData.DataTokens.ContainsKey("__virtualnodefinder__"))
                {
                    var virtualNode = controllerContext.RouteData.DataTokens["__virtualnodefinder__"] as IPublishedContent;
                    if (virtualNode != null)
                    {
                        var action = controllerContext.RouteData.GetRequiredString("action");

                        var categoryUrl = virtualNode.GetPropertyValue<string>("categoriesUrlName");
                        if (action.InvariantEquals(categoryUrl))
                        {
                            return GetActionDescriptor(controllerContext, controllerDescriptor, "Categories");
                        }

                        var tagsUrl = virtualNode.GetPropertyValue<string>("tagsUrlName");
                        if (action.InvariantEquals(tagsUrl))
                        {
                            return GetActionDescriptor(controllerContext, controllerDescriptor, "Tags");
                        }
                    }
                }
            }
            return ad;
        }

 public string GetControllerDetails(ControllerDescriptor controllerDescriptor, RequestContext requestContext)
 {
     var template = new ControllerDetails
     {
         Model = GetControllerModel(controllerDescriptor, requestContext)
     };
     return template.TransformText();
 }

        protected RegistrySelector(ActionDescriptor actionDescriptor, ControllerDescriptor controllerDescriptor, ControllerContext controllerContext)
        {
            ActionDescriptor = actionDescriptor;
            ControllerDescriptor = controllerDescriptor;
            ControllerContext = controllerContext;

            if (ControllerContextIsValid()) RegisterControllerRequestData(ControllerContext.HttpContext.Request);
            if (ControllerRouteDataIsValid()) RegisterControllerRouteData(ControllerContext.RouteData);
        }

 public virtual ILookup<string, ApiActionDescriptor> GetActionMapping(ControllerDescriptor controllerDescriptor)
 {
     if (controllerDescriptor == null)
     {
         throw Error.ArgumentNull("controllerDescriptor");
     }
     //return this.GetInternalSelector(controllerDescriptor).GetActionMapping();
     throw new NotImplementedException();
 }

            protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName) {
                if (actionName == restActionToken) {
                    // cleanup the restActionToken we set earlier
                    controllerContext.RequestContext.RouteData.Values["action"] = null;

                    List<ActionDescriptor> matches = new List<ActionDescriptor>();
                    foreach (ActionDescriptor ad in controllerDescriptor.GetCanonicalActions()) {
                        object[] acceptVerbs = ad.GetCustomAttributes(typeof(AcceptVerbsAttribute), false);
                        if (acceptVerbs.Length > 0) {
                            foreach (object o in acceptVerbs) {
                                AcceptVerbsAttribute ava = o as AcceptVerbsAttribute;
                                if (ava != null) {
                                    if (ava.Verbs.Contains(controllerContext.HttpContext.Request.GetHttpMethodOverride().ToUpperInvariant())) {
                                        matches.Add(ad);
                                    }
                                }
                            }
                        }
                    }
                    switch (matches.Count) {
                        case 0:
                            break;
                        case 1:
                            ActionDescriptor ad = matches[0];
                            actionName = ad.ActionName;
                            controllerContext.RequestContext.RouteData.Values["action"] = actionName;
                            return ad;
                        default:
                            StringBuilder matchesString = new StringBuilder(matches[0].ActionName);
                            for (int index = 1; index < matches.Count; index++) {
                                matchesString.Append(", ");
                                matchesString.Append(matches[index].ActionName);
                            }
                            return new ResourceErrorActionDescriptor(
                                controllerDescriptor,
                                HttpStatusCode.Conflict,
                                String.Format(
                                    CultureInfo.CurrentCulture,
                                    MvcResources.ResourceControllerFactory_ConflictingActions,
                                    controllerDescriptor.ControllerName,
                                    matchesString.ToString()
                                )
                            );
                    }
                }
                return base.FindAction(controllerContext, controllerDescriptor, actionName) ??
                    new ResourceErrorActionDescriptor(
                        controllerDescriptor,
                        HttpStatusCode.NotFound,
                        String.Format(
                            CultureInfo.CurrentCulture,
                            MvcResources.ResourceControllerFactory_NoActions,
                            controllerDescriptor.ControllerName
                        )
                    );
            }

        protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            var result = base.FindAction(controllerContext, controllerDescriptor, actionName);
            if (result == null)
            {
                return new NotFoundActionDescriptor();
            }

            return result;
        }

        public void FixtureSetUp()
        {
            _baseControllerContext = new ControllerContext {Controller = new TestController()};

            _baseMethodInfo = TestController.GetAction1MethodInfo<TestController>();
            _actionName = _baseMethodInfo.Name;

            _controllerDescriptor = new Mock<ControllerDescriptor>().Object;
            _reflectedActionDescriptor = new ReflectedActionDescriptor(_baseMethodInfo, _actionName, _controllerDescriptor);
        }

 /// <summary>
 /// Finds the action for the controller, if not it is inferred.
 /// </summary>
 /// <param name="controllerContext"></param>
 /// <param name="controllerDescriptor"></param>
 /// <param name="actionName"></param>
 /// <returns></returns>
 protected override ActionDescriptor FindAction(ControllerContext controllerContext,
     ControllerDescriptor controllerDescriptor, string actionName)
 {
     var foundAction = base.FindAction(controllerContext, controllerDescriptor, actionName);
     if (foundAction == null) {
         InferredAction inferredAction = GetInferredAction(controllerDescriptor, actionName);
         foundAction = new InferredActionDescriptor(actionName, controllerDescriptor, inferredAction);
     }
     return foundAction;
 }

        public InstanceRegistration(IConstraint constraint, ActionDescriptor actionDescriptor, ControllerDescriptor controllerDescriptor, FilterScope scope1)
            : base(actionDescriptor, controllerDescriptor, scope1)
        {
            if (constraint == null)
            {
                throw new ArgumentNullException("constraint", "Constraint instance can not be null.");
            }

            Constraint = constraint;
            ConstraintType = Constraint.GetType();
        }

        /// <summary>
        /// Select a member
        /// </summary>
        /// <param name="controllerContext"></param>
        /// <param name="controllerDescriptor"></param>
        /// <param name="actionName"></param>
        /// <returns></returns>
        protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            // Get all members in the controller
            var members = MvcApplication.Host.ScriptEngine.Operations.GetMemberNames(controllerContext.Controller);
            string resolvedActionName = "";

            // If memebrs match, return
            if (members.Contains(actionName))
            {
                resolvedActionName = actionName;
            }
            else
            {
                // Search with ignore-case mode
                foreach (var member in members)
                {
                    if (member.ToLower() == actionName.ToLower())
                    {
                        resolvedActionName = member;
                    }
                }
            }

            // If an action was found
            if (!string.IsNullOrWhiteSpace(resolvedActionName))
            {
                // Search for all method of this type
                var httpMethod = controllerContext.HttpContext.Request.HttpMethod; //GET POST DELETE PUT

                var member = MvcApplication.Host.ScriptEngine.Operations.GetMember(controllerContext.Controller, resolvedActionName);
                var methodInfo = member as IronPython.Runtime.Method;
                var pythonFunction = methodInfo.__func__ as PythonFunction;

                Decorator.ActionDecorator dec = null;
                if (AspNetMvcAPI.Filter.actionDecorators.TryGetValue(pythonFunction, out dec))
                {
                    if (string.IsNullOrWhiteSpace(dec.httpMethod) && httpMethod == "GET")
                    {
                        return new DynamicActionDescriptor(controllerContext, controllerDescriptor, resolvedActionName, pythonFunction);
                    }
                    else if (dec.httpMethod == httpMethod)
                    {
                        return new DynamicActionDescriptor(controllerContext, controllerDescriptor, resolvedActionName, pythonFunction);
                    }
                }
                else if (httpMethod == "GET")
                {
                    return new DynamicActionDescriptor(controllerContext, controllerDescriptor, resolvedActionName, pythonFunction);
                }
            }

            return null;
        }

        protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            var customActionName =
                _handlers
                    .Select(handler => handler.GetActionName(controllerContext))
                    .FirstOrDefault(x => x != null);

            if (customActionName == null)
                return base.FindAction(controllerContext, controllerDescriptor, actionName);

            return base.FindAction(controllerContext, controllerDescriptor, customActionName)
                         ?? base.FindAction(controllerContext, controllerDescriptor, actionName); //this would be a lot nicer if FindAction just returned null if the input is null or empty
        }

        protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            var urlType = GetUrlType(controllerContext);
            var httpMethod = GetHttpMethod(controllerContext);

            var methodInfo = GetMethodInfo(controllerContext.Controller.GetType(), urlType, httpMethod);
            if (methodInfo == null) return null;

            // Fix up the "action" name to be the Url type name (minus the "Url" suffix).
            // This makes for decent View names e.g. AuthorUrl => controller=Book, action=Author => /Views/Book/Author.aspx
            controllerContext.RouteData.Values["action"] = urlType.Name.Substring(0, urlType.Name.Length - 3);

            return new ReflectedActionDescriptor(methodInfo, httpMethod, controllerDescriptor);
        }

 protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
 {
     var action = base.FindAction(controllerContext, controllerDescriptor, actionName);
     if (action == null)
     {
         var citkaAction = Bootstrapper.ResolveCommonAction(actionName, MvcApplication.Container);
         if (citkaAction != null)
         {
             citkaAction.SetActionName(actionName);
             citkaAction.SetControllerDescriptor(controllerDescriptor);
             action = citkaAction;
         }
     }
     return action;
 }