Global query filters in Entity Framework Core (EF Core) is a powerful feature that can be effectively used to manage data access patterns.

Global query filters are LINQ query predicates applied to EF Core entity models. These filters are automatically applied to all queries that involve the corresponding entities. This is especially useful in multi-tenant applications or scenarios requiring soft deletion.

In EF Core 10, Global Query Filters were renamed to Named Query Filters.

This update now solves a significant limitation EF Core previously had: support for multiple global query filters on a single entity.

In this post, we will explore:

• Query Filters for a Soft Delete use case
• Query Filters for a Multi-Tenant application
• Named Query Filters

Let's dive in.

Let's explore a use case where global query filters are particularly useful - entity soft deletion. In some applications, entities can't be completely deleted from the database and should remain for statistics and historical purposes. Or to ensure that related data remains unchanged, i.e, referenced by foreign keys. A solution for this use case is soft deletion.

Soft deletion is implemented by adding an is_deleted column to the database table for required entities. Whenever an entity is considered deleted, this column is set to true. In most application database queries, "deleted" entities should be ignored in read operations and not be visible to end users.

Let's explore an example for the following entities:

csharp
1public class Author
2{
3    public required Guid Id { get; set; }
4    public required string Name { get; set; }
5    public required string Country { get; set; }
6    public required List<Book> Books { get; set; } = [];
7}
8
9public class Book
10{
11    public required Guid Id { get; set; }
12    public required string Title { get; set; }
13    public required int Year { get; set; }
14    public required bool IsDeleted { get; set; }
15    public required Guid TenantId { get; set; }
16    public required Author Author { get; set; }
17}

We need to create and set up our DbContext with a global query filter:

csharp
1public class ApplicationDbContext : DbContext
2{
3    public DbSet<Author> Authors { get; set; } = default!;
4    
5    public DbSet<Book> Books { get; set; } = default!;
6    
7    public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options) : base(options)
8    {
9    }
10
11    protected override void OnModelCreating(ModelBuilder modelBuilder)
12    {
13        modelBuilder.Entity<Book>()
14            .HasQueryFilter(x => !x.IsDeleted);
15        
16        base.OnModelCreating(modelBuilder);
17        
18        modelBuilder.Entity<Author>(entity =>
19        {
20            entity.ToTable("authors");
21
22            entity.HasKey(x => x.Id);
23            entity.HasIndex(x => x.Name);
24            
25            entity.Property(x => x.Id).IsRequired();
26            entity.Property(x => x.Name).IsRequired();
27            entity.Property(x => x.Country).IsRequired();
28            
29            entity.HasMany(x => x.Books)
30                .WithOne(x => x.Author);
31        });
32        
33        modelBuilder.Entity<Book>(entity =>
34        {
35            entity.ToTable("books");
36
37            entity.HasKey(x => x.Id);
38            entity.HasIndex(x => x.Title);
39            
40            entity.Property(x => x.Id).IsRequired();
41            entity.Property(x => x.Title).IsRequired();
42            entity.Property(x => x.Year).IsRequired();
43            entity.Property(x => x.IsDeleted).IsRequired();
44
45            entity.HasOne(x => x.Author)
46                .WithMany(x => x.Books);
47        });
48    }
49}

In this code, we're applying a query filter to the Book entity on the IsDeleted property:

csharp
1modelBuilder.Entity<Book>()
2    .HasQueryFilter(x => !x.IsDeleted);

Here we are filtering out all softly deleted books from the result query. When querying books from DbContext, this query filter is applied automatically. Let's have a look at the following minimal API endpoint:

csharp
1app.MapGet("/api/books", async (ApplicationDbContext dbContext) =>
2{
3    var nonDeletedBooks = await dbContext.Books.ToListAsync();
4    return Results.Ok(nonDeletedBooks);
5});

Every time we query books, we only get those that are not deleted, thus we don't need to use a LINQ Where statement in all DbContext queries.

In some cases, however, we might need to access all entities and ignore the query filter. EF Core has a special method called IgnoreQueryFilters for such a case:

csharp
1app.MapGet("/api/all-books", async (ApplicationDbContext dbContext) =>
2{
3    var allBooks = await dbContext.Books
4        .IgnoreQueryFilters()
5        .Where(x => x.IsDeleted)
6        .ToListAsync();
7    
8    return Results.Ok(allBooks);
9});

That way, all the books are retrieved from the database, and the query filter on the Book entity is completely ignored.

Another practical use case for global query filters is multi-tenancy. A multi-tenant application shares a single software instance across multiple customers. All customer data should not be visible to other customers.

Let's explore the simplest implementation of multi-tenancy: storing all data in a single database and table.

First, we need to add a TenantId property to the Books entity:

csharp
1public class Book
2{
3    // Other properties ...
4    
5    public required Guid TenantId { get; set; }
6}

Second, we need to update the DbContext:

csharp
1public class ApplicationDbContext : DbContext
2{
3    private readonly Guid? _currentTenantId;
4    
5    public DbSet<Author> Authors { get; set; } = default!;
6    
7    public DbSet<Book> Books { get; set; } = default!;
8    
9    public ApplicationDbContext(
10        DbContextOptions<ApplicationDbContext> options,
11        ITenantService tenantService) : base(options)
12    {
13        _currentTenantId = tenantService.GetCurrentTenantId();
14    }
15
16    protected override void OnModelCreating(ModelBuilder modelBuilder)
17    {
18        modelBuilder.Entity<Book>()
19            .HasQueryFilter(x => x.TenantId == _currentTenantId);
20        
21        base.OnModelCreating(modelBuilder);
22        
23        // Rest of the code remains unchanged
24    }
25}

In this code, we've updated the query filter and added an x.TenantId == _currentTenantId statement. Since we're creating a DbContext per request, we can inject the current tenant id from the request (the customer identifier accessing data in our application).

Here's a simple tenant service implementation that retrieves a tenant id from HTTP request headers:

csharp
1public interface ITenantService
2{
3    Guid? GetCurrentTenantId();
4}
5
6public class TenantService : ITenantService
7{
8    private readonly Guid? _currentTenantId;
9    
10    public TenantService(IHttpContextAccessor accessor)
11    {
12        var headers = accessor.HttpContext?.Request.Headers;
13
14        _currentTenantId = headers.TryGetValue("Tenant-Id", out var value) is true
15            ? Guid.Parse(value.ToString())
16            : null;
17    }
18
19    public Guid? GetCurrentTenantId() => _currentTenantId;
20}

Now let's create a corresponding minimal API endpoint:

csharp
1app.MapGet("/api/tenant-books", async (ApplicationDbContext dbContext) =>
2{
3    var tenantBooks = await dbContext.Books.ToListAsync();
4    return Results.Ok(tenantBooks);
5});

On every read query, a tenant ID global query filter is applied to ensure data integrity. As a result, when calling this endpoint, each customer can only retrieve their own books.

In EF Core 10, Global Query Filters were renamed to Named Query Filters.

This update now solves a significant limitation EF Core previously had: support for multiple global query filters on a single entity.

In the application, we might need to have multiple query filters for the same entity:

• One for soft deletion
• One for multi-tenancy

Let's explore how we can create two named query filters for the Book entity:

csharp
1public class ApplicationDbContext : DbContext
2{
3    public const string SoftDeleteFilter = nameof(SoftDeleteFilter);
4    public const string TenantFiler = nameof(TenantFiler);
5
6    // ...
7
8    protected override void OnModelCreating(ModelBuilder modelBuilder)
9    {
10        modelBuilder.Entity<Book>()
11            .HasQueryFilter(SoftDeleteFilter, x => !x.IsDeleted)
12            .HasQueryFilter(TenantFiler, x => x.TenantId == _currentTenantId);
13        
14        // ...
15    }
16}

Each time we query books, both filters are applied automatically:

csharp
1app.MapGet("/api/tenant-books", async (ApplicationDbContext dbContext) =>
2{
3    var tenantBooks = await dbContext.Books
4        .ToListAsync();
5
6    return Results.Ok(tenantBooks);
7});

This endpoint will return all books that are not deleted and belong to the current tenant.

To ignore a specific filter, we can use the IgnoreQueryFilters method and get all tenant books, including softly deleted ones:

csharp
1app.MapGet("/api/tenant-books", async (ApplicationDbContext dbContext) =>
2{
3    var tenantBooks = await dbContext.Books
4        .IgnoreQueryFilters([ApplicationDbContext.SoftDeleteFilter])
5        .ToListAsync();
6
7    return Results.Ok(tenantBooks);
8});

A good practice is to use constants for the filter names.

Global query filters in EF Core is a powerful feature that enforces data access rules consistently across the application.

They are particularly useful in multi-tenant architectures and in scenarios such as soft deletion, ensuring that filter queries are automatically applied to all read operations.

By applying these filters to EF Core entity models, you can significantly simplify your data access code, ensure data integrity and reduce the risk of forgetting to apply important filters to the read operations.

In EF Core 10, they got a nice update: now multiple query filters can be applied to the same entity. You need to name the filters and ignore some of them when needed.

Hope you find this newsletter useful. See you next time.