Dynamic lambda parameters based on dictionary elements

Question

My plan is to create a query, but the parameters based on a Dictionary. The Dictionary contains string key and bool value. Can be 2 or 3 or more items in the dictionary.

Dictionary<string, bool> items = new Dictionary<string, bool>();
items.Add("CostFree", true);
items.Add("Visible", true);
items.Add("Closed", true);

This is the dictionary I am sending and based on this I want to create dynamically a query like

.Where(e => e.CostFree == true || Visible == true || Closed == true)

but the dictionary can contain 2, 3 or four items.

How can I solve this ? Thanks in advance

Answer 1

The easy (but inelegant) way of doing this is to chain a series of Union statements. You can use a lookup dictionary with a key matching your strings and a value containing an appropriate predicate.

Here is an example using an extension method:

static public IQueryable<Foo> WithFlags(this IQueryable<Foo> source, string[] flags)
{
    var map = new Dictionary<string, Expression<Func<Foo, bool>>>()
    {
        { "Closed", x => x.Closed },
        { "CostFree", x => x.CostFree },
        { "Visible", x => x.Visible }
    };

    //Start with a query that returns nothing
    var query = source.Where(x => false);

    //For each flag supplied by the caller, add an additional set
    foreach (var flag in flags)
    {
        query = query.Union(query.Where(map[flag]));
    }

    return query;
}

To use:

var results = DbContext.Foo.WithFlags( new string[] { "Closed", "Visible" }).ToList();

The more elegant way to do it is to build a predicate expression containing Or logic. This would be a little involved. I recommend finding a third party toolkit. See this answer.

Answer 2

LINQ expressions can be built easily via static methods exposed on System.Linq.Expressions.Expression class. Here is a sample with your needs assuming the entity you are building the expression against named SomeClass

[TestMethod]
public void MyTestMethod()
{
    var testData = new List<SomeClass>()
    {
        new SomeClass() {Id=1, CostFree = false, Closed='N', Visible=false},
        new SomeClass() {Id=2, CostFree = true, Closed='N', Visible=false},     // expect only this one  matching
    };

    var items = new Dictionary<string, object>();
    items.Add("CostFree", true);
    items.Add("Visible", true);
    items.Add("Closed", 'Y');

    // this one will be the "e" in "e => e.CostFree == true || Visible == true || Closed == 'Y'"
    var paramExpression = Expression.Parameter(typeof(SomeClass));

    // lets construct the body ("e.CostFree == true || Visible == true || Closed == 'Y'") part step-by-step
    // the parts consists of binary "equals" expressions combined via logical "or" expression
    var bodyExpression = (Expression)null;
    foreach(var kvp in items)
    {
        // get the named property ("CostFree", ...) reference of paramExpression. this is the left hand side of "equals"
        var propertyExpression = Expression.PropertyOrField(paramExpression, kvp.Key);
        // get the constant with appropriate value to place on right hand side of "equals"
        var constantExpression = Expression.Constant(kvp.Value, kvp.Value.GetType());
        // combine them into "equals"
        var binaryEqualsExpression = Expression.Equal(propertyExpression, constantExpression);

        if (bodyExpression == null)
        {
            bodyExpression = binaryEqualsExpression;
        }
        else
        {
            // combine each "equals" parts with logical "or"
            bodyExpression = Expression.OrElse(bodyExpression, binaryEqualsExpression);
        }
    }

    // now construct the whole lambda...
    var lambdaExpression = Expression.Lambda<Func<SomeClass, bool>>(bodyExpression, paramExpression);
    // ...and make it useable in .Where()
    var compiledExpression = lambdaExpression.Compile();

    // lets execute in on our test data
    var r = testData.Where(compiledExpression);

    // only #2 should match
    Assert.AreEqual(2, r.Single().Id);
}

Update: I changed the solution:

1. items values are of type object
2. constantExpression honors the value's type.

This way the dictionary can contain other name-value pairs and the solution still works. The rule of dictionary contents: keys must match SomeClass property names and values must match the given property's type.