IEnumerable und Rekursion mit Renditerückgabe

Question

Ich habe eine IEnumerable<T> Methode, die ich verwende, um Steuerelemente in einer WebForms-Seite zu finden.

Die Methode ist rekursiv und ich habe einige Probleme beim Zurückgeben der Art, die ich will, wenn die yield return den Wert des rekursiven Aufrufs zurückgibt.

Mein Code sieht wie folgt aus:

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

Das zur Zeit wirft einen Fehler „Kann nicht Ausdruck Typ umwandeln“. Wenn diese Methode jedoch den Typ IEnumerable<Object> zurückgibt, wird der Code erstellt, aber der falsche Typ wird in der Ausgabe zurückgegeben.

Gibt es eine Möglichkeit, yield return zu verwenden, während auch Rekursion verwendet wird?

Answer 1

Innerhalb einer Methode, die IEnumerable<T>, yield return zurückgibt, muss T, nicht IEnumerable<T> zurückgegeben werden.

ersetzen

yield return c.GetDeepControlsByType<T>(); 

mit:

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

Answer 2

Sie benötigen jedes der Elemente erhalten durch den rekursiven Aufruf ergab:

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

Hinweis, dass es eine Kosten rekursive auf diese Weise - Sie werden am Ende eine Menge von iter erstellen Sie können ein Leistungsproblem verursachen, wenn Sie einen wirklich tiefen Kontrollbaum haben. Wenn Sie das vermeiden möchten, müssen Sie die Rekursion im Wesentlichen selbst innerhalb der Methode durchführen, um sicherzustellen, dass nur ein Iterator (Zustandsautomat) erstellt wird. Weitere Details und eine Beispielimplementierung finden Sie unter this question - aber das bringt natürlich auch eine gewisse Komplexität mit sich.

Answer 3

Sie müssen die Artikel vom Enumerator zurück, nicht den Enumerator selbst, in Ihrem zweiten 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; 
      } 
     } 
    } 
} 

Answer 4

Ich glaube, Sie Rückkehr jeder der Kontrollen in den enumerables ergeben haben.

Answer 5

Andere gaben Ihnen die richtige Antwort, aber ich denke nicht, dass Ihr Fall von Nachgeben profitiert.

Hier ist ein Schnipsel, der das gleiche erreicht, ohne nachzugeben.

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

Answer 6

Seredynski's syntax ist richtig, aber Sie sollten vorsichtig sein, yield return in rekursiven Funktionen zu vermeiden, weil es eine Katastrophe für die Speichernutzung ist. Siehe https://stackoverflow.com/a/3970171/284795 es skaliert explosionsartig mit der Tiefe (eine ähnliche Funktion verwendet 10% des Speichers in meiner App).

Eine einfache Lösung ist eine Liste verwenden und es mit der Rekursion passieren 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); 
    } 
} 

Alternativ können Sie einen Stapel und eine while-Schleife verwenden, um rekursive Aufrufe https://codereview.stackexchange.com/a/5661/754

Answer 7

Als Jon Skeet und Oberst zu beseitigen Paniknotizen in ihren Antworten, die in rekursiven Methoden yield return verwenden, können zu Leistungsproblemen führen, wenn der Baum sehr tief ist.

Hier ist eine generische nicht-rekursive Erweiterung Methode, die einen depth-first Traversal einer Folge von Bäumen führt:

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

Im Gegensatz zu Eric Lippert's solution arbeitet RecursiveSelect direkt mit Aufzählungen, so dass es nicht braucht Call Reverse (die die gesamte Sequenz im Speicher zwischenspeichert).

Mit RecursiveSelect, dem ursprünglichen Methode des OP kann einfach so umgeschrieben werden:

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

Answer 8

Zwar gibt es viele gute Antworten gibt, würde ich noch hinzufügen, dass es möglich ist, LINQ Methoden zu verwenden, um das gleiche zu erreichen Ding, .

Zum Beispiel könnte der ursprüngliche Code des OP neu geschrieben werden als:

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