Issue with closure variable capture in c# expression

Question

I have a function which creates a delegate using expression trees. Within this expression I use a variable captured from multiple parameters passed in to the function. The actual expression tree is rather large so as an example:

Delegate GenerateFunction<T>(T current, IList<T> parents) {
    var currentExpr = Expression.Parameter(typeof(T), "current");
    var parentsExpr = Expression.Parameter(parents.getType(), "parents");
    var parameters = new List<ParameterExpression>();
    //...
    return Expression
        .Lambda(
            Expression.Block(new List<ParameterExpression> { parentsExpr, currentExpr }, ...),
            parameters.ToArray())
        .Compile();
}

I then invoke this method from another method before passing that function to another function to use. Once that's all done I want to access the content of parents which gets updated within the expression tree.

Everything seems to compile, and my expression looks ok, but when I run it I appear (although I can't really be sure) to be getting null reference exceptions when accessing the parents variable (inside the expression/closure).

I can't find any hoisted (?) local variables within the method so I'm wondering whether they're being captured at all?

parameters.ToArray() would be an empty array, so the ParameterExpressions end up describing something that does not exist. — Jon
– Jon, Commented Jan 29, 2013 at 14:30
Yeah, sorry about that, it does actually get filled with some other parameters that are created in between its declaration and the return — Mark Jerzykowski
– Mark Jerzykowski, Commented Jan 29, 2013 at 14:33

Eric Lippert · Accepted Answer · 2013-01-29 16:05:19Z

20

I don't seem to be able to find any hoisted local variables within the method so I'm wondering whether they're being captured at all?

It looks like you are building the expression tree lambda yourself, by "manually" calling the factory methods. The compiler has no idea that that's what you're doing; it just sees method calls. If you want locals to be hoisted then you're going to have to either (1) get the compiler to do it for you, by making it rewrite the lambda, or (2) hoist 'em yourself.

That is:

int x = 123;
Expression<Func<int>> ex = ()=>x;

the compiler rewrites the lambda and hoists it for you, as though you'd said:

Closure c = new Closure();
c.x = 123;
Expression<Func<int>> ex = ()=>c.x;

Where c typically becomes a Constant expression.

But if you say

Expression<Func<int>> ex = Expression.Lambda( ...something that uses x ... );

the compiler has no idea that you're doing something where it needs to hoist x; x is not inside a lambda expression. If you're using the factories, the compiler assumes you know what you're doing and doesn't mess around with rewriting it. You'll have to hoist it yourself.

edited Jan 29, 2013 at 16:05

answered Jan 29, 2013 at 15:27

Eric Lippert

663k185 gold badges1.3k silver badges2.1k bronze badges

Sign up to request clarification or add additional context in comments.

4 Comments

Mark Jerzykowski Over a year ago

Ah, so how does one hoist the variable? I presumed that passing my outer variables to the Expression.Block did the hoisting for me?

Eric Lippert Over a year ago

@MarkJerzykowski: The same way the compiler hoists the variable. Make a class, make the variable a field of the class, and then update every usage of that variable to instead refer to that field on an instance of the class. Inside the expression block you'd typically make a Constant expression that held onto an instance of the closure class, and then do a member access expression every time you want the value of the local.

Mark Jerzykowski Over a year ago

You're a star, thanks very much! Might be worth noting that I initially tried to use the Closure class in System.Runtime.CompilerServices but that leads to unboxing issues so I did what I probably should have done and created a strongly typed class for my closure to use! Thanks again

Govert Over a year ago

@Eric: Doesn't your detailed answer here: stackoverflow.com/questions/3716492/… suggest that the Expression Trees can do the variable capture without one having to make the closure class explicitly?

Community · Accepted Answer · 2017-05-23 12:18:16Z

2

I think you're looking for Expression.Quote, which supports the variable capture in Lambda expressions. Basically the inner LambdaExpression (which will reference the captured variables) need to be wrapped in an Expression.Quote(...) call.

Examples and discussion here: What does Expression.Quote() do that Expression.Constant() can’t already do?

edited May 23, 2017 at 12:18

CommunityBot

11 silver badge

answered Feb 1, 2014 at 10:11

Govert

17k4 gold badges62 silver badges73 bronze badges

Collectives™ on Stack Overflow

Issue with closure variable capture in c# expression

2 Answers 2

4 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related