Lambda Wrangling For Fun : Part 2 – Filtering Single Columns

 

In the previous post, we developed a way of dynamically generating a lambda based on a property name to pass through to the OrderBy or OrderByDescending LINQ function in order to sort a collection of items by the specified property.

We can do the same thing to dynamically generate a filter predicate to use in several LINQ extension methods that accept predicates.

Anatomy of a Filter

A filter predicate has three parts:

• A constant value or expression to compare against
• A comparison operator
• A target property on the object which should be compared with the constant value

We already know how to express property selectors – we used them here.

Let’s approach the rest of the problem in stages:

Ceteris paribus…

Let’s fix the comparison operator to be the equality operator  - “ == “.

Then we can write a naive lambda generator thus:

public static Func<TSource, bool> GetPropertyFilterLambda<TSource>(this TSource _this, string propertyName, object filterValue)
{
    // Given that propertyName = "Foo" and filterValue = blah
    //  we want the lambda expression * _ => _.Foo == blah *

    // This gives us the * _ => * part
    var parameterExpression = Expression.Parameter(typeof (TSource), "_");

    // This gives us the * .Foo * part - see the interfaces and inheritance blog post
    var propertyInfo = typeof(TSource).GetProperty(propertyName, true);

    // This gives us the * _.Foo * part
    var accessorExpression = Expression.Property(parameterExpression, propertyInfo);

    // This gives us the * blah * part
    var valueExpression = Expression.Convert(Expression.Constant(filterValue), propertyInfo.PropertyType);

    // This gives us the * _.Foo == blah * part
    var equalityComparisionExpression = Expression.Equal(accessorExpression, valueExpression);

    // This gives us the * _ => _.Foo == blah * part
    return Expression.Lambda<Func<TSource, bool>>(equalityComparisionExpression, parameterExpression).Compile();
}

We need to incorporate the type conversion into the constant expression because it’s very likely that the constant value is a string (passed in from an ASP.NET MVC Controller, for example) while the property is an integer property.

You’re not my Type!

By happy coincidence, the C# language does the right thing for the equality operator on strings and compares values even though strings are a reference type. But other reference types will pose a problem since the equality operator only compares references.

So let’s strongly type the constant value:

public static Func<TSource, bool> GetPropertyFilterLambda<TSource, TValue>(this TSource _this, string propertyName, TValue filterValue)
{
    // Given that propertyName = "Foo" and filterValue = blah
    //  we want the lambda expression * _ => _.Foo == blah *

    // This gives us the * _ => * part
    var parameterExpression = Expression.Parameter(typeof (TSource), "_");

    // This gives us the * .Foo * part - see the interfaces and inheritance blog post
    var propertyInfo = typeof (TSource).GetProperty(propertyName, true);

    // ensure the property is of the same type as the value
    if (!propertyInfo.PropertyType.IsAssignableFrom(typeof (TValue)))
    {
        throw new MemberAccessException(String.Format("Property {0}.{1} is not of type {2}",
                                                      typeof (TSource).Name,
                                                      propertyInfo.Name,
                                                      typeof (TValue).Name));
    }

    // This gives us the * _.Foo * part
    var accessorExpression = Expression.Property(parameterExpression, propertyInfo);

    // This gives us the * blah * part
    var valueExpression = Expression.Convert(Expression.Constant(filterValue), propertyInfo.PropertyType);

    // This gives us the * _.Foo == blah * part
    var equalityComparisionExpression = Expression.Equal(accessorExpression, valueExpression);

    // This gives us the * _ => _.Foo == blah * part
    return Expression.Lambda<Func<TSource, bool>>(equalityComparisionExpression, parameterExpression).Compile();
}

So far so good.

sed ceteris non paribus…

But there’s no way to specify a different operation than simple equality comparison with this. There is not even a way to do a deep equality comparison on non-string reference objects.

What we really need is a way to provide our own comparison functions, which will give us the flexibility to compare two objects and decide if they satisfy the predicate.

Here is such a function:

public static Expression<Func<TSource, bool>> GetPropertyFilterLambda<TSource, TValue>(this TSource _this,
                                                                                       string propertyName,
                                                                                       TValue filterValue,
                                                                                       Func<TValue, TValue, bool> compareFunc)
{
    // Given that propertyName = "Foo" and filterValue = blah
    //  we want the lambda expression * _ => compareFunc(_.Foo, blah) *

    // This gives us the * _ => * part
    var parameterExpression = Expression.Parameter(typeof (TSource), "_");

    // This gives us the * .Foo * part - see the interfaces and inheritance blog post
    var propertyInfo = typeof (TSource).GetProperty(propertyName, true);

    // ensure the property is of the same type as the value
    if (!propertyInfo.PropertyType.IsAssignableFrom(typeof (TValue)))
    {
        throw new MemberAccessException(String.Format("Property {0}.{1} is not of type {2}",
                                                      typeof (TSource).Name,
                                                      propertyInfo.Name,
                                                      typeof (TValue).Name));
    }

    // This gives us the * _.Foo * part
    var accessorExpression = Expression.Property(parameterExpression, propertyInfo);

    // This gives us the * blah * part
    var valueExpression = Expression.Convert(Expression.Constant(filterValue), propertyInfo.PropertyType);

    // This gives us the * compareFunc(_.Foo, blah) * part
    var compareExpression = Expression.Call(null, compareFunc.Method, accessorExpression, valueExpression);

    // This gives us the * _ => compareFunc(_.Foo, blah) * part
    return Expression.Lambda<Func<TSource, bool>>(compareExpression, parameterExpression);
}

which can be invoked thus:

<…>.Where(default(IIngredient)
    .GetPropertyFilterLambda(
        "Name", 
        "Cheese", 
        (_l, _r) => _l.Contains(_r)));

so we aren’t constrained to an equality operation any more!

We raise the stakes one more level and curry the constant into the comparison lambda thus:

public static Expression<Func<TSource, bool>> GetPropertyFilterLambda<TSource, TValue>(this TSource _this,
                                                                                       string propertyName,
                                                                                       Func<TValue, bool> predicate)
{
    // Given that propertyName = "Foo"
    //  we want the lambda expression * _ => predicate(_.Foo) *

    // This gives us the * _ => * part
    var parameterExpression = Expression.Parameter(typeof(TSource), "_");

    // This gives us the * .Foo * part - see the interfaces and inheritance blog post
    var propertyInfo = typeof(TSource).GetProperty(propertyName, true);

    // ensure the property is of the same type as the value
    if (!propertyInfo.PropertyType.IsAssignableFrom(typeof(TValue)))
    {
        throw new MemberAccessException(String.Format("Property {0}.{1} is not of type {2}",
                                                      typeof(TSource).Name,
                                                      propertyInfo.Name,
                                                      typeof(TValue).Name));
    }

    // This gives us the * _.Foo * part
    var accessorExpression = Expression.Property(parameterExpression, propertyInfo);

    // This gives us the * predicate(_.Foo) * part
    var compareExpression = Expression.Call(null, predicate.Method, accessorExpression);

    // This gives us the * _ => predicate(_.Foo) * part
    return Expression.Lambda<Func<TSource, bool>>(compareExpression, parameterExpression);
}

which can be invoked like this:

<…>.Where(default(IIngredient)
    .GetPropertyFilterLambda(
        "Name", 
        (string _l) => _l.Contains("Cheese"));

Neat-o!