动态创建LINQ表达式或解析表达式的字符串值[英] Creating a linq expression dynamically or parsing the string value of the expression

问题描述

Got an problem where I need to crate an linq expression dynamically. But I cant seem to wrap my head around it.

So first off I got an check list box. Where I input values from a file that is selected, hence I will not know how many parameters there will be there before I run the code. Then the plan is to construct a linq sentence based on the name of the elements in the checkbox. Let me illustrate: I want to create an linq statement that looks like this:

var result = from n in data where n.Item1 == "someValueFromCheckBox"  select n;

Where the data, is an tupled list like :

List<Tuple<string, string>> 

And that is fine as long as the user only selects one item from the checkbox. But when the user for example selects two items, I need to create a linqu expression that looks like this:

var result = from n in data where n.Item1 == "someValueFromCheckBox" || n.Item1 == "someValueFromCheckBox1" select n;

So my first thought was to build the linq statement as a string. In the following manner:

        var selectedItems = checkedListBoxSelectedTerms.CheckedItems;
        var linqStatement = "";
        for (int i = 0; i < selectedItems.Count; i++ )
        {          
                linqStatement += selectedItems[i].ToString() + "|| n.item1 ==" ;                                  
        }
        //this is simply to remove the || "n.Item1 ==", at the end because it 
        is not needed after the last selecteditem. 
        linqStatement = linqStatement.Remove(linqStatement.Length - 13, 13);

But that did not work as planned, because when I put it in like this:

var result = from n in data where n.Item1 == linqStatement  select n;

The whole thing becomes a string. And I cant have the "n.Item1 ==" to be a string. In theory that solution would work great for my use, because I would not have to worry about how manay elements that are in the checkbox and how many elements the user selects, but I cannot pass linqStatement whole as a string. So any help would be appriciated, because I cant seem to find an good example to do something like this.

Thanks in advance!

推荐答案

For such a simple example, you should simply have a list or set of strings, and then do Contains. E.g.

var selectedItems = checkedListBoxSelectedTerms.CheckedItems
                        .Select(x => x.ToString()).ToList();
var result = from n in data where selectedItems.Contains(n.Item1) select n;

If you need more flexible dynamic building capabilities, try something like Dynamic LINQ or PredicateBuilder.

其他推荐答案

The PredicateBuilder is what I use for dynamic queries.

Please see here for more info:

http://www.albahari.com/nutshell/predicatebuilder.aspx

其他推荐答案

So what you're looking for is an implementation of a predicate builder that can take any number of expressions and OR them together. Here is an implementation that will work with any query provider:

public static class PredicateBuilder
{
    public static Expression<Func<T, bool>> True<T>() { return f => true; }
    public static Expression<Func<T, bool>> False<T>() { return f => false; }

    public static Expression<Func<T, bool>> Or<T>(
        this Expression<Func<T, bool>> expr1,
        Expression<Func<T, bool>> expr2)
    {
        var secondBody = expr2.Body.Replace(expr2.Parameters[0], 
            expr1.Parameters[0]);
        return Expression.Lambda<Func<T, bool>>
              (Expression.OrElse(expr1.Body, secondBody), expr1.Parameters);
    }

    public static Expression<Func<T, bool>> And<T>(
        this Expression<Func<T, bool>> expr1,
        Expression<Func<T, bool>> expr2)
    {
        var secondBody = expr2.Body.Replace(expr2.Parameters[0], 
            expr1.Parameters[0]);
        return Expression.Lambda<Func<T, bool>>
              (Expression.AndAlso(expr1.Body, secondBody), expr1.Parameters);
    }
}

which uses:

internal class ReplaceVisitor : ExpressionVisitor
{
    private readonly Expression from, to;
    public ReplaceVisitor(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node)
    {
        return node == from ? to : base.Visit(node);
    }
}

public static Expression Replace(this Expression expression,
    Expression searchEx, Expression replaceEx)
{
    return new ReplaceVisitor(searchEx, replaceEx).Visit(expression);
}

This allows you to take any two expressions and create a new expression that is the result of ORing them together.

List<Tuple<string, string>> list = CreateList();

var finalExpression = list.Aggregate(PredicateBuilder.False<Data>(),
        (predicate, pair) => predicate.Or(n => n.Item1 == pair.Item2));

var query = data.Where(finalExpression);