🔧 Dynamic LINQ = Flexible Queries
Static queries aren’t always enough. Dynamic LINQ with expression trees builds queries at runtime.
📝 Dynamic Query Builder
public class DynamicQueryBuilder{ private IQueryable _query; public DynamicQueryBuilder(IQueryable query) { _query = query; } public DynamicQueryBuilder Filter(string propertyName, object value) { var parameter = Expression.Parameter(typeof(T)); var property = Expression.Property(parameter, propertyName); var constant = Expression.Constant(value); var equal = Expression.Equal(property, constant); var lambda = Expression.Lambda >(equal, parameter); _query = _query.Where(lambda); return this; } public DynamicQueryBuilder OrderBy(string propertyName, bool ascending = true) { var parameter = Expression.Parameter(typeof(T)); var property = Expression.Property(parameter, propertyName); var lambda = Expression.Lambda(property, parameter); var methodName = ascending ? "OrderBy" : "OrderByDescending"; var method = typeof(Queryable).GetMethods() .First(m => m.Name == methodName && m.GetParameters().Length == 2) .MakeGenericMethod(typeof(T), property.Type); _query = (IQueryable )method.Invoke(null, new object[] { _query, lambda }); return this; } public DynamicQueryBuilder Skip(int count) { _query = _query.Skip(count); return this; } public DynamicQueryBuilder Take(int count) { _query = _query.Take(count); return this; } public IQueryable Build() => _query; }
🎯 Advanced Expression Trees
// Build Expression for Complex Conditions public static Expression> BuildPredicate ( string propertyName, string operation, object value) { var parameter = Expression.Parameter(typeof(T)); var property = Expression.Property(parameter, propertyName); var constant = Expression.Constant(value); Expression condition = operation switch { "Equals" => Expression.Equal(property, constant), "GreaterThan" => Expression.GreaterThan(property, constant), "LessThan" => Expression.LessThan(property, constant), "Contains" => Expression.Call(property, typeof(string).GetMethod("Contains", new[] { typeof(string) }), constant), _ => throw new NotSupportedException() }; return Expression.Lambda >(condition, parameter); } // Predicate Builder public static class PredicateBuilder { public static Expression > True () { return f => true; } public static Expression > False () { return f => false; } public static Expression > Or ( this Expression > expr1, Expression > expr2) { var invokedExpr = Expression.Invoke(expr2, expr1.Parameters); return Expression.Lambda >( Expression.OrElse(expr1.Body, invokedExpr), expr1.Parameters); } public static Expression > And ( this Expression > expr1, Expression > expr2) { var invokedExpr = Expression.Invoke(expr2, expr1.Parameters); return Expression.Lambda >( Expression.AndAlso(expr1.Body, invokedExpr), expr1.Parameters); } } // Usage var predicate = PredicateBuilder.True (); if (!string.IsNullOrEmpty(nameFilter)) { predicate = predicate.And(u => u.Name.Contains(nameFilter)); } if (minAge.HasValue) { predicate = predicate.And(u => u.Age >= minAge.Value); } var results = context.Users.Where(predicate).ToList();
💡 Dynamic LINQ Tips
- Use expression trees for dynamic queries
- Build predicates conditionally
- Chain operations for complex queries
- Handle null values carefully
- Test with different data types
Dynamic LINQ with expression trees enables flexible, runtime-constructed queries. It’s powerful and performant.
![C#: Better Exception Messages with [CallerArgumentExpression]](http://blog.ercanopak.com/wp-content/uploads/2026/02/csharp-56-150x150.png)
