Question

I need to sort in ajax response grid by column name. Column value is number stored as a string.

Let’s say some trivial class (in real-life situation there is no possibility to modify this class):

class TestObject
{
    public TestObject(string v)
    {
        this.Value = v;
    }
    public string Value { get; set; }
}

then simple test:

[Test]
public void LambdaConstructionTest()
{
   var queryable = new List<TestObject>
                   {
                       new TestObject("5"),
                       new TestObject("55"),
                       new TestObject("90"),
                       new TestObject("9"),
                       new TestObject("09"),
                       new TestObject("900"),
                   }.AsQueryable();

    var sortingColumn = "Value";

    ParameterExpression parameter = Expression.Parameter(queryable.ElementType);

    MemberExpression property = Expression.Property(parameter, sortingColumn);
    //// tried this one: var c = Expression.Convert(property, typeof(double));

        LambdaExpression lambda = Expression.Lambda(property, parameter); //// constructs: o=>o.Value

        var callExpression = Expression.Call(typeof (Double), "Parse", null, property); 

        var methodCallExpression = Expression.Call(
            typeof(Queryable),
            "OrderBy",
            new[] { queryable.ElementType, property.Type },
            queryable.Expression,
            Expression.Quote(lambda)); // works, but sorts by string values.
            //Expression.Quote(callExpression)); // getting: System.ArgumentException {"Quoted expression must be a lambda"}

        var querable =  queryable.Provider.CreateQuery<TestObject>(methodCallExpression);

        // return querable; // <- this is the return of what I need. 
}

Sorry for not being clear in my first post as @SLaks answer was correct but I do not know how to construct correct lambda expression in this case.

Finally found solution that is good for anyone who has strings in column and needs to sort by converted double value: (Special thanks for @SLaks his post was an eye opener):

    [Test]
    public void LambdaConstructionTest2()
    {
        // GIVEN
        var queryable = new List<TestObject>
                            {
                                new TestObject("5"),
                                new TestObject("55"),
                                new TestObject("90"),
                                new TestObject("9"),
                                new TestObject("09"),
                                new TestObject("900"),
                            }.AsQueryable();

        var sortingColumn = "Value";

        // WHEN
        ParameterExpression parameter = Expression.Parameter(queryable.ElementType);

        MemberExpression property = Expression.Property(parameter, sortingColumn);

        MethodCallExpression callExpression = Expression.Call(typeof (Double), "Parse", null, property);

        LambdaExpression lambda = Expression.Lambda(callExpression, parameter); // = {Param_0 => Parse(Param_0.Value)}

        UnaryExpression unaryExpression = Expression.Quote(lambda); // Expression<Func<TestObject,double>> = {Param_0 => Parse(Param_0.Value)}

        var methodCallExpression = Expression.Call(
            typeof (Queryable),
            "OrderByDescending",
            new[] { queryable.ElementType, lambda.ReturnType },
            queryable.Expression,
            unaryExpression);

        var querable = queryable.Provider.CreateQuery<TestObject>(methodCallExpression);

        // THEN
        var expectedMaxValue = queryable.Max(x => Convert.ToDouble(x.Value));
        var expectedMinValue = queryable.Min(x => Convert.ToDouble(x.Value));

        var list = querable.ToList();

        var actualMaxValue = Convert.ToDouble(list.First().Value);
        var actualMinValue = Convert.ToDouble(list.Last().Value);
        Assert.AreEqual(expectedMaxValue, actualMaxValue);
        Assert.AreEqual(expectedMinValue, actualMinValue);
    }

Answer 1

You can call Expression.Call() to create an expression node that calls a method.

Expression.Call(typeof(Double), "Parse", null, property)