Convert method/properties chain into Expression Tree

Question

I have this classes:

public class DiagnosticDetails
{
    public string PrimaryValue { get; set; }
    public Guid? Id { get; set; }
    public IEnumerable<DiagnosticValues> Values { get; set; }
}

public class DiagnosticValues
{
    public string Type { get; set; }
    public string Value { get; set; }
}

I want to construct dynamic OrderBy().ThenBy()... for every string in Values (this list can contain different amount of string) thus it should look like:

diagnosticDetails
    .OrderBy(detail => detail.Values.ElementAt(0).Value?.Trim())
    .ThenBy(detail => detail.Values.ElementAt(1).Value?.Trim())
    .ThenBy(detail => detail.Values.ElementAt(2).Value?.Trim())
    ...

But I can't convert this to expression tree:

var result = diagnosticDetails.OrderBy(detail => detail.Values.ElementAt(0).Value?.Trim());
//var expressionTreeForResult = ???

This is my code:

   private List<DiagnosticDetails> SortByValue(List<DiagnosticDetails> diagnosticDetails)
    {
        IQueryable<DiagnosticDetails> queryableData = diagnosticDetails.AsQueryable();

        ParameterExpression pe = Expression.Parameter(typeof(DiagnosticDetails), "detail");


        //var predicate = diagnosticDetails.OrderBy(detail => detail.Values.ElementAt(0).Value?.Trim());
        //var predicateExpressionTree = ???


        MethodCallExpression orderByCallExpression = Expression.Call(
            typeof(Queryable),
            "OrderBy",
            new Type[] { queryableData.ElementType },
            queryableData.Expression,
            Expression.Lambda<Func<DiagnosticDetails, string>>(predicateExpressionTree, new ParameterExpression[] { pe }));

        var maxElementsInValues = diagnosticDetails.Select(dd => dd.Values.Count()).Max();

        for (int i = 1; i < maxElementsInValues; i++)
        {
            orderByCallExpression = Expression.Call(
                typeof(Queryable),
                "ThenBy",
                new Type[] { queryableData.ElementType },
                orderByCallExpression,
                Expression.Lambda<Func<DiagnosticDetails, string>>(predicateExpressionTree, new ParameterExpression[] { pe }));
        }

        var sortedDiagnosticDetails = Expression.Lambda<List<DiagnosticDetails>>(orderByCallExpression).Compile();

        return sortedDiagnosticDetails;
    }

How .OrderBy(detail => detail.Values.ElementAt(0).Value?.Trim()) can be converted into expression tree?

Do you really insist on expression tree? I like programming expression trees, but in this particular case custom `IComparer` implementation looks more appropriate IMHO. — Ivan Stoev, Aug 31 '19 at 16:57

score 1 · Accepted Answer · answered Aug 31 '19 at 18:52

As Ivan Stoev mentioned in comment, there is no need to create expression tree in this particular case. Much easier will be to implement comparison method:

    public static int CompareDiagnosticDetailsByValuesConsistently(DiagnosticDetails dd1, DiagnosticDetails dd2)
    {
        var maxDimension = Math.Max(dd1.Values.Count(), dd2.Values.Count());

        for (int i = 0; i < maxDimension; i++)
        {
            if (dd1.Values.ElementAtOrDefault(i)?.Value == null)
            {
                if (dd2.Values.ElementAtOrDefault(i)?.Value == null)
                    continue;

                return 1;
            }

            int result = dd1.Values.ElementAt(i).Value.CompareTo(dd2.Values.ElementAt(i).Value);
            if (result == 0)
                continue;

            return result;
        }

        return 0;
    }

and use it this way:

diagnosticDetails.Sort(CompareDiagnosticDetailsByValuesConsistently);

But if you still want to use expression trees, this code does what you need:

private List<DiagnosticDetails> SortByAllValuesConsistently(List<DiagnosticDetails> diagnosticDetails)
    {
        /*
         diagnosticDetails.OrderBy(detail => detail.Values.ElementAt(0).Value)
            .ThenBy(detail => detail.Values.ElementAt(1).Value))
            .ThenBy(detail => detail.Values.ElementAt(2).Value))
            .ThenBy(detail => detail.Values.ElementAt(3).Value))
            ...

            for each value in detail.Values.

         */

        if (diagnosticDetails.IsNullOrEmpty())
            return diagnosticDetails;

        IQueryable<DiagnosticDetails> queryableData = diagnosticDetails.AsQueryable();

        // detail.Values
        ParameterExpression p = Expression.Parameter(typeof(DiagnosticDetails), "detail");
        MemberExpression prVs = Expression.Property(p, "Values");

        // detail.Values.ElementAt(0).
        ConstantExpression c0 = Expression.Constant(0, typeof(int));
        Expression callElAt = expressionTreeHelper.CallElementAt(prVs, c0);

        // detail.Values.ElementAt(0).Value
        MemberExpression prV = Expression.Property(callElAt, "Value");

        // detail => detail.Values.ElementAt(0).Value
        Delegate predicate = Expression.Lambda(prV,p).Compile();

        // diagnosticDetails.OrderBy(detail => detail.Values.ElementAt(0).Value)
        Expression orderByCallExpression = expressionTreeHelper.CallOrderBy(queryableData.Expression, predicate);

        var maxElementsInValues = diagnosticDetails.Select(dd => dd.Values.Count()).Max();

        for (int i = 1; i < maxElementsInValues; i++)
        {
            // detail.Values
            ParameterExpression pi = Expression.Parameter(typeof(DiagnosticDetails), "detail");
            MemberExpression prVsi = Expression.Property(pi, "Values");

            // detail.Values.ElementAt(i).
            ConstantExpression ci = Expression.Constant(i, typeof(int));
            Expression callElAti = expressionTreeHelper.CallElementAt(prVsi, ci);

            // detail.Values.ElementAt(i).Value
            MemberExpression prVi = Expression.Property(callElAti, "Value");

            // detail => detail.Values.ElementAt(i).Value
            Delegate predicateI = Expression.Lambda(prVi, pi).Compile();

            // orderByCallExpression.ThenBy(detail => detail.Values.ElementAt(0).Value)
            orderByCallExpression = expressionTreeHelper.CallThenBy(orderByCallExpression, predicateI);
        }

        // Get result
        var orderedList = (Func<IOrderedEnumerable<DiagnosticDetails>>)Expression.Lambda(orderByCallExpression).Compile();

        return orderedList().ToList();
    }

/// <remarks>
/// Look at https://stackoverflow.com/questions/326321/how-do-i-create-an-expression-tree-calling-ienumerabletsource-any for more details
/// </remarks>
public class ExpressionTreeHelper : IExpressionTreeHelper
{
    public Expression CallElementAt(Expression collection, ConstantExpression constant)
    {
        Type cType = GetIEnumerableImpl(collection.Type);
        collection = Expression.Convert(collection, cType);

        Type elemType = cType.GetGenericArguments()[0];

        // Enumerable.ElementAt<T>(IEnumerable<T>, int index)
        MethodInfo elementAtMethod = (MethodInfo)GetGenericMethod(
            typeof(Enumerable),
            "ElementAt",
            new[] { elemType },
            new[] { collection.Type, constant.Type }, BindingFlags.Static);

        return Expression.Call(
            elementAtMethod,
            collection,
            constant);
    }

    public Expression CallOrderBy(Expression collection, Delegate predicate)
    {
        Type cType = GetIEnumerableImpl(collection.Type);
        collection = Expression.Convert(collection, cType);

        Type elemType = cType.GetGenericArguments()[0];
        Type predType = typeof(Func<,>).MakeGenericType(elemType, predicate.Method.ReturnType);

        // Enumerable.OrderBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
        MethodInfo orderByMethod = (MethodInfo)
            GetGenericMethod(
                typeof(Enumerable),
                "OrderBy",
                new[] { elemType, predicate.Method.ReturnType },
                new[] { cType, predType }, BindingFlags.Static);

        return Expression.Call(
            orderByMethod,
            collection,
            Expression.Constant(predicate));
    }

    public Expression CallThenBy(Expression collection, Delegate predicate)
    {
        Type inputType = GetIEnumerableImpl(collection.Type);

        Type elemType = inputType.GetGenericArguments()[0];
        Type predType = typeof(Func<,>).MakeGenericType(elemType, predicate.Method.ReturnType);

        // ! important convert to IOrderedEnumerable
        Type cType = typeof(IOrderedEnumerable<>).MakeGenericType(new Type[] { elemType });
        collection = Expression.Convert(collection, cType);

        // Enumerable.CallThenBy<TSource, TKey>(IEnumerable<TSource>, Func<TSource,TKey>)
        MethodInfo thenByMethod = (MethodInfo)
            GetGenericMethod(
                typeof(Enumerable),
                "ThenBy",
                new[] { elemType, predicate.Method.ReturnType },
                new[] { cType, predType }, BindingFlags.Static);

        return Expression.Call(
            thenByMethod,
            collection,
            Expression.Constant(predicate));
    }

    private MethodBase GetGenericMethod(Type type, string name, Type[] typeArgs, Type[] argTypes, BindingFlags flags)
    {
        int typeArity = typeArgs.Length;
        var methods = type.GetMethods()
            .Where(m => m.Name == name)
            .Where(m => m.GetGenericArguments().Length == typeArity)
            .Select(m => m.MakeGenericMethod(typeArgs));

        return Type.DefaultBinder.SelectMethod(flags, methods.ToArray(), argTypes, null);
    }

    private bool IsIEnumerable(Type type)
    {
        return type.IsGenericType
               && type.GetGenericTypeDefinition() == typeof(IEnumerable<>);
    }

    private Type GetIEnumerableImpl(Type type)
    {
        // Get IEnumerable implementation. Either type is IEnumerable<T> for some T, 
        // or it implements IEnumerable<T> for some T. We need to find the interface.
        if (IsIEnumerable(type))
            return type;
        Type[] t = type.FindInterfaces((m, o) => IsIEnumerable(m), null);
        Debug.Assert(t.Length == 1);
        return t[0];
    }
}

Use it this way:

var sortedDetails = SortByAllValuesConsistently(diagnosticDetails)

Convert method/properties chain into Expression Tree

1 Answers1