Iterate over Each Argument Between && or || in an Expressions<Func<T,Bool>> Lambda Expression

Question

I want a method that operates similarly to following LINQ-to-SQL Where method.

 db.Where(r => r.Age == 42 && r.Name = "Joe");

I would like to take an implementation of:

Something something = Get<Something>()
    .FilterBy(x => x.PropOne == 123 && x.PropTwo == 456);

and using a method like below; have the ability to access the Left.Name, Operator and Right.Value of each expression argument to perform work.

public static T FilterBy<T>(this T something, Expression<Func<T, object>> e)
{
    // do work here
}

So far I can parse single condition like x => x.PropOne == 123 without the use of && or || using the below.

public static T FilterBy<T>(this T something, Expression<Func<T, object>> e)
{
    BinaryExpression binaryExpression = 
        (BinaryExpression)((UnaryExpression)e.Body).Operand;

    string left = ((MemberExpression)binaryExpression.Left).Member.Name;
    string right = binaryExpression
        .Right.GetType().GetProperty("Value")
        .GetValue(binaryExpression.Right).ToString();

    ExpressionType @operator = binaryExpression.NodeType;
    return (T)Convert.ChangeType(something, typeof(T));
}

How can I access the each of the expression arguments when parts of expression combined with && or ||?

Answer 1

Example Code

Here is an example of how to get the &&:

public static class FilterExtension
{
    public class Condition
    {
        public string Name { get; set; }
        public string Value { get; set; }
        public string Operator { get; set; }
    }

    public static T FilterBy<T>(this T something, Expression<Func<T, object>> e)
    {
        var conditions = new List<Condition>();
        BinaryExpression binaryExpression =
       (BinaryExpression)((UnaryExpression)e.Body).Operand;
        CheckConditions(conditions, binaryExpression);
        return (T)Convert.ChangeType(test, typeof(T));
    }

    private static void CheckConditions(List<Condition> conditions, BinaryExpression binaryExpression)
    {
        if (binaryExpression.NodeType == ExpressionType.AndAlso)
        {
            CheckConditions(conditions, binaryExpression.Left as BinaryExpression);
            CheckConditions(conditions, binaryExpression.Right as BinaryExpression);
        }
        else
        {
            conditions.Add(GetCondition(binaryExpression));
        }
    }

    private static Condition GetCondition(BinaryExpression binaryExpression)
    {
        var condition = new Condition();
        condition.Name = ((MemberExpression)binaryExpression.Left).Member.Name;
        condition.Value = binaryExpression
            .Right.GetType().GetProperty("Value")
            .GetValue(binaryExpression.Right, null).ToString();
        condition.Operator = binaryExpression.NodeType.ToString();
        return condition;
    }
}

Obviously the code for && is not complete; you should get an idea.

Also, I noticed that you pass in an object of type T. If this were to work like Linq-To-SQL where, it probably should be some kind of list or enumerable.

Example: public static T FilterBy<T>(this List<T> something, Expression<Func<T, object>> e)

Considerations

Just as a note of caution, a lot of different expressions can be passed into this method that will compile but will break your method.

Something something = Get<Something>().FilterBy(x => 123 == x.PropOne);

Something something = Get<Something>().FilterBy(x => x.Method() == 123);

Something something = Get<Something>().FilterBy(x => (x.PropOne == 123 || x.PropOne == 34) && x.PropTwo == 456 );

Make sure to verify that the expression is the type that you are expecting it to be.