Olostan

        private sealed class MyDumper
        {
            public static string Dump(Node root)
            {
                // get all nodes (used later for "to parent" iteration
                var allNodeTuples = EnumerateNodes(root, null);
                // main query, later we'll agregate results
                var query = allNodeTuples.Select(tuple =>
                {
                    var node = tuple.Item1;
                    var parent = tuple.Item2;
                    var s = new LinkedList<string>();
                    s.AddLast(node.Text);
                    s.AddLast(Environment.NewLine);
                    if (parent != null)
                    {
                        // thats for 'closest' childs
                        s.AddFirst("-");
                        s.AddFirst(parent.Children.Last() != node ? "├" : "└");
                        do
                        {
                            // build indention
                            node = parent;
                            var oldParent = parent;
                            parent = allNodeTuples.Where(t => t.Item1 == oldParent).FirstOrDefault().Item2;
                            if (parent != null)
                                s.AddFirst( (parent.Children.Last() != node
                                                 ? "│ "
                                                 : "  "));
                        } while (parent != null);
                    }
                    // joins results into single line
                    return string.Join(String.Empty, s);
                });
                // run query with string builder to aggregate
                return query.Aggregate(new StringBuilder(), (s, v) => s.Append(v)).ToString();
            }

            // Enumerate all tree nodes, returning tuple with first item as node, second as node's parent
            private static IEnumerable<Tuple<Node, Node>> EnumerateNodes(Node root, Node parent)
            {
                /* recursive:
                yield return new Tuple<Node,Node>(root, parent);
                foreach (var child in root.Children)
                    foreach (var sub in EnumerateNodes(child, root)) yield return sub;*/
                var workStack = new Stack<Tuple<Node, Node>>();
                workStack.Push(new Tuple<Node, Node>(root, parent));
                while (workStack.Count > 0)
                {
                    var current = workStack.Pop();
                    yield return current;
                    foreach (var child in current.Item1.Children.Reverse())
                        workStack.Push(new Tuple<Node, Node>(child, current.Item1));
                }
            }
        }