Cómo habilitar CORS en ASP.NET Core

Estoy tratando de habilitar el intercambio de recursos de origen cruzado en mi API web ASP.NET Core, pero estoy atascado.

El EnableCorsatributo acepta policyNamede 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);

¿Qué policyNamesignifica y cómo puedo configurar CORS en una API web ASP.NET Core?

Debe configurar una política CORS al inicio de la aplicación en el ConfigureServicesmétodo:

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

    // ...
}

El CorsPolicyBuilderen builderle permite configurar la política para sus necesidades. Ahora puede usar este nombre para aplicar la política a controladores y acciones:

[EnableCors("MyPolicy")]

O aplíquelo a cada solicitud:

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

Se aplica a .NET Core 1 y .Net Core 2 (más abajo)

Si usa .Net-Core 1.1

Lamentablemente, los documentos son muy confusos en este caso específico. Así que lo haré muy simple:

• Agregue el Microsoft.AspNetCore.Corspaquete nuget a su proyecto
• En ConfigureServicesmétodo, agregueservices.AddCors();

• En Configuremétodo, antes de llamar app.UseMvc()y app.UseStaticFiles()agregar:

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

Eso es. Cada cliente tiene acceso a su sitio web / API de ASP.NET Core.

Si usa .Net-Core 2.0

• Agregue el Microsoft.AspNetCore.Corspaquete nuget a su proyecto

• en ConfigureServicesmétodo, antes de llamar services.AddMvc(), agregue:

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

• (Importante) En el Configuremétodo, antes de llamar app.UseMvc(), agregue app.UseCors("AllowAll");

  AllowAlles el nombre de la política que debemos mencionar en app.UserCors. Podría ser cualquier nombre.

Basado en la respuesta de Henk, he podido encontrar el dominio específico, el método que quiero permitir y también el encabezado para el que quiero habilitar CORS:

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")]

Específicamente en dotnet core 2.2 con SignalR debes cambiar

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

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

en cambio .AllowAnyOrigin()con.AllowCredentials()

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

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

Si está alojando en IIS, una posible razón es que está obteniendo esto porque IIS está bloqueando el OPTIONSverbo. Pasé casi una hora por esto:

Una indicación reveladora es que está recibiendo un 404error durante la OPTIONSsolicitud.

Para solucionar esto, debe decirle explícitamente a IIS que no bloquee la OPTIONSsolicitud.

Vaya a Solicitud de filtrado:

Asegúrese de que las OPCIONES estén permitidas:

O simplemente cree un web.config con la siguiente configuración:

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

Tienes que configurar en la clase 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"));
        });            
    }

``

Conseguí esto trabajando con .Net Core 3.1 de la siguiente manera

1.Asegúrese de colocar el código UseCors entre app.UseRouting (); y app.UseAuthentication ();

        app.UseHttpsRedirection();

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

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

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

2. Luego coloque este código en el método ConfigureServices

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

3. Y encima del controlador base coloqué esto

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

Ahora todos mis controladores heredarán de BaseController y tendrán CORS habilitado

Paso 1: Necesitamos el paquete Microsoft.AspNetCore.Cors en nuestro proyecto. Para la instalación, vaya a Herramientas -> Administrador de paquetes NuGet -> Administrar paquetes NuGet para la solución. Busque Microsoft.AspNetCore.Cors e instale el paquete.

Paso 2: Necesitamos inyectar CORS en el contenedor para que pueda ser utilizado por la aplicación. En la clase Startup.cs, vayamos al método ConfigureServices y registremos CORS.

Entonces, en nuestra aplicación de servidor, vamos a Controladores -> HomeController.cs y agreguemos el decorador EnableCors al método Index (o su controlador y acción específicos):

Para más detalles haga clic aquí

Toda la solución mencionada anteriormente puede funcionar o no, en la mayoría de los casos no funcionará. He dado la solución aquí

Actualmente estoy trabajando en Angular y Web API (.net Core) y encontré el problema CORS explicado a continuación

La solución proporcionada anteriormente siempre funcionará. Con la solicitud 'OPCIONES' es realmente necesario habilitar 'Autenticación anónima'. Con la solución mencionada aquí, no tiene que hacer todos los pasos mencionados anteriormente, como la configuración de IIS.

De todos modos, alguien marcó mi publicación anterior como duplicada con esta publicación, pero puedo ver que esta publicación es solo para habilitar CORS en ASP.net Core, pero mi publicación está relacionada con Habilitar e implementar CORS en ASP.net Core y Angular.