Creating a generic EF Query Filter with .NET 6

Question

So I have a filter on my DbContext like this:

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        var stringList = new List<string>(); // <-- actually a service
        var guidList = new List<Guid?>(); // <-- actually a service

        modelBuilder.Entity<MyEntity>().HasQueryFilter(x =>
            (stringList.Contains(x.StringId))
                || (guidList.Contains(x.GuidId ?? Guid.Empty)));

    }

I'd like to abstract it out to something more generic like the below, but it doesn't like the params I'm passing for my filter. Any thoughts on what's causing the issue?

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);

        modelBuilder.MyFilter<MyEntity>(x => x.StringId,
            x => x.GuidId);

    }


        
    public static void MyFilter<TEntity>(this ModelBuilder modelBuilder,
        Func<TEntity, string> filterOne,
        Func<TEntity, Guid?> filterTwo)
        where TEntity : class
    {
        var stringList = new List<string>(); // <-- actually a service
        var guidList = new List<Guid?>(); // <-- actually a service

        Expression<Func<TEntity, bool>> filterExpr = entity =>
            (stringList.Contains(filterOne(entity)))
                || (guidList.Contains(filterTwo(entity) ?? Guid.Empty));
        
        foreach (var mutableEntityType in modelBuilder.Model.GetEntityTypes()
                     .Where(m => m.ClrType.IsAssignableTo(typeof(TEntity))))
        {
            // modify expression to handle correct child type
            var parameter = Expression.Parameter(mutableEntityType.ClrType);
            var body = ReplacingExpressionVisitor
                .Replace(filterExpr.Parameters.First(), parameter, filterExpr.Body);
            var lambdaExpression = Expression.Lambda(body, parameter);

            // set filter
            mutableEntityType.SetQueryFilter(lambdaExpression);
        }
    }

The marked answer was 99% of the way there but technically won't work. here is a working implementation:

using System;
using System.Linq;
using System.Collections.Generic;
using System.Linq.Expressions;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Query;
using System.ComponentModel.DataAnnotations;

public class Program
{
    public static void Main()
    {
        var options = new DbContextOptionsBuilder<TestDbContext>().UseInMemoryDatabase("inmemory").Options;
        var context = new TestDbContext(options);
        var fakeEntityVisible = new TestingEntity();
        fakeEntityVisible.StringId = "abc123";
        context.TestingEntities.AddRange(fakeEntityVisible, new TestingEntity(), new TestingEntity());
        context.SaveChanges();
        var something = context.TestingEntities.ToList();
        var count = something.Count;
        Console.WriteLine($"Count {count} should be 1");
    }

    public class TestingEntity
    {
        [Key]
        public Guid Id { get; set; }

        public string StringId { get; set; }
    }

    public class TestDbContext : DbContext
    {
        public TestDbContext(DbContextOptions<TestDbContext> options) : base(options)
        {
        }

        public DbSet<TestingEntity> TestingEntities { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            base.OnModelCreating(modelBuilder);
            var stringList = new List<string>(); // <-- this is really a service
            stringList.Add("abc123");
            // THIS IS BROKEN
            modelBuilder.SimpleFilter<TestingEntity>(x => x.StringId);
        // THIS WORKS -- HOW TO ABSTRACT THIS?
        // modelBuilder.Entity<TestingEntity>().HasQueryFilter(x => stringList.Contains(x.StringId));
        }
    }
}

public static class Extensions
{
    public static void MyFilter<TEntity>(this ModelBuilder modelBuilder, Func<TEntity, string> stringId)
        where TEntity : class
    {
        var stringList = new List<string>(); // <-- this is really a service
        stringList.Add("abc123");
        Expression<Func<TEntity, bool>> filterExpr = entity => stringList.Contains(stringId(entity));
        foreach (var mutableEntityType in modelBuilder.Model.GetEntityTypes().Where(m => m.ClrType.IsAssignableTo(typeof(TEntity))))
        {
            // modify expression to handle correct child type
            var parameter = Expression.Parameter(mutableEntityType.ClrType);
            var body = ReplacingExpressionVisitor.Replace(filterExpr.Parameters.First(), parameter, filterExpr.Body);
            var lambdaExpression = Expression.Lambda(body, parameter);
            // set filter
            mutableEntityType.SetQueryFilter(lambdaExpression);
        }
    }

    public static void SimpleFilter<TEntity>(this ModelBuilder modelBuilder, Expression<Func<TEntity, string>> filterOne)
        where TEntity : class
    {
        var stringList = new List<string>(); // <-- this is really a service
        stringList.Add("abc123");
        var stringListExpr = Expression.Constant(stringList);
        foreach (var mutableEntityType in modelBuilder.Model.GetEntityTypes().Where(m => m.ClrType.IsAssignableTo(typeof(TEntity))))
        {
            var parameter = Expression.Parameter(mutableEntityType.ClrType, "e");
            var filter1 = Expression.Call(typeof(Enumerable), nameof(Enumerable.Contains), new[]{typeof(string)}, stringListExpr, ReplacingExpressionVisitor.Replace(filterOne.Parameters[0], parameter, filterOne.Body));
            
            var body = filter1; 
            var lambdaExpression = Expression.Lambda(body, parameter);
            // set filter
            mutableEntityType.SetQueryFilter(lambdaExpression);
        }
    }
}

Problem is mixing Func<T, bool> with Expression<Func<T, bool>>. When you build ExpressionTree it always should be Expression. — Svyatoslav Danyliv
– Svyatoslav Danyliv, Commented Feb 16, 2022 at 18:52

Svyatoslav Danyliv · Accepted Answer · 2022-02-18 15:50:32Z

1

Try this implementation. Sorry, not not tested:

public static void MyFilter<TEntity>(this ModelBuilder modelBuilder,
    Expression<Func<TEntity, string>> filterOne,
    Expression<Func<TEntity, Guid?>> filterTwo)
    where TEntity : class
{
    var stringList = new List<string>(); // <-- actually a service
    var guidList = new List<Guid?>(); // <-- actually a service

    var stringListExpr = Expression.Constant(stringList);
    var guidListExpr = Expression.Constant(guidList);

    foreach (var mutableEntityType in modelBuilder.Model.GetEntityTypes()
                    .Where(m => m.ClrType.IsAssignableTo(typeof(TEntity))))
    {
        var parameter = Expression.Parameter(mutableEntityType.ClrType, "e");

        // stringList.Contains(e.StrField)
        var filter1 = Expression.Call(typeof(Enumerable), nameof(Enumerable.Contains), new []{typeof(string)}, 
            stringListExpr,
            ReplacingExpressionVisitor.Replace(filterOne.Parameters[0], parameter, filterOne.Body));

        // guidList.Contains(e.GuidField)
        var filter2 = Expression.Call(typeof(Enumerable), nameof(Enumerable.Contains), new []{typeof(Guid?)}, 
            guidListExpr,
            ReplacingExpressionVisitor.Replace(filterTwo.Parameters[0], parameter, filterTwo.Body));

        // stringList.Contains(e.StrField) || guidList.Contains(e.GuidField)
        var body = Expression.OrElse(filter1, filter2);

        // e => stringList.Contains(e.StrField) || guidList.Contains(e.GuidField)
        var lambdaExpression = Expression.Lambda(body, parameter);

        // set filter
        mutableEntityType.SetQueryFilter(lambdaExpression);
    }
}

edited Feb 18, 2022 at 15:50

answered Feb 17, 2022 at 9:49

Svyatoslav Danyliv

28.2k4 gold badges24 silver badges46 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Paul DeVito Over a year ago

this is close, but getting an issue i can't resolve. made a fiddle for reference and removed the dual list aspect to keep it even more simple. dotnetfiddle.net/D3laqQ

Svyatoslav Danyliv Over a year ago

Sorry missed that you have passed Func<>, it should. be Expression<Func<TEntity, string>> filterOne, Expression<Func<TEntity, Guid?>> filterTwo)

Paul DeVito Over a year ago

i could i swore i tried that, but i must have updated something else along with it. regardless, that got it working (and the fiddle is updated). thanks! 🍻

Collectives™ on Stack Overflow

Creating a generic EF Query Filter with .NET 6

1 Answer 1

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related