Using the Select method for dynamic queries and expression trees

c# exception-handling expression-trees linq


I am attempting to create a dynamic query using expression trees to match the following statement:

var items = data.Where(i => i.CoverageType == 2).Select(i => i.LimitSelected);

I can create the where method and get a result from it; however, I cannot create the select method.

Here is my where method:

var parm = Expression.Parameter(typeof(BaseClassData), "baseCoverage");

var queryData = data.AsQueryable();

var left = Expression.Property(parm, "CoverageType");
var right = Expression.Constant(2m);
var e1 = Expression.Equal(left, right);

var whereMethod = Expression.Call(
    new Type[] { queryData.ElementType }, 
    Expression.Lambda<Func<BaseClassData, bool>>(e1, new ParameterExpression[] { parm }));

This is what I am using for the select method:

var selectParm = Expression.Property(parm, "LimitSelected");
     var selectMethod = Expression.Call(
        new Type[]{typeof(BaseClassData), typeof(decimal)},
        Expression.Lambda<Func<BaseClassData, decimal>>(selectParm, new ParameterExpression[]{ parm})


When I run the code I get this error:

No generic method 'Select' on type 'System.Linq.Enumerable' is compatible with the supplied type arguments and arguments. No type arguments should be provided if the method is non-generic.

I have also tried changing Enumerable to Queryable and I get the same error.

2/7/2013 3:26:55 AM

Popular Answer

No need to use Expression.Call, you can directly construct Expression Tree instead; I have create a static method which help me generate dynamic query:

public static void Test(string[] args) {
  using (var db = new DBContext()) {
    //query 1
    var query1 = db.PrizeTypes.Where(m => m.rewards == 1000).Select(t =>;

    //query 2 which equal to query 1
    Expression<Func<PrizeType, bool>> predicate1 = m => m.rewards == 1000;
    Expression<Func<PrizeType, string>> selector1 = t =>;
    var query2 = db.PrizeTypes.Where(predicate1).Select(selector1);

    //query 3 which equal to query 1 and 2
    Expression<Func<PrizeType, bool>> predicate2 = GetPredicateEqual<PrizeType>("rewards", (Int16)1000);
    Expression<Func<PrizeType, string>> selector2 = GetSelector<PrizeType, string>("name");
    var query3 = db.PrizeTypes.Where(predicate2).Select(selector2);

    //as you can see, query 1 will equal query 2 equal query 3

public static Expression<Func<TEntity, bool>> GetPredicateEqual<TEntity>(string fieldName, object fieldValue) where TEntity : class {
  ParameterExpression m = Expression.Parameter(typeof(TEntity), "t");
  var p = m.Type.GetProperty(fieldName);
  BinaryExpression body = Expression.Equal(
    Expression.Property(m, fieldName),
    Expression.Constant(fieldValue, p.PropertyType)
  return Expression.Lambda<Func<TEntity, bool>>(body, m);

public static Expression<Func<T, TReturn>> GetSelector<T, TReturn>(string fieldName)
  where T : class
  where TReturn : class {
  var t = typeof(TReturn);
  ParameterExpression p = Expression.Parameter(typeof(T), "t");
  var body = Expression.Property(p, fieldName);
  return Expression.Lambda<Func<T, TReturn>>(body, new ParameterExpression[] { p });
3/4/2013 11:05:46 AM

Related Questions

Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow
Licensed under: CC-BY-SA with attribution
Not affiliated with Stack Overflow