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 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/

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.

Update .NET 6

In ASP.NET Core 6, there's no need to have explicit calls to UseRouting or UseEndpoints to register routes. UseRouting can still be used to specify where route matching happens, but UseRouting doesn't need to be explicitly called if routes should be matched at the beginning of the middleware pipeline.

Depending on where app.Use is called in the pipeline, there may not be an endpoint:

app.Use(async (context, next) =>
{
    

Console.WriteLine("Before routing runs, endpoint is always null here");
Console.WriteLine($"Endpoint: {context.GetEndpoint()?.DisplayName ?? "null"}");
await next(context);
});


app.UseRouting();


app.Use(async (context, next) =>
{
Console.WriteLine("After routing runs, endpoint will be non-null if routing found a match.");
Console.WriteLine($"Endpoint: {context.GetEndpoint()?.DisplayName ?? "null"}");
await next(context);
});


app.MapGet("/", (HttpContext context) =>
{
Console.WriteLine("Runs when this endpoint matches");
Console.WriteLine($"Endpoint: {context.GetEndpoint()?.DisplayName ?? "null"}");
return "Hello World!";
}).WithDisplayName("/");


app.UseEndpoints(_ => { });


app.Use(async (context, next) =>
{
Console.WriteLine("Runs after UseEndpoints - will only run if there was no match.");
Console.WriteLine($"Endpoint: {context.GetEndpoint()?.DisplayName ?? "null"}");
await next(context);
});

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.

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

• Any modification to the incoming request and data, that routing depends on, can be modified only before UseRouting.
• UseRouting will use the routing data to select appropriate, best-matching endpoint
• Any middleware, which comes after UseRouting and before UseEndpoints, can use endpoint information to apply some additional checks before the endpoint is executed. This might include checking CORS configurations, authentication and authorization checks, etc.
• UseEndpoints is a terminal middleware, provided the endpoint is existing in the application. This means any middleware after it would not be executed if the endpoint was found.
• Any middleware after UseEndpoints middleware would be executed only for those requests for which endpoints were not configured.

For Better Understanding: https://thecodeblogger.com/2021/05/27/asp-net-core-web-application-routing-and-endpoint-internals/