dotnet22 · September 5, 2024 09:26 · Mar 23, 2021 · Aug 7, 2020 · Apr 30, 2020 · Apr 30, 2020
diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -51,40 +51,29 @@ static void SetQueryFilter<TEntity, TEntityInterface>(
         var concreteExpression = filterExpression
             .Convert<TEntityInterface, TEntity>();
         builder.Entity<TEntity>()
-            .AddQueryFilter(concreteExpression);
+            .AppendQueryFilter(concreteExpression);
     }
 
-    // CREDIT: The AddQueryFilter and GetInternalEntityTypeBuilder methods come from this comment:
-    // https://github.com/aspnet/EntityFrameworkCore/issues/10275#issuecomment-457504348
-    // And was written by https://github.com/YZahringer
-    static void AddQueryFilter<T>(this EntityTypeBuilder entityTypeBuilder, Expression<Func<T, bool>> expression)
+    // CREDIT: This comment by magiak on GitHub https://github.com/dotnet/efcore/issues/10275#issuecomment-785916356
+    static void AppendQueryFilter<T>(this EntityTypeBuilder entityTypeBuilder, Expression<Func<T, bool>> expression)
+        where T : class
     {
         var parameterType = Expression.Parameter(entityTypeBuilder.Metadata.ClrType);
+
         var expressionFilter = ReplacingExpressionVisitor.Replace(
             expression.Parameters.Single(), parameterType, expression.Body);
 
-        var internalEntityTypeBuilder = entityTypeBuilder.GetInternalEntityTypeBuilder();
-        var queryFilter = internalEntityTypeBuilder?.Metadata.GetQueryFilter();
-        if (queryFilter != null)
+        if (entityTypeBuilder.Metadata.GetQueryFilter() != null)
         {
+            var currentQueryFilter = entityTypeBuilder.Metadata.GetQueryFilter();
             var currentExpressionFilter = ReplacingExpressionVisitor.Replace(
-                queryFilter.Parameters.Single(), parameterType, queryFilter.Body);
+                currentQueryFilter.Parameters.Single(), parameterType, currentQueryFilter.Body);
             expressionFilter = Expression.AndAlso(currentExpressionFilter, expressionFilter);
         }
 
         var lambdaExpression = Expression.Lambda(expressionFilter, parameterType);
         entityTypeBuilder.HasQueryFilter(lambdaExpression);
     }
-
-    static InternalEntityTypeBuilder? GetInternalEntityTypeBuilder(
-        this EntityTypeBuilder entityTypeBuilder)
-    {
-        var internalEntityTypeBuilder = typeof(EntityTypeBuilder)
-            .GetProperty("Builder", BindingFlags.NonPublic | BindingFlags.Instance)?
-            .GetValue(entityTypeBuilder) as InternalEntityTypeBuilder;
-
-        return internalEntityTypeBuilder;
-    }
 }
 
 public static class ExpressionExtensions

diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -1,3 +1,7 @@
+/*
+Copyright Phil Haack
+Licensed under the MIT license - https://github.com/haacked/CodeHaacks/blob/main/LICENSE.
+*/
 using System;
 using System.Linq;
 using System.Linq.Expressions;

diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -5,7 +5,7 @@
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Metadata.Builders;
 using Microsoft.EntityFrameworkCore.Metadata.Internal;
-using Remotion.Linq.Parsing.ExpressionVisitors;
+using Microsoft.EntityFrameworkCore.Query;
 
 public static class ModelBuilderExtensions
 {

diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -1,3 +1,12 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Remotion.Linq.Parsing.ExpressionVisitors;
+
 public static class ModelBuilderExtensions
 {
     static readonly MethodInfo SetQueryFilterMethod = typeof(ModelBuilderExtensions)

diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -1,13 +1,3 @@
-using System;
-using System.Collections.ObjectModel;
-using System.Linq;
-using System.Linq.Expressions;
-using System.Reflection;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-using Microsoft.EntityFrameworkCore.Metadata.Internal;
-using Remotion.Linq.Parsing.ExpressionVisitors;
-
 public static class ModelBuilderExtensions
 {
     static readonly MethodInfo SetQueryFilterMethod = typeof(ModelBuilderExtensions)
@@ -23,7 +13,7 @@ public static void SetQueryFilterOnAllEntities<TEntityInterface>(
             .Select(t => t.ClrType)
             .Where(t => typeof(TEntityInterface).IsAssignableFrom(t)))
         {
-            builder.SetEntityQueryFilter<TEntityInterface>(
+            builder.SetEntityQueryFilter(
                 type,
                 filterExpression);
         }
@@ -51,7 +41,7 @@ static void SetQueryFilter<TEntity, TEntityInterface>(
             .AddQueryFilter(concreteExpression);
     }
 
-    // The AddQueryFilter and GetInternalEntityTypeBuilder methods come from this comment:
+    // CREDIT: The AddQueryFilter and GetInternalEntityTypeBuilder methods come from this comment:
     // https://github.com/aspnet/EntityFrameworkCore/issues/10275#issuecomment-457504348
     // And was written by https://github.com/YZahringer
     static void AddQueryFilter<T>(this EntityTypeBuilder entityTypeBuilder, Expression<Func<T, bool>> expression)
@@ -61,19 +51,20 @@ static void AddQueryFilter<T>(this EntityTypeBuilder entityTypeBuilder, Expressi
             expression.Parameters.Single(), parameterType, expression.Body);
 
         var internalEntityTypeBuilder = entityTypeBuilder.GetInternalEntityTypeBuilder();
-        if (internalEntityTypeBuilder.Metadata.QueryFilter != null)
+        var queryFilter = internalEntityTypeBuilder?.Metadata.GetQueryFilter();
+        if (queryFilter != null)
         {
-            var currentQueryFilter = internalEntityTypeBuilder.Metadata.QueryFilter;
             var currentExpressionFilter = ReplacingExpressionVisitor.Replace(
-                currentQueryFilter.Parameters.Single(), parameterType, currentQueryFilter.Body);
+                queryFilter.Parameters.Single(), parameterType, queryFilter.Body);
             expressionFilter = Expression.AndAlso(currentExpressionFilter, expressionFilter);
         }
 
         var lambdaExpression = Expression.Lambda(expressionFilter, parameterType);
         entityTypeBuilder.HasQueryFilter(lambdaExpression);
     }
 
-    static InternalEntityTypeBuilder GetInternalEntityTypeBuilder(this EntityTypeBuilder entityTypeBuilder)
+    static InternalEntityTypeBuilder? GetInternalEntityTypeBuilder(
+        this EntityTypeBuilder entityTypeBuilder)
     {
         var internalEntityTypeBuilder = typeof(EntityTypeBuilder)
             .GetProperty("Builder", BindingFlags.NonPublic | BindingFlags.Instance)?

diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -51,6 +51,9 @@ static void SetQueryFilter<TEntity, TEntityInterface>(
             .AddQueryFilter(concreteExpression);
     }
 
+    // The AddQueryFilter and GetInternalEntityTypeBuilder methods come from this comment:
+    // https://github.com/aspnet/EntityFrameworkCore/issues/10275#issuecomment-457504348
+    // And was written by https://github.com/YZahringer
     static void AddQueryFilter<T>(this EntityTypeBuilder entityTypeBuilder, Expression<Func<T, bool>> expression)
     {
         var parameterType = Expression.Parameter(entityTypeBuilder.Metadata.ClrType);

diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -1,8 +1,12 @@
 using System;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Metadata.Internal;
+using Remotion.Linq.Parsing.ExpressionVisitors;
 
 public static class ModelBuilderExtensions
 {
@@ -44,16 +48,37 @@ static void SetQueryFilter<TEntity, TEntityInterface>(
         var concreteExpression = filterExpression
             .Convert<TEntityInterface, TEntity>();
         builder.Entity<TEntity>()
-            .HasQueryFilter(concreteExpression);
+            .AddQueryFilter(concreteExpression);
     }
-}
+
+    static void AddQueryFilter<T>(this EntityTypeBuilder entityTypeBuilder, Expression<Func<T, bool>> expression)
+    {
+        var parameterType = Expression.Parameter(entityTypeBuilder.Metadata.ClrType);
+        var expressionFilter = ReplacingExpressionVisitor.Replace(
+            expression.Parameters.Single(), parameterType, expression.Body);
 
-// -------------------------------------------------------
+        var internalEntityTypeBuilder = entityTypeBuilder.GetInternalEntityTypeBuilder();
+        if (internalEntityTypeBuilder.Metadata.QueryFilter != null)
+        {
+            var currentQueryFilter = internalEntityTypeBuilder.Metadata.QueryFilter;
+            var currentExpressionFilter = ReplacingExpressionVisitor.Replace(
+                currentQueryFilter.Parameters.Single(), parameterType, currentQueryFilter.Body);
+            expressionFilter = Expression.AndAlso(currentExpressionFilter, expressionFilter);
+        }
 
-using System;
-using System.Collections.ObjectModel;
-using System.Linq;
-using System.Linq.Expressions;
+        var lambdaExpression = Expression.Lambda(expressionFilter, parameterType);
+        entityTypeBuilder.HasQueryFilter(lambdaExpression);
+    }
+
+    static InternalEntityTypeBuilder GetInternalEntityTypeBuilder(this EntityTypeBuilder entityTypeBuilder)
+    {
+        var internalEntityTypeBuilder = typeof(EntityTypeBuilder)
+            .GetProperty("Builder", BindingFlags.NonPublic | BindingFlags.Instance)?
+            .GetValue(entityTypeBuilder) as InternalEntityTypeBuilder;
+
+        return internalEntityTypeBuilder;
+    }
+}
 
 public static class ExpressionExtensions
 {
@@ -74,13 +99,13 @@ class ParameterTypeVisitor<TSource, TTarget> : ExpressionVisitor
         protected override Expression VisitParameter(ParameterExpression node)
         {
             return _parameters?.FirstOrDefault(p => p.Name == node.Name)
-                ?? (node.Type == typeof(TSource) ? Expression.Parameter(typeof(TTarget), node.Name) : node);
+                   ?? (node.Type == typeof(TSource) ? Expression.Parameter(typeof(TTarget), node.Name) : node);
         }
 
         protected override Expression VisitLambda<T>(Expression<T> node)
         {
-            _parameters = VisitAndConvert<ParameterExpression>(node.Parameters, "VisitLambda");
+            _parameters = VisitAndConvert(node.Parameters, "VisitLambda");
             return Expression.Lambda(Visit(node.Body), _parameters);
         }
     }
-}
+}
diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -15,6 +15,7 @@ public static void SetQueryFilterOnAllEntities<TEntityInterface>(
         Expression<Func<TEntityInterface, bool>> filterExpression)
     {
         foreach (var type in builder.Model.GetEntityTypes()
+            .Where(t => t.BaseType == null)
             .Select(t => t.ClrType)
             .Where(t => typeof(TEntityInterface).IsAssignableFrom(t)))
         {

diff --git a/ModelBuilderExtensions.cs b/ModelBuilderExtensions.cs
@@ -0,0 +1,85 @@
+using System;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore;
+
+public static class ModelBuilderExtensions
+{
+    static readonly MethodInfo SetQueryFilterMethod = typeof(ModelBuilderExtensions)
+            .GetMethods(BindingFlags.NonPublic | BindingFlags.Static)
+            .Single(t => t.IsGenericMethod && t.Name == nameof(SetQueryFilter));
+
+    public static void SetQueryFilterOnAllEntities<TEntityInterface>(
+        this ModelBuilder builder,
+        Expression<Func<TEntityInterface, bool>> filterExpression)
+    {
+        foreach (var type in builder.Model.GetEntityTypes()
+            .Select(t => t.ClrType)
+            .Where(t => typeof(TEntityInterface).IsAssignableFrom(t)))
+        {
+            builder.SetEntityQueryFilter<TEntityInterface>(
+                type,
+                filterExpression);
+        }
+    }
+
+    static void SetEntityQueryFilter<TEntityInterface>(
+        this ModelBuilder builder,
+        Type entityType,
+        Expression<Func<TEntityInterface, bool>> filterExpression)
+    {
+         SetQueryFilterMethod
+             .MakeGenericMethod(entityType, typeof(TEntityInterface))
+            .Invoke(null, new object[] { builder, filterExpression });
+    }
+
+    static void SetQueryFilter<TEntity, TEntityInterface>(
+        this ModelBuilder builder,
+        Expression<Func<TEntityInterface, bool>> filterExpression)
+            where TEntityInterface : class
+            where TEntity : class, TEntityInterface
+    {
+        var concreteExpression = filterExpression
+            .Convert<TEntityInterface, TEntity>();
+        builder.Entity<TEntity>()
+            .HasQueryFilter(concreteExpression);
+    }
+}
+
+// -------------------------------------------------------
+
+using System;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Linq.Expressions;
+
+public static class ExpressionExtensions
+{
+    // This magic is courtesy of this StackOverflow post.
+    // https://stackoverflow.com/questions/38316519/replace-parameter-type-in-lambda-expression
+    // I made some tweaks to adapt it to our needs - @haacked
+    public static Expression<Func<TTarget, bool>> Convert<TSource, TTarget>(
+        this Expression<Func<TSource, bool>> root)
+    {
+        var visitor = new ParameterTypeVisitor<TSource, TTarget>();
+        return (Expression<Func<TTarget, bool>>)visitor.Visit(root);
+    }
+
+    class ParameterTypeVisitor<TSource, TTarget> : ExpressionVisitor
+    {
+        private ReadOnlyCollection<ParameterExpression> _parameters;
+
+        protected override Expression VisitParameter(ParameterExpression node)
+        {
+            return _parameters?.FirstOrDefault(p => p.Name == node.Name)
+                ?? (node.Type == typeof(TSource) ? Expression.Parameter(typeof(TTarget), node.Name) : node);
+        }
+
+        protected override Expression VisitLambda<T>(Expression<T> node)
+        {
+            _parameters = VisitAndConvert<ParameterExpression>(node.Parameters, "VisitLambda");
+            return Expression.Lambda(Visit(node.Body), _parameters);
+        }
+    }
+}