Build Dynamic Expression For Linq Where using PropertyInfo and a value

Question

As the title states, I would like to build a dynamic expression using propertyInfo and a value.

Currently i have something like this

public static IQueryable<T> WhereValueEquals<T>(this IQueryable<T> q, FieldFor fieldFor, string fieldValue) 
        where T : ModuleData
    {
        switch (fieldFor)
        {
            case FieldFor.Name:
                return q.Where(e => e.Name == fieldValue);
            case FieldFor.Reference:
                return q.Where(e => e.Reference == fieldValue);
            case FieldFor.Text0:
                return q.Where(e => e.Reference == fieldValue);

            default:
                return q;
        }
    }

Now the case statement is only going to get longer and longer, but this was fine during early stages of development.

Now, using the FieldFor enumeration, i can get the propertyInfo using an extension i already wrote. So how can i return an IQueryable from WhereValueEquals using the string value passed in and a propertyInfo

So far i have

public static IQueryable<T> WhereValueEquals<T>(this IQueryable<T> q, FieldFor fieldFor, string fieldValue) 
    where T : ModuleData
{
    PropertyInfo propertyInfo = typeof(T).GetFieldProperties().GetPropertyByFieldFor(fieldFor);            

    //return q.Where(expression);
}

Answer 1

At some point in the time I had to do something similar, and there are a ton of code on Stackoverflow that show you how to build an expression builder. Well this is my POC, hope it helps you

void Main()
{
    var ops  = new List<Ops>
    { 
        new Ops
        {
            //OperandType = typeof(string), 
            OpType=OpType.Equals, 
            OperandName = "Name", 
            ValueToCompare = "MM"
        },
        new Ops
        {
            //OperandType = typeof(int), 
            OpType=OpType.Equals, 
            OperandName = "ID", 
            ValueToCompare = 1
        },
    };
    var testClasses = new List<TestClass>
    {
        new TestClass { ID =1, Name = "MM", Date = new DateTime(2014,12,1)},
        new TestClass { ID =2, Name = "BB", Date = new DateTime(2014,12,2)}
    };

    var funct = ExpressionBuilder.BuildExpressions<TestClass>(ops);
    foreach(var item in testClasses.Where(funct))
    {
        Console.WriteLine("ID " +item.ID);
        Console.WriteLine("Name " +item.Name);
        Console.WriteLine("Date" + item.Date);
    }
}

// Define other methods and classes here

public enum OpType
{
    Equals
}

public class Ops
{
    //public Type OperandType {get; set;}

    public OpType OpType {get; set;}

    public string OperandName {get;set;}

    public object ValueToCompare {get;set;}
}

public class TestClass
{   
    public int ID {get;set;}
    public string Name {get; set;}
    public DateTime Date {get;set;}
}

public class ExpressionBuilder
{
    public static Func<T,bool> BuildExpressions<T>( List<Ops> opList)
    {
        Expression currentExpression= null;
        var parameter = Expression.Parameter(typeof(T), "prop");
        for(int i =0; i< opList.Count; i++)
        {
            var op =  opList[i];
            Expression innerExpression = null;
            switch(op.OpType)
            {
                case OpType.Equals :
                {
                    var innerParameter = Expression.Property(parameter,op.OperandName);
                    var ConstExpression = Expression.Constant(op.ValueToCompare);
                    innerExpression = Expression.Equal(innerParameter, ConstExpression);
                    break;
                }
            }

            if (i >0)
            {
                currentExpression = Expression.And(currentExpression, innerExpression);
            }
            else
            {
                currentExpression = innerExpression;
            }
        }
        var lambdaExpression = Expression.Lambda<Func<T,bool>>(currentExpression, new []{parameter});
        Console.WriteLine(lambdaExpression);
        return lambdaExpression.Compile() ;
    }
}