asp.net core mvc剖析：动作执行

紧跟上一篇文章。通过路由和动作匹配后，最终会得到跟当前请求最匹配的一个ActionDescriptor，然后通过IActionInvoker执行动作。

我们先来看一下IActionInvoker如何得到，代码如下：

context.Handler = (c) =>
            {
                var routeData = c.GetRouteData();
                //根据actiondescriptor实例化ActionContext对象
                var actionContext = new ActionContext(context.HttpContext, routeData, actionDescriptor);
                if (_actionContextAccessor != null)
                {
                    _actionContextAccessor.ActionContext = actionContext;
                }
                //创建IActionInvoker
                var invoker = _actionInvokerFactory.CreateInvoker(actionContext);
                if (invoker == null)
                {
                    throw new InvalidOperationException(
                        Resources.FormatActionInvokerFactory_CouldNotCreateInvoker(
                            actionDescriptor.DisplayName));
                }
                //执行invoker处理请求
                return invoker.InvokeAsync();
            };

　　从上面的代码可以看到，一个IActionInvoker是通过IActionInvokerFactory创建，框架里该接口实现类是ActionInvokerFactory，该类CreateInvoker方法实现代码如下：

public IActionInvoker CreateInvoker(ActionContext actionContext)
        {
            var context = new ActionInvokerProviderContext(actionContext);

            foreach (var provider in _actionInvokerProviders)
            {
                provider.OnProvidersExecuting(context);
            }

            for (var i = _actionInvokerProviders.Length - 1; i >= 0; i--)
            {
                _actionInvokerProviders[i].OnProvidersExecuted(context);
            }

            return context.Result;
        }

　　在方法中，首先实例化一个ActionInvokerProviderContext，然后调用IActionInvokerProvider来设置context.Result，context.Result就是一个IActionInvoker，所以我们跟踪下框架中IActionInvokerProvider实现类，来看看它里面是如何工作的。框架中的提供了一个实现类ControllerActionInvokerProvider，在OnProvidersExecuting方法中创建了IActionInvoker对象，代码如下：

public void OnProvidersExecuting(ActionInvokerProviderContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException(nameof(context));
            }

            var actionDescriptor = context.ActionContext.ActionDescriptor as ControllerActionDescriptor;

            if (actionDescriptor != null)
            {
                var controllerContext = new ControllerContext(context.ActionContext);
                // PERF: These are rarely going to be changed, so let's go copy-on-write.
                controllerContext.ValueProviderFactories = new CopyOnWriteList<IValueProviderFactory>(_valueProviderFactories);
                controllerContext.ModelState.MaxAllowedErrors = _maxModelValidationErrors;
                
                var cacheState = _controllerActionInvokerCache.GetState(controllerContext);

                context.Result = new ControllerActionInvoker(
                    _controllerFactory,
                    _argumentBinder,
                    _logger,
                    _diagnosticSource,
                    controllerContext,
                    cacheState.Filters,
                    cacheState.ActionMethodExecutor);
            }
        }

　　从上面的代码我们可以看到，最终就是实例化了一个ControllerActionInvoker对象，该类构造方法前几个参数不再介绍了，重点是最后两个参数，一个是IFilterMetadata[]，表示跟当前动作相关联的过滤器信息集合，一个是ObjectMethodExecutor，从名字上可以看出，这个就是控制器方法的执行器。而这两个参数来自cacheState，这个对象是通过调用_controllerActionInvokerCache.GetState(controllerContext)得到的，它是一个ControllerActionInvokerState结构体类型，定义如下：

 public struct ControllerActionInvokerState
        {
            public ControllerActionInvokerState(
                IFilterMetadata[] filters,
                ObjectMethodExecutor actionMethodExecutor)
            {
                Filters = filters;
                ActionMethodExecutor = actionMethodExecutor;
            }
            //动作过滤器集合
            public IFilterMetadata[] Filters { get; }
            //方法执行器
            public ObjectMethodExecutor ActionMethodExecutor { get; set; }
        }

　　cacheState创建的过程如下：

 public ControllerActionInvokerState GetState(ControllerContext controllerContext)
        {
            var cache = CurrentCache;
            var actionDescriptor = controllerContext.ActionDescriptor;

            IFilterMetadata[] filters;
            Entry cacheEntry;
            if (!cache.Entries.TryGetValue(actionDescriptor, out cacheEntry))
            {
                var filterFactoryResult = FilterFactory.GetAllFilters(_filterProviders, controllerContext);
                filters = filterFactoryResult.Filters;

                var executor = ObjectMethodExecutor.Create(
                    actionDescriptor.MethodInfo,
                    actionDescriptor.ControllerTypeInfo);

                cacheEntry = new Entry(filterFactoryResult.CacheableFilters, executor);
                cacheEntry = cache.Entries.GetOrAdd(actionDescriptor, cacheEntry);
            }
            else
            {
                // Filter instances from statically defined filter descriptors + from filter providers
                filters = FilterFactory.CreateUncachedFilters(_filterProviders, controllerContext, cacheEntry.FilterItems);
            }

            return new ControllerActionInvokerState(filters, cacheEntry.ActionMethodExecutor);
        }

　   主要看下第10行到第15行代码。首先通过FilterFactory获取到跟当前动作相关联的过滤器信息集合，然后通过ObjectMethodExecutor.Create创建一个ObjectMethodExecutor对象，创建好后进行缓存。

　　其实到这里我们已经知道IActionInvokder就是一个ControllerActionInvoker，然后调用该对象的InvokeAsync方法开始动作执行。最新版本实现采用了状态机（如果概念上错误，欢迎大家拍砖指正）的特点，执行时在不同状态之间进行切换，最终完成处理。而这部分工作就是在Next方法里实现的。方法真正执行实在State.ActionInside状态时执行，在此状态下通过调用InvokeActionMethodAsync完成控制器方法的执行，主要代码如下：

                //下面的代码就是根据方法返回值类型不同，实现不同的逻辑
                var returnType = executor.MethodReturnType;
                if (returnType == typeof(void))
                {
                    executor.Execute(controller, orderedArguments);
                    result = new EmptyResult();
                }
                else if (returnType == typeof(Task))
                {
                    await (Task)executor.Execute(controller, orderedArguments);
                    result = new EmptyResult();
                }
                else if (executor.TaskGenericType == typeof(IActionResult))
                {
                    result = await (Task<IActionResult>)executor.Execute(controller, orderedArguments);
                    if (result == null)
                    {
                        throw new InvalidOperationException(
                            Resources.FormatActionResult_ActionReturnValueCannotBeNull(typeof(IActionResult)));
                    }
                }
                else if (executor.IsTypeAssignableFromIActionResult)
                {
                    if (_executor.IsMethodAsync)
                    {
                        result = (IActionResult)await _executor.ExecuteAsync(controller, orderedArguments);
                    }
                    else
                    {
                        result = (IActionResult)_executor.Execute(controller, orderedArguments);
                    }

                    if (result == null)
                    {
                        throw new InvalidOperationException(
                            Resources.FormatActionResult_ActionReturnValueCannotBeNull(_executor.TaskGenericType ?? returnType));
                    }
                }
                else if (!executor.IsMethodAsync)
                {
                    var resultAsObject = executor.Execute(controller, orderedArguments);
                    result = resultAsObject as IActionResult ?? new ObjectResult(resultAsObject)
                    {
                        DeclaredType = returnType,
                    };
                }
                else if (executor.TaskGenericType != null)
                {
                    var resultAsObject = await executor.ExecuteAsync(controller, orderedArguments);
                    result = resultAsObject as IActionResult ?? new ObjectResult(resultAsObject)
                    {
                        DeclaredType = executor.TaskGenericType,
                    };
                }
                else
                {
                    // This will be the case for types which have derived from Task and Task<T> or non Task types.
                    throw new InvalidOperationException(Resources.FormatActionExecutor_UnexpectedTaskInstance(
                        executor.MethodInfo.Name,
                        executor.MethodInfo.DeclaringType));
                }

                _result = result;
             
            

        }

　　无论是哪种返回值类型，都是通过调用executor.Execute完成控制器方法调用，并获取结果，executor就是上面提到的ObjectMethodExecutor，我们只看下Execute方法实现：

public object Execute(object target, object[] parameters)
        {
            return _executor(target, parameters);
        }

　　这里面又是一个_executor，它是一个delegate object ActionExecutor(object target, object[] parameters)委托类型，它是在实例化ObjectMethodInvoker时通过GetExecutor方法创建的，采用的是动态lambda表达式，有了这个委托对象，就可以执行控制器方法了。

    方法执行后，会得到方法返回结果，然后进入Result相关状态流程，直到State.ResultInside状态时，调用InvokeResultAsync方法执行动作结果，具体代码如下：

protected async Task InvokeResultAsync(IActionResult result)
        {
            var actionContext = _actionContext;

            _diagnosticSource.BeforeActionResult(actionContext, result);

            try
            {
                await result.ExecuteResultAsync(actionContext);
            }
            finally
            {
                _diagnosticSource.AfterActionResult(actionContext, result);
            }
        }

　　到这里一个控制器动作就算执行完了，需要指出的是文章只介绍了主体流程，还有很多其他执行状态文章中没提到。