IEnumerable和使用yield返回的递归

我有一个IEnumerable<T>方法，我正在使用它来查找WebForms页面中的控件。

该方法是递归的，当yield return返回递归调用的值时，我在返回我想要的类型时遇到了一些问题。

我的代码如下:

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
foreach(Control c in control.Controls)
{
if (c is T)
{
yield return c;
}


if(c.Controls.Count > 0)
{
yield return c.GetDeepControlsByType<T>();
}
}
}

当前会抛出“无法转换表达式类型”;错误。然而，如果此方法返回类型IEnumerable<Object>，则构建代码，但在输出中返回错误的类型。

有没有一种方法在使用yield return的同时使用递归?

86445 次浏览
小开
最佳答案

在返回IEnumerable<T>的方法中，yield return必须返回T，而不是IEnumerable<T>。

取代

yield return c.GetDeepControlsByType<T>();

:

foreach (var x in c.GetDeepControlsByType<T>())
{
yield return x;
}
小开

你需要产生由递归调用产生的每一项:

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
foreach(Control c in control.Controls)
{
if (c is T)
{
yield return c;
}


if(c.Controls.Count > 0)
{
foreach (Control control in c.GetDeepControlsByType<T>())
{
yield return control;
}
}
}
}

注意，以这种方式递归是有代价的——你最终会创建很多迭代器，如果你有一个非常深的控制树，这可能会产生性能问题。如果希望避免这种情况，基本上需要自己在方法中进行递归，以确保只创建了一个迭代器(状态机)。有关更多细节和示例实现，请参阅这个问题 -但这显然也增加了一定程度的复杂性。

小开

在第二个yield return中，你需要从枚举数返回项目，而不是枚举数本身

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
foreach (Control c in control.Controls)
{
if (c is T)
{
yield return c;
}


if (c.Controls.Count > 0)
{
foreach (Control ctrl in c.GetDeepControlsByType<T>())
{
yield return ctrl;
}
}
}
}
小开

我认为你必须在可枚举对象中返回每个控件。

    public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
foreach (Control c in control.Controls)
{
if (c is T)
{
yield return c;
}


if (c.Controls.Count > 0)
{
foreach (Control childControl in c.GetDeepControlsByType<T>())
{
yield return childControl;
}
}
}
}
小开

别人给了你正确的答案，但我不认为让步对你的案子有好处。

这里有一个片段，它达到了同样的目的而不让步。

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
return control.Controls
.Where(c => c is T)
.Concat(control.Controls
.SelectMany(c =>c.GetDeepControlsByType<T>()));
}
小开

Seredynski的语法是正确的，但你应该小心避免在递归函数中使用yield return，因为它对内存使用是一场灾难。参见https://stackoverflow.com/a/3970171/284795，它随深度而爆炸性地扩展(类似的函数在我的应用程序中使用了10%的内存)。

一个简单的解决方案是使用一个列表并将其与递归https://codereview.stackexchange.com/a/5651/754一起传递

/// <summary>
/// Append the descendents of tree to the given list.
/// </summary>
private void AppendDescendents(Tree tree, List<Tree> descendents)
{
foreach (var child in tree.Children)
{
descendents.Add(child);
AppendDescendents(child, descendents);
}
}

或者，你可以使用堆栈和while循环来消除递归调用https://codereview.stackexchange.com/a/5661/754

小开

正如Jon Skeet和Colonel Panic在他们的回答中指出的，如果树非常深，在递归方法中使用yield return可能会导致性能问题。

下面是一个通用的非递归扩展方法，它执行对树序列的深度优先遍历:

public static IEnumerable<TSource> RecursiveSelect<TSource>(
this IEnumerable<TSource> source, Func<TSource, IEnumerable<TSource>> childSelector)
{
var stack = new Stack<IEnumerator<TSource>>();
var enumerator = source.GetEnumerator();


try
{
while (true)
{
if (enumerator.MoveNext())
{
TSource element = enumerator.Current;
yield return element;


stack.Push(enumerator);
enumerator = childSelector(element).GetEnumerator();
}
else if (stack.Count > 0)
{
enumerator.Dispose();
enumerator = stack.Pop();
}
else
{
yield break;
}
}
}
finally
{
enumerator.Dispose();


while (stack.Count > 0) // Clean up in case of an exception.
{
enumerator = stack.Pop();
enumerator.Dispose();
}
}
}

与埃里克·利珀特的解决方案不同，RecursiveSelect直接与枚举器一起工作，因此不需要调用Reverse(这将在内存中缓冲整个序列)。

使用RecursiveSelect, OP的原始方法可以像这样简单地重写:

public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
return control.Controls.RecursiveSelect(c => c.Controls).Where(c => c is T);
}
小开

虽然有很多好的答案，但我仍然想补充一点，使用LINQ方法来完成同样的事情是可能的。

例如，OP的原始代码可以重写为:

public static IEnumerable<Control>
GetDeepControlsByType<T>(this Control control)
{
return control.Controls.OfType<T>()
.Union(control.Controls.SelectMany(c => c.GetDeepControlsByType<T>()));
}

提交答案