对于.NET CORE 3.1

Question

我想做什么

我有一个Azure免费计划托管的后端ASP.Net核心Web API（源代码：https://github.com/killerrin/Portfolio-Backend）。

我还有一个客户网站，我想要使用该API。客户端应用程序不会托管在Azure上，而是托管在Github Pages或我可以访问的其他Web托管服务上。因此，域名不会排队。

考虑到这一点，我需要在Web API端启用CORS，但是我现在已经尝试了好几个小时并拒绝工作。

我如何设置客户端 它只是一个用React.js编写的简单客户端。我在Jquery中通过AJAX调用API。 React网站有效，所以我不知道它。 Jquery API调用就像我在Attempt 1中确认的那样工作。这是我如何进行调用

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

我尝试了什么

尝试1 - 正确的＆＃39;方式

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

我已经在微软网站上关注了本教程，尝试了在Startup.cs中全局启用它的所有3个选项，在每个控制器上设置它并在每个Action上尝试它。

遵循此方法，Cross Domain可以工作，但只能在单个控制器上的一个Action上运行（POST到AccountController）。对于其他所有内容，Microsoft.AspNetCore.Cors中间件拒绝设置标头。

我通过NUGET安装了Microsoft.AspNetCore.Cors，版本为1.1.2

以下是我在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();

        ...
        ...
        ...
    }

正如你所看到的，我正在做所有事情。我在MVC之前添加了Cors两次，当它没有工作时我尝试将[EnableCors("MyPolicy")]放在每个控制器上，因此

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

尝试2 - 暴力强迫

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

在尝试上一次尝试几个小时之后，我想我会尝试通过手动设置标头来强制它，强制它们在每个响应上运行。我在本教程后就如何手动为每个响应添加标题做了这个。

这些是我添加的标题

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

这些是我尝试失败的其他标题

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

使用此方法，正确应用了跨站点标头，它们显示在我的开发人员控制台和邮递员中。然而问题是，当它通过Access-Control-Allow-Origin检查时，web浏览器会抛出一个（我相信）Access-Control-Allow-Headers表示415 (Unsupported Media Type)

所以蛮力方法不起作用

最后

有没有人让这个工作，可以伸出援手，或者只是能指出我正确的方向？

修改

为了让API调用完成，我不得不停止使用JQuery并切换到纯Javascript XMLHttpRequest格式。

尝试1

我设法通过关注MindingData的答案来使Microsoft.AspNetCore.Cors工作，除了Configure方法中app.UseCors放在app.UseMvc之前。

此外，当与Javascript API解决方案options.AllowAnyOrigin()混合使用时，通配符支持也开始起作用。

尝试2

所以我设法让尝试2（暴力强迫它）工作......唯一的例外是Access-Control-Allow-Origin的通配符不起作用，因此我必须手动设置域名有权访问它。

它显然不理想，因为我只想让这个WebAPI向所有人开放，但它至少对我来说在一个单独的网站上运行，这意味着它是一个开始

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

Answer 1

因为你有一个非常简单的CORS政策（允许来自XXX域的所有请求），所以你不需要让它变得如此复杂。首先尝试执行以下操作（CORS的一个非常基本的实现）。

如果您还没有，请安装CORS nuget包。

var navigationView = FindViewById<NavigationView>(Resource.Id.nav_view); //whatever your Id for navigationview is
var headerView = navigationView.GetHeaderView(0);
var loginUser = headerView.FindViewById<TextView>(Resource.Id.login);

loginUser.Click += login_User;

private void login_User(object sender, EventArgs e)
{
    Intent intent = new Intent(this, typeof(loginPage));
    this.StartActivity(intent);
}

在startup.cs的ConfigureServices方法中，添加CORS服务。

Install-Package Microsoft.AspNetCore.Cors

然后在startup.cs的Configure方法中添加以下内容：

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

现在试一试。策略适用于您需要针对不同操作的不同策略（例如，不同的主机或不同的标头）。举个简单的例子，你真的不需要它。从这个简单的例子开始，然后根据需要进行调整。

进一步阅读：http://dotnetcoretutorials.com/2017/01/03/enabling-cors-asp-net-core/

Answer 2

在配置服务中添加services.AddCors(); 服务之前.AddMvc（）;

在配置

中添加UseCors

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

要点是在app.UseCors之前添加app.UseMvc()。

确保在MVC之前声明CORS功能，以便在MVC管道获得控制权并终止请求之前触发中间件。

Answer 3

我创建了自己的中间件类，对我有用，我认为.net核心中间件类有问题

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

并在startup.cs中以这种方式使用它

app.UseCorsMiddleware();

Answer 4

在我的情况下，根据MindingData的回答，只有get请求才能正常运行。对于其他类型的请求，您需要写：

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

不要忘记添加.AllowAnyHeader()

Answer 5

要展开user8266077的answer，我发现在.NET Core 2.1预览版中，我仍然需要为preflight requests提供OPTIONS响应：

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

然后在Startup.cs

中启用中间件

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

Answer 6

对于.NET CORE 3.1

就我而言，我在添加 cors中间件之前就使用了 https重定向，并且能够通过更改它们的顺序来解决问题

我的意思是：

更改此项：

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {

      ...
        
        app.UseHttpsRedirection();  

        app.UseCors(x => x
            .AllowAnyOrigin()
            .AllowAnyMethod()
            .AllowAnyHeader());

      ...

     }

为此：

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
    {

      ...
        
        app.UseCors(x => x
            .AllowAnyOrigin()
            .AllowAnyMethod()
            .AllowAnyHeader());

        app.UseHttpsRedirection(); 

      ...

     }

顺便说一句，允许来自任何来源和方法的请求在生产阶段可能不是一个好主意，您应该在生产时编写自己的cors政策。

Answer 7

尝试在Ajax调用之前添加jQuery.support.cors = true;

也可能是您发送给API的数据不稳定，

尝试添加以下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;
    };

然后在您的数据中：对象将其更改为

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

Answer 8

以上过程均无济于事，然后我读了article来解决了问题。

下面是代码。

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

和

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

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

并在我的操作方法的顶部

[EnableCors("CorsPolicy")]

Answer 9

.NET Core 3.1

为我工作，以及文档说的如何做：

在启动类中：

readonly string MyAllowSpecificOrigins = "_myAllowSpecificOrigins";

在ConfigureServices（）方法中：

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

在Configure（）方法中：

    app.UseCors(MyAllowSpecificOrigins);

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

Answer 10

根据您在MindingData的答案中的评论，它与您的CORS无关，它可以正常工作。

您的Controller操作正在返回错误的数据。 HttpCode 415表示＆＃34;不支持的媒体类型＆＃34;。当您将错误的格式传递给控制器（即XML到只接受json的控制器）或者返回错误的类型（在声明只返回xml的控制器中返回Xml）时会发生这种情况。

稍后检查您的操作是否存在[Produces("...")]属性

Answer 11

就我而言，我在UserRouting之前使用UseCors进行了修复。

Answer 12

我使用的是.Net CORE 3.1，当我意识到我的代码已开始实际工作但调试环境被破坏时，我花了很长时间将它撞在墙上，所以这里有2条提示，如果您正在尝试解决问题：

如果尝试使用ASP.NET中间件记录响应标头，则即使存在，“ Access-Control-Allow-Origin”标头也将永远不会显示。我不知道如何，但是它似乎被添加到了管道之外（最后我不得不使用wireshark来查看它）。
.NET CORE不会在响应中发送“ Access-Control-Allow-Origin”，除非您的请求中包含“ Origin”标头。邮递员不会自动设置此项，因此您需要自己添加。

Answer 13

我在DAYS一直在为此苦苦挣扎。

我终于通过将app.UseCors(CORS_POLICY);移至Configure()的 TOP 使其工作。

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

确保在> MVC之前将CORS功能声明为   标头必须在MVC完成请求之前应用。

<=即使我的应用未调用UseMVC()，将UseCors()移到顶部也可以解决问题

也：

Microsoft.AspNetCore.Cors曾经是.Net Core 2及更低版本中必需的NuGet软件包；现在，它自动成为.Net Core 3和更高版本中Microsoft.AspNetCore的一部分。
builder.AllowAnyOrigin()和.AllowCredentials()的CORS选项现在在.Net Core 3和更高版本中互斥
CORS策略似乎要求Angular使用https调用服务器。无论.Net Core服务器的CORS配置如何，http URL似乎都会给出CORS错误。例如，http://localhost:52774/api/Contacts会产生CORS错误；只需将URL更改为https://localhost:44333/api/Contacts即可。

附加说明：

就我而言，在我将app.UseCors()移到app.UseEndpoints(endpoints => endpoints.MapControllers())上方之前，CORS无法工作。

Answer 14

对我来说，解决方案是纠正顺序：

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

Answer 15

这是我的代码：）

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

Answer 16

我认为，如果您使用自己的 CORS 中间件，则需要通过检查 origin 标头来确保它确实是 CORS 请求。

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

Answer 17

在launchSettings.json中的iisSettings下，将anonymousAuthentication设置为true：

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

然后在Startup.cs中的ConfigureServices下，在services.AddMvc之前，添加：

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

，然后在configure方法中，在app.UseMvc（）之前添加：

app.UseCors("ApiCorsPolicy");

Answer 18

对我来说，它与我使用的代码无关。对于Azure，我们必须进入App Service的设置，在侧面菜单上输入“ CORS”。在那里，我必须添加我要从中请求内容的域。一旦有了它，一切就变得神奇了。

Answer 19

AspNetCoreModuleV2 无法处理导致预检问题的 OPTIONS

我发现 .net 核心模块不能很好地处理 OPTIONS，这造成了一个很大的 CORS 问题：

解决办法：去掉星号*

在 web.config 中，从模块中排除 OPTIONS 动词，因为该动词已由 IIS OPTIONSVerbHandler 处理：

 <add name="aspNetCore" path="*" verb="* modules="AspNetCoreModuleV2" resourceType="Unspecified" />

有了这个

<add name="aspNetCore" path="*" verb="GET,POST,PUT,DELETE" modules="AspNetCoreModuleV2" resourceType="Unspecified" />

Answer 20

对我来说，当我明确设置了要发送的标头时，它就开始工作。我添加了内容类型标头，然后它起作用了。

.net

.WithHeaders("Authorization","Content-Type")

javascript：

this.fetchoptions = {
        method: 'GET', 
        cache: 'no-cache', 
        credentials: 'include', 
        headers: {
            'Content-Type': 'application/json',
        },
        redirect: 'follow', 
    };

Answer 21

对于ASP.NET Core 3.1，这解决了我的问题 https://jasonwatmore.com/post/2020/05/20/aspnet-core-api-allow-cors-requests-from-any-origin-and-with-credentials

public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        // This method gets called by the runtime. Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddCors();
            services.AddControllers();
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            app.UseRouting();

            // global cors policy
            app.UseCors(x => x
                .AllowAnyMethod()
                .AllowAnyHeader()
                .SetIsOriginAllowed(origin => true) // allow any origin
                .AllowCredentials()); // allow credentials

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

            app.UseEndpoints(x => x.MapControllers());
        }
    }

Answer 22

在ASP.NET Core 3.1中对我有用的解决方案：

Couldn't match type `t -> [t] -> t' with `[t]'
      Expected type: [t] -> [t]

，然后更改以下内容：

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

然后程序开始工作，错误得到解决。

Answer 23

以下是适用于我的设置：

Answer 24

在我的情况下，起源名称末尾的字符<?php // do your merge... $my_posts= array_merge( get_posts($args_b), get_posts($args_a) ); // sort the resulting array... usort($my_posts, function($post_a, $post_b) { return $post_b->post_date <=> $post_a->post_date; }); // and now process the new sorted array as required. foreach($my_posts as $post):setup_postdata($post);?> <?php the_title(); ?> <?php endforeach; ?> <?php wp_reset_postdata(); ?>引起了问题。

在.NET Core 3.1中为我解决的解决方案：

usort($my_posts, function ($a, $b) {
    if ($a->post_date < $b->post_date)       return -1;
    elseif ($a->post_date > $b->post_date)   return 1;
    else                                     return 0;
});

Answer 25

我当时使用blazor webassembly作为客户端，而使用asp.net Web API核心作为后端，并且也存在cors问题。

我找到了使用以下代码的解决方案：

我的ASP.Net核心Web api Startup.cs ConfigureServices和Configure方法的第一行如下所示：

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

 //other code below...
}

和我的Configure方法：

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

将http://example.com更改为您的客户域或IP地址

Answer 26

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

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

Answer 27

使用自定义的动作/控制器属性来设置CORS标头。

示例：

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

然后在Web API控制器上执行/操作：

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

Answer 28

这是我的方法。

我看到在某些答案中，他们正在设置app.UserCors("xxxPloicy")并将[EnableCors("xxxPloicy")]放入控制器。您无需同时执行这两项操作。

这是步骤。

在ConfigureServices内部的Startup.cs中添加以下代码。

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

如果要在整个项目中应用，请在Startup.cs的Configure方法中添加以下代码

app.UseCors("xxxPolicy");

或

如果要将其添加到特定的控制器，则添加如下所示的enable cors代码。

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

有关更多信息：see this

Answer 29

我上面得到了MindingData的答案，但我必须使用Microsoft.AspNet.Cors而不是Microsoft.AspNetCore.Cors。我正在Visual Studio 2019中使用.NetCore Web应用程序API项目

Answer 30

最简单的解决方案是添加

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

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

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

到Startup.cs。

Answer 31

简单易行的方法。

安装软件包

Install-Package Microsoft.AspNetCore.Cors

将此下面的代码放在startup.cs文件中

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

Answer 32

Microsoft.AspNetCore.Cors

将允许您使用内置功能来执行CORS，但不能处理OPTIONS请求。到目前为止，最好的解决方法是按照上一篇文章中的建议创建一个新的中间件。检查以下帖子中标记为正确的答案：

Enable OPTIONS header for CORS on .NET Core Web API

Answer 33

如果您使用的是app.UseHttpsRedirection()，而您没有找到SSL端口，则只需在此处添加答案即可。

Answer 34

#include<stdio.h>
int main(){
    int fi=0;
    while(fi<=26)
    {
        if(fi>=97||fi<=122||fi>=1)
    {
    printf("%c%d%c",fi);
    }
    fi++;
    }
     return 0;
}

如何在ASP.net Core WebAPI

34 个答案:

对于.NET CORE 3.1