What are anonymous methods in C# (the delegate keyword syntax)? How do they differ from lambdas, what can they still do that lambdas cannot, can they be static, and would you use them in new code?

1. Compilation

Both anonymous methods and lambdas compile to:

• a static method on the containing class if they capture nothing and the compiler chooses that strategy,
• or (more commonly) an instance method on a singleton <>c class with a cached delegate in a static field, if they capture nothing,
• or a method on a display class (closure) if they capture locals or parameters, with a new display class instance per scope entry, plus a delegate per evaluation,
• or an instance method on the containing class if they capture only this.

The IL is the same whichever syntax you used.

2. Conversion rules for parameterless anonymous methods

delegate { ... } (no parameter list) is compatible with any delegate type where:

• the delegate has no out parameters,
• the return type matches the body's return statements (or void).

This made them useful in C# 2 for events and callbacks where parameters were irrelevant. With overloaded methods taking different delegate types, a parameterless anonymous method can be ambiguous — the compiler may report CS0121.

3. Why lambdas support expression trees and anonymous methods don't

When a lambda targets Expression<TDelegate>, the compiler emits code that builds an expression tree (calls to Expression.Lambda, Expression.Call, etc.) instead of compiling a method. The C# design team only implemented this for lambdas with expression bodies (and limited statement forms). Anonymous methods always have block bodies with statements — not representable in LINQ expression trees, which are expression-oriented.

4. Lambda features added over time

Anonymous methods received only static and discards — they're effectively frozen.

5. Capture semantics (shared)

Both capture variables, not values. A for loop variable captured by either syntax is shared across iterations; foreach variables are fresh per iteration since C# 5. Closures over this keep the object alive as long as the delegate lives.

Try it yourself

1. Write the same callback as an anonymous method and a lambda and compare IL in SharpLab.
2. Assign delegate { } to Action<int, string> and to EventHandler.
3. Try converting an anonymous method to Expression<Func<int, int>> and read the error.
4. Add static to an anonymous method that captures a local and read CS8820.

namespace Delegates.AnonymousMethods;

public static class Program
{
    public static void Main()
    {
        // Classic anonymous method
        Func<int, int> doubleIt = delegate (int x) { return x * 2; };

        // Parameter list omitted: converts to any delegate without out parameters
        Action noArgs = delegate { Console.WriteLine("no args"); };
        Action<int, string> ignoresBoth = delegate { Console.WriteLine("ignored both parameters"); };
        EventHandler onTick = delegate { Console.WriteLine("tick"); };

        // Captures like a lambda
        var threshold = 10;
        Predicate<int> isBig = delegate (int x) { return x > threshold; };
        threshold = 3; // closure sees the variable, not a copy
        Console.WriteLine(isBig(5)); // True

        // Static anonymous method (C# 9): capturing would be a compile error
        Func<int, int> square = static delegate (int x) { return x * x; };

        // Modern equivalents
        Func<int, int> doubleLambda = x => x * 2;
        EventHandler onTickLambda = (_, _) => Console.WriteLine("tick (lambda)");

        // Expression<Func<int, int>> expr = delegate (int x) { return x; }; // CS1946: not convertible to expression tree

        noArgs();
        ignoresBoth(1, "a");
        onTick(null, EventArgs.Empty);
        onTickLambda(null, EventArgs.Empty);
        Console.WriteLine(doubleIt(4) + doubleLambda(4) + square(3));
    }
}