Скомпилированное лямбда-выражение, приводящее к выделению новых делегатов, тогда как версия без выражения этого не делает

Один из вариантов здесь — скомпилировать внутреннюю лямбду и вызвать ее:

var compile = inner.Compile();
var method = compile.GetType().GetMethod(nameof(Action<int>.Invoke));

var outerExpression = Expression.Lambda<Action<int>>(
    Expression.Block(
        new[] { innerParam },
        Expression.Assign(innerParam, Expression.Constant(compile)),
        Expression.Call(innerParam, method, param))
    , param);

var outer = outerExpression.Compile();

var totalAllocatedBytes = GC.GetTotalAllocatedBytes();

for (int i = 0; i < 1000_000; i++)
{
    outer(1);
}

Console.WriteLine(GC.GetTotalAllocatedBytes() - totalAllocatedBytes);

Что должно быть полным аналогом второго фрагмента.

Я изо всех сил пытаюсь понять, почему. Это предназначено? Есть ли что-нибудь изящное трюк с кэшированием делегатов версии на основе выражений?

Это потому, что вы явно не кэшируете результат компиляции выражения внутреннего делегата.

В случае с решением, не основанным на выражениях, outerLambda фактически превращается в класс с полем, которое может удерживать innerLambda при создании экземпляра класса. Тогда вызовы внешнего будут вызовами метода экземпляра, которые используют уже созданный делегат действия в поле:

private sealed class <>c__DisplayClass0_0
{
    public Action<int> inner;

    internal void <Main>b__1(int x)
    {
        Action<int> innerParam = inner;
        innerParam(x);
    }
}

К счастью, если мы воспользуемся Expression.Constant, мы сможем иметь ту же функциональность с выражениями.

Глядя на то, что Compile делает в исходном коде — он создает Delegate в конце, вызывая этот метод:

private Delegate CreateDelegate() {
    Debug.Assert(_method is DynamicMethod);

    return _method.CreateDelegate(_lambda.Type, new Closure(_boundConstants.ToArray(), null));
}

Этот экземпляр Closure будет служить object Target внешнего Action<int>. Таким образом, делегат сможет передать его в качестве аргумента при вызове фактического скомпилированного метода Delegate:

Void lambda_method205(System.Runtime.CompilerServices.Closure, Int32)

Если мы посмотрим на исходный код outer , мы увидим, что он имеет:

/// <summary>
/// Represents the non-trivial constants and locally executable expressions that are referenced by a dynamically generated method.
/// </summary>
public readonly object[] Constants;

который заполняется VariableBinder.VisitConstant на этапе обхода перед фактической компиляцией делегата:

...
// Constants that can be emitted into IL don't need to be stored on
// the delegate
if (ILGen.CanEmitConstant(node.Value, node.Type)) {
    return node;
}

_constants.Peek().AddReference(node.Value!, node.Type);
...

Итак, чтобы изменить исходный пример (с указанием кода тестирования на другой ответ Гуру Строна), нам нужно будет:

static void Main() {
    var outerOriginal = CreateOuter(useConstantExpression: false);

    //outerOriginal.Target.Dump();
    MeasureAllocationsForInvocations(outerOriginal); // 8168 on my pc
    var outerWithConstantExpression = CreateOuter(useConstantExpression: true);
    // the Target of the delegate has the cached value of the inner Action<int>
    ////outerWithConstantExpression.Dump();
    //outerWithConstantExpression.Dump();

    MeasureAllocationsForInvocations(outerWithConstantExpression); // 0

    dynamic del = outerWithConstantExpression;
    // del.Target is Closure (using dynamic because I cannot reference the type even though it's public.. would edit if somebody assists)
    Console.WriteLine(del.Target.Constants[0].Method.ToString());
    // Void lambda_method204(System.Runtime.CompilerServices.Closure, Int32)
    Console.WriteLine(del.Method.ToString());
    //Void lambda_method205(System.Runtime.CompilerServices.Closure, Int32)
}



static void MeasureAllocationsForInvocations(Action<int> action) {
    var totalAllocatedBytes = GC.GetTotalAllocatedBytes();
    for (int i = 0; i < 100; i++) {
        action(1);
    }
    Console.WriteLine();
    Console.WriteLine(GC.GetTotalAllocatedBytes() - totalAllocatedBytes);
}

static Action<int> CreateOuter(bool useConstantExpression, bool useConsoleWriteLineInnerBody = false) {

    var intParamInnerAndOuter = Expression.Parameter(typeof(int));

    var innerBlock = Expression.Block();
    // for debugging
    if (useConsoleWriteLineInnerBody) {
        MethodInfo writeLineMethod = typeof(Console).GetMethod("Write",
              new Type[] { typeof(int) });
        var writeLineCall = Expression.Call(writeLineMethod, intParamInnerAndOuter);
        innerBlock = Expression.Block(writeLineCall);
    }

    var innerParam = Expression.Parameter(typeof(Action<int>));
    var inner = Expression.Lambda(innerParam.Type,
        innerBlock, intParamInnerAndOuter);

    Expression expressionAssignment = useConstantExpression ?
        Expression.Constant(inner.Compile()) : inner;

    var outerBlock = Expression.Block(
       new[] { innerParam }, // Action<int> a;
     Expression.Assign(innerParam, expressionAssignment), 
     // a = closureParam.Constants[0]
     // or
     // a = new Action<int>(innerExpressionCompiledMethod)
     Expression.Invoke(innerParam, intParamInnerAndOuter)); // a(intParam);

    var outerExpression = Expression.Lambda<Action<int>>(outerBlock,
        intParamInnerAndOuter);

    var outer = outerExpression.Compile();
    // if constant it will inside do -> new Closure(new object[]{inner.Compile});
    return outer;
}

Единственная разница заключается в:

Expression expressionAssignment = useConstantExpression ?
        Expression.Constant(inner.Compile()) : inner;

Это присвоение локальной переменной во внешнем выражении либо использует «кэшированный» скомпилированный делегат из Closure, либо каждый раз создает новый делегат на основе внутреннего выражения.

В тестовом коде (для моего компьютера) выделенная память составляет closureParam.Constants[0] байт для исходного случая и 8168 для второго, который зависит от 0