Espressione. Oppure, il parametro "elemento" non è nell'ambito

c# expression expression-trees linq

Domanda

Sto provando a scrivere una funzione statica su O due espressioni, ma ricevo il seguente errore:

Il parametro 'elemento' non è nell'ambito.

Descrizione: si è verificata un'eccezione non gestita durante l'esecuzione della richiesta Web corrente. Si prega di rivedere la traccia dello stack per ulteriori informazioni sull'errore e sulla sua origine nel codice.

Dettagli eccezione: System.InvalidOperationException: il parametro 'elemento' non è nell'ambito.

il metodo:

public static Expression<Func<T, bool>> OrExpressions(Expression<Func<T, bool>> left, Expression<Func<T, bool>> right)
{
    // Define the parameter to use
    var param = Expression.Parameter(typeof(T), "item");

    var filterExpression = Expression.Lambda<Func<T, bool>>
         (Expression.Or(
             left.Body,
             right.Body
          ), param);
    // Build the expression and return it
    return (filterExpression);
}

modifica : aggiunta di ulteriori informazioni

Le espressioni che sono o provengono dal metodo seguente, che vengono eseguite correttamente. se c'è un modo migliore per i risultati io sono tutto orecchie. Inoltre, non so quanti ne siano in anticipo.

public static Expression<Func<T, bool>> FilterExpression(string filterBy, object Value, FilterBinaryExpression binaryExpression)
{
    // Define the parameter to use
    var param = Expression.Parameter(typeof(T), "item");

    // Filter expression on the value
    switch (binaryExpression)
    {
        case FilterBinaryExpression.Equal:
            {
                // Build an expression for "Is the parameter equal to the value" by employing reflection
                var filterExpression = Expression.Lambda<Func<T, bool>>
                    (Expression.Equal(
                        Expression.Convert(Expression.Property(param, filterBy), typeof(TVal)),
                        Expression.Constant(Value)
                     ),
                    param);
                // Build the expression and return it
                return (filterExpression);
            }

modifica : aggiungi ancora più informazioni

In alternativa, c'è un modo migliore per fare un o? Attualmente .Where (vincolo) funziona bene dove il vincolo è di tipo Espressione>. Come posso fare dove (constraint1 o constraint2) (al vincolo n'th)

Grazie in anticipo!

Risposta accettata

Il problema è che l'espressione che stai creando nel metodo OrExpressions riutilizza il corpo delle due espressioni. Tali corpi conterranno riferimenti alla propria ParameterExpression che è stata definita in FilterExpression.

Una correzione sarebbe riscrivere le parti sinistra e destra per utilizzare la nuova ParameterExpression. O per passare il ParameterExpression originale lungo. Non è perché i due ParameterExpression hanno lo stesso nome che rappresentano lo stesso parametro.


Risposta popolare

Come già suggerito, qui puoi trovare questo bel codice (funzionante)

public static Expression<Func<T, bool>> Or<T>(this Expression<Func<T, bool>> expr1, Expression<Func<T, bool>> expr2)
{
    var invokedExpr = Expression.Invoke(expr2, expr1.Parameters.Cast<Expression>());
    return Expression.Lambda<Func<T, bool>>(Expression.Or(expr1.Body, invokedExpr), expr1.Parameters);
}

che puoi adattarti alle tue esigenze e che non è legato (IMHO) a LINQ.



Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché
Autorizzato sotto: CC-BY-SA with attribution
Non affiliato con Stack Overflow
È legale questo KB? Sì, impara il perché