S>public class TreeNode
S>{
S>    public IEnumerable<TreeNode> Children
S>    {
S>        get
S>        {
S>            return _children;
S>        }
S>    }
S>    private List<TreeNode> _children = new List<TreeNode>;
    
S>    // внимание, пошел трюк:
S>    public IEnumerable<TreeNode> AllChildren
S>    {
S>        get
S>        {
S>            foreach(TreeNode child in Children)
S>            {
S>                yield return child;
S>                foreach(TreeNode descendant in child.AllChildren)
S>                    yield return descendant;
S>            }
S>        }
S>    }
S>}
S>

public class TestTree {
    public static interface Closure<T> {
        public void execute(T object);
    }

    public static class TreeNode {
        private List<TreeNode> children = new ArrayList<TreeNode>();

        public void traverse(Closure<TreeNode> closure) {
            closure.execute(this);
            for (TreeNode child : children) child.traverse(closure);
        }
    }

    public static void main(String [] args) {
        new TreeNode().traverse(new Closure<TreeNode>() {
            public void execute(TreeNode object) {
                System.out.println(object);
            }
        });
    }
}

        public static IEnumerable<T> FindAll<T>(IEnumerable<T> input, Predicate<T> predicate)
        {
            foreach(T item in input)
                if (predicate(item))
                    yield return item;
        }

        /// <summary>
        /// Sorts the input using the specified key
        /// </summary>
        /// <typeparam name="T">The type of the enumerable - normally may be omitted since 
        /// compiler derives it from the first argument</typeparam>
        /// <typeparam name="TKey">The type of the key to perform comparison by. Must implement IComparable&lt;TKey&gt;</typeparam>
        /// <param name="collection">Source collection</param>
        /// <param name="by">The key expression</param>
        /// <returns>Array sorted by </returns>
        public static T[] Sort<T, TKey>(IEnumerable<T> collection, Converter<T, TKey> by)
            where TKey: IComparable<TKey>
        {
            return Sort(collection, delegate(T x, T y) { return by(x).CompareTo(by(y)); });
        }

1.1.4 stable rev. 510

public class TestTree {
    public static interface Closure<T> {
        public void execute(T object);
    }

    public static interface Predicate<T> {
        public boolean evaluate(T object);
    }

    public static class TreeNode {
        private List<TreeNode> children = new ArrayList<TreeNode>();

        public void traverse(Closure<TreeNode> closure, Predicate<TreeNode> predicate) {
            if (predicate.evaluate(this)) closure.execute(this);
            for (TreeNode child : children) child.traverse(closure, predicate);
        }

        public void iterate(Closure<TreeNode> closure, Predicate<TreeNode> predicate, Comparator<TreeNode> comparator) {
            final List<TreeNode> temp = new ArrayList<TreeNode>();
            traverse(new Closure<TreeNode>() { public void execute(TreeNode object) { temp.add(object); } }, predicate);
            Collections.sort(temp, comparator); for (TreeNode node : temp) closure.execute(node);
        }
    }

    public static void main(String [] args) {
        new TreeNode().iterate(
            new Closure<TreeNode>() {
                public void execute(TreeNode object) { System.out.println(object); }
            },
            new Predicate<TreeNode>() {
                public boolean evaluate(TreeNode object) { return object != null; }
            },
            new Comparator<TreeNode>() {
                public int compare(TreeNode x, TreeNode y) { return 0; }
            });
    }
}

S>public class TreeNode
S>{
S>    public IEnumerable<TreeNode> Children
S>    {
S>        get
S>        {
S>            return _children;
S>        }
S>    }
S>    private List<TreeNode> _children = new List<TreeNode>;
    
S>    // внимание, пошел трюк:
S>    public IEnumerable<TreeNode> AllChildren
S>    {
S>        get
S>        {
S>            foreach(TreeNode child in Children)
S>            {
S>                yield return child;
S>                foreach(TreeNode descendant in child.AllChildren)
S>                    yield return descendant;
S>            }
S>        }
S>    }
S>}
S>

public class TreeNode implements Iterable<TreeNode> {

private List<TreeNode> childrens = new ArrayList<TreeNode>();

public Iterator<TreeNode> iterator() {
  return childrens.iterator();
}

public Iterator<TreeNode> getAllChildrens() {
  MultiIterator<TreeNode> it = new MultiIterator<TreeNode>();
  for(TreeNode child : this) {
    it.addIterator(child.getAllChildrens());
  }
}

public static class MultiIterator implements Iterator<TreeNode> {

  private List<Iterator<TreeNode>> iterators = new ArrayList<Iterator<TreeNode>>();
  int i = 0;
  
  public void addIterator(Iterator<TreeNode> it) {
    iterators.add(it);
  }

  public TreeNode next() {
    if(hasNext()) {
    return iterators.get(i).next();
    }
    throw NoSuchElementFound();
  }

  public boolean hasNext() {
    while(i < iterators.size())
       if(iterators.get(i).hasNext()) {
          return true; 
       }  
      i++;
    }
    retun false;
  }
}

}

L>Предупреждаю сразу не компилировал, но работать должно. Жду гнилых помидоров

public class TreeNode implements Iterable<TreeNode> {

private List<TreeNode> childrens = new ArrayList<TreeNode>();

public Iterator<TreeNode> iterator() {
  return childrens.iterator();
}

public Iterator<TreeNode> getAllChildrens() {
  MultiIterator<TreeNode> it = new MultiIterator<TreeNode>();
  for(TreeNode child : this) {
    it.addIterator(child.getAllChildrens());
  }
    return it; // надо полагать?
}

1.1.4 stable rev. 510