43

描述

我有一个表达式指向我的类型的属性。但它不适用于每种属性类型。“不意味着”意味着它会导致不同的表达类型。我认为它会导致结果， MemberExpression但事实并非如此。

For intandGuid它导致 aUnaryExpression和 forstring 在 a 中MemberExpression。

我有点困惑 ;）

一些示例代码

我的课

public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }
}

测试代码

Person p = new Person { Age = 16, Name = "John" };

Expression<Func<Person, object>> expression1 = x => x.Age;
// expression1.Body = UnaryExpression;

Expression<Func<Person, object>> expression2 = x => x.Name;
// expression2.Body = MemberExpression;

问题

我如何比较两个表达式并检查它们是否意味着相同的类型和相同的属性？

更新、回答并完成示例

感谢用户dasblinkenlight让我走上了正轨。

他提供了方法

private static MemberExpression GetMemberExpression<T>(
    Expression<Func<T,object>> exp
) {
    var member = expr.Body as MemberExpression;
    var unary = expr.Body as UnaryExpression;
    return member ?? (unary != null ? unary.Operand as MemberExpression : null);
}

我编写了以下扩展方法来比较方法的结果GetMemberExpression 并检查是否GetMemberExpression().Member.Name相同。

private static bool IsSameMember<T>(this Expression<Func<T, object>> expr1, Expression<Func<T, object>> expr2)
{
    var result1 = GetMemberExpression(expr1);
    var result2 = GetMemberExpression(expr2);

    if (result1 == null || result2 == null)
       return false;

    return result1.Member.Name == result2.Member.Name;
}
4

2 回答 2

81

发生这种情况的原因是它Age是一个值类型。为了将返回值类型的表达式强制转换Func<Person,object>到编译器中，需要插入 a Convert(expr, typeof(object))、 a UnaryExpression。

然而，对于strings 和其他引用类型，不需要装箱，因此返回“直接”成员表达式。

如果你想进入MemberExpression内部UnaryExpression，你可以得到它的操作数：

private static MemberExpression GetMemberExpression<T>(
    Expression<Func<T,object>> exp
) {
    var member = exp.Body as MemberExpression;
    var unary = exp.Body as UnaryExpression;
    return member ?? (unary != null ? unary.Operand as MemberExpression : null);
}
于 2012-10-19T13:38:15.683 回答
6

Member.Name我建议不要比较字符串，而是PropertyInfo直接比较实例是否相等，以避免在不同类中的两个属性共享相同名称时出现误报。

public static bool IsSameProperty<TSourceA, TSourceB, TPropertyA, TPropertyB>(
    Expression<Func<TSourceA, TPropertyA>> expA,
    Expression<Func<TSourceB, TPropertyB>> expB)
{
    MemberExpression memExpA = expA.Body as MemberExpression;
    MemberExpression memExpB = expB.Body as MemberExpression;

    if (memExpA == null || memExpB == null)
        return false;

    PropertyInfo propA = memExpA.Member as PropertyInfo;
    PropertyInfo propB = memExpB.Member as PropertyInfo;

    if (propA == null || propB == null)
        return false;

    return propA.Equals(propB);
}

您可以通过将正确的值类型（而不是）指定为表达式的泛型类型来确保将 lambda 表达式编译为 aMemberExpression而不是简单的 a 。UnaryExpressionobjectTResultExpression<Func<T, TResult>>

Expression<Func<Person, int>> expression1 = x => x.Age;
Expression<Func<Person, int>> expression2 = x => x.Age;
Expression<Func<Person, string>> expression3 = x => x.Name;

Console.WriteLine(IsSameProperty(expression1, expression2));   // True
Console.WriteLine(IsSameProperty(expression1, expression3));   // False
于 2012-10-19T14:57:59.327 回答