Asp.net web Api源码分析-Action的执行

紧接着上文Asp.net web Api源码分析-HttpParameterBinding我们已经把Action调用的参数准备好了，现在就该开始调用Action了，这里的InvokeActionWithActionFilters（ApiController的ExecuteAsync方法）主要就是负责调用ActionFilters和Action的，这里的调用模式和mvc中的调用方式一致。这里filiter的调用就不多说，我们来看看Action的调用

controllerServices.GetActionInvoker().InvokeActionAsync(actionContext, cancellationToken);

在DefaultServices中有如下代码 SetSingle<IHttpActionInvoker>(new ApiControllerActionInvoker());所以我们知道实际调用Action是在ApiControllerActionInvoker的InvokeActionAsync方法。ApiControllerActionInvoker的InvokeActionAsync方法主要就一句

  return actionDescriptor.ExecuteAsync(controllerContext,actionContext.ActionArguments, cancellationToken)
                                       .Then(value => actionDescriptor.ResultConverter.Convert(controllerContext, value), cancellationToken);

这里的actionContext.ActionArguments是一个字典数据，key是参数名称，value参数值。

我们知道actionDescriptor这里是一个ReflectedHttpActionDescriptor实例，其ExecuteAsync方法主要代码实现如下：

  public override Task<object> ExecuteAsync(HttpControllerContext controllerContext, IDictionary<string, object> arguments, CancellationToken cancellationToken)
        {
            return TaskHelpers.RunSynchronously(() =>
            {
                object[] argumentValues = PrepareParameters(arguments, controllerContext);
                return _actionExecutor.Value.Execute(controllerContext.Controller, argumentValues);
            }, cancellationToken);
        }

其中PrepareParameters方法主要是取出Action方法所需参数的值，并且还要做一些检查，PrepareParameters实现如下：

 private object[] PrepareParameters(IDictionary<string, object> parameters, HttpControllerContext controllerContext)
        {
            // This is on a hotpath, so a quick check to avoid the allocation if we have no parameters.
            if (_parameters.Value.Count == 0)
            {
                return _empty;
            }

            ParameterInfo[] parameterInfos = MethodInfo.GetParameters();
            int parameterCount = parameterInfos.Length;
            object[] parameterValues = new object[parameterCount];
            for (int parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++)
            {
                parameterValues[parameterIndex] = ExtractParameterFromDictionary(parameterInfos[parameterIndex], parameters, controllerContext);
            }
            return parameterValues;
        }
其中ExtractParameterFromDictionary是真正取值的实现，直接调用parameters.TryGetValue(parameterInfo.Name, out value)来取值，如果参数不存在抛出异常，如果值为null，而参数类型又不允许为null抛出异常，如果值不为null，值与参数类型不匹配抛出异常，mvc中也有类似的检查。
这里的_actionExecutor.Value是个什么东东了，实际上是一个ActionExecutor实例，ActionExecutor的主要实现如下：

   private sealed class ActionExecutor        {            private readonly Func<object, object[], Task<object>> _executor; public ActionExecutor(MethodInfo methodInfo)            {                Contract.Assert(methodInfo != null);                _executor = GetExecutor(methodInfo);            }            public Task<object> Execute(object instance, object[] arguments)            {                return _executor(instance, arguments);            }  private static Func<object, object[], Task<object>> GetExecutor(MethodInfo methodInfo)            {                // Parameters to executor                ParameterExpression instanceParameter = Expression.Parameter(typeof(object), "instance");                ParameterExpression parametersParameter = Expression.Parameter(typeof(object[]), "parameters");                // Build parameter list                List<Expression> parameters = new List<Expression>();                ParameterInfo[] paramInfos = methodInfo.GetParameters();                for (int i = 0; i < paramInfos.Length; i++)                {                    ParameterInfo paramInfo = paramInfos[i];                    BinaryExpression valueObj = Expression.ArrayIndex(parametersParameter, Expression.Constant(i));                    UnaryExpression valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);                    // valueCast is "(Ti) parameters[i]"                    parameters.Add(valueCast);                }                // Call method                UnaryExpression instanceCast = (!methodInfo.IsStatic) ? Expression.Convert(instanceParameter, methodInfo.ReflectedType) : null;                MethodCallExpression methodCall = methodCall = Expression.Call(instanceCast, methodInfo, parameters);                // methodCall is "((MethodInstanceType) instance).method((T0) parameters[0], (T1) parameters[1], ...)"                // Create function                if (methodCall.Type == typeof(void))                {                    // for: public void Action()                    Expression<Action<object, object[]>> lambda = Expression.Lambda<Action<object, object[]>>(methodCall, instanceParameter, parametersParameter);                    Action<object, object[]> voidExecutor = lambda.Compile();                    return (instance, methodParameters) =>                    {                        voidExecutor(instance, methodParameters);                        return TaskHelpers.NullResult();                    };                }                else                {                    // must coerce methodCall to match Func<object, object[], object> signature                    UnaryExpression castMethodCall = Expression.Convert(methodCall, typeof(object));                    Expression<Func<object, object[], object>> lambda = Expression.Lambda<Func<object, object[], object>>(castMethodCall, instanceParameter, parametersParameter);                    Func<object, object[], object> compiled = lambda.Compile();                    if (methodCall.Type == typeof(Task))                    {                        // for: public Task Action()                        return (instance, methodParameters) =>                        {                            Task r = (Task)compiled(instance, methodParameters);                            ThrowIfWrappedTaskInstance(methodInfo, r.GetType());                            return r.CastToObject();                        };                    }                    else if (typeof(Task).IsAssignableFrom(methodCall.Type))                    {                        // for: public Task<T> Action()                        // constructs: return (Task<object>)Convert<T>(((Task<T>)instance).method((T0) param[0], ...))                        Type taskValueType = TypeHelper.GetTaskInnerTypeOrNull(methodCall.Type);                        var compiledConversion = CompileGenericTaskConversionDelegate(taskValueType);                        return (instance, methodParameters) =>                        {                            object callResult = compiled(instance, methodParameters);                            Task<object> convertedResult = compiledConversion(callResult);                            return convertedResult;                        };                    }                    else                    {                        // for: public T Action()                        return (instance, methodParameters) =>                        {                            var result = compiled(instance, methodParameters);                            // Throw when the result of a method is Task. Asynchronous methods need to declare that they                            // return a Task.                            Task resultAsTask = result as Task;                            if (resultAsTask != null)                            {                                throw Error.InvalidOperation(SRResources.ActionExecutor_UnexpectedTaskInstance,                                    methodInfo.Name, methodInfo.DeclaringType.Name);                            }                            return TaskHelpers.FromResult(result);                        };                    }                }            }}

说白了就是用表达式树创建达表示调用我们的Action。到这里我们的Action就真正的执行了返回一个object，
现在我们回到ApiControllerActionInvoker的InvokeActionAsync方法中来， actionDescriptor.ResultConverter.Convert(controllerContext, value)把我们Action返回值转化为一个

HttpResponseMessage实例。

首先我们来看看HttpActionDescriptor的ResultConverter是如果定义的：

  public virtual IActionResultConverter ResultConverter
        {
            get
            {
                if (_converter == null)
                {
                    _converter = GetResultConverter(ReturnType);
                }
                return _converter;
            }
        }

这里ReturnType是我们Action的返回值类型。

 internal static IActionResultConverter GetResultConverter(Type type)
        {
            if (type != null && type.IsGenericParameter)
            {
                // This can happen if somebody declares an action method as:
                // public T Get<T>() { }
                throw Error.InvalidOperation(SRResources.HttpActionDescriptor_NoConverterForGenericParamterTypeExists, type);
            }

            if (type == null)
            {
                return _voidResultConverter;
            }
            else if (typeof(HttpResponseMessage).IsAssignableFrom(type))
            {
                return _responseMessageResultConverter;
            }
            else
            {
                Type valueConverterType = typeof(ValueResultConverter<>).MakeGenericType(type);
                return TypeActivator.Create<IActionResultConverter>(valueConverterType).Invoke();
            }
        }

一般情况下我们action的返回值都不是HttpResponseMessage类型，所以这里默认还回一个ValueResultConverter<T>实例，其中T就是我们Action的返回类型。这里就调用ValueResultConverter<T>的Convert方法把我们的Action返回值转化为HttpResponseMessage实例，在Convert中有一句

  return controllerContext.Request.CreateResponse<T>(HttpStatusCode.OK, value, controllerContext.Configuration);

他才是真正实现转化。