We already know that lambda expressions can be assigned to Func or Action types to handle in collection memory. The .NET compiler converts an expression assigned to Func or Action into executable code at compile time. Linq introduces a new type called Expression that represents a strong lambda expression. It means that lambda expressions can also be assigned to the Expression type <TDelegate>. The .NET compiler converts the lambda expression assigned to the Expression <TDelegate> expression into an Expression expression tree instead of the executable code. This expression tree is used to Linq remotely query the data structure, build a runtime query from it (such as Linq-to-Sql, entity framework or any other Linq query that has an interface. is IQueryable <T>. The illustration below illustrates the difference when lambda expressions are assigned to Func or Action and Expression delegations in Linq.
Define an Expression
We declare a System.Linq.Expressions namespace and use an Expression <TDelegate> class to define an Expression. The requested Expression <TDelegate> is a Func or Action proxy. For example, you can assign a lambda expression to a variable isTenAger with the type Func delegate as follows:
1 2 3 4 5 6 7 8 9 | public class Student { public int StudentID { get; set; } public string StudentName { get; set; } public int Age { get; set; } } Func<Student, bool> isTeenAger = s => s.Age > 12 && s.Age < 20; |
Now we convert the above expression of Func into Expression by wrapping Func with Expresstion as follows:
Expression<Func<Student, bool>> isTeenAgerExpr = s => s.age > 12 && s.age < 20;
In the same way, you can also package an Action <t> with an Expression if it has no return value.
Expression<Action<Student>> printStudentName = s => Console.WriteLine(s.StudentName);
Call an Expression
You can call a delegate encapsulated in an Expression the same way you call a proxy, but you must first translate it using the Compile () method. Compile () returns a Func or Action proxy that you can call it as a proxy.
1 2 3 4 5 6 7 8 | Expression<Func<Student, bool>> isTeenAgerExpr = s => s.age > 12 && s.age < 20; //compile Expression using Compile method to invoke it as Delegate Func<Student, bool> isTeenAger = isTeenAgerExpr.Compile(); //Invoke bool result = isTeenAger(new Student(){ StudentID = 1, StudentName = "Steve", Age = 20}); |
Expression tree
The Expression tree, as the name implies, is nothing but its data structure arranged like a tree. Each node in the expression tree is an expression. For example, an expression tree is used to represent a mathematical expression x, y where x and y will be represented as an expression and arranged in a tree structure. The expression tree is a memory representation of the lambda expression. It contains elements of a query fact, not a result of a query. Tree expression makes the structure of lambda more explicit and clear. We can interact with the data in the expression tree just like any other data. For example, consider the following isTeenAgerExpr function:
Expression<Func<Student, bool>> isTeenAgerExpr = s => s.age > 12 && s.age < 20;
The compiler converts the above expression into the following:
1 2 3 4 5 6 | Expression.Lambda<Func<Student, bool>>( Expression.AndAlso( Expression.GreaterThan(Expression.Property(pe, "Age"), Expression.Constant(12, typeof(int))), Expression.LessThan(Expression.Property(pe, "Age"), Expression.Constant(20, typeof(int)))), new[] { pe }); |
We can also build an expression tree by hand, considering the following simple lambda example:
Func<Student, bool> isAdult = s => s.age >= 18;
This delegation is built by hand as follows:
1 2 3 4 5 | public bool function(Student s) { return s.Age > 18; } |
Let’s look at an example of an Expression tree through the following code:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 | ParameterExpression pe = Expression.Parameter(typeof(Student), "s"); MemberExpression me = Expression.Property(pe, "Age"); ConstantExpression constant = Expression.Constant(18, typeof(int)); BinaryExpression body = Expression.GreaterThanOrEqual(me, constant); var ExpressionTree = Expression.Lambda<Func<Student, bool>>(body, new[] { pe }); Console.WriteLine("Expression Tree: {0}", ExpressionTree); Console.WriteLine("Expression Tree Body: {0}", ExpressionTree.Body); Console.WriteLine("Number of Parameters in Expression Tree: {0}", ExpressionTree.Parameters.Count); Console.WriteLine("Parameters in Expression Tree: {0}", ExpressionTree.Parameters[0]); |
Output:
1 2 3 4 5 | Expression Tree: s => (s.Age >= 18) Expression Tree Body: (s.Age >= 18) Number of Parameters in Expression Tree: 1 Parameters in Expression Tree: s |