Question

Given an Expression<Func<T, TValue>> (like m => m.Name) and an index, I’d like to be able to transform my expression to m => m[index].Name). And I must admit I’m stuck…

I give you the actual scenario if you want the “Why the hell” (and maybe find a better way).

Scenario : imagine a Server Side Editable Grid (without javascript).

I build my grid with an helper which look like that :

@(Html.Grid(Model)
.Columns(columns => {
   columns.Edit(m => m.Name);
   columns.Edit(m => m.Code);
})
.AsEditable());

Model is an IQueryable<T>

m => m.Name is an Expression<Func<T, TValue>> (TValue is string)

m => m.Code is an Expression<Func<T, TValue>> (TValue is int)

When rendering my view, I’d like to display an html form.
The IQueryable<T> is enumerated (order, pagination). => ok

So I’ll have a List<T> of 5, 10 or 20 T items.

And Name and Code should be represented as TextBox, using a classic HtmlHelper.TextBoxFor(Expression<Func<T, TValue>>) (no problem to create the HtmlHelper<T>)

But as I’ve got a list, if I want correct Model binding, I can’t use directly m => m.Name, but should use m => m[indexOfItem in List<T>].Name

Edit : more details :

So let’s say we have an entity class

public class Test {
  public int Id {get;set;}
  public string Name {get;set;}
  public string Code {get;set;}
}

Then, a method retrieving an IQueryable<Test>

Then a view

@model IQueryable<Test>

@(Html.Grid(Model)
    .Columns(columns => {
       columns.Edit(m => m.Name);
       columns.Edit(m => m.Code);
    })
    .AsEditable());

as you see, Model given as parameter is IQueryable<Test>.

m => m.Name

and

m => m.Code

are just properties of the Model (which I wanna display as TextBox in my grid).

The model is an IQueryable<T> (not an IEnumerable<T>), because the Grid manages ordering and Pagination, so that my controller and service layer don’t need to know about pagination and ordering.

Is it clearer ?

Answer 1

This could be easily achieved by writing a custom ExpressionVisitor:

public static class ExpressionExtensions
{
    private class Visitor : ExpressionVisitor
    {
        private readonly int _index;
        public Visitor(int index)
        {
            _index = index;
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            return Expression.ArrayIndex(GetArrayParameter(node), Expression.Constant(_index));
        }

        public ParameterExpression GetArrayParameter(ParameterExpression parameter)
        {
            var arrayType = parameter.Type.MakeArrayType();
            return Expression.Parameter(arrayType, parameter.Name);
        }
    }

    public static Expression<Func<T[], TValue>> BuildArrayFromExpression<T, TValue>(
        this Expression<Func<T, TValue>> expression,
        int index
    )
    {
        var visitor = new Visitor(index);
        var nexExpression = visitor.Visit(expression.Body);
        var parameter = visitor.GetArrayParameter(expression.Parameters.Single());
        return Expression.Lambda<Func<T[], TValue>>(nexExpression, parameter);
    }
}

and then you could use this extension method like this:

Expression<Func<Test, string>> ex = m => m.Code;
Expression<Func<Test[], string>> newEx = ex.BuildArrayFromExpression(1);