在执行Expression之前，我需要使用ExpressionVisitor来分析它。根据我的需要，我需要评估Divide表达式的正确部分，但我不知道该怎么做。这是我的示例代码：
internal class RulesChecker : ExpressionVisitor
{
private readonly object data;
public RulesChecker(object data)
{
this.data = data;
}
protected override Expression VisitBinary(BinaryExpression node)
{
if (node.NodeType == ExpressionType.Divide)
{
var rightExpression = node.Right;
// compile the right expression and get his value
}
return base.VisitBinary(node);
}
}
假设我有这个代码来评估：
Expression<Func<DataInfo, decimal?>> expression = x => x.A / (x.B + x.C);
var rulesChecker = new RulesChecker(data);
rulesChecker.Visit(expression);
在VisitBinary函数中，我将收到一个节点，该节点将包含除法运算的左右部分。我的问题是，我如何评估我将在操作的正确部分获得的价值？
答案 0 :(得分：3)
我认为这个问题最困难的部分是处理变量。所以我首先要替换常量变量。之后，您只需执行并更新Expression。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
namespace WindowsFormsApplication1
{
static class Program
{
[STAThread]
static void Main()
{
var value1 = 1;
var value2 = 2;
var value3 = new { MyValue = 3 };
var data = new DataInfo { A = 10, B = 1, C = -1 };
Expression<Func<DataInfo, decimal?>> expression = x => x.A / (x.B + x.C) + (value1 + value2) + value3.MyValue;
// create a list of variables that will be used when evaluating the expression
var variables = new Dictionary<Type, object>();
// add the root object
variables.Add(data.GetType(), data);
// find variables that are referenced in the expression
var finder = new VariablesFinder(variables);
finder.Visit(expression);
// replace variables with ConstantExpressions
var visitor = new VariableReplacer(variables);
var newExpression = visitor.Visit(expression);
var rulesChecker = new RulesChecker();
var checkedExpression = rulesChecker.Visit(newExpression);
}
}
internal class RulesChecker : ExpressionVisitor
{
protected override Expression VisitBinary(BinaryExpression node)
{
if (node.NodeType == ExpressionType.Divide)
{
var rightBinaryExpression = node.Right as BinaryExpression;
if (rightBinaryExpression != null)
{
node = node.Update(node.Left, node.Conversion, this.Execute(rightBinaryExpression));
}
}
return base.VisitBinary(node);
}
private Expression Execute(BinaryExpression node)
{
var lambda = Expression.Lambda(node);
dynamic func = lambda.Compile();
var result = func();
return Expression.Constant(result, result.GetType());
}
}
internal class VariableReplacer : ExpressionVisitor
{
private readonly Dictionary<Type, object> _variables;
public VariableReplacer(Dictionary<Type, object> variables)
{
this._variables = variables;
}
protected override Expression VisitMember(MemberExpression node)
{
return this.HandleProperty(node) ??
this.HandleField(node) ??
node;
}
private Expression HandleField(MemberExpression memberExpression)
{
var fieldInfo = memberExpression.Member as FieldInfo;
if (fieldInfo != null)
{
var value = fieldInfo.GetValue(this.GetVarialbe(fieldInfo));
return Expression.Constant(value, fieldInfo.FieldType);
}
return null;
}
private Expression HandleProperty(MemberExpression memberExpression)
{
var propertyInfo = memberExpression.Member as PropertyInfo;
if (propertyInfo != null)
{
var value = propertyInfo.GetValue(this.GetVarialbe(propertyInfo), null);
return Expression.Constant(value, propertyInfo.PropertyType);
}
return null;
}
private object GetVarialbe(MemberInfo memberInfo)
{
return this._variables[memberInfo.DeclaringType];
}
}
internal class VariablesFinder : ExpressionVisitor
{
private readonly Dictionary<Type, object> _variables;
public VariablesFinder(Dictionary<Type, object> variables)
{
this._variables = variables;
}
protected override Expression VisitConstant(ConstantExpression node)
{
this.AddVariable(node.Type, node.Value);
return base.VisitConstant(node);
}
private void AddVariable(Type type, object value)
{
if (type.IsPrimitive)
{
return;
}
if (this._variables.Keys.Contains(type))
{
return;
}
this._variables.Add(type, value);
var fields = type.GetFields().Where(x => !x.FieldType.IsPrimitive).ToList();
foreach (var field in fields)
{
this.AddVariable(field.FieldType, field.GetValue(value));
}
}
}
class DataInfo
{
public int A { get; set; }
public int B { get; set; }
public int C { get; set; }
public int D;
}
}
答案 1 :(得分：2)
通常你可以使用这个方法来评估lambda表达式（并传递）：
protected object EvaluateExpression(Expression expression)
{
var lambda = Expression.Lambda(expression);
var compiled = lambda.Compile();
var value = compiled.DynamicInvoke(null);
return value;
}
但是，在您的情况下，这将无效，因为您尝试评估的表达式取决于x，除非您为其指定具体值，否则无法对其进行评估，如Wiktor建议的那样。 / p>
为了指定参数的值，您需要修改方法：
protected static object EvaluateExpression(Expression expression, ParameterExpression parameterX)
{
var lambda = Expression.Lambda(expression, parameterX);
var compiled = lambda.Compile();
return compiled.DynamicInvoke(5);
// 5 here is the actual parameter value. change it to whatever you wish
}
但是，此版本的方法必须将ExpressionParameter对象作为参数，该对象表示表达式中的x，以便它知道如何处理传递给DynamicInvoke()的值。
为了获得适当的ExpressionParameter对象，您需要访问根表达式，而不是访问其中一个节点，所以我想在访问者中进行访问会很尴尬。
答案 2 :(得分：1)
如果我理解正确，您希望将访问表达式的结果返回到已修改的表达式树，该表达式树具有以某种方式评估的分区的右侧。您可以使用Update的{{1}}方法将右侧节点替换为您的值：
BinaryExpression在此代码中，protected override Expression VisitBinary(BinaryExpression node)
{
if (node.NodeType == ExpressionType.Divide)
{
var rightExpression = node.Right;
// compile the right expression and get his value
var newRightExpression = Evaluate(rightExpression);
return node.Update(node.Left, node.Conversion, newRightExpression);
}
return base.VisitBinary(node);
}
必须是继承自newRightExpression的类型。如果正确的节点评估为Expression值，那么您需要将其包装在double中：
ConstantExpression答案 3 :(得分：1)
我认为@ w0lf是正确的道路。
要从访问者中获取参数，您需要覆盖VisitLambda。最好的方法是覆盖访问者的每个可用方法，并将参数传递给所有方法。
另一种方法是保存最新参数。实际上，参数数组在整个lambda表达式中都是相同的。
这是一段代码，将除法运算的右侧乘以2并将其替换为原始表达式，假设右侧和左侧都是double类型。
class Program
{
static void Main(string[] args)
{
Expression<Func<DateTime, double>> abc = v => 1.0d * v.Ticks / (v.Month + v.Minute);
MyExpressionVisitor mev = new MyExpressionVisitor(DateTime.Now);
var ret = mev.Visit(abc);
}
}
internal class MyExpressionVisitor : ExpressionVisitor
{
IEnumerable<ParameterExpression> _parameters = null;
object _parameterValue = null;
public MyExpressionVisitor(object valueOfParameter)
{
_parameterValue = valueOfParameter;
}
protected override Expression VisitLambda<T>(Expression<T> node)
{
_parameters = node.Parameters;
return base.VisitLambda<T>(node);
}
protected override Expression VisitBinary(BinaryExpression node)
{
if (_parameters != null)
{
// Evaluate right node.
var value = EvaluateExpression(node.Right, _parameters.ToArray(), _parameterValue);
// substitute value with 2 * value.
var newRight = Expression.Constant(value * 2);
var ret = node.Update(node.Left, node.Conversion, newRight);
return ret;
}
return base.VisitBinary(node);
}
protected double EvaluateExpression(Expression expression, ParameterExpression[] parameters, object parameterValue)
{
var lambda = Expression.Lambda(expression, parameters);
var compiled = lambda.Compile();
var value = compiled.DynamicInvoke(parameterValue);
return Convert.ToDouble(value);
}
}