在C#和EF Core中实现带关联查询的Specification模式

问题背景 #

在领域驱动设计（DDD）架构中，通过Repository的Specification模式对返回数据设置筛选条件，当前需要处理一张无导航属性的关联表PersonGroupMembership，实现跨表关联筛选（例如获取某个组下的所有人员，或某个人员所属的所有组）。

现有结构 #

数据库表结构 #

Group
===
uniqueidentifier Id
nvarchar(32) Name

PersonGroupMembership
===
uniqueidentifier Id
uniqueidentifier PersonId
uniqueidentifier GroupId

Person
===
uniqueidentifier Id
nvarchar(32) Name

C#实体类 #

public class Group
{
    public Guid Id { get; set; }
    public string Name { get; set; }
}

public class PersonGroupMembership
{
    public Guid Id { get; set; }
    public Guid PersonId { get; set; }
    public Guid GroupId { get; set; }
}

public class Person
{
    public Guid Id { get; set; }
    public string Name { get; set; }
}

Specification接口定义 #

public interface ISpecification<T>
{
    IQueryable<T> Apply(IQueryable<T> query);
}

Repository核心实现 #

public Task<T[]> SearchAsync(ISpecification<T>[] specifications)
{
    if ((specifications?.Length ?? 0) == 0)
        throw new ArgumentException(
            paramName: nameof(specifications),
            message: "At least one specification is required");

    IQueryable<T> query = DbSet.AsQueryable<T>();
    foreach(var specification in specifications)
        query = specification.Apply(query);

    return query.ToArrayAsync();
}

解决方案实现 #

由于实体类未定义导航属性，需在Specification中显式关联对应的DbSet，通过Exists子查询或Join实现跨表筛选。这里通过注入DbContext访问关联表的DbSet，保证EF Core能正确解析查询并转换为SQL。

1. 筛选指定组下的所有人员 #

public class FilterPersonsInGroup : ISpecification<Person>
{
    private readonly AppDbContext _dbContext;
    public required Guid GroupId { get; init; }

    public FilterPersonsInGroup(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IQueryable<Person> Apply(IQueryable<Person> query)
    {
        // 优先使用Any子查询，性能更优
        return query.Where(person => 
            _dbContext.PersonGroupMembership.Any(m => m.PersonId == person.Id && m.GroupId == GroupId));
    }
}

2. 筛选包含指定人员的所有组 #

public class FilterGroupsContainingPerson : ISpecification<Group>
{
    private readonly AppDbContext _dbContext;
    public required Guid PersonId { get; init; }

    public FilterGroupsContainingPerson(AppDbContext dbContext)
    {
        _dbContext = dbContext;
    }

    public IQueryable<Group> Apply(IQueryable<Group> query)
    {
        return query.Where(group => 
            _dbContext.PersonGroupMembership.Any(m => m.GroupId == group.Id && m.PersonId == PersonId));
    }
}

调用示例 #

// 获取指定GroupId下的所有人员
var personRepo = _serviceProvider.GetRequiredService<IRepository<Person>>();
var personSpecs = new ISpecification<Person>[]
{
    new FilterPersonsInGroup(_dbContext) { GroupId = Guid.Parse("目标组ID") }
};
var personsInGroup = await personRepo.SearchAsync(personSpecs);

// 获取指定PersonId所属的所有组
var groupRepo = _serviceProvider.GetRequiredService<IRepository<Group>>();
var groupSpecs = new ISpecification<Group>[]
{
    new FilterGroupsContainingPerson(_dbContext) { PersonId = Guid.Parse("目标人员ID") }
};
var groupsWithPerson = await groupRepo.SearchAsync(groupSpecs);

注意事项 #

• 注入DbContext到Specification中，避免内存中过滤导致的性能问题，确保EF Core生成高效的SQL查询。
• 优先选择Any子查询而非Join，尤其是关联表数据量大时，Any生成的SQL执行效率更高。
• 保持Specification的单一职责，每个类只处理一个筛选逻辑，便于组合复用。

内容的提问来源于stack exchange，提问作者Peter Morris