ASP.net Core WebAPI'de CORS nasıl etkinleştirilir

Ne yapmaya çalışıyorum

Azure Ücretsiz Planında (Kaynak Kodu: https://github.com/killerrin/Portfolio-Backend ) barındırılan bir arka uç ASP.Net Core Web API'm var .

Ayrıca bu API'yı tüketmek istediğim bir Müşteri Web Sitem var. İstemci Uygulaması Azure'da barındırılmayacak, aksine Github Sayfalarında veya erişebileceğim başka bir Web Hosting Hizmetinde barındırılacaktır. Bu nedenle alan adları sıralanmayacaktır.

Buna baktığımda, Web API tarafında CORS'yi etkinleştirmem gerekiyor, ancak şimdi birkaç saat boyunca hemen hemen her şeyi denedim ve çalışmayı reddediyor.

İstemci Kurulumu var React.js'de yazılmış basit bir istemci. Jquery AJAX aracılığıyla API'leri arıyorum. React sitesi çalışır, bu yüzden biliyorum. Jquery API çağrısı Deneme 1'de onayladığım şekilde çalışıyor. İşte çağrıları nasıl yapacağım

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

Ne denedim

Deneme 1 - 'Doğru' yol

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

Microsoft Web sitesindeki bu öğreticiyi bir T'ye kadar takip ettim, Startup.cs'ta Global olarak etkinleştirmenin tüm 3 seçeneğini deniyorum, her denetleyicide Kuruyor ve her Eylemde Deniyorum.

Bu yöntemin ardından, Etki Alanları Arası çalışır, ancak yalnızca tek bir denetleyicide tek bir Eylem üzerinde (AccountController'a POST). Diğer her şey için, Microsoft.AspNetCore.Corsara katman yazılımı üstbilgileri ayarlamayı reddeder.

Ben yüklü Microsoft.AspNetCore.CorsNuget içinden ve versiyonudur1.1.2

Startup.cs içinde nasıl kurulum var

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

        ...
        ...
        ...
    }

Gördüğünüz gibi her şeyi söylediğim gibi yapıyorum. MVC'den önce iki kez Cors ekliyorum ve bu işe yaramadığında [EnableCors("MyPolicy")]her denetleyiciyi bu şekilde koymaya çalıştım

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

Deneme 2 - Brute Forcing

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

Önceki denemede birkaç saat denedikten sonra, üstbilgileri manuel olarak ayarlamaya çalışarak bruteforce yapmaya çalışacağımı ve her yanıtta çalışmaya zorlayacağımı düşündüm. Bunu el ile her yanıta başlık eklemek için bu öğretici aşağıdaki yaptı.

Bunlar eklediğim başlıklar

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

Bunlar denediğim ve başarısız olan diğer başlıklar

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

Bu yöntemle Siteler arası başlıklar düzgün bir şekilde uygulanıyor ve geliştirici konsolumda ve Postacı'da görünüyorlar. Sorun ancak geçerken olmasıdır Access-Control-Allow-Originçek webbrowser (sanırım) bir hissy uygun atar Access-Control-Allow-Headersbelirten415 (Unsupported Media Type)

Yani kaba kuvvet yöntemi de işe yaramıyor

En sonunda

Herkes bu işe aldı ve bir el ödünç olabilir, ya da sadece doğru yönde beni işaret edebiliyor mu?

DÜZENLE

Bu yüzden API çağrıları geçmek için, JQuery kullanmayı durdurmak ve bir Saf Javascript XMLHttpRequestformatına geçmek zorunda kaldı .

Deneme 1

Ben önce koyarak Yöntem Microsoft.AspNetCore.Corsdışında MindingData yanıt takip ederek işe başardı .Configureapp.UseCorsapp.UseMvc

Ayrıca, options.AllowAnyOrigin()joker karakter desteği için Javascript API Solution ile karıştırıldığında da çalışmaya başladı.

Deneme 2

Bu yüzden Deneme 2'yi (kaba zorlama) işe almayı başardım ... Wildcard'ın Access-Control-Allow-Originişe yaramadığı tek istisna dışında ve bu nedenle ona erişimi olan etki alanlarını manuel olarak ayarlamalıyım.

Bu WebAPI'nin herkese geniş olarak açılmasını istediğim için ideal değil, ancak en azından benim için ayrı bir sitede çalışıyor, yani bir başlangıç

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

Çok basit bir CORS politikanız olduğundan (XXX alan adından tüm isteklere izin ver), bunu bu kadar karmaşık hale getirmeniz gerekmez. Önce aşağıdakileri yapmayı deneyin (CORS'in çok temel bir uygulaması).

Henüz yapmadıysanız, CORS nuget paketini kurun.

Install-Package Microsoft.AspNetCore.Cors

Startup.cs dosyasının ConfigureServices yönteminde CORS hizmetlerini ekleyin.

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

Ardından startup.cs dosyasının Configure yöntemine aşağıdakileri ekleyin:

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

Şimdi bir deneyin. Politikalar, farklı eylemler için farklı politikalar (ör. Farklı ana makineler veya farklı başlıklar) istediğinizde geçerlidir. Basit örneğiniz için buna gerçekten ihtiyacınız yok. Bu basit örnekle başlayın ve ihtiyaç duyduğunuzda ince ayar yapın.

İlave okumalar: http://dotnetcoretutorials.com/2017/01/03/enabling-cors-asp-net-core/

• Gelen ConfigureServices eklemek services.AddCors(); services.AddMvc () önce;

• Configure'da UseCors Ekleme

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

Ana nokta app.UseCors, daha önce eklemektir app.UseMvc().

MVC ardışık düzenini kontrol altına almak ve isteği sonlandırmadan önce ara katman yazılımı ateşlemek için MVC önce CORS işlevselliği bildirdiğinizden emin olun.

Yukarıdaki yöntem çalıştıktan sonra, API çağrılarını kabul etmek ve API'nızı herkese bu kadar açık bırakmaktan kaçınmak için belirli bir ORIGIN'i yapılandırabilirsiniz.

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

    services.AddMvc();
}

Configure yönteminde CORS'e az önce oluşturduğunuz politikayı kullanmasını söyleyin:

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

Konuyla ilgili bu kompakt makaleyi buldum - https://dzone.com/articles/cors-in-net-core-net-core-security-part-vi

Benim için çalışan kendi katman yazılım sınıfımı oluşturdum, bence .net çekirdek katman yazılımı ile ilgili bir sorun var

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

ve startup.cs dosyasında bu şekilde kullandı

app.UseCorsMiddleware();

Benim durumumda sadece getistek MindingData yanıt göre iyi çalışır. Diğer istek türleri için şunları yazmanız gerekir:

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

Eklemeyi unutma .AllowAnyHeader()

Genişletmek için user8266077 'ın cevabı , ben hala için tedarik SEÇENEKLERİ yanıtı için gerekli bulundu uçuş öncesi isteklerden benim kullanım durumu için .NET Çekirdek 2.1-önizleme:

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

ve ardından Startup.cs dosyasında olduğu gibi ara katman yazılımını etkinleştirin

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

GÜNLER için bununla mücadele ediyordum.

Sonunda hareket ettirerek işe aldım app.UseCors(CORS_POLICY);için İLK arasında Configure().

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

MVC isteği tamamlamadan önce başlıkların uygulanması gerektiğinden CORS işlevselliğini> MVC'den önce bildirdiğinizden emin olun.

<= Uygulamam aramasa bile UseMVC(), UseCors()en üste gitmek sorunu çözdü

Ayrıca:

• Microsoft.AspNetCore.Cors.Net Core 2 ve daha düşük sürümlerde gerekli bir NuGet paketi; artık otomatik olarak .Net Core 3 ve sonraki sürümlerde Microsoft'un bir parçası.
• builder.AllowAnyOrigin()ve .AllowCredentials()CORS seçenekleri artık .Net Core 3 ve sonraki sürümlerde birbirini dışlar
• CORS ilkesi sunucunun açısal çağrısını gerektiriyor gibi görünüyor https. Bir http URL'si, .Net Core sunucusunun CORS yapılandırmasına bakılmaksızın bir CORS hatası veriyor gibi görünüyordu. Örneğin, http://localhost:52774/api/Contactsbir CORS hatası verir; URL'yi çalışacak şekilde değiştirmeniz yeterlidir https://localhost:44333/api/Contacts.

Ek not :

Benim durumumda, app.UseCors()yukarı hareket etmeden CORS işe yaramazdı app.UseEndpoints(endpoints => endpoints.MapControllers()).

Yukarıdaki prosedürlerin hiçbiri yardımcı olmadı ve sonra sorunu çözen makaleyi okudum .

Kod aşağıdadır.

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

ve

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

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

ve benim aksiyon yöntemimin üstünde

[EnableCors("CorsPolicy")]

jQuery.support.cors = true;Ajax çağrısından önce eklemeyi deneyin

API'ya gönderdiğiniz verilerin sakat olması da olabilir,

aşağıdaki JSON işlevini eklemeyi deneyin

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

sonra verilerinizde: nesne olarak değiştirin

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

En basit çözüm ekleme

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

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

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

Başlangıç.cs.

Kendi CORS ara katmanınızı kullanıyorsanız, kaynak başlığını kontrol ederek gerçekten CORS isteği olduğundan emin olmanız gerektiğini düşünüyorum .

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

MindingData'nın cevabındaki yorumunuza dayanarak, CORS'nizle ilgisi yok, iyi çalışıyor.

Denetleyici eyleminiz yanlış verileri döndürüyor. HttpCode 415, "Desteklenmeyen Ortam türü" anlamına gelir. Bu, denetleyiciye yanlış biçim (yani yalnızca json kabul eden bir denetleyiciye XML) ilettiğinizde veya yanlış bir tür döndürdüğünüzde (yalnızca xml döndürdüğü bildirilen bir denetleyicide Xml döndürür) oluşur.

Daha sonra bir [Produces("...")]kez eyleminizde niteliğin varlığını kontrol edin

Benim için kullandığım kodla ilgisi yoktu. Azure için App Service ayarlarına gitmemiz gerekiyordu, yan menüde "CORS" girişi. Orada bir şey istediğim etki alanını eklemek zorunda kaldım. Bir kere bunu aldığımda, her şey sihirdi.

LaunchSettings.json uygulamasında, iisSettings altında anonimAuthentication (doğru) değerini true olarak ayarlayın:

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

Sonra, Startup.cs içinde, ConfigureServices altında, hizmetlerden önce.

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

ve ardından configure yönteminde app.UseMvc () öğesini ekleyin:

app.UseCors("ApiCorsPolicy");

Net CORE 3.1 kullanıyorum ve kodum gerçekten işe başladığını ama hata ayıklama ortamım bozulduğunu fark ettiğimde kafamı bir duvara çarparak yaşları harcadım, bu yüzden sorun gidermeye çalışıyorsanız 2 ipucu sorun:

1. ASP.NET ara katman yazılımını kullanarak yanıt üstbilgilerini günlüğe kaydetmeye çalışıyorsanız, "Access-Control-Allow-Origin" üstbilgisi, orada olsa bile hiçbir zaman görünmez. Nasıl bilmiyorum ama boru hattı dışında eklenmiş gibi görünüyor (sonunda ben bunu görmek için wireshark kullanmak zorunda kaldı).

2. .NET CORE, isteğinizde bir "Origin" üstbilgisi yoksa yanıtta "Access-Control-Allow-Origin" göndermez. Postacı bunu otomatik olarak ayarlamaz, bu yüzden kendiniz eklemeniz gerekir.

Benim durumumda UserRouting önce UseCors ile sabit ..

.NET Core 3.1

Benim için çalıştı ve dokümanlar bunu nasıl söyledi:

Başlangıç ​​sınıfında:

readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins"; 

ConfigureServices () yönteminde:

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

Configure () yönteminde:

    app.UseCors(MyAllowSpecificOrigins);  

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

Çalışmak için yukarıdaki MindingData yanıt aldım, ancak Microsoft.AspNetCore.Cors yerine Microsoft.AspNet.Cors kullanmak zorunda kaldı. Visual Studio 2019'da .NetCore Web Uygulaması API'sı projesini kullanıyorum

Microsoft.AspNetCore.Cors

yerleşik özelliklerle CORS yapmanıza izin verir, ancak OPTIONS isteğini işlemez. Şimdiye kadarki en iyi geçici çözüm, önceki bir gönderide önerildiği gibi yeni bir Middleware oluşturmaktır. Aşağıdaki gönderide doğru olarak işaretlenmiş yanıtı kontrol edin:

.NET Core Web API'sinde CORS için OPTIONS başlığını etkinleştir

Bunu yapmanın basit ve kolay yolu.

1. Kurulum paketi

Install-Package Microsoft.AspNetCore.Cors

2. Bu kodu startup.cs dosyasına yerleştirin

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

İşte benim kod:)

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

İşte böyle yaptım.

Bazı cevapları onlar ayarlarken görüyoruz app.UserCors("xxxPloicy")ve koyarak [EnableCors("xxxPloicy")]denetleyicileri içinde. Her ikisini de yapmanıza gerek yoktur.

İşte adımlar.

ConfigureServices içindeki Startup.cs içinde aşağıdaki kodu ekleyin.

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

Tüm projeye uygulamak istiyorsanız, Startup.cs içindeki Configure yöntemine aşağıdaki kodu ekleyin

app.UseCors("xxxPolicy");

Veya

Belirli denetleyicilere eklemek istiyorsanız, aşağıda gösterildiği gibi enable cors kodunu ekleyin.

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

Daha fazla bilgi için: buna bakın

CORS başlıklarını ayarlamak için özel bir Eylem / Denetleyici Özelliği kullanın.

Misal:

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
    }
}

Ardından Web API Denetleyicisi / İşleminde:

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

Sadece cevap eklemek için, kullanıyorsanız app.UseHttpsRedirection()ve SSL bağlantı noktası vurmuyorsanız, bunu yorumlamayı düşünün.

Ben istemci olarak blazor webassembly ve backend olarak asp.net web api core kullanıyordum ve çok cors sorunu vardı.

Bu kod ile çözüm buldum:

ASP.Net çekirdek webim api Startup.cs ConfigureServices ve Configure yöntemleri ilk satırları şöyle görünür:

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

 //other code below...
}

ve Configure yöntemim:

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

değiştirmek http://example.comistemci etki alanı veya ip adresi ile

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