IEnumerable和递归使用收益率返回?

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (8)
  • 关注 (0)
  • 查看 (143)

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的同时也使用递归?

提问于
用户回答回答于

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

替换

yield return c.GetDeepControlsByType<T>();

附加:

foreach (var x in c.GetDeepControlsByType<T>())
{
  yield return x;
}
用户回答回答于

虽然还有很多好的解决方案,但我还是要补充说,可以通过使用LINQ方法来完成同样的事情。

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

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

你应该多加注意在递归函数中的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);
    }
}

或者,你可以通过使用stack和while循环来消除递归调用。https://codereview.stackexchange.com/a/5661/754

用户回答回答于

每个枚举中的控件都必须返回。

    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>()));
}
用户回答回答于

你需要从第二个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;
            }
        }
    }
}
用户回答回答于

如果树很深,在递归方法中使用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);
}
用户回答回答于

你需要递归调用所生成的每个子项

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

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

所属标签

可能回答问题的人

  • 人生的旅途

    10 粉丝484 提问6 回答
  • 不吃貓的鱼oo

    5 粉丝466 提问6 回答
  • 富有想象力的人

    4 粉丝0 提问5 回答
  • Richel

    8 粉丝0 提问5 回答

扫码关注云+社区

领取腾讯云代金券

年度创作总结 领取年终奖励