329

我有一种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>();
        }
    }
}

这当前会引发“无法转换表达式类型”错误。但是，如果此方法返回 type IEnumerable<Object>，则代码会构建，但输出中会返回错误的类型。

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

4

8 回答 8

505

在返回的方法内部IEnumerable<T>，yield return必须返回T，而不是IEnumerable<T>.

代替

yield return c.GetDeepControlsByType<T>();

和：

foreach (var x in c.GetDeepControlsByType<T>())
{
  yield return x;
}
于 2010-01-13T10:29:49.770 回答
109

您需要产生递归调用产生的每个项目：

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;
            }
        }
    }
}

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

于 2010-01-13T10:29:57.900 回答
42

正如 Jon Skeet 和上校 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();
        }
    }
}

与Eric Lippert 的解决方案不同，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);
}
于 2015-05-25T15:21:57.253 回答
20

其他人为您提供了正确的答案，但我认为您的案例不会从屈服中受益。

这是一个片段，它可以在不产生任何效果的情况下实现相同的效果。

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>()));
}
于 2013-08-11T14:38:29.747 回答
13

您需要在第二次返回枚举器中的项目，而不是枚举器本身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;
            }
        }
    }
}
于 2010-01-13T10:30:39.483 回答
11

我认为您必须返回可枚举中的每个控件。

    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;
                }
            }
        }
    }
于 2010-01-13T10:32:02.467 回答
11

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

于 2015-05-18T10:02:27.080 回答
2

虽然那里有很多好的答案，但我仍然要补充一点，可以使用 LINQ 方法来完成同样的事情，.

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

public static IEnumerable<Control> 
                           GetDeepControlsByType<T>(this Control control)
{
   return control.Controls.OfType<T>()
          .Union(control.Controls.SelectMany(c => c.GetDeepControlsByType<T>()));        
}
于 2016-06-21T15:07:20.103 回答