C# 如何查找嵌套在多级集合中的对象

假设我有一个

列表

，每个家庭都有一个

列表

当我在代码中遇到

子对象时，如何确定该子对象是否属于任何家庭

伪代码：

If Child not in any family
    // Do something with child

class Family
{
  public List<Child> Children {get;set;}
  // Properties
}

class Child
{
  // Properties
}

class FamilyViewModel
{
  public List<Family> Families {get;set;}

  public bool ChildHasFamily(Child child)
  {
     // Determine if child is in any family or not
  } 
}

更新：

If Child not in any family
    // Do something with child

class Family
{
  public List<Child> Children {get;set;}
  // Properties
}

class Child
{
  // Properties
}

class FamilyViewModel
{
  public List<Family> Families {get;set;}

  public bool ChildHasFamily(Child child)
  {
     // Determine if child is in any family or not
  } 
}

示例模型：

If Child not in any family
    // Do something with child

class Family
{
  public List<Child> Children {get;set;}
  // Properties
}

class Child
{
  // Properties
}

class FamilyViewModel
{
  public List<Family> Families {get;set;}

  public bool ChildHasFamily(Child child)
  {
     // Determine if child is in any family or not
  } 
}

类族
{
公共列表子项{get；set；}
//性质
}
班童
{
//性质
}

示例视图模型：

If Child not in any family
    // Do something with child

class Family
{
  public List<Child> Children {get;set;}
  // Properties
}

class Child
{
  // Properties
}

class FamilyViewModel
{
  public List<Family> Families {get;set;}

  public bool ChildHasFamily(Child child)
  {
     // Determine if child is in any family or not
  } 
}

类家族视图模型
{
公共列表族{get；set；}
公立学校儿童家庭（儿童）
{
//确定孩子是否在任何家庭中
} 
}
您可以使用以下使用延迟执行的递归
遍历方法

那么就很容易做到：

IEnumerable<Family> familiesOfChild = families.Traverse(f => f.Children)
    .Where(c => c.Equals(yourChild));
if(!familiesOfChild.Any())
{
    // oh, what a poor child
}

IEnumerable familiesOfChild=families.travel（f=>f.Children）
其中（c=>c等于（你的孩子））；
如果（！familiesOfChild.Any（））
{
//哦，多么可怜的孩子啊
}

以下是扩展方法：

public static IEnumerable<T> Traverse<T>(this IEnumerable<T> source, Func<T, IEnumerable<T>> fnRecurse)
{
    foreach (T item in source)
    {
        yield return item;

        IEnumerable<T> seqRecurse = fnRecurse(item);
        if (seqRecurse != null)
        {
            foreach (T itemRecurse in Traverse(seqRecurse, fnRecurse))
            {
                yield return itemRecurse;
            }
        }
    }
}

公共静态IEnumerable遍历（此IEnumerable源代码，Func fnRecurse）
{
foreach（源中的T项）
{
收益回报项目；
IEnumerable seqRecurse=fnRecurse（项目）；
if（seqRecurse！=null）
{
foreach（遍历中的T项递归（seqRecurse，fnRecurse））
{
收益-收益项目递归；
}
}
}
}
现在我觉得这还不够干净。我认为你的
孩子
应该拥有
家庭
财产，这样事情就容易多了。如果我理解正确，您的视图模型有一个族列表，而族列表又包含一个孩子列表。当您收到孩子名单时，您想知道孩子是否在您的家庭中：

class FamilyViewModel
{
  public List<Family> Families {get;set;}

  public void ChildHasFamily(Child child)
  {
      var hasFamily = Families.SelectMany(f => f.Children)
                              .Contains(child);
  } 
}

类家族视图模型
{
公共列表族{get；set；}
公共无效儿童家庭（儿童）
{
var hasFamily=Families.SelectMany（f=>f.Children）
.包含（儿童）；
} 
}

请注意，这将进行对象引用比较。如果子机具
IEquatable
，它将开箱即用。如果没有，您可以使用：

class FamilyViewModel
{
  public List<Family> Families {get;set;}

  public void ChildHasFamily(Child child)
  {
      var hasFamily = Families.SelectMany(f => f.Children)
                              .Any(c => c.Name == child.Name);
  } 
}

类家族视图模型
{
公共列表族{get；set；}
公共无效儿童家庭（儿童）
{
var hasFamily=Families.SelectMany（f=>f.Children）
.Any（c=>c.Name==child.Name）；
} 
}

替换用于身份比较的
Where
谓词。
您的类是什么样子的？为什么
ChildHasFamily
“returns”void而不是
bool
？发现您的解决方案是最干净、最接近我所寻找的。谢谢