No se admite el uso de 'UseMvc' para configurar MVC mientras se usa Endpoint Routing

Tenía un proyecto Asp.Net core 2.2.

Recientemente, cambié la versión de .net core 2.2 a .net core 3.0 Preview 8. Después de este cambio, veo este mensaje de advertencia:

el uso de 'UseMvc' para configurar MVC no es compatible mientras se usa Endpoint Routing. Para continuar usando 'UseMvc', configure 'MvcOptions.EnableEndpointRouting = false' dentro de 'ConfigureServices'.

Entiendo que al establecer el valor EnableEndpointRoutingfalso puedo resolver el problema, pero necesito saber cuál es la forma correcta de resolverlo y por qué Endpoint Routing no necesita UseMvc()funcionar.

pero necesito saber cuál es la forma correcta de resolverlo

En general, debe usar en EnableEndpointRoutinglugar de UseMvc, y puede consultar Actualizar código de inicio de enrutamiento para conocer los pasos detallados para habilitar EnableEndpointRouting.

por qué Endpoint Routing no necesita la función UseMvc ().

Para UseMvc, usa the IRouter-based logicy EnableEndpointRoutingusa endpoint-based logic. Están siguiendo una lógica diferente que se puede encontrar a continuación:

if (options.Value.EnableEndpointRouting)
{
    var mvcEndpointDataSource = app.ApplicationServices
        .GetRequiredService<IEnumerable<EndpointDataSource>>()
        .OfType<MvcEndpointDataSource>()
        .First();
    var parameterPolicyFactory = app.ApplicationServices
        .GetRequiredService<ParameterPolicyFactory>();

    var endpointRouteBuilder = new EndpointRouteBuilder(app);

    configureRoutes(endpointRouteBuilder);

    foreach (var router in endpointRouteBuilder.Routes)
    {
        // Only accept Microsoft.AspNetCore.Routing.Route when converting to endpoint
        // Sub-types could have additional customization that we can't knowingly convert
        if (router is Route route && router.GetType() == typeof(Route))
        {
            var endpointInfo = new MvcEndpointInfo(
                route.Name,
                route.RouteTemplate,
                route.Defaults,
                route.Constraints.ToDictionary(kvp => kvp.Key, kvp => (object)kvp.Value),
                route.DataTokens,
                parameterPolicyFactory);

            mvcEndpointDataSource.ConventionalEndpointInfos.Add(endpointInfo);
        }
        else
        {
            throw new InvalidOperationException($"Cannot use '{router.GetType().FullName}' with Endpoint Routing.");
        }
    }

    if (!app.Properties.TryGetValue(EndpointRoutingRegisteredKey, out _))
    {
        // Matching middleware has not been registered yet
        // For back-compat register middleware so an endpoint is matched and then immediately used
        app.UseEndpointRouting();
    }

    return app.UseEndpoint();
}
else
{
    var routes = new RouteBuilder(app)
    {
        DefaultHandler = app.ApplicationServices.GetRequiredService<MvcRouteHandler>(),
    };

    configureRoutes(routes);

    routes.Routes.Insert(0, AttributeRouting.CreateAttributeMegaRoute(app.ApplicationServices));

    return app.UseRouter(routes.Build());
}

Para EnableEndpointRouting, utiliza EndpointMiddleware para enrutar la solicitud a los puntos finales.

Encontré la solución, en la siguiente documentación oficial " Migrar de ASP.NET Core 2.2 a 3.0 ":

Hay 3 enfoques:

1. Reemplace UseMvc o UseSignalR con UseEndpoints.

En mi caso, el resultado se veía así

  public class Startup
{

    public void ConfigureServices(IServiceCollection services)
    {
        //Old Way
        services.AddMvc();
        // New Ways
        //services.AddRazorPages();
    }


    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseStaticFiles();
        app.UseRouting();
        app.UseCors();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllerRoute("default", "{controller=Home}/{action=Index}");
        });

    }
}

O
2. Use AddControllers () y UseEndpoints ()

public class Startup
{

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllers();
    }


    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {
        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseStaticFiles();
        app.UseRouting();
        app.UseCors();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });

    }
}

O
3. Deshabilite el enrutamiento de punto final. Como sugiere el mensaje de excepción y como se menciona en la siguiente sección de documentación: use mvc sin enrutamiento de punto final

services.AddMvc(options => options.EnableEndpointRouting = false);
//OR
services.AddControllers(options => options.EnableEndpointRouting = false);

Esto funcionó para mí (agregar en Startup.cs> método ConfigureServices):

services.AddMvc (opción => opción.EnableEndpointRouting = false)

El problema que encontré se debe a las actualizaciones en el marco .NET Core. La última versión publicada de .NET Core 3.0 requiere una aceptación explícita para usar MVC.

Este problema es más visible cuando se intenta migrar de una versión anterior de .NET Core (2.2 o versión preliminar 3.0) a .NET Core 3.0

Si está migrando de 2.2 a 3.0, utilice el siguiente código para solucionar el problema.

services.AddMvc(options => options.EnableEndpointRouting = false);

Si usa la plantilla .NET Core 3.0,

services.AddControllers(options => options.EnableEndpointRouting = false);

Método ConfigServices después de arreglar como se muestra a continuación,

Gracias

Para DotNet Core 3.1

Utilizar a continuación

Archivo: Startup.cs public void Configure (aplicación IApplicationBuilder, entorno IHostingEnvironment) {

        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
        }

        app.UseHttpsRedirection();
        app.UseRouting();
        app.UseAuthentication();
        app.UseHttpsRedirection();
        app.UseEndpoints(endpoints =>
        {
            endpoints.MapControllers();
        });
    }

Puede utilizar: en el método ConfigureServices:

services.AddControllersWithViews();

Y para el método Configurar:

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

Esto funcionó para mí en .Net Core 3.1.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }

    app.UseRouting();

    app.UseAuthorization();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllers();
    });
}

Usar código a continuación

app.UseEndpoints(endpoints =>
            {
                endpoints.MapDefaultControllerRoute();
                endpoints.MapGet("/", async context =>
                {
                    await context.Response.WriteAsync("Hello World!");
                });
            });