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的主要实现如下：

+ View Code?

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

他才是真正实现转化。