IEnumerable e Recursion utilizzando il rendimento

Ho un IEnumerable<T>metodo che sto usando per trovare i controlli in una pagina WebForms.

Il metodo è ricorsivo e sto riscontrando dei problemi nel restituire il tipo desiderato quando yield returnrestituisce il valore della chiamata ricorsiva.

Il mio codice ha il seguente aspetto:

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

Questo attualmente genera un errore "Impossibile convertire il tipo di espressione". Se tuttavia questo metodo restituisce il tipo IEnumerable<Object>, il codice viene generato, ma nell'output viene restituito il tipo errato.

C'è un modo di usare yield returnmentre si utilizza anche la ricorsione?

All'interno di un metodo che ritorna IEnumerable<T>, yield returndeve tornare T, non un IEnumerable<T>.

Sostituire

yield return c.GetDeepControlsByType<T>();

con:

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

È necessario cedere ciascuno degli articoli prodotti dalla chiamata ricorsiva:

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

Tieni presente che il costo in questo modo è ricorrente: finirai per creare molti iteratori, che possono creare un problema di prestazioni se hai un albero di controllo molto profondo. Se vuoi evitarlo, devi fondamentalmente eseguire tu stesso la ricorsione all'interno del metodo, per assicurarti che sia stato creato un solo iteratore (macchina a stati). Vedi questa domanda per maggiori dettagli e un'implementazione di esempio, ma ovviamente ciò aggiunge anche una certa complessità.

Come notano Jon Skeet e il colonnello Panic nelle loro risposte, l'uso yield returndi metodi ricorsivi può causare problemi di prestazioni se l'albero è molto profondo.

Ecco un metodo di estensione generico non ricorsivo che esegue un attraversamento in profondità di una sequenza di alberi:

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 differenza della soluzione di Eric Lippert , RecursiveSelect funziona direttamente con gli enumeratori in modo da non dover chiamare Reverse (che bufferizza l'intera sequenza in memoria).

Usando RecursiveSelect, il metodo originale dell'OP può essere riscritto semplicemente in questo modo:

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

Altri ti hanno fornito la risposta corretta, ma non credo che il tuo caso tragga beneficio dal cedere.

Ecco uno snippet che raggiunge lo stesso senza cedere.

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

È necessario restituire gli elementi dall'enumeratore, non dall'enumeratore stesso, nel secondoyield 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;
            }
        }
    }
}

Penso che devi cedere ogni singolo controllo negli enumerabili.

    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 sintassi di Seredynski è corretta, ma dovresti stare attento a evitare yield returnle funzioni ricorsive perché è un disastro per l'utilizzo della memoria. Vedi https://stackoverflow.com/a/3970171/284795 ridimensiona in modo esplosivo con la profondità (una funzione simile utilizzava il 10% della memoria nella mia app).

Una soluzione semplice è utilizzare un elenco e passarlo con la ricorsione 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);
    }
}

In alternativa, è possibile utilizzare uno stack e un ciclo while per eliminare le chiamate ricorsive https://codereview.stackexchange.com/a/5661/754

Mentre ci sono molte buone risposte là fuori, aggiungerei ancora che è possibile utilizzare i metodi LINQ per ottenere lo stesso risultato.

Ad esempio, il codice originale dell'OP potrebbe essere riscritto come:

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