Yazar: mennan

Global Query Filters, entity nesnelerinde özellikle Where sorgu operatörüyle gönderdiğimiz sorguların her sorguya otomatik olarak eklemek için kullanılır. Kullanım senaryolarına örnek vermek gerekirse soft delete veya multi tenancy sorguları verilebilir. Bu yazıda örnek olması açısından soft delete senaryosu üzerinden ilerleyeceğiz. Global Query Filter tanımları DbContext sınıfının virtual olan OnModelCreating metodunda tanımlanır.

Bu uygulamamızda yapacağımız örnekte Users tablosunda IsRemoved kolonunun değeri false olan kullanıcıların listesinin gelmesi sağlanacaktır. Global Query Filter kullanmadan önce yapacağımız sorgu aşağıki gibidir.

context.Users.Where(u => !u.IsRemoved).ToList();

Normalde bu kullanım doğrudur. Ancak kodumuzun birçok yerinde Users tablosundan veri çekerken Where ile sürekli IsRemoved kontrolünün yapılması gerekmektedir. Bu işlemde kodun bakım maliyetini artırmaktadır. Bu işlemi Global Query Filter ile otomatikleştirerek kodumuzu aşağıdaki şekilde kullanmaya başlayacağız.

context.Users.ToList();

Şimdi uygulamamızı geliştirmeye başlayabiliriz. Örnek uygulama için ASP.NET Core MVC projesi oluşturacağım. Aşağıdaki komutu terminale yazarak yeni bir proje oluşturuyorum.

dotnet new mvc -n EFCore.GlobalQueryFiltersSample

İlk önce projeme IRemovable isminde bir interface ekliyorum ve içeriğini aşağıdaki şekilde düzenliyorum.

public interface IRemovable
{
    bool IsRemoved { get; set; }
}

Projeme SampleDbContext isminde bir sınıf ekliyorum ve içeriğini aşağıdaki şekilde değiştiriyorum.

using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Microsoft.EntityFrameworkCore;

namespace EFCore.GlobalQueryFiltersSample
{
    [Table("Users")]
    public class User : IRemovable
    {
        [Key]
        public Guid UserId { get; set; }
        public string UserName { get; set; }
        public string Email { get; set; }
        public string Name { get; set; }
        public bool IsRemoved { get; set; }
    }

    public class SampleDbContext : DbContext
    {
        public DbSet<User> Users { get; set; }

        public SampleDbContext(DbContextOptions<SampleDbContext> options) : base(options)
        {
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.Entity<User>().HasQueryFilter(u => !u.IsRemoved);
            base.OnModelCreating(modelBuilder);
        }
    }
}

Global Query Filter tanımını SampleDbContext sınıfının 29. satırında yaptık. Global Query Filter tanımını HasQueryFilter metodu aracılığıyla yapmaktayız. Parametre olarak aldığı Expression ile sorgu tanımımızı gerçekleştirdik. Bu sorgu tanımına göre User tipindeki nesnelere ait verileri getirirken IsRemoved alanındaki değeri false olanları getirmesini sağladık.

Bu işlemleri yaptıktan sonra Entity Framework’ün ayarlarını yapmaya geldi. Ben bu yazı için InMemory database kullanacağım. Entity framework’ü InMemory database ile kullanabilmek için Microsoft.EntityFrameworkCore.InMemory paketini projeye eklememiz gerekmektedir. Projeye paketi eklemek için aşağıdaki komutu terminale yazmamız gerekmektedir.

dotnet add package Microsoft.EntityFrameworkCore.InMemory --version 2.2.4

İlgili paketi projeye ekledikten sonra DbContext’imizi ASP.NET Core uygulamıza tanıtmak kaldı. İlgili işlemi Startup.cs dosyamızda yapacağız. Startup.cs dosyamızın içeriği aşağıdaki gibidir.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.HttpsPolicy;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;

namespace EFCore.GlobalQueryFiltersSample
{
    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.Configure<CookiePolicyOptions>(options =>
            {
                // This lambda determines whether user consent for non-essential cookies is needed for a given request.
                options.CheckConsentNeeded = context => true;
                options.MinimumSameSitePolicy = SameSiteMode.None;
            });

            services.AddDbContext<SampleDbContext>(options => options.UseInMemoryDatabase("Sample"));
            services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_2);
        }

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
                // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
                app.UseHsts();
            }

            app.UseHttpsRedirection();
            app.UseStaticFiles();
            app.UseCookiePolicy();

            app.UseMvc(routes =>
            {
                routes.MapRoute(
                    name: "default",
                    template: "{controller=Home}/{action=Index}/{id?}");
            });
        }
    }
}

Şimdi controller’ımıza geçip uygulamamızı test etmeye geldi. Ben HomeController üzerinde çalışacağım. İçeriği aşağıdaki gibidir.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Mvc;
using EFCore.GlobalQueryFiltersSample.Models;

namespace EFCore.GlobalQueryFiltersSample.Controllers
{
    public class HomeController : Controller
    {
        private readonly SampleDbContext _context;

        public HomeController(SampleDbContext context)
        {
            _context = context;

            var users = new List<User>
                {
                    new User {
                        UserId = Guid.NewGuid(),
                        UserName = "mennan",
                        Name = "Mennan",
                        IsRemoved = false
                    },
                    new User {
                        UserId = Guid.NewGuid(),
                        UserName = "anil",
                        Name = "Anıl",
                        IsRemoved = true
                    }
                };

            _context.Users.AddRange(users);
            _context.SaveChanges();
        }

        public IActionResult Index()
        {
            var users = _context.Users.ToList();

            return View(users);
        }

        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
}

Controller’ın constructor metodunda DbContext’imizin instance’ı DI ile alıyoruz ve örnek verilerimizi veritabanına kaydediyoruz. Index action’ında ise veritabanındaki tüm kayıtların listesini alıyoruz. Şimdi Index view’ın içeriğini aşağıdaki şekilde değiştiriyoruz.

@model List<User>
@{
    ViewData["Title"] = "Home Page";
}

<ul>
    @foreach (var user in Model)
    {
        <li>
            @user.Name - @user.UserName
        </li>
    }
</ul>

Gerekli değişiklikleri yaptıktan sonra sıra uygulamamızı test etmeye geldi. Terminalden dotnet run komutunu yazarak uygulamamızı tarayıcı üzerinden açalım.

Normalde veritabanımızda 2 adet kayıt olduğu halde sadece IsRemoved değeri false olan kayıt gelmiştir.

Bazı durumlarda GlobalQueryFilter’ı pasif hale getirmemiz gerekebilir. Bunun için LINQ sorgunuza IgnoreQueryFilters metodunu eklemeniz gerekmektedir. Örnek kullanımı aşağıdaki gibidir.

context.Users.IgnoreQueryFilters().ToList();

IRemovable’dan türeyen tüm entity tipleri için tek tek Global Query Filter tanımı yapmamıza gerek yok. Yapmamız gereken reflection ile IRemovable arayüzünden türeyen tipleri bulup bunları DbContext’in OnModelCreating metodunda dinamik olarak eklemek. Bunun için SampleDbContext sınıfımızı aşağıdaki şekilde düzenliyoruz.

using System;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata;

namespace EFCore.GlobalQueryFiltersSample
{
    [Table("Users")]
    public class User : IRemovable
    {
        [Key]
        public Guid UserId { get; set; }
        public string UserName { get; set; }
        public string Email { get; set; }
        public string Name { get; set; }
        public bool IsRemoved { get; set; }
    }

    public class SampleDbContext : DbContext
    {
        public DbSet<User> Users { get; set; }
        private static readonly MethodInfo ConfigureGlobalFiltersMethodInfo = typeof(SampleDbContext).GetMethod(nameof(ConfigureGlobalFilters), BindingFlags.Instance | BindingFlags.NonPublic);

        public SampleDbContext(DbContextOptions<SampleDbContext> options) : base(options)
        {
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            foreach (var entityType in modelBuilder.Model.GetEntityTypes())
            {
                ConfigureGlobalFiltersMethodInfo
                    .MakeGenericMethod(entityType.ClrType)
                    .Invoke(this, new object[] { modelBuilder, entityType });
            }

            base.OnModelCreating(modelBuilder);
        }

        protected void ConfigureGlobalFilters<TEntity>(ModelBuilder modelBuilder, IMutableEntityType entityType) where TEntity : class
        {
            if (entityType.BaseType != null || !ShouldFilterEntity<TEntity>(entityType)) return;
            var filterExpression = CreateFilterExpression<TEntity>();
            if (filterExpression == null) return;
            if (entityType.IsQueryType)
                modelBuilder.Query<TEntity>().HasQueryFilter(filterExpression);
            else
                modelBuilder.Entity<TEntity>().HasQueryFilter(filterExpression);
        }

        protected virtual bool ShouldFilterEntity<TEntity>(IMutableEntityType entityType) where TEntity : class
        {
            return typeof(IRemovable).IsAssignableFrom(typeof(TEntity));
        }

        protected Expression<Func<TEntity, bool>> CreateFilterExpression<TEntity>() where TEntity : class
        {
            Expression<Func<TEntity, bool>> expression = null;

            if (typeof(IRemovable).IsAssignableFrom(typeof(TEntity)))
            {
                Expression<Func<TEntity, bool>> removedFilter = e => !((IRemovable)e).IsRemoved;
                expression = expression == null ? removedFilter : CombineExpressions(expression, removedFilter);
            }

            return expression;
        }

        protected Expression<Func<T, bool>> CombineExpressions<T>(Expression<Func<T, bool>> expression1, Expression<Func<T, bool>> expression2)
        {
            return ExpressionCombiner.Combine(expression1, expression2);
        }
    }
}

DbContext’i bu şekilde düzenlediğimiz zaman artık elle IRemovable için elle tekrardan tanıtma işlemi yapmamıza gerek kalmamıştır.

Yazıda bahsi geçen uygulamanın kaynak kodlarına https://github.com/mennan/efcore-globalqueryfilters-sample adresinden ulaşabilirsiniz.