Explore Global Query Filters in EF Core

author.cs

public class Author
{
    // omitted code

    public Guid Id { get; private set; }
    public string FirstName { get; private set; }
    public string LastName { get; private set; }
    public DateTime DateOfBirth { get; private set; }
    public bool IsDeleted { get; private set; }
}

c-sharp-query.cs

var authors = context.Authors
                .Where(author => author.LastName.StartsWith("joh"));

db-context.cs

public class BookstoreDbContext : DbContext
{
    // omitted code

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Author>()
                    .HasQueryFilter(author => !author.IsDeleted);

        base.OnModelCreating(modelBuilder);
    }

    public DbSet<Author> Authors { get; set; }
}

ICanBeSoftDeleted.cs

public interface ICanBeSoftDeleted
{
    bool IsDeleted{ get; set;}
}

public class Author : ICanBeSoftDeleted
{
    // omitted code
}

public class Book : ICanBeSoftDeleted
{
    // omitted code
}

ignore-filter.cs

var authors = context.Authors
                .Where(author => author.LastName.StartsWith("joh"))
                .IgnoreQueryFilters();

on-model-creating.cs

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    var softDeleteEntities = typeof(ICanBeSoftDeleted).Assembly.GetTypes()
                .Where(type => typeof(ICanBeSoftDeleted)
                                .IsAssignableFrom(type)
                                && type.IsClass
                                && !type.IsAbstract);

    foreach (var softDeleteEntity in softDeleteEntities)
    {
        modelBuilder.Entity(softDeleteEntity)
                    .HasQueryFilter(
                        GenerateQueryFilterLambda(softDeleteEntity)
                        );
    }

    base.OnModelCreating(modelBuilder);
}

query-filter.cs

private LambdaExpression GenerateQueryFilterLambdaExpression(Type type)
{
    // we should generate:  e => e.IsDeleted == false
    // or: e => !e.IsDeleted

    // e =>
    var parameter = Expression.Parameter(type, "e");

    // false
    var falseConstant = Expression.Constant(false);

    // e.IsDeleted
    var propertyAccess = Expression.PropertyOrField(parameter, nameof(ICanBeSoftDeleted.IsDeleted));

    // e.IsDeleted == false
    var equalExpression = Expression.Equal(propertyAccess, falseConstant);

    // e => e.IsDeleted == false
    var lambda = Expression.Lambda(equalExpression, parameter);

    return lambda;
}

sql-query.sql

SELECT  a.*
FROM    dbo.Authors as a
WHERE   a.LastName  LIKE 'joh%'
    AND a.IsDelete  =     0