GraphQL加载嵌套对象问题：嵌套类型为何无法自动过滤？

你的核心问题在于嵌套关联数据没有自动关联顶层过滤条件，同时当前硬编码的数据加载逻辑存在错误，导致每个Customer都拿到了所有Orders。以下是具体的修复方案：

一、先修正硬编码数据的基础错误 #

当前代码中，你给每个Customer赋值Orders时传入了空字符串，且OrderService的返回逻辑也没有正确根据customerId过滤数据，导致所有Customer的Orders都是重复的。先把这部分基础逻辑修复：

1. 修正OrderService的过滤逻辑 #

public ICollection<Order> GetOrdersByCustomerId(string customerId)
{
    return new List<Order>
    {
        new() { OrderId = $"{customerId}-99", CustomerId = customerId },
        new() { OrderId = $"{customerId}-98", CustomerId = customerId }
    };
}

2. 修正Customer数据的Orders赋值 #

[UseProjection]
[UseFiltering]
[UseSorting]
public IQueryable<Customer> Customers()
{
    var customers = new List<Customer>
    {
        new()
        {
            CustomerId = "1", Forename = "Foo", LastName = "Blah",
            Orders = _orderService.GetOrdersByCustomerId("1") // 传入当前Customer的ID
        },
        new()
        {
            CustomerId = "2", Forename = "Bar", LastName = "BlahBlah",
            Orders = _orderService.GetOrdersByCustomerId("2") // 传入当前Customer的ID
        }
    };
    
    return customers.AsQueryable();
}

这一步修复后，每个Customer的Orders会自动匹配自身的CustomerId，不需要在查询里手动加where条件。但这只是硬编码场景的临时解决，生产环境需要用更规范的方式处理嵌套关联。

二、生产环境规范解决方案：使用DataLoader自动关联过滤 #

如果是基于Hot Chocolate（你用的UseProjection/UseFiltering是它的特性），正确处理嵌套关联的方式是使用DataLoader，它不仅能避免N+1查询问题，还能自动关联父节点的过滤条件。

1. 实现Order批量DataLoader #

public class OrderBatchDataLoader : BatchDataLoader<string, ICollection<Order>>
{
    private readonly IOrderService _orderService;

    public OrderBatchDataLoader(IBatchScheduler batchScheduler, IOrderService orderService)
        : base(batchScheduler)
    {
        _orderService = orderService;
    }

    protected override async Task<ILookup<string, ICollection<Order>>> LoadBatchAsync(IReadOnlyList<string> customerIds, CancellationToken cancellationToken)
    {
        // 批量获取所有目标Customer的Orders，按CustomerId分组
        var allOrders = new List<Order>();
        foreach (var id in customerIds)
        {
            allOrders.AddRange(_orderService.GetOrdersByCustomerId(id));
        }
        
        return allOrders
            .GroupBy(o => o.CustomerId)
            .ToLookup(g => g.Key, g => (ICollection<Order>)g.ToList());
    }
}

2. 配置Customer类型的Orders字段Resolver #

在GraphQL的Customer类型定义中，给Orders字段配置Resolver，用DataLoader自动加载关联数据：

public class CustomerType : ObjectType<Customer>
{
    protected override void Configure(IObjectTypeDescriptor<Customer> descriptor)
    {
        descriptor.Field(c => c.CustomerId).Type<StringType>();
        descriptor.Field(c => c.Forename).Type<StringType>();
        descriptor.Field(c => c.LastName).Type<StringType>();
        
        // 用DataLoader加载关联的Orders，自动关联父节点的CustomerId
        descriptor.Field(c => c.Orders)
            .Resolve(async context =>
            {
                var currentCustomer = context.Parent<Customer>();
                var orderLoader = context.DataLoader<OrderBatchDataLoader>();
                return await orderLoader.LoadAsync(currentCustomer.CustomerId, context.RequestAborted);
            })
            .UseFiltering() // 保留嵌套过滤能力
            .UseSorting();
    }
}

3. 简化Query层的数据返回 #

此时Query层不需要提前加载Orders，DataLoader会在查询嵌套字段时自动加载：

[UseProjection]
[UseFiltering]
[UseSorting]
public IQueryable<Customer> Customers()
{
    var customers = new List<Customer>
    {
        new() { CustomerId = "1", Forename = "Foo", LastName = "Blah" },
        new() { CustomerId = "2", Forename = "Bar", LastName = "BlahBlah" }
    };
    
    return customers.AsQueryable();
}

三、ORM场景（如EF Core）的简化方案 #

如果你的数据来自数据库，直接返回EF的IQueryable<Customer>即可，Hot Chocolate会自动将GraphQL查询转换成SQL关联查询，嵌套的Orders会自动匹配顶层过滤的CustomerId：

[UseProjection]
[UseFiltering]
[UseSorting]
public IQueryable<Customer> Customers(AppDbContext dbContext)
{
    return dbContext.Customers; // 不需要手动Include Orders，UseProjection会自动处理
}

此时执行你最初的查询：

query {
  customers(where: { customerId: { eq: "1" } }) {
    forename
    lastName
    orders {
      orderId
    }
  }
}

会自动返回Customer 1对应的Orders，无需手动添加嵌套where条件。

内容的提问来源于stack exchange，提问作者Dr Schizo