It is an academic exercise how to use Expression trees, you would probably use filters just specifying lambda function with LINQ, but the code shows how you can build an Expression incrementally and compile it to a function. If there is a use-case where LINQ does not fit, perhaps some late-binding scenario or where LINQ does not offer an operator, you can use the approach shows in this article, but the article shows simple usage of Expression trees for introducing Expression trees to C# developers wanting to
test them out in more detail.
The sample code below shows the sample code testing out how to build the Expression incrementally using extension method loading some sample data. An important gotcha is to keep sending in same the objectParameter which is the parameter expression used in the lambda function that is built up, this must be the same parameter. Consider some lambda function of an object 'Person' where the parameter 'x' like:
x => x.Age > 3 && x.Age < 9
The point is that the ParameterExpression x must be the same object, or else we get an error.
FilterHelper.cs
public static class FilterHelper {
public enum ComparisonOperator {
Equal,
LessThan,
LessThanOrEqual,
GreaterThan,
GreaterThanOrEqual,
NotEqual
}
public static Func<TClass, bool> CompileFilter<TClass>(this Expression expression, ParameterExpression objectParameter){
var expr = Expression.Lambda<Func<TClass, bool>>(expression, false, new List<ParameterExpression>{ objectParameter });
return expr.Compile();
}
public static Expression BuildFilter<TClass, TProp>(this Expression previousExpression, Expression<Func<TClass, TProp>> prop, object value,
ComparisonOperator op, ParameterExpression objectParameter){
var propertyInfo = GetPropertyInfo(prop);
var propertyToCall = Expression.Property(objectParameter, propertyInfo);
var valueToTest = Expression.Constant(value);
Expression operatorExpression = null;
switch (op)
{
case ComparisonOperator.Equal:
operatorExpression = Expression.Equal(propertyToCall, valueToTest);
break;
case ComparisonOperator.NotEqual:
operatorExpression = Expression.NotEqual(propertyToCall, valueToTest);
break;
case ComparisonOperator.LessThan:
operatorExpression = Expression.LessThan(propertyToCall, valueToTest);
break;
case ComparisonOperator.LessThanOrEqual:
operatorExpression = Expression.LessThanOrEqual(propertyToCall, valueToTest);
break;
case ComparisonOperator.GreaterThan:
operatorExpression = Expression.GreaterThan(propertyToCall, valueToTest);
break;
case ComparisonOperator.GreaterThanOrEqual:
operatorExpression = Expression.GreaterThanOrEqual(propertyToCall, valueToTest);
break;
}
if (previousExpression == null){
return operatorExpression;
}
else {
return Expression.AndAlso(previousExpression, operatorExpression);
}
}
/// <summary>
/// Gets the corresponding <see cref="PropertyInfo" /> from an <see cref="Expression" />.
/// </summary>
/// <param name="property">The expression that selects the property to get info on.</param>
/// <returns>The property info collected from the expression.</returns>
/// <exception cref="ArgumentNullException">When <paramref name="property" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">The expression doesn't indicate a valid property."</exception>
private static PropertyInfo GetPropertyInfo<T, P>(Expression<Func<T, P>> property)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
if (property.Body is UnaryExpression unaryExp)
{
if (unaryExp.Operand is MemberExpression memberExp)
{
return (PropertyInfo)memberExp.Member;
}
}
else if (property.Body is MemberExpression memberExp)
{
return (PropertyInfo)memberExp.Member;
}
throw new ArgumentException($"The expression doesn't indicate a valid property. [ {property} ]");
}
}
The sample data uses a POCO Employee as entity class: Employee.cs
public class Employee
{
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Department { get; set; }
public string Position { get; set; }
public decimal Salary { get; set; }
public DateTime HireDate { get; set; }
public DateOnly HireDateOnly
{
get { return DateOnly.FromDateTime(HireDate); }
}
}
The sample program loads up the Json data, then it builds the expression with method BuildFilter shown above and then finally calls CompileFilter to build the expression into a Func<TClass, bool> where TClass is the employee type.
Program.cs
void Main()
{
string json = File.ReadAllText(Path.Combine(@"C:\Users\SomeUser\Documents\LINQPad Queries\SampleData\Employees.json"));
var employees = JsonSerializer.Deserialize<List<Employee>>(json,
new JsonSerializerOptions { PropertyNameCaseInsensitive = true });
//employees.Dump();
var objectParameter = Expression.Parameter(typeof(Employee));
Expression currentFilter = null;
currentFilter = FilterHelper.BuildFilter<Employee, object>(currentFilter, e => e.Department,
"Engineering", FilterHelper.ComparisonOperator.Equal, objectParameter)
.BuildFilter<Employee, object>(e => e.Salary, 79000m,
FilterHelper.ComparisonOperator.GreaterThan, objectParameter);
Func<Employee, bool> employeeFilter = currentFilter.CompileFilter<Employee>(objectParameter);
var matchingEmployees = employees.Where(employeeFilter).ToList();
matchingEmployees.Dump();
}
Sample data json looks like this - an array of employees
Employees.json
[
{
"id": 1,
"firstName": "Alice",
"lastName": "Johnson",
"department": "HR",
"position": "Manager",
"salary": 60000,
"hireDate": "2022-03-15"
},
{
"id": 2,
"firstName": "Bob",
"lastName": "Smith",
"department": "Engineering",
"position": "Software Engineer",
"salary": 80000,
"hireDate": "2021-09-10"
},
{
"id": 3,
"firstName": "Charlie",
"lastName": "Brown",
"department": "Finance",
"position": "Financial Analyst",
"salary": 70000,
"hireDate": "2020-05-20"
},
{
"id": 4,
"firstName": "David",
"lastName": "Lee",
"department": "Marketing",
"position": "Marketing Specialist",
"salary": 65000,
"hireDate": "2019-11-05"
},
{
"id": 5,
"firstName": "Eva",
"lastName": "Garcia",
"department": "Sales",
"position": "Sales Representative",
"salary": 75000,
"hireDate": "2018-07-12"
},
{
"id": 6,
"firstName": "Frank",
"lastName": "Wang",
"department": "Engineering",
"position": "Senior Developer",
"salary": 95000,
"hireDate": "2017-02-28"
},
{
"id": 7,
"firstName": "Grace",
"lastName": "Miller",
"department": "HR",
"position": "Recruiter",
"salary": 55000,
"hireDate": "2016-08-18"
},
{
"id": 8,
"firstName": "Henry",
"lastName": "Chen",
"department": "Finance",
"position": "Financial Manager",
"salary": 90000,
"hireDate": "2015-04-03"
},
{
"id": 9,
"firstName": "Ivy",
"lastName": "Nguyen",
"department": "Marketing",
"position": "Content Writer",
"salary": 60000,
"hireDate": "2014-10-22"
},
{
"id": 10,
"firstName": "Jack",
"lastName": "Kim",
"department": "Sales",
"position": "Account Executive",
"salary": 80000,
"hireDate": "2013-06-14"
},
{
"id": 11,
"firstName": "Karen",
"lastName": "Taylor",
"department": "Engineering",
"position": "QA Engineer",
"salary": 75000,
"hireDate": "2012-01-09"
},
{
"id": 12,
"firstName": "Leo",
"lastName": "Rodriguez",
"department": "HR",
"position": "HR Specialist",
"salary": 55000,
"hireDate": "2011-07-27"
},
{
"id": 13,
"firstName": "Mia",
"lastName": "Liu",
"department": "Finance",
"position": "Financial Advisor",
"salary": 70000,
"hireDate": "2010-03-16"
},
{
"id": 14,
"firstName": "Nina",
"lastName": "Martinez",
"department": "Marketing",
"position": "Social Media Manager",
"salary": 65000,
"hireDate": "2009-09-05"
},
{
"id": 15,
"firstName": "Oscar",
"lastName": "Hernandez",
"department": "Sales",
"position": "Sales Manager",
"salary": 100000,
"hireDate": "2008-04-21"
}
]
The filter is more limited than just sticking to LINQ, but the code in this example shows how you can build a filter incrementally.
Traditionally, you would use Linq and an IEnumerable of TClass and you can keep on filter it too.
Here are some closing arguments for why you could make use of Expression trees and have to use them too and not be able to use Linq:
Purpose: Expression trees represent code as data structures. They allow you to build executable code dynamically in C#. Use Cases: - Dynamic Code Generation: When you need to create or modify code at runtime (e.g., building custom queries or transformations). - Remote Execution: Expression trees are useful for scenarios where you want to send calculations across the wire (e.g., database queries, web services). - Custom Query Providers: If you’re building your own query provider (like LINQ to SQL or Entity Framework), expression trees help translate queries into other formats (e.g., SQL).
Note that the currentFilter is initially sent in as null as the initial expression and later AND-ed with the previous value
ReplyDelete