选择器表达式在IQueryable上动态

Question

I would like to generate dynamically a selector expression from some lambdas.

I want to declare a list of lambda expression like this

Expression<Func<MyEntity, object>> select1 = myentity => myentity.Label;
Expression<Func<MyEntity, object>> select2 = myentity => myentity.User.Name;
Expression<Func<MyEntity, object>> select3 = myentity => myentity.Fields.Where(1 == 1).Select(f => f.Code).FirstOrDefault();

And let's say i have a class :

class MyClass 
{
   public string Label { get; set; }
   public string UserName { get; set; }
   public string CodeField { get; set; }
}

I want to compose dynamically the selector expression using the declared expressions. The goal is that I want to choose the data to recover, not all together.

Expression.Lambda<Func<MyEntity, MyClass>> selectExpression = ?? 

req.Select(selectExpression).ToList();

I want to generate a selector expression to have something like this

return req.Select(myentity => new MyClass {
    Label = myentity.Label,
    UserName = myentity.User.Name,
    CodeField = myentity.Fields.Where(1 == 1).Select(f => f.Code).FirstOrDefault()
}).ToList();

Can i do this?

---

I succeeded for example like this but it's not the way that i'm look for

var entityT = Expression.Parameter(typeof(MyEntity), "entity");

var propertyA = Expression.Property(entityT, typeof(MyEntity).GetProperty("Label"));

var propertyB = Expression.Property(entityT, typeof(MyEntity).GetProperty("User"));
var propertyC = Expression.Property(propertyB, typeof(UserEntity).GetProperty("Name"));


var binding = Expression.MemberInit(Expression.New(typeof(MyClass)),
   new[]
   {
       Expression.Bind(typeof(MyClass).GetProperty("Label"), propertyA),
       Expression.Bind(typeof(MyClass).GetProperty("UserName"), propertyC),   
   });

var selectExpression = Expression.Lambda<Func<Benef, MyClass>>(binding, entityT);

return req.Select(selectExpression).ToList();

---

In the same idea, I was tempted to do this, it compiles but does'nt work:

var binding = Expression.MemberInit(Expression.New(typeof(T)),
    new[]
    {
        Expression.Bind(typeof(T).GetProperty("Label"), select1.Body),
        Expression.Bind(typeof(T).GetProperty("UserName"), select2.Body),   
    });

I have this error : "variable 'myentity' of type 'MyEntity' referenced from scope '', but it is not defined"

Thank you for your answers.

Answer 1

Basically you need to extract expressions from each lambda and connect it with parameter from MyClass .

Something like: Expression.Bind(typeof(MyClass).GetParameter("x"), selectX.Body) .

The only difficulty is that all selectX.Body needs to point to the same paramter, so each body expression needs to be adjusted.

Here is sample code:

class Program
{
    static void Main(string[] args)
    {
        var mapped = entities
            .Select(MakeExpression<MyEntity, MyClass>(select1, select2, select3))
            .ToList();
    }

    // Create lambda expression 
    private static Expression<Func<TEntity, TModel>> MakeExpression<TEntity, TModel>(params Expression<Func<TEntity, object>>[] select)
    {
        var param = Expression.Parameter(typeof(TEntity));

        // Map expressions [select1, ..., selectN] with properties
        // For keeping things simple I map nth expression with nth property
        // eg. select1 with first property from MyClass
        var body = Expression.MemberInit(
            Expression.New(typeof(TModel)),
            typeof(TModel)
                .GetProperties()
                .Select((p, i) => Expression.Bind(p, MakeParam(param, select[i])))
                .ToArray()
        );  

        return Expression.Lambda<Func<TEntity, TModel>>(body, param);
    }

    // Replace parameter from given expression with param
    // All expressions must have same MyEntity parameter
    private static Expression MakeParam<TEntity>(ParameterExpression param, Expression<Func<TEntity, object>> select)
    {
        Expression body = select.Body;

        return new ParamVisitor<TEntity>(param).Visit(body);
    }
}

class ParamVisitor<TEntity> : ExpressionVisitor
{
    private readonly ParameterExpression _param;

    public ParamVisitor(ParameterExpression param)
    {
        this._param = param;
    }

    protected override Expression VisitParameter(ParameterExpression node)
    {
        if (node.Type == typeof(TEntity))
        {
            return this._param;
        }

        return base.VisitParameter(node);
    }
}