C# 参数表达式类型为'；MyClass'；不能用于类型为'；System.Object'；

我构建了一个

Func

类型的表达式树。但当我试图编译它时，我得到了一个异常：

类型为“MyClass”的ParameterExpression不能用于类型为“System.Object”的委托参数

调用对象的类型在运行时之前是未知的

Expression leftFunc, rightFunc;
var x = Expression.Parameter(t);
if (left_element.All(char.IsDigit)) 
    leftFunc = Expression.Constant(int.Parse(left_element));
else 
    leftFunc = Expression.PropertyOrField(x, left_element);
if (right_element.All(char.IsDigit)) 
    rightFunc = Expression.Constant(int.Parse(right_element));
else 
    rightFunc = Expression.PropertyOrField(x, right_element);
var result = Expression.Lambda<Func<object, bool>>(
        Expression.GreaterThan(leftFunc, rightFunc), x); //exception thrown on this line
return result;

表达式leftFunc，righfunc；
var x=表达式参数（t）；
if（左_元素全部（字符为数字））
leftFunc=Expression.Constant（int.Parse（left_元素））；
其他的
leftFunc=Expression.PropertyOrField（x，left_元素）；
if（右_元素全部（字符为数字））
rightFunc=Expression.Constant（int.Parse（right_元素））；
其他的
rightFunc=Expression.PropertyOrField（x，right\u元素）；
var result=Expression.Lambda(
表达式.GreaterThan（leftFunc，rightFunc），x）//此行上引发异常
返回结果；

---

x

属于

MyClass

类型，我可以以某种方式使用转换器吗

阅读评论后更新

完整代码，工作：

void Main()
{
    var method = something(typeof(MyClass), "propA", "propB");
    var classes = new List<MyClass>();
    classes.Add(new MyClass { propA = 1, propB = 2 }); // Should return false
    classes.Add(new MyClass { propA = 3, propB = 2 }); // Should return true
    classes.Add(new MyClass { propA = 2, propB = 2 }); // Should return false
    var res = classes.Where(method);
    res.Dump(); //Only class with propA = 3 && propB == 2 is returned
}

private Func<object, bool> something(Type t, string left_element, string right_element)
{
    var props = t.GetProperties();
    return (onObject) => {
        int left_int;
        object leftSide;
        if (!int.TryParse(left_element, out left_int))
        {
            leftSide = props.FirstOrDefault (p => p.Name == left_element).GetValue(onObject);
        } else {
            leftSide = left_int;
        }

        int right_int;
        object rightSide;
        if (!int.TryParse(right_element, out right_int))
        {
            rightSide = props.FirstOrDefault (p => p.Name == right_element).GetValue(onObject);
        } else {
            rightSide = left_int;
        }

        return Comparer.Default.Compare(leftSide, rightSide) > 0;       
    };
}

private class MyClass {
    public int propA {get;set;}
    public int propB {get;set;}
}

void Main（）
{
var方法=某物（typeof（MyClass），“propA”，“propB”）；
var classes=新列表（）；
Add（newmyclass{propA=1，propB=2}）；//应返回false
Add（新的MyClass{propA=3，propB=2}）；//应该返回true
Add（newmyclass{propA=2，propB=2}）；//应返回false
var res=类别。其中（方法）；
res.Dump（）；//只返回propA=3&&propB=2的类
}
private Func something（类型t，字符串左\u元素，字符串右\u元素）
{
var props=t.GetProperties（）；
返回（onObject）=>{
int左_int；
对象左侧；
if（！int.TryParse（left_元素，out left_int））
{
leftSide=props.FirstOrDefault（p=>p.Name==left_元素）.GetValue（onObject）；
}否则{
leftSide=left_int；
}
右内；
对象右侧；
if（！int.TryParse（right_元素，out right_int））
{
rightSide=props.FirstOrDefault（p=>p.Name==right\u元素）.GetValue（onObject）；
}否则{
右侧=左侧；
}
返回Comparer.Default.Compare（左侧、右侧）>0；
};
}
私有类MyClass{
公共int-propA{get；set；}
公共int propB{get；set；}
}

我以为你会期待这样的事情。我使用泛型类型来避免参数异常

Expression Example<T>(T customeType)
{
    Expression leftFunc, rightFunc;
    var x = Expression.Parameter(typeof(T), "x");

    string left_element = "Length";
    string right_element = "Length";

    if (left_element.All(char.IsDigit))
        leftFunc = Expression.Constant(int.Parse(left_element));
    else
        leftFunc = Expression.PropertyOrField(x, left_element);
    if (right_element.All(char.IsDigit))
        rightFunc = Expression.Constant(int.Parse(right_element));
    else
        rightFunc = Expression.PropertyOrField(x, right_element);
    var result = Expression.Lambda<Func<T, bool>>(
            Expression.GreaterThan(leftFunc, rightFunc), x); 
    return result;
}

表达式示例（T customeType）
{
表达式leftFunc，righfunc；
var x=表达式参数（typeof（T），“x”）；
字符串left_element=“Length”；
字符串右键\u element=“Length”；
if（左_元素全部（字符为数字））
leftFunc=Expression.Constant（int.Parse（left_元素））；
其他的
leftFunc=Expression.PropertyOrField（x，left_元素）；
if（右_元素全部（字符为数字））
rightFunc=Expression.Constant（int.Parse（right_元素））；
其他的
rightFunc=Expression.PropertyOrField（x，right\u元素）；
var result=Expression.Lambda(
表达式.GreaterThan（leftFunc，rightFunc），x）；
返回结果；
}

这样，我得到的“MyProperty”不是else leftFunc assignment（left_element=“MyProperty”）上类型为“System.Object”的成员，然后转到相反的方向。将parameter语句更改回原处，并将Lambda语句更改为

Expression。Lambda

MyClass在编译时之前是未知的，它可以是任何内容。您绝对需要使用

Expression

？在这种情况下，通过简单的反射实现这一点要容易得多。我的目标是使用表达式过滤列表