C# Linq表达式->；使用枚举类型创建具有等于的CallExpression

我正在尝试构建一个

调用表达式

，比如：

f.Equals(s);

其中，

f

和

t

是

enum SType

所以

var equalsMethod=typeof（SType）.GetMethod（“等于”，新[]{typeof（SType）}）；
ConstantExpression ConstantExpression=表达式.常量（值，类型（SType））；
var newBody=Expression.Call（expr.Body，equalsMethod，constantExpression）；
返回表达式Lambda（newBody，expr.Parameters）；

我不知道，但是

equalsMethod

是

Boolean Equals（System.Object）

而不是

Boolean Equals（SType）

因此，当我想构建

调用表达式时，

.Net告诉我，我不能使用

类型SType

的表达式作为

方法的
Boolean Equals（System.Object）
类型
System.Object
的参数

怎么了？
当您调用
f.Equals（s）
时，您实际上在做：

f.Equals((object)s)

。。。因为
Enum
和
ValueType
不会重载
等于
。因此，基本上您需要在其中进行转换，并且您可以更清楚地了解您正在调用的
Equals
方法：

var equalsMethod = typeof(object).GetMethod("Equals", new[] { typeof(object) });
var constant = Expression.Constant(value, typeof(SType));
var boxed = Expression.Convert(constant, typeof(object));
var newBody = Expression.Call(expr.Body, equalsMethod, boxed);
return Expression.Lambda<Func<TEntity, bool>>(newBody, expr.Parameters);

var equalsMethod=typeof（object）.GetMethod（“Equals”，new[]{typeof（object）}）；
var常量=表达式常量（值，类型（SType））；
var boxed=Expression.Convert（常量，typeof（object））；
var newBody=Expression.Call（expr.Body，equalsMethod，已装箱）；
返回表达式Lambda（newBody，expr.Parameters）；

诚然，您可以避免单独的步骤，只需：

var equalsMethod = typeof(object).GetMethod("Equals", new[] { typeof(object) });
// Let this do the boxing for you...
var constant = Expression.Constant(value, typeof(object));
var newBody = Expression.Call(expr.Body, equalsMethod, constant);
return Expression.Lambda<Func<TEntity, bool>>(newBody, expr.Parameters);

var equalsMethod=typeof（object）.GetMethod（“Equals”，new[]{typeof（object）}）；
//让这个为你做拳击。。。
变量常量=表达式常量（值，类型（对象））；
var newBody=Expression.Call（expr.Body，equalsMethod，常量）；
返回表达式Lambda（newBody，expr.Parameters）；

我没有试过，但我怀疑它会很好地工作。
当你调用
f.Equals（s）
时，你真的在做：

f.Equals((object)s)

。。。因为
Enum
和
ValueType
不会重载
等于
。因此，基本上您需要在其中进行转换，并且您可以更清楚地了解您正在调用的
Equals
方法：

var equalsMethod = typeof(object).GetMethod("Equals", new[] { typeof(object) });
var constant = Expression.Constant(value, typeof(SType));
var boxed = Expression.Convert(constant, typeof(object));
var newBody = Expression.Call(expr.Body, equalsMethod, boxed);
return Expression.Lambda<Func<TEntity, bool>>(newBody, expr.Parameters);

var equalsMethod=typeof（object）.GetMethod（“Equals”，new[]{typeof（object）}）；
var常量=表达式常量（值，类型（SType））；
var boxed=Expression.Convert（常量，typeof（object））；
var newBody=Expression.Call（expr.Body，equalsMethod，已装箱）；
返回表达式Lambda（newBody，expr.Parameters）；

诚然，您可以避免单独的步骤，只需：

var equalsMethod = typeof(object).GetMethod("Equals", new[] { typeof(object) });
// Let this do the boxing for you...
var constant = Expression.Constant(value, typeof(object));
var newBody = Expression.Call(expr.Body, equalsMethod, constant);
return Expression.Lambda<Func<TEntity, bool>>(newBody, expr.Parameters);

var equalsMethod=typeof（object）.GetMethod（“Equals”，new[]{typeof（object）}）；
//让这个为你做拳击。。。
变量常量=表达式常量（值，类型（对象））；
var newBody=Expression.Call（expr.Body，equalsMethod，常量）；
返回表达式Lambda（newBody，expr.Parameters）；

我没有试过，但我怀疑它会很好地工作。
Jon已经描述了你的代码有什么问题。但是，我想知道为什么您要费心创建
MethodCallExpression
到
Equals
方法，而有一种专门的方法（准确地说，是用于进行相等比较的）：

返回表达式.Lambda(
Expression.Equal（expr.Body，Expression.Constant（value）），
表达式参数）；
乔恩已经描述了你的代码有什么问题。但是，我想知道为什么您要费心创建
MethodCallExpression
到
Equals
方法，而有一种专门的方法（准确地说，是用于进行相等比较的）：

返回表达式.Lambda(
Expression.Equal（expr.Body，Expression.Constant（value）），
表达式参数）；
注意
Expression.Equal
是对
操作符==
的调用，而不是
Equals
。如果对表达式进行编译，则不能保证它们是等效的，但强烈建议使用。如果表达式用于EntityFramework/LinqToSql查询，则它们的翻译相同。请注意，
expression.Equal
是对
操作符==
的调用，而不是对
Equals
的调用。如果对表达式进行编译，则不能保证它们是等效的，但强烈建议使用。如果在EntityFramework/LinqToSql查询中使用该表达式，则它们的转换方式相同。