M B A R K's Blog
What are Expression Trees in C#?

What are Expression Trees in C#?

M B A R K's photo
M B A R K
·

4 min read

Table of contents

Expression trees are a data structure that represents a lambda expression as a tree-like structure. They can be used to represent LINQ queries in a more abstract and easily manipulable form.

How do Expression Trees work in C#?

In C#, expression trees are created using the Expression class and its various derived types. These classes represent different types of expressions, such as constants, variables, and method calls.

For example, consider the following code:

// Create an expression tree that represents the expression "2 + 3"
Expression<Func<int>> addExpression = () => 2 + 3;

// Prints the expression tree to the console
Console.WriteLine(addExpression);
// Outputs: "() => (2 + 3)"

Here, we use the Expression<TDelegate> class to create an expression tree that represents the lambda expression () => 2 + 3. This expression tree can be evaluated to produce the result of the expression, which is 5 in this case.

Use Cases for Expression Trees

Expression trees can be useful in a variety of situations, including:

  • Representing LINQ queries in a more abstract form, allowing them to be easily manipulated and optimized.

  • Creating dynamic queries at runtime based on user input or other criteria.

  • Analyzing and modifying lambda expressions or other expressions at runtime.

For example, consider the following code:

// Create an expression tree that represents the LINQ query "from x in numbers where x > 5 select x"
IEnumerable<int> numbers = new[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

var query =
    from x in numbers
    where x > 5
    select x;

Expression<Func<IEnumerable<int>>> expression = () =>
    from x in numbers
    where x > 5
    select x;

// Prints the expression tree to the console
Console.WriteLine(expression);
// Outputs: "() => IEnumerable<Int32>._Where(x => (x > 5), IEnumerable<Int32>.Select(x => x, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))"

Here, we create an expression tree that represents a LINQ query that filters a list of numbers to only include those greater than 5. This expression tree can be easily modified or analyzed at runtime, allowing us to create dynamic queries or optimize existing ones.

Examples

Here are a couple of real-world examples demonstrating the use of expression trees in C#:

Example 1: Creating a Dynamic LINQ Query

Expression trees can be used to create dynamic LINQ queries at runtime based on user input or other criteria.

For example, consider the following code:

IEnumerable<Employee> employees = GetEmployees();

// Builds an expression tree that represents the LINQ query "from e in employees where e.Age > 25 select e"
Expression<Func<Employee, bool>> agePredicate = e => e.Age > 25;
Expression<Func<IEnumerable<Employee>>> query = () => employees.Where(agePredicate);

// Executes the query and prints the results to the console
foreach (var employee in query.Compile()())
{
    Console.WriteLine(employee);
}

Here, we use an expression tree to represent a LINQ query that filters a list of employees to only include those with an age greater than 25. The expression tree is created using the Expression<TDelegate> class and the Where method.

The Compile method is then used to convert the expression tree into a delegate that can be executed to produce the results of the query.

Example 2: Analyzing and Modifying an Expression

Expression trees can be used to analyze and modify lambda expressions or other expressions at runtime.

For example, consider the following code:

Expression<Func<int, int, int>> addExpression = (x, y) => x + y;

// Analyzes the expression tree and prints the type and value of each node to the console
foreach (var node in addExpression.Body.DescendantNodes())
{
    Console.WriteLine($"Type: {node.NodeType}, Value: {node.ToString()}");
}

// Outputs:
// Type: Parameter, Value: x
// Type: Parameter, Value: y
// Type: Add, Value: +

// Modifies the expression tree to multiply the two parameters instead of adding them
var parameter1 = Expression.Parameter(typeof(int), "x");
var parameter2 = Expression.Parameter(typeof(int), "y");
var multiplyExpression = Expression.Multiply(parameter1, parameter2);
var lambdaExpression = Expression.Lambda<Func<int, int, int>>(multiplyExpression, parameter1, parameter2);

// Executes the modified expression and prints the result to the console
var result = lambdaExpression.Compile()(3, 4);
Console.WriteLine(result); // Outputs "12"

Here, we use an expression tree to analyze and modify a lambda expression that adds two integers. We use the DescendantNodes method to traverse the expression tree and print the type and value of each node.

We then use the Expression class to create a new expression tree that multiplies the two parameters instead of adding them. Finally, we use the Expression.Lambda method to create a new lambda expression from the modified expression tree, and the Compile method to execute the lambda expression and produce the result.

Conclusion

Expression trees are a useful feature in C# that allow you to represent lambda expressions and other expressions as a tree-like data structure. They can be used to represent LINQ queries in a more abstract form, allowing them to be easily manipulated and optimized. They can also be useful for creating dynamic queries at runtime or analyzing and modifying expressions at runtime.

C#