Entity Framework Core: crea dinamicamente una lista di selezione con proprietà di navigazione

EF esaminerà le operazioni di invocazione lambda come se il corpo di quell'espressione fosse allineato. Quindi consiglierei di lasciare da sole le espressioni di origine e di generare espressioni per invocarle.

Inoltre vorrei mantenere semplice il tipo di risultato e restituire ogni riga come una matrice di oggetti. Ciò dovrebbe comportare un sovraccarico minore rispetto alla creazione di molti dizionari. Se è necessario accedere ai campi per nome, è necessario creare un singolo dizionario per mantenere la relazione tra nomi e numeri di colonna.

public class SelectList<TSource>
{
    private List<LambdaExpression> members = new List<LambdaExpression>();
    public SelectList<TSource> Add<TValue>(Expression<Func<TSource, TValue>> selector)
    {
        members.Add(selector);
        return this;
    }

    public Expression<Func<TSource, TResult>> ToDynamicColumns()
    {
        var parameter = Expression.Parameter(typeof(TSource), "e");
        return Expression.Lambda<Func<TSource, object[]>>(
            Expression.NewArrayInit(
                typeof(object),
                members.Select(m =>
                    Expression.Convert(Expression.Invoke(m, parameter), typeof(object))
                )
            ),
            parameter);
    }
}

Sebbene nel tuo caso, dal momento che stai scrivendo un metodo di estensione per restituire solo gli stessi dettagli chiave e un singolo campo aggiuntivo, potresti probabilmente definire un singolo tipo generico per contenere i risultati ed evitare qualsiasi confusione con le espressioni Linq;

public class UserResult<V>{
    public int Id { get; set; }
    public string DisplayName { get; set; }
    public V Value { get; set; }
}

public static IQueryable<UserResult<V>> SelectCustom<V>(this IQueryable<User> query, Expression<Func<User, V>> ValueGetter)
{
    return query.Select(u => new UserResult<V>{
        Id = u.Id,
        DisplayName = u.DisplayName,
        Value = ValueGetter(u)
    });
}

Beh, quasi, se c # ti consentisse di compilare una chiamata di Expression<Delegate> dall'interno di un'altra. Invece possiamo implementare un ExpressionVisitor per scartare qualsiasi chiamata alla compilazione;

public class DontCompile : ExpressionVisitor
{
    protected override Expression VisitMember(MemberExpression node)
    {
        // Inline any lambda arguments that are expressions
        if (node.Expression is ConstantExpression lambdaArgs
            && node.Member is FieldInfo field
            && typeof(Expression).IsAssignableFrom(field.FieldType))
            return (Expression)field.GetValue(lambdaArgs.Value);
        return base.VisitMember(node);
    }

    protected override Expression VisitMethodCall(MethodCallExpression node)
    {
        // Don't compile lambda expressions
        if (node.Method.Name == "Compile" 
            && typeof(LambdaExpression).IsAssignableFrom(node.Object.Type))
            return Visit(node.Object);
        return base.VisitMethodCall(node);
    }

    public static Expression<T> Tidy<T>(Expression<T> func) => (Expression<T>)new DontCompile().Visit(func);
}
...
    return query.Select(DontCompile.Tidy<...>(u => new UserResult<V>{
        Id = u.Id,
        DisplayName = u.DisplayName,
        Value = ValueGetter.Compile()(u)
    });
...

Ma questo inizia a sembrare un po 'confuso.