Async IRouteConstraint - IRouter.GetVirtualPath alternative in EndpointRouting?

[alienwareone]

There should be an async version of Microsoft.AspNetCore.Routing.IRouteConstraint.

Task<bool> MatchAsync(HttpContext httpContext, IRouter route, string routeKey, RouteValueDictionary values, RouteDirection routeDirection)
{
    return await dbContext.Products.Any(x => x.PageName == values[routeKey]);
}

[rynowak]

Route constraints have to run during URL generation which is synchronous, so it's not straightforward to add something like this. If you want to achieve the same effect, you could add a MatcherPolicy.

[alienwareone]

Thanks for your answer!

I guess I'll go with "DynamicRouteValueTransformer" to replace my custom IRouter implementation.

What is the "VirtualPathData GetVirtualPath(VirtualPathContext context)" alternative for complex url generation?

For example:

public override VirtualPathData GetVirtualPath(VirtualPathContext context)
{
  var routeContext = context["context"] as new ProductListRouteContext();
  var pathSegements = new List<string>();
  if (context?.Category?.PageName != null)
  {
    pathSegments.Add(context.Category.PageName);
  }
  // Add other pathSegements based on the context/filters...
  return new new VirtualPathData(this, string.Join("/", pathSegments));
}

In my view:

Url.RouteUrl("ProductList", new { context = Model.ProductListRouteContext });

[rynowak]

We don't have one right now. Depending on your scenario you might want to stick with old routing in 3.X.

If you want to provide more info about what you need to accomplish, I can make sure to include it in 5.0 plans.

[alienwareone]

Right now there seems no way to generate an Url based on a DynamicRouteValueTransformer-Route.

// Currently:
routeBuilder.MapDynamicControllerRoute<ProductListTransformer>(pattern: "search/{*path}");

// Should be:
routeBuilder.MapDynamicControllerRoute<ProductListTransformer>(routeName: "ProductList", pattern: "search/{*path}");

// View:
Url.RouteUrl("ProductList", new { path = GeneratePath(Model.Context) });
// e.g. "search/filter1/filter2"

[javiercn]

@alienwareone I think @rynowak is trying to ask for a use case so that he can understand if we need to add a feature here or if he can recommend an alternative way of achieving the same thing.

[alienwareone]

Here is the relevant code for my use case. Just ask me if anything is unclear. Thanks.

// Startup.cs:
app.UseMvc(routes =>
{
    routes.Routes.Add(new ProductListRoute(RouteName.ProductIndex, GetControllerName<ProductsController>(), nameof(ProductsController.Index), "products", routes.DefaultHandler));
    // Now you can use "ProductListRoute" wherever you need the "ProductListRouteContext":
    routes.Routes.Add(new ProductListRoute(RouteName.ProductSearchForm, GetControllerName<ProductsController>(), nameof(ProductsController.SearchForm), "products/searchform", routes.DefaultHandler));
});

public class ProductListRoute : INamedRouter
{
    public ProductListRoute(string name, string controller, string action, string pathPrefix, IRouter next)
    {
        Name = name;
        Next = next;
        Controller = controller;
        Action = action;
        PathPrefix = pathPrefix;
    }

    public string Name { get; }
    public string Controller { get; }
    public string Action { get; }
    public string PathPrefix { get; }
    public IRouter Next { get; }

    public async Task RouteAsync(RouteContext context)
    {
        var routeContext = new ProductListRouteContext();
        var pathSegements = context.Path.Split('/').Skip(1/*Skip PathPrefix*/).ToArray();
        var dbContext = context.RequestServices.GetRequiredService<AppDbContext>();
       
        foreach (var pathSegment in pathSegements)
        {
            var category = await dbContext.Categories.AnyAsync(x => x.PageName = pathSegement);
            if (category != null)
            {
                routeContext.Category = category;
                continue;
            }

            var location = await dbContext.Locations.AnyAsync(x => x.PageName = pathSegement);
            if (location != null)
            {
                routeContext.Location = category;
                continue;
            }
        }

        int page;
        if (int.TryParse(query["page"], out page))
        {
            routeContext.Page = page;
        }
        else
        {
            routeContext.Page = 1;
        }

        // Minimum one active filter required or in the "root" path:
        if (routeContext.CountActiveFilters() == 0 || !context.Path.StartsWithSegments(PathPrefix))
        {
            return;
        }

        context.RouteData.Values["controller"] = Controller;
        context.RouteData.Values["action"] = Action;
        context.RouteData.Values["context"] = routeContext;

        await Next.RouteAsync(context);
    }

    public VirtualPathData GetVirtualPath(VirtualPathContext context)
    {
        var routeContext = context.Values["context"] ?? new ProductListRouteContext();

        var pathSegments = new Dictionary<string, string>();
        var query = new Dictionary<string, string>();

        // Filters:
        if (routeContext.Category != null)
        {
            pathSegments["Category"] = routeContext.Category.PageName;
        }
        if (routeContext.Location != null)
        {
            pathSegments["Location"] = routeContext.Location.PageName;
        }

        if (routeContext.Page > 1)
        {
            query["page"] = routeContext.Page.ToString();
        }

        // Generic QueryString values:
        // e.g. Html.RouteUrl(RouteName.ProductIndex, new { context = new ProductListRouteContext { ... }, @ref = "navigation-link-clicked" }}
        foreach (var item in context.Values)
        {
            if (item.Key != "context")
            {
                query[item.Key] = Uri.EscapeDataString(item.Value?.ToString() ?? string.Empty);
            }
        }

        return string.Format("{0}/{1}?{2}",
            PathPrefix,
            string.Join("/", pathSegments.Values),
            string.Join("&", query.Select(x => $"{x.Key}={x.Value}")))
            .TrimEnd('?');
    }
}

public class ProductsController : Controller
{
    public async Task<IActionResult> Index(ProductListRouteContext context)
    {
        var viewModel = new ProductIndexViewModel
        {
            ProductListRoute = context,
            Categories = await _dbContext.Categories.ToList()
        };
        return View(viewModel);
    }

    public async Task<IActionResult> SearchForm(ProductListRouteContext context)
    {
        var viewModel = new SearchFormViewModel
        {
            ProductListRoute = context,
            Categories = await _dbContext.Categories.ToList(),
            Locations = await _dbContext.Locations.ToList()
        };
        return View(viewModel);
    }
}

// View example for Category filters in Products/Index.cshtml:
@foreach (var category in Model.Categories)
{
    <a href="@Html.RouteUrl(RouteName.ProductIndex, new { context = new ProductListRouteContext(copy: Model.CurrentProductListRouteContext) { Category = category } })">@category.Name</a>
}

// View example for paging in Products/Index.cshtml:
@for (var page = 1; page < Model.Pages; page++)
{
    <a href="@Html.RouteUrl(RouteName.ProductIndex, new { context = new ProductListRouteContext(copy: Model.CurrentProductListRouteContext) { Page = page } })">Page @page</a>
}

// View example for an external SearchForm where we need the current "ProductListRouteContext":
<a href="@Html.RouteUrl(RouteName.ProductSearchForm, new { context = new ProductListRouteContext(copy: Model.CurrentProductListRouteContext) })">Show Filters</a>