Combinare più alberi di espressioni

Sto ottenendo il seguente errore

Il parametro 'p' non era associato nell'espressione di query LINQ to Entities specificata.

Comprendo il problema (la stessa istanza di ParameterExpression dovrebbe essere utilizzata con tutte le espressioni nell'albero) e ho tentato di utilizzare soluzioni che ho trovato online ma senza fortuna.

Questo è il mio metodo

private void SeedEntity<TEntity>(DatabaseContext context, ref TEntity entity, params Expression<Func<TEntity, object>>[] identifierExpressions) where TEntity : class
{
    Expression<Func<TEntity, bool>> allExpresions = null;

    var parameters = identifierExpressions.SelectMany(x => x.Parameters).GroupBy(x => x.Name).Select(p => p.First()).ToList();

    foreach (Expression<Func<TEntity, object>> identifierExpression in identifierExpressions)
    {
        Func<TEntity, object> vv = identifierExpression.Compile();
        object constant = vv(entity);

        ConstantExpression constExp = Expression.Constant(constant, typeof(object));
        BinaryExpression equalExpression1 = Expression.Equal(identifierExpression.Body, constExp);
        Expression<Func<TEntity, bool>> equalExpression2 = Expression.Lambda<Func<TEntity, bool>>(equalExpression1, parameters);

        if (allExpresions == null)
        {
            allExpresions = equalExpression2;
        }
        else
        {
            BinaryExpression bin = Expression.And(allExpresions.Body, equalExpression2.Body);
            allExpresions = Expression.Lambda<Func<TEntity, bool>>(bin, parameters);
        }
    }

    TEntity existingEntity = null;
    if (allExpresions != null)
    {
        existingEntity = context.Set<TEntity>().FirstOrDefault(allExpresions);
    }

    if (existingEntity == null)
    {
        context.Set<TEntity>().Add(entity);
    }
    else
    {
        entity = existingEntity;
    }
}

Genera un'espressione per la ricerca di un'entità basata su un numero di proprietà.

Funziona bene per una singola espressione, l'errore si verifica solo quando si passa in più.

Chiamato in questo modo:

SeedEntity(context, ref e, p=> p.Name);//Works
SeedEntity(context, ref e, p=> p.Name, p=> p.Age);//Fails

Genera qualcosa di simile a me eseguendo quanto segue:

context.Set<TEntity>().FirstOrDefault(p=>p.Name == e.Name && p.Age == e.Age);

Sostituire e.Name && e.Age con un'espressione ConstantExpression

Puoi vedere nel metodo qui sopra che prendo tutti i parametri univoci e li memorizzo nei parameters in alto, quindi uso la stessa variabile in tutto. Questo è l'inizio, ma poi ho bisogno di sostituire le istanze del parametro in ognuna delle Expression<Func<TEntity, bool>> passato come array params , questo è dove sto fallendo.

Ho provato a enumerare le espressioni e utilizzare il metodo .Update() che passa nei parametri

Ho anche provato una soluzione usando ExpressionVisitor

public class ExpressionSubstitute : ExpressionVisitor
{
    public readonly Expression from, to;
    public ExpressionSubstitute(Expression from, Expression to)
    {
        this.from = from;
        this.to = to;
    }
    public override Expression Visit(Expression node)
    {
        if (node == from) return to;
        return base.Visit(node);
    }
}

public static class ExpressionSubstituteExtentions
{
    public static Expression<Func<TEntity, TReturnType>> RewireLambdaExpression<TEntity, TReturnType>(Expression<Func<TEntity, TReturnType>> expression, ParameterExpression newLambdaParameter)
    {
        var newExp = new ExpressionSubstitute(expression.Parameters.Single(), newLambdaParameter).Visit(expression);
        return (Expression<Func<TEntity, TReturnType>>)newExp;
    }
}