What are the differences between app.UseRouting() and app.UseEndPoints()?

As I'm trying to understand them, It seem like they are both used to route/map the request to a certain endpoint

UseRouting: Matches request to an endpoint.

UseEndpoints: Execute the matched endpoint.

It decouples the route matching and resolution functionality from the endpoint executing functionality, which until now was all bundled in with the MVC middleware.

> This makes the ASP.NET Core framework more flexible and allows other > middlewares to act between UseRouting and UseEndpoints. That allows > those middlewares to utilize the information from endpoint routing, > for example, the call to UseAuthentication must go after > UseRouting, so that route information is available for authentication decisions and before UseEndpoints so that users are > authenticated before accessing the endpoints.

Based dotnet core documentation:

╔══════════════════════════════════════════╦═══════════════════════════════════════╗
║             app.UseRouting()             ║          app.UseEndPoints()           ║
╠══════════════════════════════════════════╬═══════════════════════════════════════╣
║               Find Endpoint              ║           Execute Endpoint            ║
║                                          ║                                       ║
║  Adds route matching to the middleware   ║  Adds endpoint execution to the       ║
║  pipeline. This middleware looks at the  ║  middleware pipeline.                 ║
║  set of endpoints defined in the app,    ║  It runs the delegate associated      ║
║  and selects the best match based        ║  with the selected endpoint.          ║
║  on the request.                         ║                                       ║
║                                          ║                                       ║
╚══════════════════════════════════════════╩═══════════════════════════════════════╝

Based above table we should take care about some tips:

1. If the app calls UseStaticFiles, place UseStaticFiles before UseRouting.

2. it's important that you place the Authentication and Authorization middleware between UseRouting and UseEndPoints .

3. Any middleware that appears after the UseRouting() call will know which endpoint will run eventually.

4. Any middleware that appears before the UseRouting() call won't know which endpoint will run eventually.

First of all,you could have a look at their source code:

1.UseRouting

public static IApplicationBuilder UseRouting(this IApplicationBuilder builder)
    {
        if (builder == null)
        {
            throw new ArgumentNullException(nameof(builder));
        }

        VerifyRoutingServicesAreRegistered(builder);

        var endpointRouteBuilder = new DefaultEndpointRouteBuilder(builder);
        builder.Properties[EndpointRouteBuilder] = endpointRouteBuilder;

        return builder.UseMiddleware<EndpointRoutingMiddleware>(endpointRouteBuilder);
    }

2.UseEndPoint

public static IApplicationBuilder UseEndpoints(this IApplicationBuilder builder, Action<IEndpointRouteBuilder> configure)
    {
        if (builder == null)
        {
            throw new ArgumentNullException(nameof(builder));
        }

        if (configure == null)
        {
            throw new ArgumentNullException(nameof(configure));
        }

        VerifyRoutingServicesAreRegistered(builder);

        VerifyEndpointRoutingMiddlewareIsRegistered(builder, out var endpointRouteBuilder);

        configure(endpointRouteBuilder);

        // Yes, this mutates an IOptions. We're registering data sources in a global collection which
        // can be used for discovery of endpoints or URL generation.
        //
        // Each middleware gets its own collection of data sources, and all of those data sources also
        // get added to a global collection.
        var routeOptions = builder.ApplicationServices.GetRequiredService<IOptions<RouteOptions>>();
        foreach (var dataSource in endpointRouteBuilder.DataSources)
        {
            routeOptions.Value.EndpointDataSources.Add(dataSource);
        }

        return builder.UseMiddleware<EndpointMiddleware>();
    }

Then refer to https://stackoverflow.com/questions/56156657/no-overload-for-method-userouting-takes-1-arguments which explains the differences between them in detail.

> ASP.NET Core 3 uses a refined endpoint routing which will generally > give more control about routing within the application. Endpoint > routing works in two separate steps: > > In a first step, the requested route is matched agains the configured > routes to figure out what route is being accessed.

>In a final step, > the determined route is being evaluated and the respective middleware, > e.g. MVC, is called.

> The two steps are set up by app.UseRouting() and app.UseEndpoints(). The former will register the middleware that runs the logic to determine the route. The latter will then execute that route.

Also, refer to

https://asp.net-hacker.rocks/2019/08/12/aspnetcore30-look-into-startup.html https://aregcode.com/blog/2019/dotnetcore-understanding-aspnet-endpoint-routing/

UseRouting calculates what route should be used for a request URL path, but doesn't route at this point in the pipeline. UseRouting adds metadata that can be used by subsequent middleware.

UseEndpoints executes the Controller and corresponding handler.

Take a look at this helpful write-up: https://andrewlock.net/converting-a-terminal-middleware-to-endpoint-routing-in-aspnetcore-3/

app.UseRouting()

Marks the position in the middleware pipeline where a routing decision is made or where request is matched to endpoints. In Other words where the endpoint is selected.

app.UseEndPoints()

Marks the position in the middleware pipeline where the selected endpoint is executed. It Execute the endpoints.

app.UseRouting :

UseRouting adds route matching to the middleware pipeline. This middleware looks at the set of endpoints defined in the app, and selects the best match based on the request.

app.UseEndpoints :

UseEndpoints adds endpoint execution to the middleware pipeline. It runs the delegate associated with the selected endpoint.

An endpoint is something that can be:

1. Selected, by matching the URL and HTTP method.
2. Executed, by running the delegate.

Endpoints that can be matched and executed by the app are configured in UseEndpoints