1

学习 LINQ 表达式我发现了一个奇怪的行为。请看下面的课程。它可能看起来不是很方便，但这只是一个例子。

class IntTestClass
{
    public int Id { get; private set; }

    Func<IntTestClass, bool> check;

    public IntTestClass(int _id)
    {
        Id = _id;

        Expression<Func<IntTestClass, int>> GetId = tc => tc.Id;

        Expression<Func<int, bool>> e1 = i => i.Equals(Id);
        var equals1 = (e1.Body as MethodCallExpression).Method;
        string s1 = equals1.ToString();
        Console.WriteLine(s1);

        var x1 = Expression.Call(Expression.Constant(Id), equals1, GetId.Body);
        var exp1 = (Expression<Func<IntTestClass, bool>>)
                             Expression.Lambda(x1, GetId.Parameters.ToArray());
        check = exp1.Compile();
    }

    public bool Check(IntTestClass t)
    {
        var result =  check(t);
        Console.WriteLine(result);
        return result;
    }
}

只是为了运行测试，可以使用：

var intTestClass= new IntTestClass(0);
intTestClass.Check(new IntTestClass(0)); //true
intTestClass.Check(new IntTestClass(1)); //false

然后我试图使这个类通用：

class TestClass<T>
{
    public T Id { get; private set; }

    public TestClass(T _Id)
    {
        Id = _Id;

        Expression<Func<TestClass<T>, T>> GetId = tc => tc.Id;

        Expression<Func<T, bool>> e1 = i => i.Equals(Id);
        var equals1 = (e1.Body as MethodCallExpression).Method;
        string s1 = equals1.ToString();
        Console.WriteLine(s1);

        var x1 = Expression.Call(Expression.Constant(Id), equals1, GetId.Body);
        ....
    }
    ....
}

所以当我尝试运行类似的代码时：

 var testClass = new TestClass<int>(0);

它在构造函数中的行初始化变量上抛出异常x1，说

“System.Int32”类型的表达式不能用于“Boolean Equals(System.Object)”方法的“System.Object”类型参数

因此，构造函数中的equals1（包含方法）似乎是MethodInfoEqualsTestClass<T>Boolean Equals(System.Object)

但在IntTestClass构造函数equals1中是Boolean Equals(Int32).

为什么呢？在运行时的泛型类中T是System.Int32. 为什么e1变量中的表达式使用Equals来自System.Object类，而不是来自System.Int32？

4

1 回答 1

2

嗯，这是因为手动构建表达式树需要技巧知识，当您编写常规代码时，编译器会为您完成。

您可以通过两种方式解决此特定问题：

1) 将-int表达式转换为object-表达式：

var x1 = Expression.Call(Expression.Constant(Id), equals1, Expression.Convert(GetId.Body, typeof(object)));

这将为Object.Equals方法参数添加转换代码，反过来，当您调用已编译的 lambda 时，该代码将提供装箱。

2）对您的泛型施加约束：

class TestClass<T>
    where T : IEquatable<T>
{
}

并留下这一行：

var x1 = Expression.Call(Expression.Constant(Id), equals1, GetId.Body);

不变。

这里的约束有助于说明，您将使用IEquatable<T>.Equals(T)而不是Object.Equals. IEquatable<T>.Equals(T)不需要任何参数转换，因为它本身就是通用的。

于 2013-11-12T05:53:36.883 回答