Optimize OrderBy Generic Method Here is my OrderBy method which includes concatenated column names.
Can this be achieved more efficiently?

public static IQueryable&lt;T&gt; Sort&lt;T&gt;(this IQueryable&lt;T&gt; query, List&lt;SortationDto&gt; sortations)
    where T : BaseEntity
{
    sortations.ForEach(s =&gt;
    {
        Expression value = null;
        ParameterExpression parameter = Expression.Parameter(query.ElementType, "item");

        // if sortation is a concatenation of two columns
        if (s.Concatenated.Count &gt; 0)
        {
            Expression concat = null;
            s.Concatenated.ForEach(c =&gt;
            {
                //get first property
                value = c.Column.Split('.').Aggregate((Expression)parameter, Expression.PropertyOrField);

                //if first property add as initial property
                if (concat == null)
                {
                    concat = value;
                }
                else //else concatenate with first property
                {
                    MethodInfo concatMethod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string), typeof(string) });
                    value = Expression.Call(concatMethod, concat, Expression.Constant(" "), value);
                }
            });
        }
        else //else use one and only property
        {
            value = s.Column.Split('.').Aggregate((Expression)parameter, Expression.PropertyOrField);
        }

        //build lambda expression
        LambdaExpression predicate = Expression.Lambda(value, parameter);

        //define orderby method name based on current iteration of sortations
        string methodName = (sortations.IndexOf(s) == 0 ? "Order" : "Then") + (s.Direction == "asc" ? "By" : "ByDescending");

        //call method
        MethodCallExpression orderBy = Expression.Call(typeof(Queryable), methodName, new Type[] { query.ElementType, value.Type }, query.Expression, Expression.Quote(predicate));

        //add final expression to query
        query = query.Provider.CreateQuery&lt;T&gt;(orderBy);
    });

    return query;
}
Removed unnecessary concatenation.

public static IQueryable&lt;T&gt; Sort&lt;T&gt;(this IQueryable&lt;T&gt; query, List&lt;SortationDto&gt; sortations)
    where T : BaseEntity
{
    List&lt;SortationDto&gt; combined = sortations.Where(s =&gt; s.Concatenated.Count == 0).Union(sortations.SelectMany(so =&gt; so.Concatenated)).ToList();

    combined.ForEach(s =&gt;
    {
        ParameterExpression parameter = Expression.Parameter(query.ElementType, "item");
        Expression value = s.Column.Split('.').Aggregate((Expression)parameter, Expression.PropertyOrField);
        LambdaExpression predicate = Expression.Lambda(value, parameter);

        string methodName = (combined.IndexOf(s) == 0 ? "Order" : "Then") + (s.Direction == "asc" ? "By" : "ByDescending");
        MethodCallExpression orderBy = Expression.Call(typeof(Queryable), methodName, new Type[] { query.ElementType, value.Type }, query.Expression, Expression.Quote(predicate));             
        query = query.Provider.CreateQuery&lt;T&gt;(orderBy);
    });

    return query;
}