first post - yay! :)
A while ago i was debugging a method that generates a Linq query and returns IQueryable .
I had a problem with it's results and i wanted to check-out the IQueryable object that was generated,
so I set an "Add watch" to the return value and was trying to find my generated linq. that wasn't so simple as i though.
In fact, the IQueryable dose not keeps the Linq statement as is, but saves it in an Expression object(also known as Expression tree).
You can see this in the IQueryable interface definition:
public interface IQueryable : IEnumerable
{
Type ElementType { get; }
Expression Expression { get; }
IQueryProvider Provider { get; }
}
What is an expression tree?
“Expression trees represent language-level code in the form of data”
msdn.microsoft.com
-This means that an expression tree gives us some kind of meta-data for our code.
To explain the concept of the Expression trees we need to start from the very beginning....
Lets say we have this method:
public void PrintNumbers(Func<int,bool> filter)
{
for(int i=0;i<=10;++I)
{
if (filter(i))
Console.writeline(i);
}
}
The method takes a filter function and prints all the numbers from 1 to 10 that match the filter.
Until now we had 3 ways to do this:
1) Declare a method that match the parameter,something like this:
private bool MyFilter(int x)
{
return (x%2) == 1;
}
And call our method like this:
PrintNumbers(MyFilter);
2) we could call it with anonymous delegates:
PrintNumbers(delegate(int x)
{
return (x%2) == 1;
}
3) Lambdas expression:
PrintNumbers(x => (x % 2) == 1);
And Now we have a new way - Expressions:
Expression<Func<int, bool>> myExpression = x => (x % 2) == 1;
This expression is of type Func<int, bool> and assigned with lambdas expression.
when doing this assignment the expression object's properties are filled as follows:
1)Body - the expression: (x % 2) == 1
2)Parameters - x
3)NodeType - LambdaExpression
4)Type - Func<int, bool>
Becasue expressions are nested types(that's why they are called trees) we would like to view them in a tree format.
you can download the visualizer from
Visual studio 2008 sampels.
For exmple, if we run the visualizer on our current expression, we will get the following result:
Our Expression is an : ExpressionEqual which equals between (marked in pink underline)
ExpressionModulo(left) and
ExpressionConstant(righ).
The Expression modulo represent a modulo operation between ExpressionParamter "x" and a ConstantParameter "2' ,and the ExpressionConstant represent the const "1".
Expression trees and Linq
As I said in the begining of the post,the linq statement is saved in the Expression property of the IQueryable object. when the query is "executed" the expression is translated into sql statment.
for example, if we run the expression tree visualizer on the query:
var query = from c in db.Customers
where c.City == “London"
select new { c.City, c.CompanyName };
We will get the:
and now that we can read this, it is simpler to debug Linq queries.
There are some more usages to the Expression trees such as generating code and reflection, but thats for a diffrent post....
Barko(aka Tal)
Posts
