剖析ASP.NET Core(Part 4)- 调用MVC中间件(译)

时间:2022-08-28 15:17:48

原文:https://www.stevejgordon.co.uk/invoking-mvc-middleware-asp-net-core-anatomy-part-4 
发布于:2017年5月
环境:ASP.NET Core 1.1

本系列前三篇文章我们研究了AddMvcCore,AddMvc和UseMvc作为程序启动的一部分所发生的事情。一旦MVC服务和中间件注册到我们的ASP.NET Core应用程序中,MVC就可以开始处理HTTP请求。

本文我想介绍当一个请求流入MVC中间件时所发生的初始步骤。这是一个相当复杂的领域,要分开来叙述。我将它拆分成我认为合理的流程代码,忽略某些行为分支和细节,让本文容易理解。一些我忽略的实现细节我会重点指出,并在以后的文章中论述。

和先前一样,我使用原始的基于project.json(1.1.2)的MVC源码,因为我还没有找到一种可靠的方法来调试MVC源码,尤其是包含其他组件如路由。

好了让我们开始,看看MVC如何通过一个有效路由来匹配一个请求,并且最终执行一个可处理请求的动作(action)。快速回顾一下, ASP.NET Core程序在Startup.cs文件中配置了中间件管道(middleware pipeline),它定义了请求处理的流程。每个中间件将被按照一定顺序调用,直到某个中间件确定能提供适当的响应。

MvcSandbox项目的配置方法如下:

public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
{
app.UseDeveloperExceptionPage();
app.UseStaticFiles();
loggerFactory.AddConsole();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}

假设之前的中间件(UseDeveloperExceptionPage,UseStaticFiles)都没有处理请求,我们通过调用UseMvc来到达MVC管道和中间件。一旦请求到达MVC管道,我们碰到的中间件就是 RouterMiddleware。它的调用方法如下:

public async Task Invoke(HttpContext httpContext)
{
var context = new RouteContext(httpContext);
context.RouteData.Routers.Add(_router); await _router.RouteAsync(context); if (context.Handler == null)
{
_logger.RequestDidNotMatchRoutes();
await _next.Invoke(httpContext);
}
else
{
httpContext.Features[typeof(IRoutingFeature)] = new RoutingFeature()
{
RouteData = context.RouteData,
}; await context.Handler(context.HttpContext);
}
}

Invoke所做的第一件事是将当前的HttpContext对象传递给构造函数,构造一个新的RouteContext。

public RouteContext(HttpContext httpContext)
{
HttpContext = httpContext;
RouteData = new RouteData();
}

HttpContext作为参数传递给RouteContext,然后生成一个新的RouteData实例对象。

返回Invoke方法,注入的IRouter(本例是在UseMvc设置期间创建的RouteCollection)被添加到RouteContext.RouteData对象上的IRouter对象列表中。值得强调的是RouteData对象为其集合使用了延迟初始化模式,只有在它们被调用是才分配它们。这种模式体现了在如ASP.NET Core等大型框架中必须考虑的性能。

例如,下面是Routers如何定义属性:

public IList<IRouter> Routers
{
get
{
if (_routers == null)
{
_routers = new List<IRouter>();
} return _routers;
}
}

第一次访问该属性时,一个新的List将分配和存储到一个内部字段。

返回Invoke方法,在RouteCollection上调用RouteAsync:

public async virtual Task RouteAsync(RouteContext context)
{
// Perf: We want to avoid allocating a new RouteData for each route we need to process.
// We can do this by snapshotting the state at the beginning and then restoring it
// for each router we execute.
var snapshot = context.RouteData.PushState(null, values: null, dataTokens: null); for (var i = ; i < Count; i++)
{
var route = this[i];
context.RouteData.Routers.Add(route); try
{
await route.RouteAsync(context); if (context.Handler != null)
{
break;
}
}
finally
{
if (context.Handler == null)
{
snapshot.Restore();
}
}
}
}

首先RouteAsync通过RouteCollection创建一个RouteDataSnapshot。如注释所示,不是每次路由处理都会分配一个RouteData对象。为避免这种情况,RouteData对象的快照会被创建一次,并允许每次迭代时重置它。这是ASP.NET Core团队对性能考虑的另一个例子。

snapshot通过调用RouteData类中的PushState实现:

public RouteDataSnapshot PushState(IRouter router, RouteValueDictionary values, RouteValueDictionary dataTokens)
{
// Perf: this is optimized for small list sizes, in particular to avoid overhead of a native call in
// Array.CopyTo inside the List(IEnumerable<T>) constructor.
List<IRouter> routers = null;
var count = _routers?.Count;
if (count > )
{
routers = new List<IRouter>(count.Value);
for (var i = ; i < count.Value; i++)
{
routers.Add(_routers[i]);
}
} var snapshot = new RouteDataSnapshot(
this,
_dataTokens?.Count > ? new RouteValueDictionary(_dataTokens) : null,
routers,
_values?.Count > ? new RouteValueDictionary(_values) : null); if (router != null)
{
Routers.Add(router);
} if (values != null)
{
foreach (var kvp in values)
{
if (kvp.Value != null)
{
Values[kvp.Key] = kvp.Value;
}
}
} if (dataTokens != null)
{
foreach (var kvp in dataTokens)
{
DataTokens[kvp.Key] = kvp.Value;
}
} return snapshot;
}

首先创建一个List<IRoute>。为了尽可能的保持性能,只有在包含RouteData路由器的私有字段(_routers)中至少有一个IRouter时,才会分配一个列表。如果是这样,将使用正确的大小(特定大小)来创建一个新的列表,避免内部Array.CopyTo调用时改变底层数组的大小。从本质上讲,这个方法现在有一个复制的RouteData的内部IRouter列表实例。

接下来 RouteDataSnapshot对象被创建。RouteDataSnapshot定义为结构体(struct)。它的构造函数签名如下所示:

public RouteDataSnapshot(
RouteData routeData,
RouteValueDictionary dataTokens,
IList<IRouter> routers,
RouteValueDictionary values)

RouteCollection为所有参数调用PushState,其值为空值。在使用非空IRoute参数调用PushState方法的情况下,它会被添加到路由器列表中。值和DataTokens以相同的方式处理。如果PushState参数中包含任何参数,则会更新RouteData上的Values和DataTokens属性中的相应项。

最后,snapshot返回到RouteCollection中的RouteAsync。

接下来一个for循环开始,直到达到属性数量值。 Count只是暴露了RouteCollection上的Routers(List <IRouter>)数量。

在循环内部,它首先通过值循环(value of the loop)获得一个route。如下:

public IRouter this[int index]
{
get { return _routes[index]; }
}

这只是从列表中返回特定索引的IRouter。在MvcSandbox示例中,索引为0的第一个IRouter是AttributeRoute。

在Try / Finally块中,在IRouter(AttributeRoute)上调用RouteAsync方法。我们最终希望找到一个匹配路由数据(route data)的合适的Handler(RequestDelegate)。

我们将在后面的文章中深入研究AttributeRoute.RouteAsync方法内部发生的事情,因为在那里发生了很多事情,目前我们还没有在MvcSandbox中定义任何AttributeRoutes。在我们的例子中,因为没有定义AttributeRoutes,所以Handler值保持为空。

在finally块内部,当Handler为空时,在RouteDataSnapshot上调用Restore方法。此方法将在创建快照时将RouteData对象恢复到其状态。由于RouteAsync方法在处理过程中可能已经修改了RouteData,因此可以确保我们回到对象的初始状态。

在MvcSandbox示例中,列表中的第二个IRouter是名为“default”的路由,它是Route的一个实例。这个类不覆盖基类上的RouteAsync方法,因此将调用RouteBase抽象类中的代码。

public virtual Task RouteAsync(RouteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
} EnsureMatcher();
EnsureLoggers(context.HttpContext); var requestPath = context.HttpContext.Request.Path; if (!_matcher.TryMatch(requestPath, context.RouteData.Values))
{
// If we got back a null value set, that means the URI did not match
return TaskCache.CompletedTask;
} // Perf: Avoid accessing dictionaries if you don't need to write to them, these dictionaries are all
// created lazily.
if (DataTokens.Count > )
{
MergeValues(context.RouteData.DataTokens, DataTokens);
} if (!RouteConstraintMatcher.Match(
Constraints,
context.RouteData.Values,
context.HttpContext,
this,
RouteDirection.IncomingRequest,
_constraintLogger))
{
return TaskCache.CompletedTask;
}
_logger.MatchedRoute(Name, ParsedTemplate.TemplateText); return OnRouteMatched(context);
}

首先调用私有方法EnsureMatcher,如下所示:

private void EnsureMatcher()
{
if (_matcher == null)
{
_matcher = new TemplateMatcher(ParsedTemplate, Defaults);
}
}

这个方法将实例化一个新的TemplateMatcher,传入两个参数。同样,这似乎是一个分配优化(allocation optimisation),只有在传递给构造函数的属性可用时,才会创建此对象。

如果你想知道这些属性设置在哪里,是发生在RouteBase类的构造函数内部。这个构造函数是在默认路由被调用时,由MvcSandbox启动类的配置方法调用UseMvc扩展方法中的MapRoute而创建的。

RouteBase.RouteAsync方法内部,下一步调用的是EnsureLoggers:

private void EnsureLoggers(HttpContext context)
{
if (_logger == null)
{
var factory = context.RequestServices.GetRequiredService<ILoggerFactory>();
_logger = factory.CreateLogger(typeof(RouteBase).FullName);
_constraintLogger = factory.CreateLogger(typeof(RouteConstraintMatcher).FullName);
}
}

此方法从RequestServices获取ILoggerFactory实例,并使用它来设置两个ILogger。第一个是RouteBase类本身,第二个将由RouteConstraintMatcher使用。

接下来它存储一个局部变量,该变量持有从HttpContext中获取的请求的路径。

再往下,调用TemplateMatcher中的TryMatch,传入请求路径以及任何路由数据。我们将在另一篇文章中深入分析TemplateMathcer内部。现在,假设TryMatch返回true,我们的例子中就是这种情况。如果不匹配(TryMatch返回false)将返回TaskCache.CompletedTask,只是将任务(Task)设置为完成。

再往下,如果有任何DataTokens(RouteValueDictionary对象)设置,则context.RouteData.DataTokens会按需更新。正如注释中提到的,只有在值被实际更新的时候才会这样做。RouteData中的属性DataTokens只是在其第一次被调用(lazily instantiated 延迟实例化)时创建。因此,在没有更新的值时调用它可能会冒险分配一个新的不需要的RouteValueDictionary。

在我们使用的MvcSandbox中,没有DataTokens,所以MergeValues不会被调用。但为了完整性,它的代码如下:

private static void MergeValues(RouteValueDictionary destination, RouteValueDictionary values)
{
foreach (var kvp in values)
{
// This will replace the original value for the specified key.
// Values from the matched route will take preference over previous
// data in the route context.
destination[kvp.Key] = kvp.Value;
}
}

当被调用时,它从RouteBase类的DataTokens参数中的RouteValueDictionary中循环任何值,并更新context.RouteData.DataTokens属性上匹配键的目标值。

接下来,返回RouteAsync方法,RouteConstraintMatcher.Match被调用。这个静态方法遍历任何传入的IRouteContaints,并确定它们是否全部满足条件。Route constraints允许使用附加的匹配规则。例如,路由参数可以被约束为仅使用整数。我们的示列中没有约束,因此返回true。我们将在另一篇文章中查看带有约束的URL。

ILoger的扩展方法MatchedRoute生成了一个logger项。这是一个有趣的模式,可以根据特定需求重复使用更复杂的日志消息格式。

这个类的代码:

internal static class TreeRouterLoggerExtensions
{
private static readonly Action<ILogger, string, string, Exception> _matchedRoute; static TreeRouterLoggerExtensions()
{
_matchedRoute = LoggerMessage.Define<string, string>(
LogLevel.Debug,
,
"Request successfully matched the route with name '{RouteName}' and template '{RouteTemplate}'.");
} public static void MatchedRoute(
this ILogger logger,
string routeName,
string routeTemplate)
{
_matchedRoute(logger, routeName, routeTemplate, null);
}
}

当TreeRouterLoggerExtensions类第一次被构造时定义了一个action代理,该代理定义了日志消息该如何格式化。

当MatchRoute扩展方法被调用时,将路由名和模板字符串作为参数传递。然后将它们传递给_matchedRoute动作(Action)。该动作使用提供的参数创建调试级别的日志项。在visual studio中调试时,你会看到它出现在输出(output)窗口中。

返回RouteAsync;OnRouteMatched方法被调用。这被定义为RouteBase上的一个抽象方法,所以实现来自继承类。在我们的例子中,它是Route类。OnRouteMatched的重写方法如下:

protected override Task OnRouteMatched(RouteContext context)
{
context.RouteData.Routers.Add(_target);
return _target.RouteAsync(context);
}

其名为_target的IRouter字段被添加到context.RouteData.Routers列表中。在这种情况下,它是MVC的默认处理程序MvcRouteHandler。

然后在MvcRouteHandler上调用RouteAsync方法。该方法的细节相当重要,所以我保留下来作为未来讨论的主题。总之,MvcRouteHandler.RouteAsync将尝试建立一个合适的处理请求的操作方法。有一件重要的事情要知道,当一个动作被发现时,RouteContext上的Handler属性是通过lambda表达式定义的。我们可以再次深入该代码,但总结一下,RequestDelegate是一个接受HttpContext并且可以处理请求的函数。

回到RouterMiddleware上的invoke方法,我们可能已经有一个MVC已确定的处理程序(handler)可以处理请求。如果没有,则调用_logger.RequestDidNotMatchRoutes()。这是我们前面探讨的logger扩展风格的另一个例子。他将添加一条调试信息,指示路由不匹配。在这种情况下,ASP.NET中间件管道中的下一个RequestDelegate被调用,因为MVC已经确定它不能处理请求。

在客户端web/api应用程序的常规配置中,在UseMvc之后不会再有任何中间件的定义。在这种情况下,但我们到达管道末端时,ASP.NET Core返回一个默认的404未找到的HTTP状态码响应。

在我们有一个可以处理请求路由的处理程序的情况下,我们将进入Invoke方法else块。

一个新的RoutingFeature被实例化并被添加到HttpContext的Features集合中。简单地说,features(特性)是ASP.NET Core的一个概念,它允许服务器定义接收请求的特征。这包括数据在整个请求生命周期中的流动。像RouterMiddleware这样的中间件可以添加/修改特征集合,并可以将其用作通过请求传递数据的机制。在我们的例子中,RouteContext中的RouteData作为IRoutingFeature定义的一部分添加,以便其他中间件和请求处理程序可以使用它。

然后该方法调用Handler RequestDelegate,它将最终通过适当的MVC动作(action)来处理请求。到此为止,本文就要结束了。接下来会发生什么,以及我跳过的项目将构成本系列的下一部分。

小结:

我们已经看到MVC是如何作为中间件管道的一部分被调用的。一旦调用,MVC RouterMiddleware确定MVC是否知道如何处理传入的请求路径和值。如果MVC有一个可用于处理请求中的路由和路由数据的动作,则使用此处理程序来处理请求并提供响应。