Como habilitar o CORS no ASP.net Core WebAPI

O que estou tentando fazer

Eu tenho uma API Web ASP.Net Core de back-end hospedada em um Plano Gratuito do Azure (código-fonte: https://github.com/killerrin/Portfolio-Backend ).

Eu também tenho um site do cliente que eu quero fazer consumir essa API. O Aplicativo Cliente não será hospedado no Azure, mas sim nas Páginas do Github ou em outro Serviço de Hospedagem da Web ao qual tenho acesso. Por esse motivo, os nomes de domínio não se alinham.

Analisando isso, preciso habilitar o CORS no lado da API da Web, no entanto, tentei quase tudo por várias horas e agora ele se recusa a trabalhar.

Como eu tenho a configuração do cliente É apenas um cliente simples escrito em React.js. Estou chamando as APIs através do AJAX no Jquery. O site React funciona, então eu sei que não é isso. A chamada da API do Jquery funciona como eu confirmei na tentativa 1. Aqui está como eu faço as chamadas

    var apiUrl = "http://andrewgodfroyportfolioapi.azurewebsites.net/api/Authentication";
    //alert(username + "|" + password + "|" + apiUrl);
    $.ajax({
        url: apiUrl,
        type: "POST",
        data: {
            username: username,
            password: password
        },
        contentType: "application/json; charset=utf-8",
        dataType: "json",
        success: function (response) {
            var authenticatedUser = JSON.parse(response);
            //alert("Data Loaded: " + authenticatedUser);
            if (onComplete != null) {
                onComplete(authenticatedUser);
            }
        },
        error: function (xhr, status, error) {
            //alert(xhr.responseText);
            if (onComplete != null) {
                onComplete(xhr.responseText);
            }
        }
    });

O que eu tentei

Tentativa 1 - O caminho 'adequado'

https://docs.microsoft.com/en-us/aspnet/core/security/cors

Eu segui este tutorial no site da Microsoft até um T, tentando todas as 3 opções de ativá-lo globalmente no Startup.cs, configurando-o em todos os controladores e testando-o em todas as ações.

Seguindo esse método, o domínio cruzado funciona, mas apenas em uma única ação em um único controlador (POST para o AccountController). Para todo o resto, o Microsoft.AspNetCore.Corsmiddleware se recusa a definir os cabeçalhos.

Eu instalei Microsoft.AspNetCore.Corsatravés do NUGET e a versão é1.1.2

Aqui está como eu o configurei no Startup.cs

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        // Add Cors
        services.AddCors(o => o.AddPolicy("MyPolicy", builder =>
        {
            builder.AllowAnyOrigin()
                   .AllowAnyMethod()
                   .AllowAnyHeader();
        }));

        // Add framework services.
        services.AddMvc();
        services.Configure<MvcOptions>(options =>
        {
            options.Filters.Add(new CorsAuthorizationFilterFactory("MyPolicy"));
        });

        ...
        ...
        ...
    }

    // This method gets called by the runtime. Use this method to configure 
    //the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IHostingEnvironment env,
    ILoggerFactory loggerFactory)
    {
        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();

        // Enable Cors
        app.UseCors("MyPolicy");

        //app.UseMvcWithDefaultRoute();
        app.UseMvc();

        ...
        ...
        ...
    }

Como você pode ver, estou fazendo tudo o que foi dito. Eu adiciono Cors antes do MVC as duas vezes e, quando isso não funcionou, tentei colocar [EnableCors("MyPolicy")]todos os controladores assim

[Route("api/[controller]")]
[EnableCors("MyPolicy")]
public class AdminController : Controller

Tentativa 2 - Brute Forçando-o

https://andrewlock.net/adding-default-security-headers-in-asp-net-core/

Depois de várias horas tentando a tentativa anterior, imaginei que tentaria forçá-la tentando definir os cabeçalhos manualmente, forçando-os a executar todas as respostas. Fiz isso seguindo este tutorial sobre como adicionar cabeçalhos manualmente a todas as respostas.

Estes são os cabeçalhos que adicionei

.AddCustomHeader("Access-Control-Allow-Origin", "*")
.AddCustomHeader("Access-Control-Allow-Methods", "*")
.AddCustomHeader("Access-Control-Allow-Headers", "*")
.AddCustomHeader("Access-Control-Max-Age", "86400")

Estes são outros cabeçalhos que tentei que falharam

.AddCustomHeader("Access-Control-Allow-Methods", "GET, POST, PUT, PATCH, DELETE")
.AddCustomHeader("Access-Control-Allow-Headers", "content-type, accept, X-PINGOTHER")
.AddCustomHeader("Access-Control-Allow-Headers", "X-PINGOTHER, Host, User-Agent, Accept, Accept: application/json, application/json, Accept-Language, Accept-Encoding, Access-Control-Request-Method, Access-Control-Request-Headers, Origin, Connection, Content-Type, Content-Type: application/json, Authorization, Connection, Origin, Referer")

Com esse método, os cabeçalhos entre sites estão sendo aplicados corretamente e são exibidos no meu console do desenvolvedor e no Postman. O problema, no entanto, é que, enquanto passa na Access-Control-Allow-Originverificação, o navegador da web lança um chiado (acredito) Access-Control-Allow-Headersafirmando415 (Unsupported Media Type)

Portanto, o método da força bruta também não funciona

Finalmente

Alguém conseguiu que isso funcionasse e poderia dar uma mãozinha ou apenas ser capaz de me apontar na direção certa?

EDITAR

Portanto, para obter as chamadas da API, tive que parar de usar o JQuery e mudar para o XMLHttpRequestformato Javascript puro .

Tentativa 1

Eu consegui fazer o Microsoft.AspNetCore.Corstrabalho seguindo a resposta de MindingData, exceto dentro do Configuremétodo colocando o app.UseCorsantes app.UseMvc.

Além disso, quando combinado com a solução da API Javascript options.AllowAnyOrigin()para suporte a caracteres curinga começou a funcionar também.

Tentativa 2

Então, eu consegui fazer com que a Tentativa 2 (força bruta) funcione ... com a única exceção de que o curinga Access-Control-Allow-Originnão funciona e, como tal, tenho que definir manualmente os domínios que têm acesso a ela.

Obviamente, não é o ideal, pois eu só quero que essa WebAPI seja aberta a todos, mas pelo menos funciona para mim em um site separado, o que significa que é um começo

app.UseSecurityHeadersMiddleware(new SecurityHeadersBuilder()
    .AddDefaultSecurePolicy()
    .AddCustomHeader("Access-Control-Allow-Origin", "http://localhost:3000")
    .AddCustomHeader("Access-Control-Allow-Methods", "OPTIONS, GET, POST, PUT, PATCH, DELETE")
    .AddCustomHeader("Access-Control-Allow-Headers", "X-PINGOTHER, Content-Type, Authorization"));

Como você possui uma política CORS muito simples (Permitir todas as solicitações do domínio XXX), não é necessário torná-la tão complicada. Tente fazer o seguinte primeiro (uma implementação muito básica do CORS).

Se você ainda não o fez, instale o pacote de nuget CORS.

Install-Package Microsoft.AspNetCore.Cors

No método ConfigureServices do seu startup.cs, adicione os serviços CORS.

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(); // Make sure you call this previous to AddMvc
    services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
}

Em seguida, no método Configure do seu startup.cs, adicione o seguinte:

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
{
    // Make sure you call this before calling app.UseMvc()
    app.UseCors(
        options => options.WithOrigins("http://example.com").AllowAnyMethod()
    );

    app.UseMvc();
}

Agora tente. As políticas são para quando você deseja políticas diferentes para ações diferentes (por exemplo, hosts diferentes ou cabeçalhos diferentes). Para seu exemplo simples, você realmente não precisa dele. Comece com este exemplo simples e ajuste conforme necessário a partir daí.

Outras leituras: http://dotnetcoretutorials.com/2017/01/03/enabling-cors-asp-net-core/

• No ConfigureServices, adicione services.AddCors(); ANTES de services.AddMvc ();

• Adicionar UseCors no Configure

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

O ponto principal é que adicionar app.UseCorsantes app.UseMvc().

Certifique-se de declarar a funcionalidade CORS antes do MVC, para que o middleware seja acionado antes que o pipeline do MVC obtenha o controle e finalize a solicitação.

Depois que o método acima funciona, você pode alterá-lo, configurar uma ORIGIN específica para aceitar chamadas da API e evitar deixar sua API tão aberta para qualquer pessoa

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options => options.AddPolicy("ApiCorsPolicy", builder =>
    {
        builder.WithOrigins("http://localhost:4200").AllowAnyMethod().AllowAnyHeader();
    }));

    services.AddMvc();
}

No método configure, diga ao CORS para usar a política que você acabou de criar:

app.UseCors("ApiCorsPolicy");
app.UseMvc();

Acabei de encontrar este artigo compacto sobre o assunto - https://dzone.com/articles/cors-in-net-core-net-core-security-part-vi

Eu criei minha própria classe de middleware que funcionou para mim, acho que há algo errado com a classe de middleware .net core

public class CorsMiddleware
{
    private readonly RequestDelegate _next;

    public CorsMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public Task Invoke(HttpContext httpContext)
    {
        httpContext.Response.Headers.Add("Access-Control-Allow-Origin", "*");
        httpContext.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
        httpContext.Response.Headers.Add("Access-Control-Allow-Headers", "Content-Type, X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Content-Length, Content-MD5, Date, X-Api-Version, X-File-Name");
        httpContext.Response.Headers.Add("Access-Control-Allow-Methods", "POST,GET,PUT,PATCH,DELETE,OPTIONS");
        return _next(httpContext);
    }
}

// Extension method used to add the middleware to the HTTP request pipeline.
public static class CorsMiddlewareExtensions
{
    public static IApplicationBuilder UseCorsMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<CorsMiddleware>();
    }
}

e usado dessa maneira no startup.cs

app.UseCorsMiddleware();

No meu caso, apenas o getpedido funciona bem de acordo com a resposta do MindingData. Para outros tipos de solicitação, você precisa escrever:

app.UseCors(corsPolicyBuilder =>
   corsPolicyBuilder.WithOrigins("http://localhost:3000")
  .AllowAnyMethod()
  .AllowAnyHeader()
);

Não esqueça de adicionar .AllowAnyHeader()

Para expandir a user8266077 's resposta , eu descobri que eu ainda precisava de resposta opções de fornecimento de pedidos de pré-vôo em .NET Núcleo 2,1-visualização para o meu caso de uso:

// https://stackoverflow.com/a/45844400
public class CorsMiddleware
{
  private readonly RequestDelegate _next;

  public CorsMiddleware(RequestDelegate next)
  {
    _next = next;
  }

  public async Task Invoke(HttpContext context)
  {
    context.Response.Headers.Add("Access-Control-Allow-Origin", "*");
    context.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
    // Added "Accept-Encoding" to this list
    context.Response.Headers.Add("Access-Control-Allow-Headers", "Content-Type, X-CSRF-Token, X-Requested-With, Accept, Accept-Version, Accept-Encoding, Content-Length, Content-MD5, Date, X-Api-Version, X-File-Name");
    context.Response.Headers.Add("Access-Control-Allow-Methods", "POST,GET,PUT,PATCH,DELETE,OPTIONS");
    // New Code Starts here
    if (context.Request.Method == "OPTIONS")
    {
      context.Response.StatusCode = (int)HttpStatusCode.OK;
      await context.Response.WriteAsync(string.Empty);
    }
    // New Code Ends here

    await _next(context);
  }
}

e, em seguida, habilitou o middleware como em Startup.cs

public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
  app.UseMiddleware(typeof(CorsMiddleware));
  // ... other middleware inclusion such as ErrorHandling, Caching, etc
  app.UseMvc();
}

    public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {      
       app.UseCors(builder => builder
                .AllowAnyHeader()
                .AllowAnyMethod()
                .SetIsOriginAllowed((host) => true)
                .AllowCredentials()
            );
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddCors();
    }

Eu estava lutando com isso por dias.

Finalmente consegui trabalhar movendo app.UseCors(CORS_POLICY); para o TOPO de Configure().

https://weblog.west-wind.com/posts/2016/sep/26/aspnet-core-and-cors-gotchas

Certifique-se de declarar a funcionalidade CORS antes de> MVC, pois os cabeçalhos devem ser aplicados antes que o MVC conclua a solicitação.

<= Mesmo que meu aplicativo não tenha ligado UseMVC(), movendoUseCors() para o topo corrigiu o problema

Além disso:

• Microsoft.AspNetCore.Corscostumava ser um pacote NuGet necessário no .Net Core 2 e inferior; agora faz parte automaticamente do Microsoft.AspNetCore no .Net Core 3 e superior.
• builder.AllowAnyOrigin() e .AllowCredentials() CORS agora são mutuamente exclusivas no .Net Core 3 e superior
• A política do CORS parece exigir a chamada Angular ao servidor https. Um URL http parecia dar um erro CORS, independentemente da configuração CORS do servidor .Net Core. Por exemplo, http://localhost:52774/api/Contactsdaria um erro de CORS; simplesmente alterando o URL para https://localhost:44333/api/Contactsfuncionado.

Nota adicional :

No meu caso, o CORS não funcionaria até que eu me movesse app.UseCors()acima app.UseEndpoints(endpoints => endpoints.MapControllers()).

Nenhum dos procedimentos acima ajudou e li o artigo que resolveu o problema.

Abaixo está o código.

public void ConfigureServices(IServiceCollection services)
{
    // Add service and create Policy with options
    services.AddCors(options =>
    {
        options.AddPolicy("CorsPolicy",
            builder => builder.AllowAnyOrigin()
            .AllowAnyMethod()
            .AllowAnyHeader()
            .AllowCredentials() );
    });


    services.AddMvc(); 
}

e

public void Configure(IApplicationBuilder app)
{
    // ...

    // global policy - assign here or on each controller
    app.UseCors("CorsPolicy");

e no topo do meu método de ação

[EnableCors("CorsPolicy")]

tente adicionar jQuery.support.cors = true; antes da chamada do Ajax

Também pode ser que os dados que você está enviando para a API sejam instáveis,

tente adicionar a seguinte função JSON

        var JSON = JSON || {};

    // implement JSON.stringify serialization
    JSON.stringify = JSON.stringify || function (obj) {

        var t = typeof (obj);
        if (t != "object" || obj === null) {

            // simple data type
            if (t == "string") obj = '"' + obj + '"';
            return String(obj);

        }
        else {

            // recurse array or object
            var n, v, json = [], arr = (obj && obj.constructor == Array);

            for (n in obj) {
                v = obj[n]; t = typeof (v);

                if (t == "string") v = '"' + v + '"';
                else if (t == "object" && v !== null) v = JSON.stringify(v);

                json.push((arr ? "" : '"' + n + '":') + String(v));
            }

            return (arr ? "[" : "{") + String(json) + (arr ? "]" : "}");
        }
    };

    // implement JSON.parse de-serialization
    JSON.parse = JSON.parse || function (str) {
        if (str === "") str = '""';
        eval("var p=" + str + ";");
        return p;
    };

em seus dados: objeto, altere-o para

    data: JSON.stringify({
        username: username,
        password: password
    }),

A solução mais simples é adicionar

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

        app.UseCors(options => options.AllowAnyOrigin());

        app.UseHttpsRedirection();
        app.UseMvc();
    }

para Startup.cs.

Acho que se você usa seu próprio middleware CORS, precisa se certificar de que é realmente uma solicitação CORS , verificando o cabeçalho de origem .

 public class CorsMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    private readonly ILogger<CorsMiddleware> _logger;

    public CorsMiddleware(RequestDelegate next, IMemoryCache cache, ILogger<CorsMiddleware> logger)
    {
        _next = next;
        _cache = cache;
        _logger = logger;
    }
    public async Task InvokeAsync(HttpContext context, IAdministrationApi adminApi)
    {
        if (context.Request.Headers.ContainsKey(CorsConstants.Origin) || context.Request.Headers.ContainsKey("origin"))
        {
            if (!context.Request.Headers.TryGetValue(CorsConstants.Origin, out var origin))
            {
                context.Request.Headers.TryGetValue("origin", out origin);
            }

            bool isAllowed;
            // Getting origin from DB to check with one from request and save it in cache 
            var result = _cache.GetOrCreateAsync(origin, async cacheEntry => await adminApi.DoesExistAsync(origin));
            isAllowed = result.Result.Result;

            if (isAllowed)
            {
                context.Response.Headers.Add(CorsConstants.AccessControlAllowOrigin, origin);
                context.Response.Headers.Add(
                    CorsConstants.AccessControlAllowHeaders,
                    $"{HeaderNames.Authorization}, {HeaderNames.ContentType}, {HeaderNames.AcceptLanguage}, {HeaderNames.Accept}");
                context.Response.Headers.Add(CorsConstants.AccessControlAllowMethods, "POST, GET, PUT, PATCH, DELETE, OPTIONS");

                if (context.Request.Method == "OPTIONS")
                {
                    _logger.LogInformation("CORS with origin {Origin} was handled successfully", origin);
                    context.Response.StatusCode = (int)HttpStatusCode.NoContent;
                    return;
                }

                await _next(context);
            }
            else
            {
                if (context.Request.Method == "OPTIONS")
                {
                    _logger.LogInformation("Preflight CORS request with origin {Origin} was declined", origin);
                    context.Response.StatusCode = (int)HttpStatusCode.NoContent;
                    return;
                }

                _logger.LogInformation("Simple CORS request with origin {Origin} was declined", origin);
                context.Response.StatusCode = (int)HttpStatusCode.Forbidden;
                return;
            }
        }

        await _next(context);
    }

Com base no seu comentário na resposta do MindingData, isso não tem nada a ver com o seu CORS, está funcionando bem.

Sua ação do controlador está retornando os dados incorretos. HttpCode 415 significa "Tipo de mídia não suportado". Isso acontece quando você passa o formato errado para o controlador (ou seja, XML para um controlador que aceita apenas json) ou quando retorna um tipo errado (retorna Xml em um controlador declarado para retornar apenas xml).

Para mais tarde, verifique a existência do [Produces("...")]atributo em sua ação

Para mim, não tinha nada a ver com o código que eu estava usando. Para o Azure, tivemos que entrar nas configurações do Serviço de Aplicativo, no menu lateral, na entrada "CORS". Lá, tive que adicionar o domínio do qual estava solicitando coisas. Depois que eu entendi, tudo foi mágico.

No launchSettings.json, em iisSettings, defina anonymousAuthentication como true:

"iisSettings": {
    "windowsAuthentication": true,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:4200/",
      "sslPort": 0
    }
  }

Em Startup.cs, em ConfigureServices, antes de services.AddMvc, adicione:

services.AddCors(options => options.AddPolicy("ApiCorsPolicy", builder =>
{
    builder
        .AllowAnyOrigin()
        .WithHeaders(HeaderNames.AccessControlAllowHeaders, "Content-Type")
        .AllowAnyMethod()
        .AllowCredentials();
}));

e, em seguida, no método configure, antes de app.UseMvc () adicione:

app.UseCors("ApiCorsPolicy");

Estou usando o .Net CORE 3.1 e passei anos batendo minha cabeça contra uma parede com essa quando percebi que meu código estava realmente funcionando, mas meu ambiente de depuração estava quebrado, então aqui estão duas dicas, se você estiver tentando solucionar o problema problema:

1. Se você estiver tentando registrar cabeçalhos de resposta usando o middleware ASP.NET, o cabeçalho "Access-Control-Allow-Origin" nunca será exibido, mesmo que esteja lá. Não sei como, mas parece ser adicionado fora do pipeline (no final, tive que usar o wireshark para vê-lo).

2. O .NET CORE não enviará o "Access-Control-Allow-Origin" na resposta, a menos que você tenha um cabeçalho "Origin" em sua solicitação. O Carteiro não definirá isso automaticamente, portanto você precisará adicioná-lo.

No meu caso, eu consertei com o UseCors antes do UserRouting.

.NET Core 3.1

Trabalhou para mim e como os documentos dizem para fazê-lo:

na classe Inicialização:

readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins"; 

No método ConfigureServices ():

    services.AddCors(options =>
    {
        options.AddPolicy(MyAllowSpecificOrigins,
        builder =>
        {
            builder.WithOrigins("http://example.com",
                                "http://www.contoso.com");
        });
    });

No método Configure ():

    app.UseCors(MyAllowSpecificOrigins);  

https://docs.microsoft.com/en-us/aspnet/core/security/cors?view=aspnetcore-3.1

Eu obtive a resposta do MindingData acima para funcionar, mas tive que usar o Microsoft.AspNet.Cors em vez do Microsoft.AspNetCore.Cors. Estou usando o projeto .NetCore Web Application API no Visual Studio 2019

o

Microsoft.AspNetCore.Cors

permitirá que você execute o CORS com recursos internos, mas ele não processa a solicitação OPTIONS. Até agora, a melhor solução alternativa é criar um novo Middleware, conforme sugerido em uma postagem anterior. Verifique a resposta marcada como correta na seguinte postagem:

Ativar cabeçalho OPTIONS para CORS na API da Web do .NET Core

Maneira simples e fácil de fazê-lo.

1. Instalar pacote

Install-Package Microsoft.AspNetCore.Cors

2. Coloque este código abaixo no arquivo startup.cs

app.UseCors(options => options.AllowAnyOrigin());

Aqui está o meu código:)

  app.Use((ctx, next) =>
        {
            ctx.Response.Headers.Add("Access-Control-Allow-Origin", ctx.Request.Headers["Origin"]);
            ctx.Response.Headers.Add("Access-Control-Allow-Methods", "*");
            ctx.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
            ctx.Response.Headers.Add("Access-Control-Allow-Headers", "AccessToken,Content-Type");
            ctx.Response.Headers.Add("Access-Control-Expose-Headers", "*");
            if (ctx.Request.Method.ToLower() == "options")
            {
                ctx.Response.StatusCode = 204;

                return Task.CompletedTask;
            }
            return next();
        });

Aqui está como eu fiz isso.

Vejo que em algumas respostas eles estão definindo app.UserCors("xxxPloicy")e colocando[EnableCors("xxxPloicy")] controladores. Você não precisa fazer as duas coisas.

Aqui estão os passos.

Em Startup.cs, no ConfigureServices, adicione o seguinte código.

    services.AddCors(c=>c.AddPolicy("xxxPolicy",builder => {
        builder.AllowAnyOrigin()
        .AllowAnyMethod()
        .AllowAnyHeader();
    }));

Se você deseja aplicar todo o projeto, adicione o seguinte código no método Configure em Startup.cs

app.UseCors("xxxPolicy");

Ou

Se você deseja adicioná-lo aos controladores específicos, adicione o código de ativação cors como mostrado abaixo.

[EnableCors("xxxPolicy")]
[Route("api/[controller]")]
[ApiController]
public class TutorialController : ControllerBase {}

Para mais informações: consulte este

Use um Atributo de Ação / Controlador personalizado para definir os cabeçalhos do CORS.

Exemplo:

public class AllowMyRequestsAttribute : ControllerAttribute, IActionFilter
{
    public void OnActionExecuted(ActionExecutedContext context)
    {
        // check origin
        var origin = context.HttpContext.Request.Headers["origin"].FirstOrDefault();
        if (origin == someValidOrigin)
        {
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Origin", origin);
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Credentials", "true");
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Headers", "*");
            context.HttpContext.Response.Headers.Add("Access-Control-Allow-Methods", "*");
            // Add whatever CORS Headers you need.
        }
    }

    public void OnActionExecuting(ActionExecutingContext context)
    {
        // empty
    }
}

Em seguida, no Web API Controller / Action:

[ApiController]
[AllowMyRequests]
public class MyController : ApiController
{
    [HttpGet]
    public ActionResult<string> Get()
    {
        return "Hello World";
    }
}

Apenas para adicionar uma resposta aqui, se você estiver usando app.UseHttpsRedirection()e não estiver acessando a porta SSL, considere comentar isso.

Eu estava usando o blazor webassembly como cliente e o asp.net web api core como back-end e também tive problemas com o cors.

Encontrei solução com estes códigos:

As primeiras linhas da API do núcleo da API do ASP.Net Startup.cs ConfigureServices e Configure são assim:

public void ConfigureServices(IServiceCollection services)
{
   services.AddCors(options => options.AddPolicy("ApiCorsPolicy", builder =>
   {
        builder.WithOrigins("http://example.com").AllowAnyMethod().AllowAnyHeader();
    }));

 //other code below...
}

e meu método Configure:

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseCors(
        options =>   options.WithOrigins("http://example.com").AllowAnyMethod().AllowAnyHeader()
            );
 //other code below...
}

mude http://example.comcom o domínio do cliente ou endereço IP

services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2)
                .AddJsonOptions(options => {
                    var resolver = options.SerializerSettings.ContractResolver;
                    if (resolver != null)
                        (resolver as DefaultContractResolver).NamingStrategy = null;
                });

            services.AddDbContext<PaymentDetailContext>(options => options.UseSqlServer(Configuration.GetConnectionString("DevConnection"))); //Dependency Injection
            // options => options.UseSqlServer() Lamda Expression

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