What are local functions in C#? How do they differ from lambdas in capture, allocation and recursion, and when do you use a static local function?

1. How the compiler lowers a capturing lambda

int threshold = 10;
Func<int, bool> isBig = x => x > threshold;

becomes (simplified):

sealed class DisplayClass { public int threshold; public bool Lambda(int x) => x > threshold; }

var closure = new DisplayClass();      // heap allocation #1
closure.threshold = 10;                // the local LIVES in the closure now
var isBig = new Func<int, bool>(closure.Lambda);  // heap allocation #2

The captured local is no longer a stack variable — every read and write in the outer method goes through the closure object. All lambdas in the same scope share one display class, so capturing a large object in one lambda keeps it alive for all of them (a subtle memory-leak source in long-lived event handlers).

Non-capturing lambdas are cached in a static field (<>c.<>9__0_0), so they allocate the delegate only once per app domain.

2. How the compiler lowers a local function

int threshold = 10;
bool IsBig(int x) => x > threshold;
var r = IsBig(5);

becomes:

struct DisplayStruct { public int threshold; }
static bool <M>g__IsBig|0_0(int x, ref DisplayStruct s) => x > s.threshold;

DisplayStruct s = default;
s.threshold = 10;
var r = <M>g__IsBig|0_0(5, ref s);   // no heap allocation

Because a direct call cannot outlive the enclosing frame, captured state can live in a struct on the stack passed by ref. This is the core performance difference.

But if you convert the local function to a delegate (list.Where(IsBig), Task.Run(DoWork), subscribe it to an event), the compiler must use a heap closure — exactly like a lambda. And if any lambda in the same scope captures the same variable, both share the class-based closure.

3. Async and iterator local functions

An async or iterator local function is itself compiled into a state machine. Captured variables are hoisted into a class because the state machine may outlive the frame. So async local functions do allocate (the state machine when it suspends, plus the closure), but they still give you the eager-validation benefit.

4. Definite assignment rules differ

int x;
Func<int> f = () => x;   // CS0165: x is unassigned when the lambda is CREATED

int y;
int G() => y;
y = 5;
Console.WriteLine(G());   // fine: y is assigned before the CALL

The compiler analyses local functions at each call site, which also means recursion "just works" without the Func<> f = null; f = ... dance.

5. Static local functions and static lambdas

static makes capture a compile error. Two practical effects:

1. Performance guarantee — future edits cannot accidentally introduce a capture and an allocation.
2. Lifetime safety — the helper cannot hold this or large locals alive.

Static lambdas (C# 9) give the same guarantee for delegates, combined with APIs that take a state argument to avoid closures:

_cache.GetOrAdd(key, static (k, factory) => factory.Create(k), _factory);

ConcurrentDictionary.GetOrAdd, string.Create, ThreadPool.QueueUserWorkItem<TState> and IMemoryCache helpers all have such state-passing overloads.

6. Debugging and naming

Local functions get mangled names like <CalculateTotal>g__LineTotal|0_0, which appear in stack traces. Since .NET Core 2.1, stack traces demangle these to CalculateTotal()+LineTotal(OrderLine line), which is readable. Lambdas show as <>c__DisplayClass0_0.<Method>b__0, which is harder to read — another small argument for named local functions in complex code.

7. Measuring the difference

[MemoryDiagnoser]
public class CaptureBench
{
    private readonly int[] _data = Enumerable.Range(0, 1000).ToArray();

    [Benchmark] public int Lambda()
    {
        int t = 500; Func<int, bool> f = x => x > t;
        int c = 0; foreach (var x in _data) if (f(x)) c++; return c;
    }

    [Benchmark] public int LocalFunction()
    {
        int t = 500; bool F(int x) => x > t;
        int c = 0; foreach (var x in _data) if (F(x)) c++; return c;
    }
}

Expect the lambda version to show ~88 bytes allocated per call (closure + delegate) and slower invocation (delegate calls are indirect and harder to inline); the local function shows 0 bytes and can be inlined by the JIT.

Try it yourself

1. Paste both versions above into SharpLab and compare the lowered C#.
2. Run the benchmark with BenchmarkDotNet.
3. Convert the local function to a delegate (_data.Count(F)) and watch the allocation reappear.
4. Add static to a capturing local function and read CS8421.

namespace Basics;

public static class LocalFunctions
{
    // 1. Eager validation + lazy iterator
    public static IEnumerable<T> TakeEvery<T>(IEnumerable<T> source, int step)
    {
        ArgumentNullException.ThrowIfNull(source);
        ArgumentOutOfRangeException.ThrowIfNegativeOrZero(step);
        return Iterator(source, step);

        static IEnumerable<T> Iterator(IEnumerable<T> items, int every)
        {
            int i = 0;
            foreach (var item in items)
            {
                if (i++ % every == 0) yield return item;
            }
        }
    }

    // 2. Eager validation + async work
    public static Task<string> ReadHeaderAsync(string path, CancellationToken ct = default)
    {
        ArgumentException.ThrowIfNullOrWhiteSpace(path);
        return Core(path, ct);

        static async Task<string> Core(string p, CancellationToken token)
        {
            using var reader = new StreamReader(p);
            return await reader.ReadLineAsync(token) ?? string.Empty;
        }
    }

    // 3. Recursion and generics
    public static int Depth<T>(T node, Func<T, IEnumerable<T>> children)
    {
        return Walk(node);

        int Walk(T n) => 1 + children(n).Select(Walk).DefaultIfEmpty(0).Max();
    }

    // 4. Capturing local function: struct closure, no allocation when called directly
    public static int SumAbove(int[] values, int threshold)
    {
        int total = 0;
        foreach (var v in values) Add(v);
        return total;

        void Add(int v) { if (v > threshold) total += v; }   // captures total, threshold
    }

    public static void Main()
    {
        Console.WriteLine(string.Join(",", TakeEvery(Enumerable.Range(1, 10), 3))); // 1,4,7,10
        Console.WriteLine(SumAbove([1, 5, 10, 20], 4));                            // 35
    }
}