L'utilisation de 'UseMvc' pour configurer MVC n'est pas prise en charge lors de l'utilisation du routage de point final

J'avais un projet Asp.Net core 2.2.

Récemment, j'ai changé la version de .net core 2.2 à .net core 3.0 Preview 8. Après ce changement, je vois ce message d'avertissement:

l'utilisation de «UseMvc» pour configurer MVC n'est pas prise en charge lors de l'utilisation de Endpoint Routing. Pour continuer à utiliser «UseMvc», veuillez définir «MvcOptions.EnableEndpointRouting = false» dans «ConfigureServices».

Je comprends qu'en définissant EnableEndpointRoutingsur false, je peux résoudre le problème, mais j'ai besoin de savoir quelle est la bonne façon de le résoudre et pourquoi Endpoint Routing n'a pas besoin de UseMvc()fonction.

mais j'ai besoin de savoir quelle est la bonne façon de le résoudre

En général, vous devez utiliser à la EnableEndpointRoutingplace de UseMvc, et vous pouvez vous référer au code de démarrage du routage de mise à jour pour connaître les étapes détaillées à activer EnableEndpointRouting.

pourquoi Endpoint Routing n'a pas besoin de la fonction UseMvc ().

Car UseMvc, il utilise the IRouter-based logicet EnableEndpointRoutingutilise endpoint-based logic. Ils suivent une logique différente que l'on peut trouver ci-dessous:

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

Pour EnableEndpointRouting, il utilise EndpointMiddleware pour acheminer la demande vers les points de terminaison.

J'ai trouvé la solution, dans la documentation officielle suivante " Migrate from ASP.NET Core 2.2 to 3.0 ":

Il existe 3 approches:

1. Remplacez UseMvc ou UseSignalR par UseEndpoints.

Dans mon cas, le résultat ressemblait à ça

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

    }
}

OU
2. Utilisez AddControllers () et 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();
        });

    }
}

OU
3. Désactivez le routage des points de terminaison. Comme le suggère le message d'exception et comme mentionné dans la section suivante de la documentation: utilisez mvc sans routage de point de terminaison

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

Cela a fonctionné pour moi (ajoutez la Startup.csméthode ConfigureServices):

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

Le problème que j'ai trouvé était dû à des mises à jour sur le framework .NET Core. La dernière version publiée de .NET Core 3.0 nécessite une acceptation explicite pour l'utilisation de MVC.

Ce problème est le plus visible lorsque l'on essaie de migrer de l'ancienne .NET Core (version 2.2 ou préversion 3.0) vers .NET Core 3.0

Si vous migrez de la version 2.2 vers la version 3.0, veuillez utiliser le code ci-dessous pour résoudre le problème.

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

Si vous utilisez le modèle .NET Core 3.0,

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

Méthode ConfigServices après correction comme ci-dessous,

Merci

Pour DotNet Core 3.1

Utilisez ci-dessous

Fichier: Startup.cs public void Configure (application IApplicationBuilder, env IHostingEnvironment) {

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

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

Vous pouvez utiliser: dans la méthode ConfigureServices:

services.AddControllersWithViews();

Et pour la méthode Configure:

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

Cela a fonctionné pour moi sur .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();
    });
}

Utilisez le code ci-dessous

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