LINQ递归函数？

Question

让我们以这个 n 层深度结构为例：

public class SomeItem 
{
     public Guid ID { get;set; }
     public string Name { get; set; }
     public bool HasChildren { get;set; }
     public IEnumerable<SomeItem> Children { get; set; }
}

如果我想通过 ID（结构中的任何位置）获取特定项目，是否有一些 LINQ 优点可以用来在单个语句中轻松获取它，或者我是否必须使用一些递归函数如下：

   private SomeItem GetSomeItem(IEnumerable<SomeItem> items, Guid ID)
    {
        foreach (var item in items)
        {
            if (item.ID == ID)
            {
                return item;
            }
            else if (item.HasChildren)
            {
                return GetSomeItem(item.Children, ID);
            }
        }
        return null;
    }

Answer 1

LINQ 并没有真正很好地“执行”递归。您的解决方案似乎是合适的 - 尽管我不确定是否真的需要 HasChildren...为什么不只对没有孩子的项目使用空列表？

另一种方法是编写一个 DescendantsAndSelf 方法，该方法将返回所有后代（包括项目本身），如下所示；

// Warning: potentially expensive!
public IEnumerable<SomeItem> DescendantsAndSelf()
{
    yield return this;
    foreach (var item in Children.SelectMany(x => x.DescendantsAndSelf()))
    {
        yield return item;
    }
}

然而，如果树很深，最终效率会非常低，因为每个项目都需要“通过”其祖先的所有迭代器。 Wes Dyer 关于此问题的博客，显示更有效的实施。

无论如何，如果您有这样的方法（无论它是如何实现的），您可以使用普通的“where”子句来查找项目（或 First/FirstOrDefault 等）。

Answer 2

这是一个没有递归的情况。这避免了传递多层迭代器的成本，因此我认为它的效率与它们一样高。

    public static IEnumerable<T> IterateTree<T>(this T root, Func<T, IEnumerable<T>> childrenF)
    {
        var q = new List<T>() { root };
        while (q.Any())
        {
            var c = q[0];
            q.RemoveAt(0);
            q.AddRange(childrenF(c) ?? Enumerable.Empty<T>());
            yield return c;
        }
    }

像这样调用：

            var subtree = root.IterateTree(x => x. Children).ToList();

Answer 3

希望这有帮助

public static IEnumerable<Control> GetAllChildControls(this Control parent)
{
  foreach (Control child in parent.Controls)
  {
    yield return child;

    if (child.HasChildren)
    {
      foreach (Control grandChild in child.GetAllChildControls())
        yield return grandChild;
    }
  }
}

Answer 4

重要的是要记住，您不需要使用 LINQ 执行所有操作，也不需要默认使用递归。使用数据结构时有一些有趣的选项。以下是一个简单的扁平化函数，以防有人感兴趣。

    public static IEnumerable<SomeItem> Flatten(IEnumerable<SomeItem> items)
    {
        if (items == null || items.Count() == 0) return new List<SomeItem>();

        var result = new List<SomeItem>();
        var q = new Queue<SomeItem>(collection: items);

        while (q.Count > 0)
        {
            var item = q.Dequeue();
            result.Add(item);

            if (item?.Children?.Count() > 0)
                foreach (var child in item.Children)
                    q.Enqueue(child);
        }

        return result;
    }

Answer 5

虽然有一些扩展方法可以在 LINQ 中启用递归（并且可能看起来像您的函数），但没有提供开箱即用的扩展方法。

这些扩展方法的示例可以在 此处或这里。

我想说你的功能很好。