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

他才是真正实现转化。