Come abilitare CORS in ASP.NET Core

Sto cercando di abilitare la condivisione delle risorse tra le origini sulla mia API Web ASP.NET Core, ma sono bloccato.

L' EnableCorsattributo accetta policyNamedi tipo stringcome parametro:

// Summary:
//     Creates a new instance of the Microsoft.AspNetCore.Cors.Core.EnableCorsAttribute.
//
// Parameters:
//   policyName:
//     The name of the policy to be applied.
public EnableCorsAttribute(string policyName);

Che cosa policyNamesignifica e come posso configurare CORS su un'API Web ASP.NET Core?

È necessario configurare un criterio CORS all'avvio dell'applicazione nel ConfigureServicesmetodo:

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
    {
        builder.AllowAnyOrigin()
               .AllowAnyMethod()
               .AllowAnyHeader();
    }));

    // ...
}

L' CorsPolicyBuilderin builderconsente di configurare la politica alle proprie esigenze. È ora possibile utilizzare questo nome per applicare la politica ai controller e alle azioni:

[EnableCors("MyPolicy")]

O applicalo a ogni richiesta:

public void Configure(IApplicationBuilder app)
{
    app.UseCors("MyPolicy");

    // ...

    // This should always be called last to ensure that
    // middleware is registered in the correct order.
    app.UseMvc();
}

Si applica a .NET Core 1 e .Net Core 2 (più in basso)

Se si utilizza .Net-Core 1.1

Purtroppo i documenti sono molto confusi in questo caso specifico. Quindi lo renderò estremamente semplice:

• Aggiungi il Microsoft.AspNetCore.Corspacchetto nuget al tuo progetto
• Nel ConfigureServicesmetodo, aggiungiservices.AddCors();

• Nel Configuremetodo, prima di chiamare app.UseMvc()e app.UseStaticFiles(), aggiungi:

  app.UseCors(builder => builder
      .AllowAnyOrigin()
      .AllowAnyMethod()
      .AllowAnyHeader()
      .AllowCredentials());

Questo è tutto. Ogni client ha accesso al tuo sito Web / API ASP.NET Core.

Se si utilizza .Net-Core 2.0

• Aggiungi il Microsoft.AspNetCore.Corspacchetto nuget al tuo progetto

• nel ConfigureServicesmetodo, prima di chiamare services.AddMvc(), aggiungi:

   services.AddCors(options =>
      {
          options.AddPolicy("AllowAll",
              builder =>
              {
                  builder
                  .AllowAnyOrigin() 
                  .AllowAnyMethod()
                  .AllowAnyHeader()
                  .AllowCredentials();
              });
      });

• (Importante) Nel Configuremetodo, prima di chiamare app.UseMvc(), aggiungere app.UseCors("AllowAll");

  AllowAllè il nome della politica che dobbiamo menzionare in app.UserCors. Potrebbe essere qualsiasi nome.

Sulla base della risposta di Henk sono stato in grado di trovare il dominio specifico, il metodo che voglio consentire e anche l'intestazione che voglio abilitare CORS per:

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
         options.AddPolicy("AllowSpecific", p => p.WithOrigins("http://localhost:1233")
                                                   .WithMethods("GET")
                                                   .WithHeaders("name")));
    services.AddMvc();
}

utilizzo:

[EnableCors("AllowSpecific")]

In particolare in dotnet core 2.2 con SignalR è necessario modificare

.WithOrigins("http://localhost:3000") o

.SetIsOriginAllowed(isOriginAllowed: _ => true) //for all origins

invece .AllowAnyOrigin()con.AllowCredentials()

https://trailheadtechnology.com/breaking-change-in-aspnetcore-2-2-for-signalr-and-cors/

https://github.com/aspnet/AspNetCore/issues/4483

Se stai ospitando su IIS, un possibile motivo è che stai ottenendo questo perché IIS sta bloccando il OPTIONSverbo. Ho trascorso quasi un'ora per questo:

Un'indicazione rivelatrice è che stai ricevendo un 404errore durante la OPTIONSrichiesta.

Per risolvere questo problema, è necessario indicare esplicitamente a IIS di non bloccare la OPTIONSrichiesta.

Vai a Filtro richieste:

Assicurarsi che le OPZIONI siano consentite:

Oppure, basta creare un web.configcon la seguente impostazione:

<system.webServer>
    <security>
        <requestFiltering>
            <verbs>
                <remove verb="OPTIONS" />
                <add verb="OPTIONS" allowed="true" />
            </verbs>
        </requestFiltering>
    </security>
</system.webServer>

Devi configurare nella classe Startup.cs

services.AddCors(options =>
        {
            options.AddPolicy("CorsPolicy",
                builder => builder.AllowAnyOrigin()
                .AllowAnyMethod()
                .AllowAnyHeader()
                .AllowCredentials());
        });

`

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors(options =>
        {
            options.AddPolicy("AllowAnyOrigin",
                builder => builder
                .AllowAnyOrigin()
                .AllowAnyMethod()
                .AllowAnyHeader());
        });

        services.Configure<MvcOptions>(options => {
            options.Filters.Add(new CorsAuthorizationFilterFactory("AllowAnyOrigin"));
        });            
    }

`

Ha funzionato con .Net Core 3.1 come segue

1.Assicurati di inserire il codice UseCors tra app.UseRouting (); e app.UseAuthentication ();

        app.UseHttpsRedirection();

        app.UseRouting();
        app.UseCors("CorsApi");

        app.UseAuthentication();
        app.UseAuthorization();

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

2. Quindi inserire questo codice nel metodo ConfigureServices

services.AddCors(options =>
        {
            options.AddPolicy("CorsApi",
                builder => builder.WithOrigins("http://localhost:4200", "http://mywebsite.com")
            .AllowAnyHeader()
            .AllowAnyMethod());
        });

3.E sopra il controller di base ho inserito questo

[EnableCors("CorsApi")]
[Route("api/[controller]")]
[ApiController]
public class BaseController : ControllerBase

Ora tutti i miei controller erediteranno dal BaseController e avranno CORS abilitato

Passaggio 1: abbiamo bisogno del pacchetto Microsoft.AspNetCore.Cors nel nostro progetto. Per l'installazione vai su Strumenti -> Gestione pacchetti NuGet -> Gestisci pacchetti NuGet per soluzione. Cerca Microsoft.AspNetCore.Cors e installa il pacchetto.

Passaggio 2: è necessario iniettare CORS nel contenitore in modo che possa essere utilizzato dall'applicazione. Nella classe Startup.cs, andiamo al metodo ConfigureServices e registriamo CORS.

Quindi, nella nostra app server, andiamo su Controller -> HomeController.cs e aggiungiamo il decoratore EnableCors al metodo Index (O il tuo controller e azione specifici):

Per maggiori dettagli clicca qui

Tutta la soluzione sopra menzionata potrebbe funzionare o non funzionare, nella maggior parte dei casi non funzionerà. Ho dato la soluzione qui

Attualmente sto lavorando su API angolare e Web (.net Core) e ho riscontrato il problema CORS spiegato di seguito

La soluzione fornita sopra funzionerà sempre. Con la richiesta 'OPZIONI' è davvero necessario abilitare 'Autenticazione anonima'. Con la soluzione menzionata qui non è necessario eseguire tutti i passaggi sopra menzionati, come le impostazioni IIS.

Comunque qualcuno ha contrassegnato il mio post sopra come duplicato con questo post, ma posso vedere che questo post è solo per abilitare CORS in ASP.net Core, ma il mio post è correlato, Abilitare e implementare CORS in ASP.net Core e Angolare.