关于c＃：使用yield return的IEnumerable和Recursion


IEnumerable and Recursion using yield return

我有一个IEnumerable方法，用于在WebForms页面中查找控件。

该方法是递归的，当yield return返回递归调用的值时，返回所需的类型时遇到一些问题。

我的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    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，代码将生成，但输出中返回的类型错误。

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

相关讨论

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

替换

1
yield return c.GetDeepControlsByType<T>();

用：

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
            }
        }
    }
}

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

相关讨论

正如jon skeet和colonel panic在他们的答案中指出的，如果树非常深，在递归方法中使用yield return可能会导致性能问题。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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();
        }
    }
}

与EricLippert的解决方案不同，RecursiveSelect直接与枚举器一起工作，这样它就不需要调用Reverse(这会缓冲内存中的整个序列)。

使用recursiveselect，可以这样简单地重写op的原始方法：

1
2
3
4
public static IEnumerable<Control> GetDeepControlsByType<T>(this Control control)
{
    return control.Controls.RecursiveSelect(c => c.Controls).Where(c => c is T);
}
相关讨论

其他人给了你正确的答案，但我认为你的案子不会从屈服中获益。

这里有一个片段，它可以在不屈服的情况下实现相同的结果。

1
2
3
4
5
6
7
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>()));
}
相关讨论

您需要从第二个yield return中的枚举器返回项目，而不是枚举器本身。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
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;
            }
        }
    }
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    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;
                }
            }
        }
    }

seredynski的语法是正确的，但是在递归函数中应该小心避免使用yield return，因为这是内存使用的灾难。请参阅https://stackoverflow.com/a/3970171/284795，它可以根据深度进行爆炸性缩放(类似的功能在我的应用程序中使用了10%的内存)。

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

1
2
3
4
5
6
7
8
9
10
11
/// <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

虽然有很多好的答案，但我还是要补充的是，使用LINQ方法来完成相同的事情是可能的。

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

1
2
3
4
5
6
public static IEnumerable<Control>
                           GetDeepControlsByType<T>(this Control control)
{
   return control.Controls.OfType<T>()
          .Union(control.Controls.SelectMany(c => c.GetDeepControlsByType<T>()));        
}
相关讨论