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?}");
    });
}

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

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

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

        return _routers;
    }
}

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

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

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

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

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

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

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

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

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

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