Dynamically building LINQ queries from string

I would approach this problem little differently, since what you are already having is List<object>, which internally contain a QueryClass containing all the relevant fields containing information, FieldName,Operator and Value, where you are aware which of the binary expressions have to be bundled in a parentheses. Important point is how can you create a Run-time Expression to take care of all kinds of scenarios.

Following is a sample to mimic your scenario:

Sample Class

public class Car
{
    public string Make {get; set;}

    public string Model {get; set;}

    public int Year {get; set;}
}

Query

((c.Make.Equals("Honda") AndAlso c.Model.Contains("Civic")) Or (c.Year >= 2015))

Linqpad Code

void Main()
{
    var cars = new List<Car>();

    Expression<Func<Car,bool>> e1 = c => c.Make.Equals("Honda");

    Expression<Func<Car,bool>> e2 = c => c.Model.Contains("Civic");

    Expression<Func<Car,bool>> e3 = c => c.Year >= 2015;

    var expr1 = Expression.AndAlso(e1.Body,e2.Body);

    var expr2 = e3;

    var finalExpression = Expression.Or(expr1,expr2.Body);

    finalExpression.Dump();
}

Purpose

As it can be seen that I have manually constructed the Expressions and finally Dump the final expression, since in Linqpad it provides a graphical representation of how shall the Expression be constructed dynamically, overall image is too big and deep to be pasted here (you may try yourself using LinqPad), but following are the relevant details:

1. Create a ParameterExpression, this acts as a lambda parameter representing the Car class object (this is independent of the fields of the Query class)

   var parameterExpression = Expression.Parameter(typeof(Car),"c");

2. Create MemberExpression to access each relevant field of the Car class, which is used in the Query (this one needs Field property of the Query class)

   var makeMemberAccessExpression = Expression.MakeMemberAccess(parameterExpression, typeof(Car).GetProperty("Make"));
   
   var modelMemberAccessExpression = Expression.MakeMemberAccess(parameterExpression, typeof(Car).GetProperty("Model"));
   
   var yearMemberAccessExpression = Expression.MakeMemberAccess(parameterExpression, typeof(Car).GetProperty("Year"));
   

3. Completing the Expression:

a.) c => c.Make.Equals("Honda") we create as follows: (this one needs Value property of the QueryClass)

var makeConstantExpression = Expression.Constant("Honda");

var makeEqualExpression = Expression.Equal(makeMemberAccessExpression, makeConstantExpression);

b.) c.Model.Contains("Civic") can be represented as follows here we need supply the MethodInfo for the string Contains method and create a MethodCallEXpression

var modelConstantExpression = Expression.Constant("Civic");

var stringContainsMethodInfo = typeof(string).GetMethod("Contains", new[] { typeof(string) });

var modelContainsMethodExpression = Expression.Call(modelMemberAccessExpression, stringContainsMethodInfo, modelConstantExpression);

c.) c.Year >= 2015 can simply projected as:

var yearConstantExpression = Expression.Constant(2015);

var yearGreaterThanEqualExpression = Expression.GreaterThanOrEqual(yearMemberAccessExpression, yearConstantExpression);

4. Combining all together to form the Composite Expression:

Expressions a.) and b.) are combined together as follows:

((c.Make.Equals("Honda") AndAlso c.Model.Contains("Civic"))

var firstExpression = Expression.AndAlso(makeEqualExpression,modelContainsMethodExpression);

Expression c.) is independent:

c.Year >= 2015
var secondExpression = yearGreaterThanEqualExpression;

5. Final Combined Expression and Creation a Func Delegate

   // Expressions combined via Or (||)
   var finalCombinedExpression = Expression.Or(firstExpression,secondExpression);
   
   // Create Lambda Expression
   var lambda = Expression.Lambda<Func<Car,bool>>(finalCombinedExpression, parameterExpression);
   
   // Create Func delegate via Compilation
   var func = lambda.Compile();
   

func delegate thus can be used in any of the where clause in the Linq, which expects Func<Car,bool>

Design Suggestions

1. Using the explanation above and values from the Query Class placeholders or directly from the Dictionary it is feasible to create any number of Expressions to be used dynamically in the code, to be compiled and used as a Func delegate
2. Binary expressions like Equal, GreaterThan, LessThan, LessThanOrEqual,GreaterThanOrEqual are all exposed by the Expression trees to be used directly, For method like Contains available by default you need Reflection to get theb MethodInfo, similarly it can be done for the Static methods, just that there's object expressions
3. All Expressions expect values to be supplied Left to Right in the correct order, it cannot be random or incorrect order, else it will fail at run-time.
4. In your case, since you have few queries combined in parentheses and few independent, I would recommend creating multiple List<Expression>, where each List is combined in parentheses using AndAlso or OrElse and each list can thus be combined using And / Or

By this approach you shall be able to construct very complex requirements at runtime using Linq Expressions.

You should be able to use Linq Expressions (System.Linq.Expressions) and leverage predicates to handle your filtering.

public IQueryable<Car> GetCars(Expression<Func<Car, bool>> filter)
{
   return context.Cars.Where(filter);
}

That said, the challenge will be to build your predicate expressions based off of your custom QueryClass object. To handle the filter on each Dictionary you can create a method to handle each:

public Expression<Func<Car, bool>> GetModelFilter(QueryClass modelQuery)
{
    return modelQuery.Operator == "CONTAINS"? car => car.Model.Contains(modelQuery.Value) : car => car.Model == modelQuery.Value;
}

Considering you have a limited amount of filters, the above may be acceptable. However, when dealing with a large set this can also be done more dynamically, using reflection or a dynamic predicate builder but for simplicity you can follow the above.

HTH