So aktivieren Sie CORS in ASP.NET Core

Ich versuche, die gemeinsame Nutzung von Cross-Origin-Ressourcen auf meiner ASP.NET Core-Web-API zu aktivieren, stecke jedoch fest.

Das EnableCorsAttribut akzeptiert policyNamevom Typ stringals Parameter:

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

Was bedeutet das policyNameund wie kann ich CORS auf einer ASP.NET Core-Web-API konfigurieren ?

Sie müssen beim Start der Anwendung eine CORS-Richtlinie in der folgenden ConfigureServicesMethode konfigurieren :

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

    // ...
}

Mit dem CorsPolicyBuilderIn builderkönnen Sie die Richtlinie gemäß Ihren Anforderungen konfigurieren. Mit diesem Namen können Sie die Richtlinie jetzt auf Controller und Aktionen anwenden:

[EnableCors("MyPolicy")]

Oder wenden Sie es auf jede Anfrage an:

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

Gilt für .NET Core 1 und .Net Core 2 (weiter unten)

Bei Verwendung .Net-Core 1.1

Leider sind die Dokumente in diesem speziellen Fall sehr verwirrend. Also mache ich es ganz einfach:

• Fügen Microsoft.AspNetCore.CorsSie Ihrem Projekt ein Nuget-Paket hinzu
• Fügen Sie in ConfigureServicesmethod hinzuservices.AddCors();

• Fügen Sie in Configuremethod vor dem Aufruf von app.UseMvc()und app.UseStaticFiles()Folgendes hinzu:

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

Das ist es. Jeder Client hat Zugriff auf Ihre ASP.NET Core-Website / API.

Bei Verwendung .Net-Core 2.0

• Fügen Microsoft.AspNetCore.CorsSie Ihrem Projekt ein Nuget-Paket hinzu

• ConfigureServicesFügen Sie in method vor dem Aufruf services.AddMvc()Folgendes hinzu:

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

• (Wichtig) Fügen Sie in der ConfigureMethode vor dem Aufruf app.UseMvc()add hinzu app.UseCors("AllowAll");

  AllowAllist der Richtlinienname, den wir in app.UserCors erwähnen müssen. Es könnte jeder Name sein.

Basierend auf Henks Antwort konnte ich die spezifische Domäne, die Methode, die ich zulassen möchte, und auch den Header, für den ich CORS aktivieren möchte, finden:

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

Verwendung:

[EnableCors("AllowSpecific")]

Speziell in Dotnet Core 2.2 mit SignalR müssen Sie ändern

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

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

stattdessen .AllowAnyOrigin()mit.AllowCredentials()

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

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

Wenn Sie auf IIS hosten, ist ein möglicher Grund, dass Sie dies erhalten, weil IIS das OPTIONSVerb blockiert . Aus diesem Grund habe ich fast eine Stunde verbracht:

Ein verräterischer Hinweis ist, dass Sie 404während der OPTIONSAnfrage einen Fehler erhalten .

Um dies zu beheben, müssen Sie IIS ausdrücklich anweisen , die Anforderung nicht zu blockieren OPTIONS.

Gehen Sie zu Anforderungsfilterung:

Stellen Sie sicher, dass OPTIONEN zulässig sind:

Oder erstellen Sie einfach eine web.configmit der folgenden Einstellung:

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

Sie müssen in der Klasse Startup.cs konfigurieren

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

`

Habe dies mit .Net Core 3.1 wie folgt funktioniert

1. Stellen Sie sicher, dass Sie den UseCors-Code zwischen app.UseRouting () platzieren. und app.UseAuthentication ();

        app.UseHttpsRedirection();

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

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

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

2. Platzieren Sie diesen Code dann in der ConfigureServices-Methode

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

3.Und über dem Basis-Controller habe ich dies platziert

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

Jetzt erben alle meine Controller vom BaseController und haben CORS aktiviert

Schritt 1: Wir benötigen das Microsoft.AspNetCore.Cors-Paket in unserem Projekt. Zur Installation gehen Sie zu Tools -> NuGet Package Manager -> NuGet Packages for Solution verwalten. Suchen Sie nach Microsoft.AspNetCore.Cors und installieren Sie das Paket.

Schritt 2: Wir müssen CORS in den Behälter injizieren, damit er von der Anwendung verwendet werden kann. Wechseln Sie in der Klasse Startup.cs zur ConfigureServices-Methode und registrieren Sie CORS.

Gehen Sie in unserer Server-App zu Controller -> HomeController.cs und fügen Sie den EnableCors-Dekorator zur Indexmethode hinzu (oder zu Ihrem spezifischen Controller und Ihrer Aktion):

Für mehr Details klicken Sie hier

Alle oben genannten Problemumgehungen funktionieren möglicherweise oder funktionieren möglicherweise nicht. In den meisten Fällen funktioniert dies nicht. Ich habe hier die Lösung gegeben

Derzeit arbeite ich an Angular und Web API (.net Core) und bin auf das unten erläuterte CORS-Problem gestoßen

Die oben angegebene Lösung funktioniert immer. Bei der Anforderung 'OPTIONEN' ist es wirklich erforderlich, die 'Anonyme Authentifizierung' zu aktivieren. Mit der hier genannten Lösung müssen Sie nicht alle oben genannten Schritte ausführen, wie z. B. die IIS-Einstellungen.

Wie auch immer, jemand hat meinen obigen Beitrag als Duplikat mit diesem Beitrag markiert, aber ich kann sehen, dass dieser Beitrag nur CORS in ASP.net Core aktiviert, aber mein Beitrag bezieht sich auf das Aktivieren und Implementieren von CORS in ASP.net Core und Angular.