如果我有一个产品。
var p = new Product { Price = 30 };
我有以下的 LINQ 查询：
var q = repo.Products().Where(x=>x.Price == p.Price).ToList()
var memberExpression = (MemberExpression)GetRootConstantExpression(m);
var fi = (PropertyInfo)memberExpression.Member;
var val = fi.GetValue(((ConstantExpression)memberExpression.Expression).Value, null);
祝你好运。
private object GetValue(MemberExpression member)
{
var objectMember = Expression.Convert(member, typeof(object));
var getterLambda = Expression.Lambda<Func<object>>(objectMember);
var getter = getterLambda.Compile();
return getter();
}
当解析表达式树时，本地评估是一种常见的技术。LINQ to SQL 在许多地方都使用了这种方法。
MemberExpression right = (MemberExpression)((BinaryExpression)p.Body).Right;
Expression.Lambda(right).Compile().DynamicInvoke();
DynamicInvoke的东西可以是最快的@iggymoran，你测试过吗？或者你是指打字最快？;) - nawfal这个常量表达式将指向编译器生成的捕获类。我没有包括决策点等，但以下内容可以得到30：
var p = new Product { Price = 30 };
Expression<Func<Product, bool>> predicate = x => x.Price == p.Price;
BinaryExpression eq = (BinaryExpression)predicate.Body;
MemberExpression productToPrice = (MemberExpression)eq.Right;
MemberExpression captureToProduct = (MemberExpression)productToPrice.Expression;
ConstantExpression captureConst = (ConstantExpression)captureToProduct.Expression;
object product = ((FieldInfo)captureToProduct.Member).GetValue(captureConst.Value);
object price = ((PropertyInfo)productToPrice.Member).GetValue(product, null);
price 现在是 30。请注意，我假设 Price 是一个属性，但实际上你应该编写一个 GetValue 方法来处理属性/字段。
Evaluate 和 TryEvaluate：http://code.google.com/p/protobuf-net/source/browse/trunk/protobuf-net.Extensions/ServiceModel/Client/ProtoClientExtensions.cs - Marc GravellMemberExpression 然后评估它，还是到达其 PropertyInfo/FieldInfo 然后像 TryEvaluate 一样评估它？ - Ashraf Sabry这个辅助方法会优雅地检索任何表达式的值，而不需要"编译黑客"：
public static object GetMemberExpressionValue (MemberExpression expression)
{
// Dependency chain of a MemberExpression is of the form:
// MemberExpression expression
// MemberExpression expression.Expression
// ... MemberExpression expression.[...].Expression
// ConstantExpression expression.[...].Expression.Expression <- base object
var dependencyChain = new List<MemberExpression>();
var pointingExpression = expression;
while (pointingExpression != null)
{
dependencyChain.Add(pointingExpression);
pointingExpression = pointingExpression.Expression as MemberExpression;
}
if (!(dependencyChain.Last().Expression is ConstantExpression baseExpression))
{
throw new Exception(
$"Last expression {dependencyChain.Last().Expression} of dependency chain of {expression} is not a constant." +
"Thus the expression value cannot be found.");
}
var resolvedValue = baseExpression.Value;
for (var i = dependencyChain.Count; i > 0; i--)
{
var expr = dependencyChain[i - 1];
resolvedValue = new PropOrField(expr.Member).GetValue(resolvedValue);
}
return resolvedValue;
}
PropOrField 类：
public class PropOrField
{
public readonly MemberInfo MemberInfo;
public PropOrField (MemberInfo memberInfo)
{
if (!(memberInfo is PropertyInfo) && !(memberInfo is FieldInfo))
{
throw new Exception(
$"{nameof(memberInfo)} must either be {nameof(PropertyInfo)} or {nameof(FieldInfo)}");
}
MemberInfo = memberInfo;
}
public object GetValue (object source)
{
if (MemberInfo is PropertyInfo propertyInfo) return propertyInfo.GetValue(source);
if (MemberInfo is FieldInfo fieldInfo) return fieldInfo.GetValue(source);
return null;
}
public void SetValue (object target, object source)
{
if (MemberInfo is PropertyInfo propertyInfo) propertyInfo.SetValue(target, source);
if (MemberInfo is FieldInfo fieldInfo) fieldInfo.SetValue(target, source);
}
public Type GetMemberType ()
{
if (MemberInfo is PropertyInfo propertyInfo) return propertyInfo.PropertyType;
if (MemberInfo is FieldInfo fieldInfo) return fieldInfo.FieldType;
return null;
}
}
public class Item
{
public int Id { get; set; }
}
以及对象的一个实例：
var myItem = new Item { Id = 7 };
你可以使用以下代码来使用表达式获取Id的值：
Expression<Func<Item, int>> exp = x => x.Id;
var me = exp.Body as MemberExpression;
var propInfo = me.Member as PropertyInfo;
var myValue = propInfo.GetValue(myItem, null);
myValue将包含"7"
value 是一个保留标识符。 - Nick GallimoreExpression.Lambda(myParameterlessExpression).Compile().Invoke()存在一些缺点：
.Compile()速度较慢。即使对于小的表达式片段，它也可能需要多毫秒才能完成。但是之后的Invoke调用非常快，对于简单的算术表达式或成员访问，只需要几个纳秒。.Compile()将生成（发出）MSIL代码。这听起来很完美（并解释了优秀的执行速度），但问题在于：该代码占用内存，即使GC收集了委托引用，该内存也不能在应用程序完成前被释放！Compile()来避免这些问题，或者缓存编译后的委托以便重复使用。我的expression-utils库提供了两种方法：对Expressions进行解释和缓存编译，其中所有表达式的常量和闭包都会自动替换为附加参数，然后重新插入到闭包中，并返回给用户。这两个过程都经过了充分测试，在生产中使用，它们各有优缺点，但比Compile()快100倍以上 - 并避免了内存泄漏！q 是一个 List<Product> 类型。该列表没有价格属性 - 只有单个产品有。
第一个或最后一个产品将有一个价格。
q.First().Price
q.Last().Price
q.Single().Price
.ToList()会将其转换为列表。 - Kirk Broadhurstrepo.Products.ToList()绝对是一个List。 - Kirk Broadhurst你能使用以下内容吗：
var price = p.Price;
var q = repo.Products().Where(x=>x.Price == price).ToList()
var valueOfPrice = q[0].Price;
Expression<Func<T>>的无参表达式expr（例如expr包含表达式() => myObj），那么一行代码object exprValue = expr.Compile()();就可以搞定了。之后再将其转换成所需的类型。在某些情况下非常有用。 - Matt