6. Expression Trees

Expression trees are necessary for scenarios where you need to manipulate code dynamically, such as building queries dynamically, defining expression-based APIs, analyzing and transforming code at runtime, or supporting declarative programming paradigms. They provide a powerful and flexible mechanism for representing and working with code expressions as data structures.

This allows you to create queries dynamically at runtime. It can be used for filtering or taking user input. Expression trees can be analyzed and transformed at runtime for various tasks such as optimization, validation, or code generation.

Now showing an Indian YouTuber’s video: Click here

Example 1:

using System.Linq.Expressions;
 
Expression<Func<int, bool>> lambda = num => num < 5;
bool result = lambda.Compile()(2); // Here compile() and (2) is value insert
Console.WriteLine(result);
// Ans: True

Example 2:

 
//Suppose we write code for this expression:         Expression (10*2) + (10/5) - (5-1)
using System.Linq.Expressions;
 
BinaryExpression b1 = Expression.MakeBinary(
    ExpressionType.Multiply,
    Expression.Constant(10),
    Expression.Constant(2)
); //10*2
BinaryExpression b2 = Expression.MakeBinary(
    ExpressionType.Divide,
    Expression.Constant(10),
    Expression.Constant(5)
); // 10/5
BinaryExpression b3 = Expression.MakeBinary(
    ExpressionType.Subtract,
    Expression.Constant(5),
    Expression.Constant(1)
); // 5-1
 
BinaryExpression b4 = Expression.MakeBinary(ExpressionType.Add, b1, b2);
BinaryExpression b5 = Expression.MakeBinary(ExpressionType. Subtract, b4, b3);
int result = Expression.Lambda<Func<int>> (b5). Compile()();
Console.WriteLine("(10*2) + (10/5) - (5-1) = {0}", result );
// Ans: 18

LLM (ChatGPT) Example :

//..........Without expression tree.................
using System;
 
class Program
{
    static void Main(string[] args)
    {
        // Without expression
        int x = 5;
        int y = 3;
        int z = 2;
 
        // Perform operations
        int result = (x + y) * z;
 
        Console.WriteLine("Result without expression: " + result); // Output: 16
    }
}
 
//..........With expression tree.................
using System;
using System.Linq.Expressions;
 
class Program
{
    static void Main(string[] args)
    {
        // With expression
        ParameterExpression a = Expression.Parameter(typeof(int), "a");
        ParameterExpression b = Expression.Parameter(typeof(int), "b");
        ParameterExpression c = Expression.Parameter(typeof(int), "c");
 
        BinaryExpression add = Expression.Add(a, b);
        BinaryExpression multiply = Expression.Multiply(add, c);
 
        Expression<Func<int, int, int, int>> lambda = Expression.Lambda<Func<int, int, int, int>>(multiply, a, b, c);
 
        Func<int, int, int, int> operation = lambda.Compile();
 
        int result = operation(5, 3, 2);
        Console.WriteLine("Result with expression: " + result); // Output: 16
    }
}