IEnumerable e Recursion usando retorno de rendimento

Eu tenho um IEnumerable<T>método que estou usando para encontrar controles em uma página WebForms.

O método é recursivo e estou tendo alguns problemas para retornar o tipo desejado quando o yield returnretorno é o valor da chamada recursiva.

Meu código é o seguinte:

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

No momento, isso gera um erro "Não é possível converter o tipo de expressão". Se, no entanto, esse método retornar tipo IEnumerable<Object>, o código será gerado, mas o tipo errado será retornado na saída.

Existe uma maneira de usar yield returnenquanto também usa recursão?

Dentro de um método que retorna IEnumerable<T>, yield returntem que retornar T, não um IEnumerable<T>.

Substituir

yield return c.GetDeepControlsByType<T>();

com:

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

Você precisa produzir cada um dos itens gerados pela chamada 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;
            }
        }
    }
}

Observe que há um custo para se repetir dessa maneira - você acabará criando muitos iteradores, o que pode criar um problema de desempenho se você tiver uma árvore de controle realmente profunda. Se você deseja evitar isso, basicamente precisa fazer a recursão dentro do método, para garantir que haja apenas um iterador (máquina de estado) criado. Veja esta pergunta para obter mais detalhes e uma implementação de amostra - mas isso obviamente também adiciona uma certa complexidade.

Como Jon Skeet e Coronel Panic observam em suas respostas, o uso de yield returnmétodos recursivos pode causar problemas de desempenho se a árvore for muito profunda.

Aqui está um método genérico de extensão não recursiva que executa uma travessia profunda de uma sequência de árvores:

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

Diferentemente da solução de Eric Lippert , o RecursiveSelect trabalha diretamente com enumeradores para que não precise chamar Reverse (que armazena em buffer toda a sequência na memória).

Usando RecursiveSelect, o método original do OP pode ser reescrito da seguinte maneira:

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

Outros forneceram a resposta correta, mas não creio que seu caso seja beneficiado.

Aqui está um trecho que alcança o mesmo sem 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>()));
}

Você precisa retornar os itens do enumerador, não do próprio enumerador, no seu 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;
            }
        }
    }
}

Eu acho que você tem que render retornar cada um dos controles nos enumeráveis.

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

A sintaxe de Seredynski está correta, mas você deve evitar as yield returnfunções recursivas, pois é um desastre para o uso da memória. Consulte https://stackoverflow.com/a/3970171/284795, que escala de forma explosiva com a profundidade (uma função semelhante estava usando 10% da memória no meu aplicativo).

Uma solução simples é usar uma lista e passá-la com a recursão 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);
    }
}

Como alternativa, você pode usar uma pilha e um loop while para eliminar chamadas recursivas https://codereview.stackexchange.com/a/5661/754

Embora haja muitas boas respostas por aí, eu ainda acrescentaria que é possível usar os métodos LINQ para realizar a mesma coisa.

Por exemplo, o código original do OP pode ser reescrito como:

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