IEnumerable and Recursion using return return

Mam IEnumerable<T>metodę, której używam do znajdowania formantów na stronie WebForms.

Ta metoda jest rekurencyjna i mam pewne problemy ze zwróceniem żądanego typu, gdy yield returnzwraca wartość wywołania rekurencyjnego.

Mój kod wygląda następująco:

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

To powoduje obecnie błąd „Nie można przekonwertować typu wyrażenia”. Jeśli jednak ta metoda zwraca typ IEnumerable<Object>, kod jest budowany, ale w wyniku zwracany jest niewłaściwy typ.

Czy istnieje sposób korzystania z yield returnjednoczesnej rekurencji?

Wewnątrz metody, która zwraca IEnumerable<T>, yield returnmusi zwrócić T, a nie an IEnumerable<T>.

Zastąpić

yield return c.GetDeepControlsByType<T>();

z:

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

Musisz wydać każdy przedmiot uzyskany w wyniku rekurencyjnego połączenia:

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

Zauważ, że rekursja w ten sposób wiąże się z pewnymi kosztami - w końcu stworzysz wiele iteratorów, które mogą powodować problemy z wydajnością, jeśli masz naprawdę głębokie drzewo kontroli. Jeśli chcesz tego uniknąć, po prostu musisz wykonać rekursję w ramach metody, aby upewnić się, że utworzono tylko jeden iterator (maszynę stanu). Zobacz to pytanie, aby uzyskać więcej szczegółów i przykładową implementację - ale to oczywiście dodaje pewnej złożoności.

Jak zauważają Jon Skeet i pułkownik Panic w swoich odpowiedziach, stosowanie yield returnmetod rekurencyjnych może powodować problemy z wydajnością, jeśli drzewo jest bardzo głębokie.

Oto ogólna nierekurencyjna metoda przedłużania, która wykonuje najpierw głębokość przechodzenia przez sekwencję drzew:

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

W przeciwieństwie do rozwiązania Erica Lipperta RecursiveSelect współpracuje bezpośrednio z modułami wyliczającymi, dzięki czemu nie musi wywoływać funkcji Reverse (która buforuje całą sekwencję w pamięci).

Za pomocą RecursiveSelect oryginalną metodę OP można przepisać w następujący sposób:

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

Inni podali prawidłową odpowiedź, ale nie sądzę, aby twoja sprawa przyniosła korzyść z ustępstw.

Oto fragment kodu, który osiąga to samo bez ustępowania.

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

Musisz zwrócić elementy z modułu wyliczającego, a nie z samego modułu wyliczającego, na sekundę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;
            }
        }
    }
}

Myślę, że musisz dać zwrot każdej z formantów w wyliczeniach.

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

Składnia Seredynskiego jest poprawna, ale należy uważać, aby unikać yield returnfunkcji rekurencyjnych, ponieważ jest to katastrofa z powodu zużycia pamięci. Zobacz https://stackoverflow.com/a/3970171/284795 . Skaluje się gwałtownie z głębokością (podobna funkcja używała 10% pamięci w mojej aplikacji).

Prostym rozwiązaniem jest użycie jednej listy i przekazanie jej z rekurencją 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);
    }
}

Alternatywnie możesz użyć stosu i pętli while, aby wyeliminować rekurencyjne połączenia https://codereview.stackexchange.com/a/5661/754

Chociaż istnieje wiele dobrych odpowiedzi, nadal dodam, że możliwe jest użycie metod LINQ do osiągnięcia tego samego,.

Na przykład oryginalny kod OP może zostać przepisany jako:

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