Die Verwendung von 'UseMvc' zum Konfigurieren von MVC wird bei Verwendung von Endpoint Routing nicht unterstützt

Ich hatte ein Asp.Net Core 2.2-Projekt.

Vor kurzem habe ich die Version von .net Core 2.2 auf .net Core 3.0 geändert. Vorschau 8. Nach dieser Änderung wird folgende Warnmeldung angezeigt:

Die Verwendung von 'UseMvc' zum Konfigurieren von MVC wird bei Verwendung von Endpoint Routing nicht unterstützt. Um 'UseMvc' weiterhin zu verwenden, setzen Sie bitte 'MvcOptions.EnableEndpointRouting = false' in 'ConfigureServices'.

Ich verstehe, dass EnableEndpointRoutingich das Problem durch Setzen auf false lösen kann, aber ich muss wissen, wie es richtig gelöst werden kann und warum Endpoint Routing keine UseMvc()Funktion benötigt .

aber ich muss wissen, wie ich es richtig lösen kann

Im Allgemeinen sollten Sie EnableEndpointRoutinganstelle von verwenden UseMvc, und Sie können den Startcode für das Routing des Updates für detaillierte Schritte zum Aktivieren verwenden EnableEndpointRouting.

Warum Endpoint Routing keine UseMvc () -Funktion benötigt.

Denn UseMvces benutzt the IRouter-based logicund EnableEndpointRoutingbenutzt endpoint-based logic. Sie folgen einer anderen Logik, die unten zu finden ist:

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

Zum Beispiel EnableEndpointRoutingwird EndpointMiddleware verwendet , um die Anforderung an die Endpunkte weiterzuleiten.

Ich fand die Lösung in der folgenden offiziellen Dokumentation " Von ASP.NET Core 2.2 auf 3.0 migrieren ":

Es gibt 3 Ansätze:

1. Ersetzen Sie UseMvc oder UseSignalR durch UseEndpoints.

In meinem Fall sah das Ergebnis so aus

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

    }
}

ODER
2. Verwenden Sie AddControllers () und 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();
        });

    }
}

ODER
3. Deaktivieren Sie das Endpunkt-Routing. Wie in der Ausnahmemeldung vorgeschlagen und im folgenden Abschnitt der Dokumentation erwähnt: Verwenden Sie mvc ohne Endpunktrouting

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

Dies hat bei mir funktioniert (hinzufügen Startup.cs> ConfigureServices-Methode):

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

Das Problem war auf Updates im .NET Core-Framework zurückzuführen. Die neueste veröffentlichte Version von .NET Core 3.0 erfordert eine explizite Anmeldung für die Verwendung von MVC.

Dieses Problem tritt am deutlichsten auf, wenn versucht wird, von älterem .NET Core (Version 2.2 oder Vorschau 3.0) auf .NET Core 3.0 zu migrieren

Verwenden Sie bei der Migration von 2.2 auf 3.0 den folgenden Code, um das Problem zu beheben.

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

Wenn Sie eine .NET Core 3.0-Vorlage verwenden,

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

ConfigServices-Methode nach dem Fix wie unten,

Danke

Für DotNet Core 3.1

Verwenden Sie unten

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

Sie können Folgendes verwenden: in der ConfigureServices-Methode:

services.AddControllersWithViews();

Und für die Konfigurationsmethode:

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

Dies funktionierte bei mir auf .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();
    });
}

Verwenden Sie den folgenden Code

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