C# Expression Trees - Architecture Insights

What Are Expression Trees

Expression trees turn code into data. Instead of executing a lambda, you can inspect its structure, transform it, or translate it to another language like SQL.

Expression trees represent code as data structures. Instead of executing immediately, the code is captured as a tree that can be analyzed, modified, or compiled.

using System.Linq.Expressions;

// Lambda expression - executes immediately
Func<int, int> doubleFunc = x => x * 2;
int result = doubleFunc(5);  // 10

// Expression tree - captured as data
Expression<Func<int, int>> doubleExpr = x => x * 2;
// Can inspect: Parameter "x", Multiply operation, Constant 2

// Compile to function when ready
Func<int, int> compiled = doubleExpr.Compile();
int result2 = compiled(5);  // 10

Why Expression Trees Matter

Where You Use Expression Trees

If you've written .Where(p => p.Age > 18) with Entity Framework, you've used expression trees. EF Core translates that lambda into SQL because it's an expression tree, not executable code.

Expression trees power:

LINQ to SQL/EF Core: Translates C# queries to SQL
Dynamic queries: Build queries at runtime
Serialization: Send code across boundaries
Code generation: Create optimized delegates
Mocking frameworks: Capture method calls

// EF Core translates this to SQL
var adults = dbContext.People
    .Where(p => p.Age >= 18)  // Expression<Func<Person, bool>>
    .OrderBy(p => p.Name)     // Expression<Func<Person, string>>
    .ToList();

// Generated SQL:
// SELECT * FROM People WHERE Age >= 18 ORDER BY Name

Expression Tree Structure

Anatomy of an Expression

Expression<Func<int, int, int>> addExpr = (a, b) => a + b;

// Tree structure:
// LambdaExpression
// ├── Parameters: [a, b]
// └── Body: BinaryExpression (Add)
//     ├── Left: ParameterExpression (a)
//     └── Right: ParameterExpression (b)

// Inspect the tree
var lambda = (LambdaExpression)addExpr;
Console.WriteLine($"Parameters: {string.Join(", ", lambda.Parameters)}");
Console.WriteLine($"Body: {lambda.Body}");
Console.WriteLine($"Body Type: {lambda.Body.NodeType}");  // Add

var binary = (BinaryExpression)lambda.Body;
Console.WriteLine($"Left: {binary.Left}");   // a
Console.WriteLine($"Right: {binary.Right}"); // b

Common Expression Types

Type	Description	Example
`ConstantExpression`	Literal value	`5`, `"hello"`
`ParameterExpression`	Parameter reference	`x` in `x => x + 1`
`BinaryExpression`	Two operands	`a + b`, `x > 5`
`UnaryExpression`	One operand	`-x`, `!flag`
`MemberExpression`	Property/field access	`person.Name`
`MethodCallExpression`	Method invocation	`str.ToUpper()`
`ConditionalExpression`	Ternary	`x > 0 ? x : -x`
`NewExpression`	Constructor call	`new Point(1, 2)`
`LambdaExpression`	Lambda definition	`x => x * 2`

Building Expressions Manually

Simple Expressions

// Build: x => x * 2
var param = Expression.Parameter(typeof(int), "x");
var constant = Expression.Constant(2);
var multiply = Expression.Multiply(param, constant);
var lambda = Expression.Lambda<Func<int, int>>(multiply, param);

Func<int, int> compiled = lambda.Compile();
Console.WriteLine(compiled(5));  // 10

Property Access

public class Person
{
    public string Name { get; set; } = "";
    public int Age { get; set; }
}

// Build: p => p.Name
var param = Expression.Parameter(typeof(Person), "p");
var property = Expression.Property(param, "Name");
var lambda = Expression.Lambda<Func<Person, string>>(property, param);

var getName = lambda.Compile();
var person = new Person { Name = "Alice" };
Console.WriteLine(getName(person));  // Alice

Method Calls

// Build: s => s.ToUpper()
var param = Expression.Parameter(typeof(string), "s");
var method = typeof(string).GetMethod("ToUpper", Type.EmptyTypes)!;
var call = Expression.Call(param, method);
var lambda = Expression.Lambda<Func<string, string>>(call, param);

var toUpper = lambda.Compile();
Console.WriteLine(toUpper("hello"));  // HELLO

Complex Expressions

// Build: (a, b) => a > 0 ? a + b : a - b
var a = Expression.Parameter(typeof(int), "a");
var b = Expression.Parameter(typeof(int), "b");

var condition = Expression.GreaterThan(a, Expression.Constant(0));
var ifTrue = Expression.Add(a, b);
var ifFalse = Expression.Subtract(a, b);
var conditional = Expression.Condition(condition, ifTrue, ifFalse);

var lambda = Expression.Lambda<Func<int, int, int>>(conditional, a, b);
var func = lambda.Compile();

Console.WriteLine(func(5, 3));   // 8
Console.WriteLine(func(-5, 3)); // -8

Dynamic Query Building

Building Where Clauses

public static class QueryBuilder
{
    public static Expression<Func<T, bool>> BuildPredicate<T>(
        string propertyName,
        object value)
    {
        var param = Expression.Parameter(typeof(T), "x");
        var property = Expression.Property(param, propertyName);
        var constant = Expression.Constant(value);
        var equals = Expression.Equal(property, constant);

        return Expression.Lambda<Func<T, bool>>(equals, param);
    }
}

// Usage
var predicate = QueryBuilder.BuildPredicate<Person>("Name", "Alice");
var results = dbContext.People.Where(predicate).ToList();

Combining Predicates

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> And<T>(
        Expression<Func<T, bool>> left,
        Expression<Func<T, bool>> right)
    {
        var param = Expression.Parameter(typeof(T), "x");

        var leftBody = ReplaceParameter(left.Body, left.Parameters[0], param);
        var rightBody = ReplaceParameter(right.Body, right.Parameters[0], param);

        var combined = Expression.AndAlso(leftBody, rightBody);
        return Expression.Lambda<Func<T, bool>>(combined, param);
    }

    public static Expression<Func<T, bool>> Or<T>(
        Expression<Func<T, bool>> left,
        Expression<Func<T, bool>> right)
    {
        var param = Expression.Parameter(typeof(T), "x");

        var leftBody = ReplaceParameter(left.Body, left.Parameters[0], param);
        var rightBody = ReplaceParameter(right.Body, right.Parameters[0], param);

        var combined = Expression.OrElse(leftBody, rightBody);
        return Expression.Lambda<Func<T, bool>>(combined, param);
    }

    private static Expression ReplaceParameter(
        Expression expression,
        ParameterExpression oldParam,
        ParameterExpression newParam)
    {
        return new ParameterReplacer(oldParam, newParam).Visit(expression);
    }
}

// Usage
Expression<Func<Person, bool>> isAdult = p => p.Age >= 18;
Expression<Func<Person, bool>> hasEmail = p => p.Email != null;

var combined = PredicateBuilder.And(isAdult, hasEmail);
var results = dbContext.People.Where(combined).ToList();

Dynamic OrderBy

public static IQueryable<T> OrderByProperty<T>(
    this IQueryable<T> source,
    string propertyName,
    bool descending = false)
{
    var param = Expression.Parameter(typeof(T), "x");
    var property = Expression.Property(param, propertyName);
    var lambda = Expression.Lambda(property, param);

    string methodName = descending ? "OrderByDescending" : "OrderBy";

    var method = typeof(Queryable).GetMethods()
        .First(m => m.Name == methodName && m.GetParameters().Length == 2)
        .MakeGenericMethod(typeof(T), property.Type);

    return (IQueryable<T>)method.Invoke(null, new object[] { source, lambda })!;
}

// Usage
var sorted = dbContext.People
    .OrderByProperty("Name")
    .ToList();

Expression Visitors

Traversing and Modifying Trees

public class ParameterReplacer : ExpressionVisitor
{
    private readonly ParameterExpression _oldParam;
    private readonly ParameterExpression _newParam;

    public ParameterReplacer(ParameterExpression oldParam, ParameterExpression newParam)
    {
        _oldParam = oldParam;
        _newParam = newParam;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        return node == _oldParam ? _newParam : base.VisitParameter(node);
    }
}

Query Analysis

public class MemberAccessVisitor : ExpressionVisitor
{
    public List<string> AccessedMembers { get; } = new();

    protected override Expression VisitMember(MemberExpression node)
    {
        AccessedMembers.Add(node.Member.Name);
        return base.VisitMember(node);
    }
}

// Usage - find all properties accessed in a query
Expression<Func<Person, bool>> expr = p => p.Age > 18 && p.Name.StartsWith("A");
var visitor = new MemberAccessVisitor();
visitor.Visit(expr);
// AccessedMembers: ["Age", "Name"]

Expression Transformation

// Convert property access to dictionary lookup
public class PropertyToDictVisitor : ExpressionVisitor
{
    private readonly ParameterExpression _dictParam;

    public PropertyToDictVisitor(ParameterExpression dictParam)
    {
        _dictParam = dictParam;
    }

    protected override Expression VisitMember(MemberExpression node)
    {
        if (node.Expression is ParameterExpression)
        {
            // Convert p.Name to dict["Name"]
            var key = Expression.Constant(node.Member.Name);
            var indexer = typeof(Dictionary<string, object>)
                .GetProperty("Item")!;
            return Expression.MakeIndex(_dictParam, indexer, new[] { key });
        }
        return base.VisitMember(node);
    }
}

Compiled Expressions for Performance

Caching Compiled Delegates

Compile() Is Expensive

Compiling an expression tree to a delegate is slow, much slower than reflection. Always cache the compiled result when the same expression will be used repeatedly.

public static class PropertyAccessor<T>
{
    private static readonly ConcurrentDictionary<string, Func<T, object?>> Getters = new();

    public static Func<T, object?> GetGetter(string propertyName)
    {
        return Getters.GetOrAdd(propertyName, CreateGetter);
    }

    private static Func<T, object?> CreateGetter(string propertyName)
    {
        var param = Expression.Parameter(typeof(T), "x");
        var property = Expression.Property(param, propertyName);
        var converted = Expression.Convert(property, typeof(object));
        var lambda = Expression.Lambda<Func<T, object?>>(converted, param);
        return lambda.Compile();
    }
}

// Usage - much faster than reflection after first call
var getter = PropertyAccessor<Person>.GetGetter("Name");
var name = getter(person);

Fast Property Setters

public static class PropertySetter<T>
{
    private static readonly ConcurrentDictionary<string, Action<T, object?>> Setters = new();

    public static Action<T, object?> GetSetter(string propertyName)
    {
        return Setters.GetOrAdd(propertyName, CreateSetter);
    }

    private static Action<T, object?> CreateSetter(string propertyName)
    {
        var param = Expression.Parameter(typeof(T), "x");
        var valueParam = Expression.Parameter(typeof(object), "value");
        var property = Expression.Property(param, propertyName);
        var converted = Expression.Convert(valueParam, property.Type);
        var assign = Expression.Assign(property, converted);
        var lambda = Expression.Lambda<Action<T, object?>>(assign, param, valueParam);
        return lambda.Compile();
    }
}

Practical Examples

Generic Mapper

public static class Mapper<TSource, TDest> where TDest : new()
{
    private static readonly Func<TSource, TDest> MapFunc = CreateMapper();

    private static Func<TSource, TDest> CreateMapper()
    {
        var sourceParam = Expression.Parameter(typeof(TSource), "src");
        var bindings = new List<MemberBinding>();

        foreach (var destProp in typeof(TDest).GetProperties())
        {
            var sourceProp = typeof(TSource).GetProperty(destProp.Name);
            if (sourceProp != null && sourceProp.PropertyType == destProp.PropertyType)
            {
                var sourceAccess = Expression.Property(sourceParam, sourceProp);
                bindings.Add(Expression.Bind(destProp, sourceAccess));
            }
        }

        var newExpr = Expression.New(typeof(TDest));
        var memberInit = Expression.MemberInit(newExpr, bindings);
        var lambda = Expression.Lambda<Func<TSource, TDest>>(memberInit, sourceParam);

        return lambda.Compile();
    }

    public static TDest Map(TSource source) => MapFunc(source);
}

// Usage
var dto = Mapper<Person, PersonDto>.Map(person);

Specification Pattern

public abstract class Specification<T>
{
    public abstract Expression<Func<T, bool>> ToExpression();

    public bool IsSatisfiedBy(T entity)
    {
        return ToExpression().Compile()(entity);
    }

    public Specification<T> And(Specification<T> other)
    {
        return new AndSpecification<T>(this, other);
    }

    public Specification<T> Or(Specification<T> other)
    {
        return new OrSpecification<T>(this, other);
    }
}

public class AndSpecification<T> : Specification<T>
{
    private readonly Specification<T> _left;
    private readonly Specification<T> _right;

    public AndSpecification(Specification<T> left, Specification<T> right)
    {
        _left = left;
        _right = right;
    }

    public override Expression<Func<T, bool>> ToExpression()
    {
        return PredicateBuilder.And(_left.ToExpression(), _right.ToExpression());
    }
}

// Concrete specifications
public class AdultSpecification : Specification<Person>
{
    public override Expression<Func<T, bool>> ToExpression()
        => p => p.Age >= 18;
}

// Usage
var spec = new AdultSpecification()
    .And(new HasEmailSpecification());
var results = dbContext.People.Where(spec.ToExpression()).ToList();

Limitations and Considerations

What Can’t Be in Expression Trees

// These compile as Func, not Expression:

// Dynamic
Expression<Func<dynamic, int>> bad1 = d => d.Value;  // Error

// Out/ref parameters
Expression<Action<out int>> bad2 = (out int x) => x = 1;  // Error

// Named/optional parameters
Expression<Func<int>> bad3 = () => Method(name: "test");  // Error in some cases

// Async lambdas
Expression<Func<Task<int>>> bad4 = async () => await Task.FromResult(1);  // Error

// Statements (only expressions allowed)
Expression<Action> bad5 = () => { var x = 1; };  // Error

Performance Notes

// Compile() is expensive - cache results
// BAD: Compiles every call
public bool Check(Expression<Func<Person, bool>> expr, Person p)
{
    return expr.Compile()(p);  // Slow!
}

// GOOD: Cache compiled delegate
private readonly ConcurrentDictionary<Expression, Delegate> _cache = new();

public bool CheckCached(Expression<Func<Person, bool>> expr, Person p)
{
    var compiled = (Func<Person, bool>)_cache.GetOrAdd(
        expr,
        e => ((Expression<Func<Person, bool>>)e).Compile());
    return compiled(p);
}

Version History

Feature	Version	Significance
Expression Trees	C# 3.0	LINQ foundation
Expression Visitor	.NET 4.0	Tree traversal/modification
Improved debugging	.NET 4.0	DebugView property
Block expressions	.NET 4.0	Statement-like expressions
Index expressions	.NET 4.0	Indexer access

Key Takeaways

Code as data: Expression trees let you inspect and manipulate code structure at runtime.

LINQ translation: They’re how EF Core and other providers translate C# to SQL.

Cache compiled delegates: Compile() is expensive. Cache results for repeated use.

Use ExpressionVisitor: The standard way to traverse and transform expression trees.

Prefer lambdas when possible: Manual tree building is verbose. Use Expression<Func<>> from lambdas when the expression is known at compile time.

Limitations exist: Async, out parameters, statements, and some language features aren’t supported.