What makes the C# compiler output an expression tree instead of code?

Question

Here is the code.

  int[] data = new int[] { 1, 2, 3, 4, 5 };
  var q1 = data.Select(x => 10 * x);
  var q2 = data.AsQueryable().Select(x => 10 * x);
  Expression<Func<int,int>> qe = (x) => 10 * x;

In the first case the compiler generates code to evaluate the expression. There is no expression tree in the output.

In the second it generates an expression tree (visible on debug), which at run-time is compiled and executed to perform the query (and does exactly the same thing).

In the third case, the same lambda as (2) is created directly as an expression tree (not as code).

What makes the compiler generate an expression tree instead of code in these two cases, and are there any other interesting cases?

The reason: I want to 'pick apart' the top level of the expression tree at runtime, and then compile and execute the lower levels. I'm having trouble getting the compiler to do things my way!

It's a case of "that's how the compiler is written". It needs to do it that way to make expressions work. It's just like methods that return IEnumerable<T> can use yield return. Special compiler operations to support language features. — Enigmativity
– Enigmativity, Commented Aug 17, 2016 at 4:38
The list goes on. The compiler treats Nullable<T> types differently. It can use duck-typing for foreach loops. LINQ queries are really just re-arranged methods (usually extension method, but don't need to be). using statements only work with disposables, etc. — Enigmativity
– Enigmativity, Commented Aug 17, 2016 at 4:44
Your first statement isn't really an expression; it's a constructor call. The two Select statements are Linq statements which produce expressions as part of their normal operation. The fourth statement generates an expression because you specified an expression as the resulting type. — Robert Harvey
– Robert Harvey, Commented Aug 17, 2016 at 4:54
Very unclear what you have problem with - if code asks for expression (like Queryable.Select you use) than obviously compiler will construct expression tree... So what exactly you have problem with? — Alexei Levenkov
– Alexei Levenkov, Commented Aug 17, 2016 at 5:15
Thanks all but none of these answer the question: what is the critical feature that decides which path the compiler will take for a lambda? — david.pfx
– david.pfx, Commented Aug 17, 2016 at 14:24

Damien_The_Unbeliever · Accepted Answer · 2016-08-17 06:40:35Z

3

Enumerable's Select method accepts a parameter of type Func<TSource,TResult>. Queryable's Select method accepts a parameter of type Expression<Func<TSource,TResult>>.

It's as simple as that - if the compiler has a lambda expression it can either generate an expression or compile the lambda, and that decision is based on what it's being asked to create - if it's an Expression of some type, it will generate the expression tree. If it's a Func or other delegate type, it generates the code.

edited Aug 17, 2016 at 6:40

answered Aug 17, 2016 at 6:30

Damien_The_Unbeliever

241k28 gold badges358 silver badges470 bronze badges

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

2 Comments

david.pfx Over a year ago

Damn! It really is that simple! The compiler generates code if the parameter derives from Delegate and an expression tree if it derives from Expression, and there are no other choices. Thanks!

Sagi Over a year ago

Just bear in mind that delegates can span to multiple lines but an expression tree which is written the same way as a delegate e.g. Expression<Func<int[]>> lambda = () => new int[] { 1, 2, 3, 4, 5 }; can only be one line.

Collectives™ on Stack Overflow

What makes the C# compiler output an expression tree instead of code?

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related