IEnumerable y recursiva utilizando rendimiento de rendimiento

Tengo un IEnumerable<T>método que estoy usando para buscar controles en una página de WebForms.

El método es recursivo y tengo algunos problemas para devolver el tipo que quiero cuando yield returndevuelve el valor de la llamada recursiva.

Mi código se ve de la siguiente manera:

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

Esto actualmente arroja un error "No se puede convertir el tipo de expresión". Sin embargo, si este método devuelve el tipo IEnumerable<Object>, el código se construye, pero el tipo incorrecto se devuelve en la salida.

¿Hay alguna forma de usar yield returnmientras se usa también la recursividad?

Dentro de un método que regresa IEnumerable<T>, yield returntiene que regresar T, no un IEnumerable<T>.

Reemplazar

yield return c.GetDeepControlsByType<T>();

con:

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

Debe entregar cada uno de los elementos producidos por la llamada recursiva:

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

Tenga en cuenta que hay un costo para recurrir de esta manera: terminará creando muchos iteradores, lo que puede crear un problema de rendimiento si tiene un árbol de control realmente profundo. Si desea evitar eso, básicamente necesita hacer la recursión usted mismo dentro del método, para asegurarse de que solo se haya creado un iterador (máquina de estado). Consulte esta pregunta para obtener más detalles y una implementación de muestra, pero esto obviamente también agrega una cierta cantidad de complejidad.

Como Jon Skeet y el coronel Panic señalan en sus respuestas, el uso yield returnde métodos recursivos puede causar problemas de rendimiento si el árbol es muy profundo.

Aquí hay un método genérico de extensión no recursiva que realiza un recorrido en profundidad de una secuencia de árboles:

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

A diferencia de la solución de Eric Lippert , RecursiveSelect trabaja directamente con los enumeradores, por lo que no necesita llamar a Reverse (que almacena la secuencia completa en la memoria).

Usando RecursiveSelect, el método original del OP se puede reescribir simplemente así:

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

Otros le proporcionaron la respuesta correcta, pero no creo que su caso se beneficie con el rendimiento.

Aquí hay un fragmento que logra lo mismo sin ceder.

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

Debe devolver los elementos del enumerador, no del enumerador en sí, en su segundoyield 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;
            }
        }
    }
}

Creo que debe devolver cada uno de los controles en los enumerables.

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

La sintaxis de Seredynski es correcta, pero debe tener cuidado de evitarla yield returnen las funciones recursivas porque es un desastre para el uso de la memoria. Consulte https://stackoverflow.com/a/3970171/284795 que escala explosivamente con la profundidad (una función similar estaba usando el 10% de la memoria en mi aplicación).

Una solución simple es usar una lista y pasarla con la recursión 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);
    }
}

Alternativamente, puede usar una pila y un ciclo while para eliminar las llamadas recursivas https://codereview.stackexchange.com/a/5661/754

Si bien hay muchas buenas respuestas, todavía agregaría que es posible usar métodos LINQ para lograr lo mismo,.

Por ejemplo, el código original del OP podría reescribirse como:

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