Averiguar si una expresión contiene un parámetro "solo" ParameterExpression

Question

¿Existe una manera simple de averiguar si una expresión contiene una expresión de parámetros que no está incluida en, por ejemplo, MemberExpression?

Ejemplo:

x => x.Method() ? x : null < = 1 ocurrencia de x sin ninguna evaluación adicional

x => x.Method() ? x.Property : null < = 0 ocurrencias de x sin ninguna evaluación adicional

En pocas palabras mi caso de uso es que sé que el Método (sin parámetros) y valores de propiedad y desea averiguar si esto es suficiente para evaluar la expresión sin recuperar todo el "objeto" de la tienda.

Editar: Mi ejemplo es tal vez simplificado. Hay más tipos de expresiones que deben manejarse (por ejemplo, UnaryExpression).

x => ((Cast) x).Property < = 0 ocurrencias de x sin ninguna evaluación adicional

Busco una respuesta a la siguiente pregunta: ¿

dada una expresión, si sé que todos los valores de retorno del método y los valores de propiedad de el parámetro de entrada pero no el valor del parámetro en sí, ¿puedo evaluar la expresión?

Answer 1

Si está en .NET 4 o posterior, puede usar ExpressionVisitor para esto.

No estoy muy seguro de cómo se defina "parámetro solo", pero si desea excluir llamadas a métodos directos, miembro de accesos y indexador accesos de parámetros, se puede usar algo como esto (no probado):

utilizar de esta manera:

new MyExpressionVisitor().GetNumLonelyParameterExpressions(myExpression.Body) 

---

public class MyExpressionVisitor : ExpressionVisitor 
{ 
    private int numLonelyParameterExpressions; 

    public int GetNumLonelyParameterExpressions(Expression expression) 
    { 
     numLonelyParameterExpressions = 0; 
     Visit(expression); 
     return numLonelyParameterExpressions; 
    } 

    protected override Expression VisitParameter(ParameterExpression node) 
    { 
     // Every time we encounter a lonely parameter, increment. 
     numLonelyParameterExpressions++; 
     return base.VisitParameter(node); 
    } 

    protected override Expression VisitMethodCall(MethodCallExpression node) 
    { 
     // Don't visit parameters that have methods called on them. 
     var expr = (node.Object is ParameterExpression) 
      ? Expression.Default(node.Object.Type) 
      : node.Object; 

     // We need to make sure the arguments are visited though. 
     return base.VisitMethodCall(node.Update(expr, node.Arguments)); 
    } 


    protected override Expression VisitMember(MemberExpression node) 
    { 
      // Don't visit parameters with member accesses on them. 
      if (node.Expression is ParameterExpression) 
       return Expression.Default(node.Type); 

      return base.VisitMember(node); 
    } 

    protected override Expression VisitIndex(IndexExpression node) 
    { 
     // Same idea here. 
     var expr = (node.Object is ParameterExpression) 
      ? Expression.Default(node.Object.Type) 
      : node.Object; 

     return base.VisitIndex(node.Update(expr, node.Arguments)); 
    } 
}