Можно ли составить System.Linq.Expressions.Expression из более мелких выражений?

Чтобы реализовать лямбда-расширитель для Expression-дерева (есть и другие типы экспандеров, которые можно сделать), вам нужно пометить лямбды для расширения, вызвав их с помощью метода XInvoke, создать ExpressionVisitor для поиска вызовов и их расширения, и используйте общий посетитель замены Expression, чтобы применить аргументы XInvoke к лямбде, которую вы расширяете.

public static class ExpandXInvokeExt {
    public static TRes XInvoke<TArg1, TRes>(this Expression<Func<TArg1, TRes>> fnE, TArg1 arg1)
        => throw new InvalidOperationException($"Illegal call to XInvoke({fnE},{arg1})");

    public static TRes XInvoke<TArg1, TArg2, TRes>(this Expression<Func<TArg1, TArg2, TRes>> fnE, TArg1 arg1, TArg2 arg2)
        => throw new InvalidOperationException($"Illegal call to XInvoke({fnE},{arg1},{arg2})");

    public static T ExpandXInvoke<T>(this T orig) where T : Expression => (T)new ExpandXInvokeVisitor().Visit(orig);

    public static T Evaluate<T>(this T e) where T : Expression => (T)((e is ConstantExpression c) ? c.Value : Expression.Lambda(e).Compile().DynamicInvoke());

    /// <summary>
    /// ExpressionVisitor to expand a MethodCallExpression of XInvoke with an applied version of the first argument,
    /// an Expression.
    /// </summary>
    public class ExpandXInvokeVisitor : ExpressionVisitor {
        public override Expression Visit(Expression node) {
            if (node?.NodeType == ExpressionType.Call) {
                var callnode = (MethodCallExpression)node;
                if (callnode.Method.Name == "XInvoke" && callnode.Method.DeclaringType == typeof(ExpandXInvokeExt)) {
                    var lambda = (LambdaExpression)(callnode.Arguments[0].Evaluate());
                    Expression expr = lambda.Body;
                    for (int argNum = 1; argNum < callnode.Arguments.Count; ++argNum)
                        expr = expr.Replace(lambda.Parameters[argNum - 1], callnode.Arguments[argNum]);

                    return expr;
                }
            }

            return base.Visit(node);
        }
    }

    /// <summary>
    /// Replaces an Expression (reference Equals) with another Expression
    /// </summary>
    /// <param name = "orig">The original Expression.</param>
    /// <param name = "from">The from Expression.</param>
    /// <param name = "to">The to Expression.</param>
    /// <returns>Expression with all occurrences of from replaced with to</returns>
    public static T Replace<T>(this T orig, Expression from, Expression to) where T : Expression => (T)new ReplaceVisitor(from, to).Visit(orig);

    /// <summary>
    /// ExpressionVisitor to replace an Expression (that is Equals) with another Expression.
    /// </summary>
    public class ReplaceVisitor : ExpressionVisitor {
        readonly Expression from;
        readonly Expression to;

        public ReplaceVisitor(Expression from, Expression to) {
            this.from = from;
            this.to = to;
        }

        public override Expression Visit(Expression node) => node == from ? to : base.Visit(node);
    }
}

Этот код предоставляет XInvoke для одного и двух аргументов, другие могут быть добавлены таким же образом.

Имея эти доступные расширения, вы можете написать свой ToPurchaseDetailsShallow следующим образом:

public static Expression<Func<Purchase, PurchaseDetailsShallow>> ToPurchaseDetailsShallowTemplate
    => (purchase) => new PurchaseDetailsShallow() {
        Price = purchase.Price,
        Purchaser = ToPersonDetailsShallow.Invoke(purchase.Purchaser)
    };

public static Expression<Func<Purchase, PurchaseDetailsShallow>> ToPurchaseDetailsShallow => ToPurchaseDetailsShallowTemplate.ExpandXInvoke();

Примечание: я использовал имя XInvoke, чтобы компилятор не перепутал неправильное количество аргументов с попытками вызова Expression.Invoke (я не думаю, что это должно быть, но это так).

Примечание. При наличии достаточного количества круглых скобок и приведения типов вы можете избежать использования переменной шаблона, но я не уверен, что это сделает что-то лучше:

public static Expression<Func<Purchase, PurchaseDetailsShallow>> ToPurchaseDetailsShallow
    => ((Expression<Func<Purchase, PurchaseDetailsShallow>>)(
        (purchase) => new PurchaseDetailsShallow() {
            Price = purchase.Price,
            Purchaser = ToPersonDetailsShallow.XInvoke(purchase.Purchaser)
        })
       )
       .ExpandXInvoke();