.Net Core Web Api’de Custom CORS Extension Yazmak

Amacımız uygulama ayağa kalktığında veritabanından gelen subdomain’leri CORS kuralına eklemek.

Öncelikle Startup.cs dosyamızı açıyoruz ve aşağıdaki kodları ekliyoruz.

public void ConfigureServices(IServiceCollection services)
{
  ...
// Veritabani olarak postgresql kullanilmistir.
  services.AddDbContextPool<ProjectDbContext>(options => 
  options.UseNpgsql(Configuration.GetConnectionString("DefaultConnection")));
  services.AddCors(); 
  ...
}
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)Daha 

Daha sonra aşağıdaki fonksiyonu buluyoruz.

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
  ...
}

Bu fonksiyona parametre olarak dbContext’i (ör: ProjectDbContext) veriyoruz.

public void Configure(
  IApplicationBuilder app,
  IWebHostEnvironment env,
  ProjectDbContext dbContext){ ... }

Daha sonra bu fonksiyonun içine aşağıdaki kodu ekleyelim.

public void Configure(
  IApplicationBuilder app,
  IWebHostEnvironment env,
  ProjectDbContext dbContext)
{
  ...
  app.UseCustomCors(dbContext);
  ...

}

Henüz custom cors sınıfı yazmadığımızdan bu kod hata verecektir. Şimdi CorsCustomMiddlewareExtensions.cs adında bir dosya oluşturalım.

Normalde app.UseCors(); ile varsayılan CorsExtension’i çağırdığımızda program CorsMiddlewareExtensions.cs dosyasını kullanır.

Bu dosyanın koduna bakarsak aşağıdaki gibi olduğunu görürüz. (.NET 7.0 için). Kodu biraz incelersek asıl işi yapanın CorsMiddleware olduğunu görürüz.

// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

using Microsoft.AspNetCore.Cors.Infrastructure;

namespace Microsoft.AspNetCore.Builder;

/// <summary>
/// The <see cref="IApplicationBuilder"/> extensions for adding CORS middleware support.
/// </summary>
public static class CorsMiddlewareExtensions
{
    /// <summary>
    /// Adds a CORS middleware to your web application pipeline to allow cross domain requests.
    /// </summary>
    /// <param name="app">The IApplicationBuilder passed to your Configure method</param>
    /// <returns>The original app parameter</returns>
    public static IApplicationBuilder UseCors(this IApplicationBuilder app)
    {
        if (app == null)
        {
            throw new ArgumentNullException(nameof(app));
        }

        return app.UseMiddleware<CorsMiddleware>();
    }

    /// <summary>
    /// Adds a CORS middleware to your web application pipeline to allow cross domain requests.
    /// </summary>
    /// <param name="app">The IApplicationBuilder passed to your Configure method</param>
    /// <param name="policyName">The policy name of a configured policy.</param>
    /// <returns>The original app parameter</returns>
    public static IApplicationBuilder UseCors(this IApplicationBuilder app, string policyName)
    {
        if (app == null)
        {
            throw new ArgumentNullException(nameof(app));
        }

        return app.UseMiddleware<CorsMiddleware>(policyName);
    }

    /// <summary>
    /// Adds a CORS middleware to your web application pipeline to allow cross domain requests.
    /// </summary>
    /// <param name="app">The IApplicationBuilder passed to your Configure method.</param>
    /// <param name="configurePolicy">A delegate which can use a policy builder to build a policy.</param>
    /// <returns>The original app parameter</returns>
    public static IApplicationBuilder UseCors(
        this IApplicationBuilder app,
        Action<CorsPolicyBuilder> configurePolicy)
    {
        if (app == null)
        {
            throw new ArgumentNullException(nameof(app));
        }

        if (configurePolicy == null)
        {
            throw new ArgumentNullException(nameof(configurePolicy));
        }

        var policyBuilder = new CorsPolicyBuilder();
        configurePolicy(policyBuilder);
        return app.UseMiddleware<CorsMiddleware>(policyBuilder.Build());
    }
}

Şimdi custom cors için bir extension yazalım.

namespace API.Extensions
{
    public static class CorsCustomMiddlewareExtensions
    {
        public static IApplicationBuilder UseCustomCors(
            this IApplicationBuilder app, ProjectDbContext dbContext)
        {
            if (app == null)
            {
                throw new ArgumentNullException(nameof(app));
            }

            if (dbContext == null)
            {
                throw new ArgumentNullException(nameof(dbContext));
            }

            var subdomains = dbContext.Units.Select(x =>
                string.Concat("https://",x.UnitCode, ".merterr.com")
            ).ToList();

            var policyBuilder = new CorsPolicyBuilder();
            policyBuilder.WithOrigins(subdomains.ToArray())
                          .AllowAnyHeader()
                          .AllowAnyMethod();
            return app.UseMiddleware<CorsMiddleware>(policyBuilder.Build());
        }
    }
}

Yukarıdaki kodda dbContext parametresi ile veritabanına erişiyoruz. Veritabanından birimlerin kodunu çekerek sistemimizdeki subdomain’lere erişiyoruz. Daha sonra bu subdomain’leri cors policy builder’a ekliyoruz ve build ediyoruz.

Kolay Gelsin :)