如何将请求动态路由到特定的 controller 并使用原始请求路径作为参数进行操作

Question

I am unable to find any documentation/details on the format of the middleware endpoints pattern field. Or endpoints at all really. Only examples of common use case scenarios for routing.

What I'd like to do is accept a request like:

example.com/anything1/anything2

and send it forward to:

example.com/Home/Display?var1=anything1&var2=anything2

The browser should display the original request and not change.

My end goal is to return the home controller's layout with the view getting data from a database.

I've been throwing random data at it to see what breaks it but not successful at understanding what works.

pattern: "{custompath}/{custompage}");

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
    endpoints.MapControllerRoute(
        name: "notDefault",
        pattern: "{area:exists}/{controller=Content}/{action=Index}/{id?}");
});

This is the current default setup that works with my areas and controllers but I don't fully understand why either.

Update The migration article from asp.net core 2.2 to 3 says that "Endpoint Routing supports the same route pattern syntax and route pattern authoring features as IRouter". https://docs.microsoft.com/en-us/aspnet/core/migration/22-to-30?view=aspnetcore-3.0&tabs=visual-studio#mvc-service-registration

There are no links to the expected syntax but I've found some old articles that have information. While being helpful they are still incomplete and/or inaccurate. When applying the logic I have found bugs. This was the most informative. https://aspnetcore.readthedocs.io/en/stable/fundamentals/routing.html

Some routes work but break when I add others. For instance, this route based on the article above should only be accepted when someone types "Account" as the first parameter but instead when requesting with no paths or arguments it manipulates the request to include Account the next route's controller default. But then returns the last route as expected.

When requesting https://localhost:port

endpoints.MapControllerRoute(
    name: "account",
    pattern: "Account/{controller=Dashboard}/{action=Overview}",
    defaults: new { area = "Account" });
endpoints.MapControllerRoute(
    name: "manage",
    pattern: "Manage/{controller=Content}/{action=Index}",
    defaults: new { area = "Manage" });
endpoints.MapControllerRoute(
    name: "default",
    pattern: "",
    defaults: new { controller = "Content", action = "Display", path = "Public", page = "Index" });

it manipulates the request to https://localhost:port/Account/Content/ and with contents from https://localhost:port/Content/Display/

I was expecting that when I didn't type in Account or Manage it would fall through to the blank route and stop there. But it seems that after it gets there it does some other stuff. Half of what I want is accomplished lol.

Latest Update Currently, I have this working with minimal bugs. Conceptually when making these I imagined that the pattern was the structure that exists in my app (controller > action > param, which is backward from what I originally imagined. (that the pattern was what the user request is*)

    endpoints.MapControllerRoute(
                    name: "Public",
                    pattern: "{page}",
                    defaults: new { controller = "Content", action = "Display", path = "Public" });
                endpoints.MapControllerRoute(
                    name: "Default",
                    pattern: "{path=Public}/{page=Index}",
                    defaults: new { controller = "Content", action = "Display" });                
                endpoints.MapControllerRoute(
                    name: "Controllers",
                    pattern: "{controller}/{action}/{id?}");

notes:

"areaName:" adds the name in quotes to the request. "defaults:" manipulates the request. I was able to inject a controller and action.

The other thing to note is that these endpoints affect the generated routes for links that use asp-*

Answer 1

I don't think a document exists for the pattern syntax or format but I was able to get something working.

With the below code I was able to send a request like:

example.com/anything1/anything2

and it was forwarded to the controller "Home", action "Display" with anything1 and anything2 sent as arguments. And the user still sees the original request.

app.UseEndpoints(endpoints =>
{
     endpoints.MapControllerRoute(
           name: "default",
           pattern: "{path}/{page}",
           defaults: new {controller="Home", action="Display", path="", page="" }); 
});

Additionally, adding text in the quotes of path and page will allow for default values to be sent if nothing is requested. I originally wrote middleware to handle writing the entire response but had to generate razor pages which ran much slower. This allows me to use the shared layouts which is what I wanted to start.

Note: The .net-core documentation on routing namespaces is limited to common use cases and method signatures which is rather useless because the default site templates start with that code. An old article for mvc routing is what made me think to try the code above but still have no idea what's going on in the background.