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

原文：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 = 0; 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 > 0)
    {
        routers = new List<IRouter>(count.Value);
        for (var i = 0; i < count.Value; i++)
        {
            routers.Add(_routers[i]);
        }
    }

    var snapshot = new RouteDataSnapshot(
        this,
        _dataTokens?.Count > 0 ? new RouteValueDictionary(_dataTokens) : null, 
        routers,
        _values?.Count > 0 ? 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 > 0)
    {
        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,
            1,
            "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有一个可用于处理请求中的路由和路由数据的动作，则使用此处理程序来处理请求并提供响应。