在C#中如何整合list1、list2、list3生成指定结构JSON？

嘿，我来帮你捋捋这个问题！你的需求其实完全可以用LINQ一步到位搞定，不用写那么多层嵌套循环，既简洁又高效，还能避免很多语法错误。

首先得先指出你原代码里的几个小语法问题，这些问题会导致编译报错：

• LINQ计数要用Count()方法（注意大写C），不是小写的count
• 条件判断里的赋值符号=要改成比较符号==（比如g.Where(a => a.userid == userid)）
• 变量名冲突（比如你写的user.Where(a => a.id == user)，这里user既是变量又是集合名，会混淆）
• LINQ查询的语法错误（比如from p. where多了个多余的点，应该是from p in pCollection where ...）

接下来，我们可以直接用LINQ嵌套查询，一次性构建出和目标JSON结构完全匹配的对象，然后直接序列化即可，完全不需要多次单独查询list1、list2、list3，也不用多层循环嵌套。

完整示例代码 #

假设你的数据源是对应业务集合（比如用户集合、时段集合、商品集合），代码可以写成这样：

// 替换成你实际的数据源集合
var list1Source = ...; // 原list1的查询数据源
var list2Source = ...; // 原list2的查询数据源
var list3Source = ...; // 原list3的查询数据源

// 用LINQ一次性构建嵌套结构
var finalResult = (from x in list1Source
                   join y in ... // 保留你原list1的join逻辑
                   select new 
                   {
                       list1 = new 
                       {
                           id = x.id, // 替换成实际的id字段
                           name = x.name, // 替换成实际的name字段
                           // 嵌套生成当前list1对应的list2集合
                           list2 = (from f in list2Source
                                    join g in list2Source.Where(g => g.userid == x.id) // 关联当前list1的id
                                    on ... // 保留你原list2的join条件
                                    select new 
                                    {
                                        hourId = f.hourId, // 替换成实际字段
                                        hourName = f.hourName, // 替换成实际字段
                                        // 嵌套生成当前list2对应的list3集合
                                        list3 = (from p in list3Source
                                                 join q in list3Source.Where(q => q.hourId == f.hourId) // 关联当前list2的hourId
                                                 on ... // 保留你原list3的join条件
                                                 select new 
                                                 {
                                                     productId = p.productId, // 替换成实际字段
                                                     productName = p.productName // 替换成实际字段
                                                 }).ToList()
                                    }).ToList()
                       }
                   }).ToList();

// 序列化生成JSON（用System.Text.Json）
string targetJson = System.Text.Json.JsonSerializer.Serialize(finalResult, 
    new System.Text.Json.JsonSerializerOptions { WriteIndented = true });

// 如果你习惯用Newtonsoft.Json，也可以这么写：
// string targetJson = Newtonsoft.Json.JsonConvert.SerializeObject(finalResult, Newtonsoft.Json.Formatting.Indented);

关键说明 #

1. 为什么不需要多次单独查询？
   LINQ允许在select语句中嵌套子查询，直接把list2和list3作为外层对象的属性生成，所有关联逻辑一次性完成，避免了多次遍历集合，性能更优，代码也更集中。
2. 关联条件的绑定
   注意子查询的关联条件要和外层对象绑定（比如g.userid == x.id绑定当前list1的id，q.hourId == f.hourId绑定当前list2的hourId），这样才能保证每个list1对应自己的list2，每个list2对应自己的list3。
3. 实体类替代匿名类型（可选）
   如果需要复用这个结构，也可以定义对应的实体类，这样代码可读性更好，也方便后续扩展：

   public class List3Item
   {
       public int productId { get; set; }
       public string productName { get; set; }
   }
   
   public class List2Item
   {
       public int hourId { get; set; }
       public string hourName { get; set; }
       public List<List3Item> list3 { get; set; }
   }
   
   public class List1Item
   {
       public int id { get; set; }
       public string name { get; set; }
       public List<List2Item> list2 { get; set; }
   }
   
   public class RootObject
   {
       public List1Item list1 { get; set; }
   }
   

   然后在LINQ的select里生成RootObject类型的对象，序列化出来的JSON结构和你要的完全一致。

原代码的优化点 #

原代码的多层循环会导致多次遍历集合，还容易出现索引越界、逻辑错误等问题，用LINQ嵌套查询可以把所有逻辑集中在一起，代码更简洁，也更容易维护。

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