Introduction

Flattening a tree means turning hierarchical nodes into one sequence that can be filtered, projected, or searched with ordinary LINQ queries. The tricky part is that LINQ does not magically recurse on its own. You need a traversal method that walks each node and then emits its descendants in a predictable order.

Model the Tree Clearly

Assume each node has a value and a sequence of children. A simple class is enough for the examples:

1using System.Collections.Generic;
2
3public class Node
4{
5    public string Name { get; set; } = "";
6    public List<Node> Children { get; set; } = new();
7}

Now imagine a tree such as a company hierarchy or category structure. The goal is to convert that nested shape into IEnumerable<Node> so you can use normal LINQ operations on it.

A Recursive LINQ-Friendly Flatten Method

The common approach is a recursive extension method. It returns each node, then recursively returns all descendants.

1using System.Collections.Generic;
2using System.Linq;
3
4public static class TreeExtensions
5{
6    public static IEnumerable<T> Flatten<T>(
7        this IEnumerable<T> source,
8        Func<T, IEnumerable<T>> childrenSelector)
9    {
10        foreach (var item in source)
11        {
12            yield return item;
13
14            foreach (var child in childrenSelector(item).Flatten(childrenSelector))
15            {
16                yield return child;
17            }
18        }
19    }
20}

This method is generic, so it works with any tree-like model as long as you can tell it how to get a node's children.

Use it like this:

1using System;
2using System.Collections.Generic;
3using System.Linq;
4
5var tree = new List<Node>
6{
7    new Node
8    {
9        Name = "Root",
10        Children =
11        {
12            new Node { Name = "A" },
13            new Node
14            {
15                Name = "B",
16                Children =
17                {
18                    new Node { Name = "B1" },
19                    new Node { Name = "B2" }
20                }
21            }
22        }
23    }
24};
25
26var names = tree
27    .Flatten(n => n.Children)
28    .Select(n => n.Name);
29
30Console.WriteLine(string.Join(", ", names));

This produces a depth-first traversal in the same order the children are stored.

Why SelectMany Appears in Many Solutions

You will often see recursive LINQ solutions written with Concat and SelectMany. That style is compact and expresses the same idea.

1using System;
2using System.Collections.Generic;
3using System.Linq;
4
5public static class TreeExtensions
6{
7    public static IEnumerable<T> Flatten<T>(
8        this T node,
9        Func<T, IEnumerable<T>> childrenSelector)
10    {
11        return new[] { node }
12            .Concat(childrenSelector(node).SelectMany(child => child.Flatten(childrenSelector)));
13    }
14}

This version is elegant, but the yield return version is often easier to debug and reason about. Both are valid. Choose the one your team will read comfortably.

Flatten Multiple Roots

Many real datasets are forests, not single trees. The earlier IEnumerable<T> extension already handles that case because it accepts a sequence of roots.

That means you can flatten:

• menu systems with several top-level entries
• organization charts with multiple departments
• file-like category groupings loaded from a database

Once flattened, ordinary LINQ becomes much easier:

1var leafNames = tree
2    .Flatten(n => n.Children)
3    .Where(n => n.Children.Count == 0)
4    .Select(n => n.Name);

This is the real payoff. Flatten first, then write simple queries against the flat sequence.

Watch for Deep Trees

Recursion is clear, but extremely deep trees can overflow the stack. If the data may be very deep, switch to an iterative traversal using an explicit Stack<T>.

1using System.Collections.Generic;
2
3public static IEnumerable<T> FlattenIterative<T>(
4    IEnumerable<T> roots,
5    Func<T, IEnumerable<T>> childrenSelector)
6{
7    var stack = new Stack<T>(roots.Reverse());
8
9    while (stack.Count > 0)
10    {
11        var current = stack.Pop();
12        yield return current;
13
14        foreach (var child in childrenSelector(current).Reverse())
15        {
16            stack.Push(child);
17        }
18    }
19}

This still gives you a depth-first walk, but without depending on the call stack.

Choose the Traversal Order Intentionally

Not every flattening problem wants the same order. The examples above are depth-first. If you need breadth-first traversal, use a queue instead of recursion or a stack.

The important design question is not "how do I use LINQ". It is "what order should the flattened sequence represent". Once that is clear, the code becomes straightforward.

Common Pitfalls

• Expecting plain SelectMany to recurse automatically through all descendants.
• Forgetting that recursive solutions can fail on very deep trees.
• Losing the intended node order by using an unsuitable traversal strategy.
• Writing a tree-specific helper when a generic childrenSelector version would be reusable.
• Flattening nodes when you really needed only leaf nodes or only descendants, not the root.

Summary

• Flattening a tree in LINQ requires an explicit traversal method.
• A generic recursive extension method is the most common solution.
• 'yield return versions are often easier to maintain than heavily nested LINQ expressions.'
• Use an iterative stack-based traversal when tree depth may be large.
• Decide on depth-first versus breadth-first order before writing the flatten logic.