L'utilizzo di "UseMvc" per configurare MVC non è supportato durante l'utilizzo di Endpoint Routing

Avevo un progetto Asp.Net core 2.2.

Recentemente, ho cambiato la versione da .net core 2.2 a .net core 3.0 Preview 8. Dopo questa modifica vedo questo messaggio di avviso:

l'utilizzo di "UseMvc" per configurare MVC non è supportato durante l'utilizzo di Endpoint Routing. Per continuare a utilizzare "UseMvc", impostare "MvcOptions.EnableEndpointRouting = false" all'interno di "ConfigureServices".

Capisco che impostando EnableEndpointRoutingfalse posso risolvere il problema, ma ho bisogno di sapere qual è il modo corretto per risolverlo e perché Endpoint Routing non necessita di UseMvc()funzionalità.

ma ho bisogno di sapere qual è il modo corretto per risolverlo

In generale, dovresti usare al EnableEndpointRoutingposto di UseMvce potresti fare riferimento al codice di avvio del routing di aggiornamento per i passaggi dettagliati da abilitare EnableEndpointRouting.

perché Endpoint Routing non necessita della funzione UseMvc ().

Per UseMvc, usa the IRouter-based logice EnableEndpointRoutingusa endpoint-based logic. Stanno seguendo una logica diversa che potrebbe essere trovata di seguito:

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());
}

Per EnableEndpointRouting, utilizza EndpointMiddleware per instradare la richiesta agli endpoint.

Ho trovato la soluzione, nella seguente documentazione ufficiale " Migrate from ASP.NET Core 2.2 to 3.0 ":

Ci sono 3 approcci:

1. Sostituisci UseMvc o UseSignalR con UseEndpoints.

Nel mio caso, il risultato sembrava quello

  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}");
        });

    }
}

OPPURE
2. Usa AddControllers () e 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();
        });

    }
}

OPPURE
3. Disabilitare il routing dell'endpoint. Come suggerisce il messaggio di eccezione e come menzionato nella seguente sezione della documentazione: utilizzare mvcwithout endpoint routing

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

Questo ha funzionato per me (aggiungi in Startup.cs> metodo ConfigureServices):

services.AddMvc (option => option.EnableEndpointRouting = false)

Il problema che ho riscontrato è dovuto agli aggiornamenti sul framework .NET Core. L'ultima versione rilasciata di .NET Core 3.0 richiede un consenso esplicito per l'utilizzo di MVC.

Questo problema è più visibile quando si tenta di eseguire la migrazione da .NET Core precedente (versione 2.2 o anteprima 3.0) a .NET Core 3.0

Se esegui la migrazione da 2.2 a 3.0, utilizza il codice seguente per risolvere il problema.

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

Se si utilizza il modello .NET Core 3.0,

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

Metodo ConfigServices dopo la correzione come di seguito,

Grazie

Per DotNet Core 3.1

Usa sotto

File: Startup.cs public void Configure (IApplicationBuilder app, IHostingEnvironment env) {

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

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

È possibile utilizzare: nel metodo ConfigureServices:

services.AddControllersWithViews();

E per il metodo Configure:

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

Questo ha funzionato per me su .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();
    });
}

Usa sotto il codice

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