HotChocolate 15中多对多关系如何使用投影与DataLoader？

一、实现多对多关系的DataLoader #

以产品-标签的多对多场景为例，先明确EF Core模型结构（支持隐式/显式连接表，这里以显式连接表为例，更灵活）：

public class Product
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<ProductTag> ProductTags { get; set; }
}

public class Tag
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<ProductTag> ProductTags { get; set; }
}

// 显式多对多连接表
public class ProductTag
{
    public int ProductId { get; set; }
    public Product Product { get; set; }
    public int TagId { get; set; }
    public Tag Tag { get; set; }
}

1. 实现TagsByProductIdDataLoader #

核心逻辑是批量接收产品ID列表，通过连接表关联查询标签，再按产品ID分组返回：

public class TagsByProductIdDataLoader : BatchDataLoader<int, IReadOnlyList<Tag>>
{
    private readonly IDbContextFactory<AppDbContext> _dbContextFactory;

    public TagsByProductIdDataLoader(
        IDbContextFactory<AppDbContext> dbContextFactory,
        IBatchScheduler batchScheduler,
        DataLoaderOptions options = null)
        : base(batchScheduler, options)
    {
        _dbContextFactory = dbContextFactory;
    }

    protected override async Task<IReadOnlyDictionary<int, IReadOnlyList<Tag>>> LoadBatchAsync(
        IReadOnlyList<int> productIds,
        CancellationToken cancellationToken)
    {
        await using var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken);

        // 批量查询关联标签并按产品ID分组
        var productTagList = await context.ProductTags
            .Where(pt => productIds.Contains(pt.ProductId))
            .Include(pt => pt.Tag)
            .Select(pt => new { pt.ProductId, pt.Tag })
            .ToListAsync(cancellationToken);

        return productTagList
            .GroupBy(pt => pt.ProductId)
            .ToDictionary(
                group => group.Key,
                group => (IReadOnlyList<Tag>)group.Select(pt => pt.Tag).ToList());
    }
}

2. 在GraphQL产品类型中集成DataLoader并支持投影 #

在产品的GraphQL类型字段中注入DataLoader，同时启用投影支持，只返回请求的字段：

public class ProductType : ObjectType<Product>
{
    protected override void Configure(IObjectTypeDescriptor<Product> descriptor)
    {
        descriptor.Field(p => p.Id);
        descriptor.Field(p => p.Name);

        descriptor.Field("tags")
            .Resolve(async (context, ct) =>
            {
                var product = context.Parent<Product>();
                var dataLoader = context.DataLoader<TagsByProductIdDataLoader>();
                var tags = await dataLoader.LoadAsync(product.Id, ct);
                
                // 应用HotChocolate自动生成的投影表达式，裁剪返回字段
                var projection = context.Projection<Tag>();
                await using var dbContext = await context.Service<IDbContextFactory<AppDbContext>>().CreateDbContextAsync(ct);
                return projection.Apply(dbContext.Set<Tag>().AsQueryable(), tags.AsQueryable());
            })
            .UseProjection(); // 启用投影支持
    }
}

二、投影优化进阶 #

如果想在数据库查询阶段就应用投影（减少数据传输量），可以简化实现：直接在Resolve中结合UseDataLoader自动批量处理，同时应用投影：

descriptor.Field("tags")
    .Resolve(async (context, ct) =>
    {
        var product = context.Parent<Product>();
        var projection = context.Projection<Tag>();
        await using var dbContext = await context.Service<IDbContextFactory<AppDbContext>>().CreateDbContextAsync(ct);

        return await dbContext.ProductTags
            .Where(pt => pt.ProductId == product.Id)
            .Select(pt => pt.Tag)
            .ApplyProjection(projection)
            .ToListAsync(ct);
    })
    .UseProjection()
    .UseDataLoader(); // 自动合并相同产品ID的查询，避免N+1

三、无DataLoader的替代方案 #

如果暂时不想使用DataLoader，可通过以下方式避免N+1问题：

• EF Core批量预加载：在根查询中使用Include(p => p.ProductTags).ThenInclude(pt => pt.Tag)，结合Where筛选目标产品，再应用投影，适合数据量不大的场景。
• 手动批量查询：在根查询中先获取所有产品ID，一次性查询所有关联标签并按产品ID分组，再分配给对应产品字段。
• 显式连接表批量查询：直接查询连接表，关联标签后按产品ID分组，将结果字典传递给各个产品的标签字段解析逻辑。

内容的提问来源于stack exchange，提问作者Thu Nguyen