A .NET service suddenly crashes with a StackOverflowException. Why can't you catch it, and how do you find and fix the cause?

1. The stack filling up

high addresses
+-----------------------------+
| Main                        |
| Handle(request)             |
| Evaluate(rule1)             |
| Evaluate(rule2)             |
| Evaluate(rule1)   <- cycle  |
| Evaluate(rule2)             |
| ...                         |
| Evaluate(rule1)             |
+-----------------------------+  <- guard page touched: stack overflow, process terminated
low addresses

2. Estimating depth limits

stack size / frame size ≈ max depth
1 MB / 100 bytes per frame  ≈ 10,000 levels
1 MB / 1 KB per frame       ≈ 1,000 levels   (big structs or stackalloc in the frame)

Optimised (Release) frames are often smaller than Debug frames, so a recursion that overflows in Debug might survive in Release, and vice versa if inlining changes. Never rely on "it worked on my machine".

3. Recursion to iteration

// Recursive depth-first traversal
void Visit(Node node) { Process(node); foreach (var child in node.Children) Visit(child); }

// Iterative with an explicit stack (heap-allocated, no depth limit beyond memory)
void VisitIterative(Node root)
{
    var stack = new Stack<Node>();
    stack.Push(root);
    while (stack.TryPop(out var node))
    {
        Process(node);
        for (var i = node.Children.Count - 1; i >= 0; i--) stack.Push(node.Children[i]);
    }
}

C# doesn't guarantee tail-call elimination, so rewriting as tail recursion isn't a reliable fix.

4. Dump configuration for containers

env:
  - name: DOTNET_DbgEnableMiniDump
    value: "1"
  - name: DOTNET_DbgMiniDumpType
    value: "2"            # 1 mini, 2 with heap, 3 triage, 4 full
  - name: DOTNET_DbgMiniDumpName
    value: /dumps/%e-%p-%t.dmp
volumeMounts:
  - name: dumps
    mountPath: /dumps     # persistent or shared volume so the dump survives the restart

Dumps can contain personal information from memory; store them securely and delete them after analysis (Privacy Act and your organisation's data handling rules apply).

5. Security angle

Any recursion driven by user input is a potential denial-of-service: one crafted request crashes the whole process and every in-flight request with it. Depth limits on parsers and validators are a security control, not just a robustness one. System.Text.Json's MaxDepth exists for this reason.

6. Related but different

7. Try it yourself

1. Write int Recurse(int n) => Recurse(n + 1) + 1;, run it, and read the output on your .NET version.
2. Set DOTNET_DbgEnableMiniDump=1 and the dump name, run again, and analyse the dump with dotnet-dump analyze and clrstack.
3. Add RuntimeHelpers.EnsureSufficientExecutionStack() at the top of a recursive tree evaluator and test it with a 100,000-level tree.
4. Rewrite the evaluator iteratively and confirm it handles the same tree.

namespace StackOverflowFixes;

using System.Runtime.CompilerServices;
using System.Text.Json;

public sealed class RuleNode
{
    public required string Name { get; init; }
    public List<RuleNode> Children { get; } = [];
}

public static class RuleEvaluator
{
    public const int MaxDepth = 50;

    // Iterative, cycle-safe and depth-limited evaluation.
    public static int CountNodes(RuleNode root)
    {
        var visited = new HashSet<RuleNode>(ReferenceEqualityComparer.Instance);
        var stack = new Stack<(RuleNode Node, int Depth)>();
        stack.Push((root, 0));
        int count = 0;

        while (stack.TryPop(out var item))
        {
            if (item.Depth > MaxDepth)
            {
                throw new InvalidOperationException($"Rule nesting exceeds {MaxDepth} levels.");
            }
            if (!visited.Add(item.Node))
            {
                throw new InvalidOperationException($"Rule '{item.Node.Name}' is part of a cycle.");
            }
            count++;
            foreach (var child in item.Node.Children)
            {
                stack.Push((child, item.Depth + 1));
            }
        }
        return count;
    }

    // If you must recurse, guard it: throws a catchable InsufficientExecutionStackException.
    public static int Depth(RuleNode node)
    {
        RuntimeHelpers.EnsureSufficientExecutionStack();
        int max = 0;
        foreach (var child in node.Children) max = Math.Max(max, Depth(child));
        return max + 1;
    }
}

public static class SafeJson
{
    // Limit nesting of untrusted JSON (the default is 64; lower it if your schema allows).
    public static readonly JsonSerializerOptions Options = new() { MaxDepth = 32 };
}

public sealed class Customer
{
    private string _name = "";

    // BUG (commented out): the getter calls itself and overflows the stack.
    // public string Name { get => Name; set => _name = value; }

    public string Name { get => _name; set => _name = value; }
}