{"id":3023,"date":"2009-09-14T13:37:00","date_gmt":"2009-09-14T13:37:00","guid":{"rendered":"https:\/\/blogs.msdn.microsoft.com\/visualstudio\/2009\/09\/14\/generating-dynamic-methods-with-expression-trees-in-visual-studio-2010\/"},"modified":"2019-02-14T15:42:21","modified_gmt":"2019-02-14T23:42:21","slug":"generating-dynamic-methods-with-expression-trees-in-visual-studio-2010","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/visualstudio\/generating-dynamic-methods-with-expression-trees-in-visual-studio-2010\/","title":{"rendered":"Generating Dynamic Methods with Expression Trees in Visual Studio 2010"},"content":{"rendered":"

Expression trees first appeared in Visual Studio 2008, where they were mainly used by LINQ providers. You can use expression trees to represent code in a tree-like format, where each node is an expression. You can also convert expression trees into compiled code and run it. This transformation enables dynamic modification of executable code as well as the execution of LINQ queries in various databases and the creation of dynamic queries. Expression trees in Visual Studio 2008 are explained in Charlie Calvert’s blog post <\/font>Expression Tree Basics<\/font><\/a>.<\/font><\/p>\n

In this post I’m going to show how expression trees were extended in Visual Studio 2010 and how you can use them to generate dynamic methods (a problem that previously could be solved only by emitting MSIL). But although I strongly recommend reading Charlie’s blog post first, I still need to repeat some basics to spell out certain nuances.<\/font><\/p>\n

Creating Expression Trees<\/font><\/h2>\n

The easiest way to generate an expression tree is to create an instance of the <\/font>Expression<T><\/span> type, where <\/font>T<\/span> is a delegate type, and assign a lambda expression to this instance. Let’s take a look at the code.<\/font><\/font><\/p>\n

<\/p>\n

\/\/ Creating an expression tree by providing a lambda expression.<\/p>\n

<\/span><\/p>\n

Expression<\/span><<\/font>Action<\/span><<\/font>int<\/span>>> printExpr = (arg) => <\/font>Console<\/span>.WriteLine(arg);<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

 <\/font><\/p>\n

<\/span><\/p>\n

\/\/ Compiling and invoking the expression tree.<\/p>\n

<\/span><\/p>\n

printExpr.Compile()(10);<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

<\/span><\/p>\n

\/\/ Prints 10.<\/p>\n

<\/span><\/p>\n

\n

<\/span>In this example, the C# compiler generates the expression tree from the provided lambda expression. Note that if you use <\/font>Action<int><\/span> instead of <\/font>Expression<Action<int>><\/span> as a type of the <\/font>printExpr<\/span> object, no expression tree will be created, because delegates are not converted into expression trees.<\/font><\/font><\/p>\n

However, this is not the only way to create an expression tree. You can also use classes and methods from the <\/font>System.LINQ.Expressions<\/span> namespace. For example, you can create the same expression tree by using the following code.<\/font><\/font><\/p>\n

\/\/ Creating a parameter for the expression tree.<\/p>\n

<\/span><\/p>\n

ParameterExpression<\/span> param = Expression<\/span>.Parameter(typeof<\/span>(int<\/span>), “arg”<\/span>);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

\/\/ Creating an expression for the method call and specifying its parameter.<\/p>\n

<\/span><\/p>\n

MethodCallExpression<\/span> methodCall = Expression<\/span>.Call(<\/p>\n

<\/span><\/p>\n

typeof<\/span>(Console<\/span>).GetMethod(“WriteLine”<\/span>, new<\/span> Type<\/span>[] { typeof<\/span>(int<\/span>) }),<\/p>\n

<\/span><\/p>\n

param<\/p>\n

<\/span><\/p>\n

);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

\/\/ Compiling and invoking the methodCall expression.<\/p>\n

<\/span><\/p>\n

Expression<\/span>.Lambda<Action<\/span><int<\/span>>>(<\/p>\n

<\/span><\/p>\n

methodCall,<\/p>\n

<\/span><\/p>\n

new<\/span> ParameterExpression<\/span>[] { param }<\/p>\n

<\/span><\/p>\n

).Compile()(10);<\/p>\n

<\/span><\/p>\n

<\/p>\n

<\/span><\/p>\n

\/\/ Also prints 10.<\/p>\n

<\/span><\/p>\n

Of course this looks much more complicated, but this is what actually happens when you supply a lambda expression to an expression tree.<\/font><\/p>\n

Expression Trees vs. Lambda Expressions<\/font><\/h2>\n

A common misconception is that expression trees are identical to lambda expressions. This is not true. On the one hand, as I have already shown, you can create and modify expression trees by using API methods, without using lambda expression syntax at all. On the other hand, not every lambda expression can be implicitly converted into an expression tree. For example, multiline lambdas (also called statement lambdas<\/i>) cannot be implicitly converted into expression trees. <\/font><\/p>\n

\/\/ You can use multiline lambdas in delegates.<\/p>\n

<\/span><\/p>\n

Action<\/span><int<\/span>> printTwoLines = (arg) =><\/p>\n

<\/span><\/p>\n

{<\/p>\n

<\/span><\/p>\n

Console<\/span>.WriteLine(“Print arg:”<\/span>);<\/p>\n

<\/span><\/p>\n

Console<\/span>.WriteLine(arg);<\/p>\n

<\/span><\/p>\n

};<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

\/\/ But in expression trees this generates a compiler error.<\/p>\n

<\/span><\/p>\n

Expression<\/span><Action<\/span><int<\/span>>> printTwoLinesExpr = (arg) =><\/p>\n

<\/span><\/p>\n

{<\/p>\n

<\/span><\/p>\n

Console<\/span>.WriteLine(“Print arg:”<\/span>);<\/p>\n

<\/span><\/p>\n

Console<\/span>.WriteLine(arg);<\/p>\n

<\/span><\/p>\n

};<\/p>\n

<\/span><\/p>\n

Expression Trees in Visual Studio 2010<\/font><\/h2>\n

All the code examples I have shown so far work (or don’t work) the same in both Visual Studio 2008 and Visual Studio 2010. Now let’s move to C# 4.0 and Visual Studio 2010.<\/font><\/p>\n

In Visual Studio 2010, the expression trees API was extended and added to the dynamic language runtime (DLR), so that language implementers can emit expression trees rather than MSIL. To support this new goal, control flow and assignment features were added to expression trees: loops, conditional blocks, try-catch blocks, and so on. <\/font><\/p>\n

There is a catch: You cannot use these new features “an easy way”, by using lambda expressions syntax. You must use the expression trees API. So the last code example in the previous section still generates a compiler error, even in Visual Studio 2010. <\/font><\/p>\n

But now you have a way to create such an expression tree by using API methods that were not available in Visual Studio 2008. One of these methods is <\/font>Expression.Block<\/span>, which enables the execution of several expressions sequentially, and this is exactly the method that I need for this example.<\/font><\/font><\/p>\n

\/\/ Creating a parameter for an expression tree.<\/p>\n

<\/span><\/p>\n

ParameterExpression<\/span> param = Expression<\/span>.Parameter(typeof<\/span>(int<\/span>), “arg”<\/span>);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

\/\/ Creating an expression for printing a constant string.<\/p>\n

<\/span><\/p>\n

MethodCallExpression<\/span> firstMethodCall = Expression<\/span>.Call(            <\/span><\/p>\n

<\/span><\/p>\n

typeof<\/span>(Console<\/span>).GetMethod(“WriteLine”<\/span>, new<\/span> Type<\/span>[] { typeof<\/span>(String<\/span>) }),<\/p>\n

<\/span><\/p>\n

Expression<\/span>.Constant(“Print arg:”<\/span>)<\/p>\n

<\/span><\/p>\n

);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

\/\/ Creating an expression for printing a passed argument.<\/p>\n

<\/span><\/p>\n

MethodCallExpression<\/span> secondMethodCall = Expression<\/span>.Call(           <\/span><\/p>\n

<\/span><\/p>\n

typeof<\/span>(Console<\/span>).GetMethod(“WriteLine”<\/span>, new<\/span> Type<\/span>[] { typeof<\/span>(int<\/span>) }),<\/p>\n

<\/span><\/p>\n

param<\/p>\n

<\/span><\/p>\n

);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

\/\/ Creating a block expression that combines two method calls.<\/p>\n

<\/span><\/p>\n

BlockExpression<\/span> block = Expression<\/span>.Block(firstMethodCall, secondMethodCall);<\/p>\n

<\/span><\/p>\n

<\/p>\n

 <\/p>\n

<\/span><\/p>\n

\/\/ Compiling and invoking an expression tree.<\/p>\n

<\/span><\/p>\n

Expression<\/span>.Lamb\nda<Action<\/span><int<\/span>>>(<\/p>\n

<\/span><\/p>\n

block,<\/p>\n

<\/span><\/p>\n

new<\/span> ParameterExpression<\/span>[] { param }<\/p>\n

<\/span><\/p>\n

).Compile()(10); <\/p>\n

<\/span><\/p>\n

I’ll repeat this: Although the expression trees API was extended, the way expression trees work with lambda expression syntax did not change. This means that LINQ queries in Visual Studio 2010 have the same features (and the same limitations) that they had in Visual Studio 2008.<\/font><\/p>\n

But because of the new features, you can find more areas outside of LINQ where you can use expression trees. <\/font><\/p>\n

Generating Dynamic Methods<\/font><\/h2>\n

Now let’s move to the real problems where the new API can help. The most well-known one is creating dynamic methods. The common solution to this problem is to use <\/font>System.Reflection.Emit<\/span> and work directly with MSIL. Needless to say, the resulting code is hard to write and read. <\/font><\/font><\/p>\n

Basically, the expression tree that prints two lines to the console that I have shown previously is already an example of a dynamic method. But let’s try a little bit more complex one to demonstrate more features of the new API.  <\/span>Thanks to John Messerly, a developer on the DLR team, for providing the following example.<\/font><\/p>\n

Assume that you have a simple method that calculates the factorial of a number.<\/font><\/p>\n

static<\/span> int<\/span> CSharpFact(int<\/span> value)<\/p>\n

<\/span><\/p>\n

{<\/p>\n

<\/span><\/p>\n

  <\/span>    <\/span>int<\/span> result = 1;<\/p>\n

<\/span><\/p>\n

while<\/span> (value > 1)<\/p>\n

<\/span><\/p>\n

{<\/p>\n

<\/span><\/p>\n

result *= value–;<\/p>\n

<\/span><\/p>\n

}<\/p>\n

<\/span><\/p>\n

return<\/span> result;<\/p>\n

<\/span><\/p>\n

}<\/p>\n

<\/span><\/p>\n

Now you want a dynamic method that does the same thing. We have several essential elements here: a parameter that is passed to a method, a local variable, and a loop. This is how you can represent these elements by using the expression trees API. <\/font><\/p>\n

<\/p>\n

static<\/span> <\/font>Func<\/span><<\/font>int<\/span>, <\/font>int<\/span>> ETFact()<\/p>\n

<\/font><\/span><\/p>\n

{<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

 <\/font><\/p>\n

<\/span><\/p>\n

\/\/ Creating a parameter expression.<\/span><\/p>\n

<\/span><\/p>\n

ParameterExpression<\/span> value = <\/font>Expression<\/span>.Parameter(<\/font>typeof<\/span>(<\/font>int<\/span>), <\/font>“value”<\/span>);<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

 <\/font><\/p>\n

<\/span><\/p>\n

\/\/ Creating an expression to hold a local variable. <\/p>\n

<\/span><\/p>\n

ParameterExpression<\/span> result = <\/font>Expression<\/span>.Parameter(<\/font>typeof<\/span>(<\/font>int<\/span>), <\/font>“result”<\/span>);                                <\/span>   <\/span><\/p>\n

<\/font><\/span><\/p>\n

            <\/span><\/p>\n

<\/font><\/span><\/p>\n

\/\/ Creating a label to jump to from a loop.<\/span><\/p>\n

<\/span><\/p>\n

LabelTarget<\/span> label = <\/font>Expression<\/span>.Label(<\/font>typeof<\/span>(<\/font>int<\/span>));<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

 <\/font><\/p>\n

<\/span><\/p>\n

\/\/ Creating a method body.<\/span><\/p>\n

<\/span><\/p>\n

BlockExpression<\/span> block = <\/font>Expression<\/span>.Block(<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

 <\/font><\/p>\n

<\/span><\/p>\n

\/\/ Adding a local variable.<\/span><\/p>\n

<\/span><\/p>\n

new<\/span>[] { result },<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

 <\/font><\/p>\n

<\/span><\/p>\n

\/\/ Assigning a constant to a local variable: result = 1<\/span><\/p>\n

<\/span><\/p>\n

Expression<\/span>.Assign(result, <\/font>Expression<\/span>.Constant(1)),<\/p>\n

<\/font><\/span><\/p>\n

<\/p>\n

 <\/font><\/p>\n

<\/span><\/p>\n

\/\/ Adding a loop.<\/span><\/p>\n

<\/span><\/p>\n

Expression<\/span>.Loop(<\/p>\n

<\/font><\/span><\/p>\n

<\/span><\/p>\n

<\/span><\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

Expression trees first appeared in Visual Studio 2008, where they were mainly used by LINQ providers. You can use expression trees to represent code in a tree-like format, where each node is an expression. You can also convert expression trees into compiled code and run it. This transformation enables dynamic modification of executable code as […]<\/p>\n","protected":false},"author":13,"featured_media":255385,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[155],"tags":[3,1383,185,13],"class_list":["post-3023","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-visual-studio","tag-net-framework","tag-c","tag-node-js","tag-visual-studio-2010"],"acf":[],"blog_post_summary":"

Expression trees first appeared in Visual Studio 2008, where they were mainly used by LINQ providers. You can use expression trees to represent code in a tree-like format, where each node is an expression. You can also convert expression trees into compiled code and run it. This transformation enables dynamic modification of executable code as […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts\/3023","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/users\/13"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/comments?post=3023"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/posts\/3023\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/media\/255385"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/media?parent=3023"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/categories?post=3023"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/visualstudio\/wp-json\/wp\/v2\/tags?post=3023"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}