C# 集合中的集合Lambda

考虑到下面的情况，我需要获取属于分配给顶层的中间对象列表的所有底层类级别的对象。我的结构意味着中间层的对象挂在顶层，而底层只是所有对象的集合。因此，我需要得到所有的底层对象，这些对象有效地“挂起”了顶层和中层，即使列表不存在。在lambda有什么好办法吗

class Program
{
    static void Main(string[] args)
    {
        List<TopClass> topClasses = new List<TopClass>();

        List<MiddleClass> mcList1 = new List<MiddleClass>();
        mcList1.Add(new MiddleClass(1));
        mcList1.Add(new MiddleClass(3));
        mcList1.Add(new MiddleClass(5));
        TopClass tc1 = new TopClass(1, mcList1);
        topClasses.Add(tc1);

        List<MiddleClass> mcList2 = new List<MiddleClass>();
        mcList2.Add(new MiddleClass(2));
        mcList2.Add(new MiddleClass(4));
        TopClass tc2 = new TopClass(2, mcList2);
        topClasses.Add(tc2);

        List<MiddleClass> mcList3 = new List<MiddleClass>();
        mcList3.Add(new MiddleClass(6));
        mcList3.Add(new MiddleClass(7));
        TopClass tc3 = new TopClass(3, mcList3);
        // ** Note not added to the global list

        List<BottomClass> bottomClasses = new List<BottomClass>();
        bottomClasses.Add(new BottomClass(10, 1));
        bottomClasses.Add(new BottomClass(20, 2));
        bottomClasses.Add(new BottomClass(30, 3));
        bottomClasses.Add(new BottomClass(40, 4));
        bottomClasses.Add(new BottomClass(50, 5));
        bottomClasses.Add(new BottomClass(60, 6));
        bottomClasses.Add(new BottomClass(70, 7));

        bottomClass.FindAll(b => ....?
    }
}

public class TopClass //Instruments
{
    public int Id { get; set; }
    public List<MiddleClass> MiddleClasses { get; set; }

    public TopClass(int id, List<MiddleClass> middleClasses)
    {
        this.Id = id;
        this.MiddleClasses = middleClasses;
    }
}

public class MiddleClass // Sequences
{
    public int Id { get; set; }

    public MiddleClass(int id)
    {
        this.Id = id;
    }
}


public class BottomClass //SequenceItem
{
    public int Id { get; set; }
    public int MiddleClassId { get; set; }

    public BottomClass(int id, int middleClassId)
    {
        this.Id = id;
        this.MiddleClassId = middleClassId;
    }
}

类程序
{
静态void Main（字符串[]参数）
{
List topClasses=新列表（）；
List mcList1=新列表（）；
新增（新中产阶级（1））；
mcList1.Add（新中产阶级（3））；
mcList1.Add（新中产阶级（5））；
TopClass tc1=新的TopClass（1，mcList1）；
topClasses.Add（tc1）；
List mcList2=新列表（）；
新增（新中产阶级（2））；
mcList2.Add（新中产阶级（4））；
TopClass tc2=新的TopClass（2，mcList2）；
topClasses.Add（tc2）；
List mcList3=新列表（）；
mcList3.Add（新中产阶级（6））；
mcList3.Add（新中产阶级（7））；
TopClass tc3=新的TopClass（3，mcList3）；
//**注：未添加到全球清单
List bottomClasses=新列表（）；
添加（新的底层类（10,1））；
添加（新的底层类（20,2））；
添加（新的底部类（30,3））；
添加（新的底层类（40,4））；
添加（新的底层类（50,5））；
添加（新的底层类（60,6））；
添加（新的底层类（70,7））；
bottomClass.FindAll（b=>。。。。？
}
}
公共级顶级//仪器
{
公共int Id{get；set；}
公共列表中间类{get；set；}
公共顶级类（int id，列出中间类）
{
这个.Id=Id；
这个。中产阶级=中产阶级；
}
}
公共类中间类//序列
{
公共int Id{get；set；}
公共中间阶层（int id）
{
这个.Id=Id；
}
}
公共类BottomClass//SequenceItem
{
公共int Id{get；set；}
public int MiddleClassId{get；set；}
公共底层类（int-id，int-middleClassId）
{
这个.Id=Id；
this.MiddleClassId=MiddleClassId；
}
}

---

结果将是一个包含10到50的列表，而不是60和70。

不确定这是否是您想要的

var test = bottomClasses.Where(b => b.Id >= 10 && b.Id <= 50);

var-test=bottomClasses.Where（b=>b.Id>=10&&b.Id

topClasses
 .SelectMany(x=>x.MiddleClasses)
 .SelectMany(x=>bottomClasses.Where(y=>y.MiddleClassId==x.Id))

可选择在末尾添加
.Distinct（）
，以实现唯一性

还是从另一个角度

bottomClasses.Where(
  b=>topClasses.Any(t=>t.MiddleClasses.Any(m=>m.Id==b.MiddleClassId))
)

这就是您想要的。因此，给定一个顶级类，例如tc3，这将为您提供所有挂起tc3的底层类

   var allMiddleClasses = topClasses.SelectMany(t => t.MiddleClasses);

    var allBC = 
            bottomClasses
                .Where(b => allMiddleClasses.Select(m => m.Id).Contains(b.MiddleClassId))
                    .ToList();

你能发布类的类结构摘要吗？你只想过滤“底层类”吗？我看不到lambada中包含哪些属性。编辑：只看到了类结构：）你们所有的底层阶级都是指中产阶级，而所有的中产阶级都是指上层阶级，所以所有的底层阶级都是指上层/中层阶级class@saj但是如果你看中产阶级没有直接指向上层阶级或底层阶级的话，那么就没有明确的链条可以遵循，没错，鲍勃，这是一种推断的链条，不是最好的Structure我知道，但玩你发的牌和所有这些。谢谢saj，除了这个返回60和70，但不是10到50；我该如何反转它？OP要求一个特定的过滤器，并表示10-50将是这个特定案例的正确答案谢谢，第二个解决方案正是我想要的，包括一个ToList（）。