Como habilitar o CORS no ASP.NET Core

Estou tentando habilitar o compartilhamento de recursos de origem cruzada na minha API da Web do ASP.NET Core, mas estou preso.

O EnableCorsatributo aceita policyNamedo tipo stringcomo parâmetro:

// 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);

O que policyNamesignifica e como posso configurar o CORS em uma API da Web do ASP.NET Core?

Você precisa configurar uma política do CORS na inicialização do aplicativo no ConfigureServicesmétodo:

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

    // ...
}

O CorsPolicyBuilderin builderpermite que você configure a política de acordo com suas necessidades. Agora você pode usar esse nome para aplicar a política a controladores e ações:

[EnableCors("MyPolicy")]

Ou aplique-o a cada solicitação:

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

Aplica-se ao .NET Core 1 e .Net Core 2 (mais abaixo)

Se estiver usando .Net-Core 1.1

Infelizmente, os documentos são muito confusos neste caso específico. Então, eu vou simplificar:

• Adicione Microsoft.AspNetCore.Corsum pacote nuget ao seu projeto
• No ConfigureServicesmétodo, adicioneservices.AddCors();

• No Configuremétodo, antes de chamar app.UseMvc()e app.UseStaticFiles(), adicione:

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

É isso aí. Todo cliente tem acesso ao seu site / API principal do ASP.NET.

Se estiver usando .Net-Core 2.0

• Adicione Microsoft.AspNetCore.Corsum pacote nuget ao seu projeto

• No ConfigureServicesmétodo, antes de chamar services.AddMvc(), adicione:

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

• (Importante) No Configuremétodo, antes de chamar app.UseMvc(), adicione app.UseCors("AllowAll");

  AllowAllé o nome da política que precisamos mencionar em app.UserCors. Pode ser qualquer nome.

Com base na resposta de Henk, consegui criar um domínio específico, o método que desejo permitir e também o cabeçalho que desejo ativar o CORS para:

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

uso:

[EnableCors("AllowSpecific")]

Especificamente no dotnet core 2.2 com SignalR, você deve alterar

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

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

em vez disso .AllowAnyOrigin()com.AllowCredentials()

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

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

Se você está hospedando no IIS, um possível motivo é que você está recebendo isso porque o IIS está bloqueando o OPTIONSverbo. Passei quase uma hora por causa disso:

Uma indicação reveladora é que você está recebendo 404erro durante a OPTIONSsolicitação.

Para corrigir isso, você precisa dizer explicitamente ao IIS para não bloquear a OPTIONSsolicitação.

Vá para Solicitar filtragem:

Verifique se OPTIONS é permitido:

Ou, basta criar um web.configcom a seguinte configuração:

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

Você precisa configurar na 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"));
        });            
    }

`

Trabalhei com o .Net Core 3.1 da seguinte maneira

1. Certifique-se de colocar o código UseCors entre app.UseRouting (); e app.UseAuthentication ();

        app.UseHttpsRedirection();

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

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

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

2.Em seguida, coloque esse código no método ConfigureServices

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

3.E acima do controlador base, coloquei este

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

Agora todos os meus controladores herdarão do BaseController e terão o CORS ativado

Etapa 1: precisamos do pacote Microsoft.AspNetCore.Cors em nosso projeto. Para instalar, vá em Ferramentas -> Gerenciador de Pacotes NuGet -> Gerenciar pacotes NuGet para solução. Procure Microsoft.AspNetCore.Cors e instale o pacote.

Etapa 2: precisamos injetar o CORS no contêiner para que ele possa ser usado pelo aplicativo. Na classe Startup.cs, vamos para o método ConfigureServices e registramos o CORS.

Portanto, em nosso aplicativo para servidor, vamos para Controllers -> HomeController.cs e adicione o decorador EnableCors ao método Index (ou seu controlador e ação específicos):

Para mais detalhes clique aqui

Toda a solução alternativa mencionada acima pode funcionar ou pode não funcionar, na maioria dos casos não funcionará. Eu dei a solução aqui

Atualmente, estou trabalhando em Angular e Web API (.net Core) e me deparei com o problema do CORS explicado abaixo

A solução fornecida acima sempre funcionará. Com a solicitação 'OPTIONS', é realmente necessário habilitar 'Autenticação Anônima'. Com a solução mencionada aqui, você não precisa executar todas as etapas mencionadas acima, como as configurações do IIS.

De qualquer forma, alguém marcou minha postagem acima como duplicada nesta postagem, mas posso ver que essa postagem é apenas para habilitar o CORS no ASP.net Core, mas minha postagem está relacionada a, Habilitando e implementando o CORS no ASP.net Core e Angular.