Ich bin nicht sicher, was ich vermisse, kann aber meine CORS-Richtlinie anscheinend nicht mit .NET Core 3.1 und Angular 8 clientseitig zum Laufen bringen.

Startup.cs::

        public void ConfigureServices(IServiceCollection services)
        {
            // ...

            // Add CORS policy
            services.AddCors(options =>
            {
                options.AddPolicy("foo",
                builder =>
                {
                    // Not a permanent solution, but just trying to isolate the problem
                    builder.AllowAnyOrigin().AllowAnyMethod().AllowAnyHeader();
                });
            });

            services.AddControllers();
        }

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

            app.UseHttpsRedirection();

            // Use the CORS policy
            app.UseCors("foo");

            app.UseRouting();

            app.UseAuthorization();

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

Fehlermeldung Clientseitig:

Access to XMLHttpRequest at 'https://localhost:8082/api/auth/' from origin 'http://localhost:4200' has been blocked by CORS policy: No 'Access-Control-Allow-Origin' header is present on the requested resource.

AKTUALISIEREN:

Obwohl ich war CORS falsch (und die akzeptierte Antwort unten in der Tat helfen mit , dass) die Wurzel Problem Konfiguration war in keinem Zusammenhang. Für zusätzlichen Kontext funktionierte die App einwandfrei, wenn die API und die Angular-App über die CLI ausgeführt wurden. Dieses Problem trat erst auf, nachdem beide auf einem Webserver bereitgestellt wurden.

Das "eigentliche" Problem hing schließlich mit der SQL-Verbindung zusammen, die ich erst entdeckte, nachdem ich der API eine Flatfile-Fehlerprotokollierung hinzugefügt und einen SQL Server-Trace ausgeführt hatte, um festzustellen, dass die App überhaupt keine Verbindung zu SQL herstellen konnte.

Normalerweise würde ich erwarten, dass dies nur eine 500 zurückgibt, und ich hätte das Problem innerhalb von 10 Sekunden erkannt. Die falsche Konfiguration von CORS bedeutete jedoch, dass eine 500 nie zurückgegeben wurde, da die CORS-Middleware zuerst fehlschlug. Das war, gelinde gesagt, immens frustrierend! . Ich möchte dies jedoch hier hinzufügen, falls sich andere in dieser Situation befinden, da ich "das falsche Kaninchen gejagt" habe, wenn Sie so wollen. Nachdem ich die CORS-Konfiguration korrigiert hatte, stellte ich fest, dass das eigentliche Problem völlig unabhängig von CORS war.

TL; DR; - Manchmal können serverseitige .NET-Fehler "Nicht-CORS" als CORS-Fehler zurückgegeben werden, wenn die CORS-Richtlinien nicht richtig festgelegt wurden

Verweise:

https://docs.microsoft.com/en-us/aspnet/core/security/cors?view=aspnetcore-3.1#cors-with-named-policy-and-middleware

https://medium.com/swlh/cors-headers-with-dot-net-core-3-5c9dfc664785

zuerst app.UseRouting();dannapp.UseCors("foo");

Ändern Sie Ihre ConfigureMethode wie folgt:

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

    app.UseHttpsRedirection();



    app.UseRouting();  // first
    // Use the CORS policy
    app.UseCors("foo"); // second

    app.UseAuthorization();

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

Es hat bei mir funktioniert!

Web-API verwendet app.UseHttpsRedirection(); Dies führt zu CORSProblemen, wenn der anfordernde Client nicht httpsbasiert. Um es mit dem httpClient zu verwenden, müssen wir diese Zeile kommentieren oder entfernen.

Dieses Problem tritt nicht auf CORS, das https verursacht dieses Problem, aber der ausgelöste Fehler besagt, dass es sich um CORS handelt.

Versuchen Sie dieses util

https://www.nuget.org/packages/Microsoft.AspNetCore.Cors/ Mit dieser Option können Sie die Cors in Ihrer .net-Kernanwendung aktivieren / deaktivieren

Wenn Sie localhost as verwenden http://localhost:4200, versuchen Sie, es in Ihrer Konfiguration festzulegen:

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options => options.AddPolicy("ApiCorsPolicy", build =>
    {                
        build.WithOrigins("http://localhost:4200")
             .AllowAnyMethod()
             .AllowAnyHeader();
        }));
        // ... other code is omitted for the brevity
     }
}

Und ConfigureMethode:

public void Configure(IApplicationBuilder app, IHostingEnvironment env, IServiceProvider provider)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    app.UseCors("ApiCorsPolicy");
    app.UseHttpsRedirection();
    app.UseAuthentication();
    app.UseMvc();
}

Wenn die Cors Service - Zugabe sicher zu schließen , .SetIsOriginAllowed((host) => true)nachdem.WithOrigins("http://localhost:4200")

services.AddCors(options => {
            options.AddPolicy("mypolicy",builder => builder
            .WithOrigins("http://localhost:4200/")
            .SetIsOriginAllowed((host) => true)
            .AllowAnyMethod()
            .AllowAnyHeader());
  });

FÜR .NET CORE 3.1

Der beste Weg ist, den Ursprungspfad in der Datei app.settings zu speichern

"Origins": {
    "Server": "http://localhost:5001/",
    "Client": "http://localhost:4200/",
    "CorsOrigins": "http://localhost:4200,http://localhost:5001"
}

und in ConfigureServicesMethode definieren Ursprünge aus Konfigurationsabschnitt

services.AddCors(
            options => options.AddPolicy(
                PolicyNames.AllowOrigins,
                builder => builder
                    .WithOrigins(
                        Configuration["Origins:CorsOrigins"]
                            .Split(",", StringSplitOptions.RemoveEmptyEntries)
                            .Select(s => s.TrimEnd('/'))
                            .ToArray()
                    )
                    .AllowAnyHeader()
                    .AllowAnyMethod()
                    .AllowCredentials()
            )
        );

Verwenden Sie zum Schluss einfach cors in Configuremethod (egal in welcher Reihenfolge!)

app.UseCors(PolicyNames.AllowOrigins);     //Enable CORS!