¿Es posible escribir una recursiva IEnumerable <T>

Question

tengo una clase como:

class Spline 
    int ChildrenCount; 
    Spline GetChild (int index) 

class SplineCollection : IEnumerable<Spline> 
    Spline Master 

¿Es posible escribir un IEnumerable recursiva para el SplineCollection donde va a devolver todos los niños uno por uno?

EDITAR: So Master es el Root Box, y la jerarquía de sus hijos puede ser de cualquier profundidad.

EDITAR: Al usar el cuadro Nombre, creo confundir a algunas personas. Se supone que es un objeto geométrico, no un contenedor. Entonces cambiándolo a Spline.

Answer 1

Esto hará un recorrido en profundidad del Box 'árbol'. A continuación, puede llamar a este método en el cuadro Master para devolver todos los secundarios recursivos.

public class Box 
{ 
    // ... 

    public IEnumerable<Box> GetBoxes() 
    { 
     yield return this; 

     for (int i=0; i<box.ChildrenCount; i++) 
     { 
      foreach (Box child in box.GetChild(i).GetBoxes()) 
      { 
       yield return child; 
      } 
     } 
    } 
} 

Answer 2

Sí, consulte esta sección para Recursive Iterations utilizando los iteradores C#.

Answer 3

class Box 
{ 
    int ChildrenCount; 
    Box GetChild (int index){/* some implementation*/} 
    public IEnumerable<Box> Children 
    { 
    get 
    { 
     for(int i = 0; i != ChildrenCount; ++i) 
     yield return GetChild(i); 
    } 
    } 
    public IEnumerable<Box> Descendants 
    { 
    get 
    { 
     foreach(Box child in Children) 
     { 
     yield return child; 
     foreach(Box desc in child.Descendants) 
      yield return desc; 
     } 
    } 
    } 
} 

Puede llamar esto desde BoxCollection, pero dado que la caja ya es una colección de cajas, que no ven lo que el propósito de BoxCollection está aquí. Para el caso, tener Box implemetar IEnumerable<Box> o uno de sus descendientes (ICollection<Box>, IList<Box>) probablemente mejoraría la utilidad.

También es posible hacerlo de forma iterativa en lugar de recurrente, que a veces tiene un mejor rendimiento (casi siempre que el compilador no convierta la recursión en interation de todos modos), pero recursivo es más legible y normalmente más que lo suficientemente eficiente.

Answer 4

Sure. Que ni siquiera realmente necesita un BoxContainer, ya que la caja, por su nombre, existe como un contenedor:

public class Box 
{ 
    private List<Box> myBoxes; 

    public IEnumerable<Box> GetAllBoxes() 
    { 
     yield return this; 
     foreach (var box in myBoxes) 
     { 
      var enumerator = box.GetAllBoxes().GetEnumerator(); 
      while(enumerator.MoveNext()) 
       yield return enumerator.Current; 
     } 
    } 
} 

Si Caja A celebró cajas B y C, caja B celebró casillas D y E, y la caja C celebrada cuadro F, el enumerable saldría A, B, D, E, C, F.

Answer 5

Sí, pero debe enumerar el resultado recursivo. No puede simplemente devolverlo, porque el tipo no coincide.

IEnumerable<int> Triangle(int n) { 
    yield return n; 
    if (n > 0) 
     foreach (var e in Triangle(n - 1)) 
      yield return e; 
} 

Answer 6

Me gustaría mantener manualmente una pila en lugar de confiar en la pila de llamadas aquí. El motivo se debe a que debería crearse un nuevo IEnumerable<Spline> para cada Spline visitado si utilizaba la pila de llamadas llamando recursivamente al método que obtiene los descendientes. Eso sería ineficiente. Puede mejorar significativamente el recorrido utilizando su propia pila.

public IEnumerable<Spline> Descendants 
{ 
    get 
    { 
     // This performs a simple iterative preorder traversal. 
     var stack = new Stack<Spline>(new Spline[] { this }); 
     while (stack.Count > 0) 
     { 
      Spline current = stack.Pop(); 
      yield return current; 
      for (int i = current.ChildrenCount - 1; i >= 0; i--) 
      { 
       stack.Push(current.GetChild(i)); 
      } 
     } 
    } 
}