使用yield return的IEnumerable和Recursion

时间:2010-01-13 10:26:21

标签: c# generics 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

8 个答案:

答案 0 :(得分:473)

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

替换

yield return c.GetDeepControlsByType<T>();

使用:

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

答案 1 :(得分:93)

您需要通过递归调用产生每个项

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

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

答案 2 :(得分:21)

正如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's solution不同,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);
}

答案 3 :(得分:16)

其他人为您提供了正确的答案,但我不认为您的案件会因屈服而受益。

这是一个实现同样而不屈服的片段。

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

答案 4 :(得分:12)

您需要在第二个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;
            }
        }
    }
}

答案 5 :(得分:9)

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

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

答案 6 :(得分:6)

Seredynski's syntax是正确的,但您应该小心避免递归函数中的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

答案 7 :(得分:0)

虽然有很多好的答案,但我仍然会补充说可以使用LINQ方法来完成同样的事情,。

例如,OP的原始代码可以改写为:

$("#wrapper").outerHeight();