Question

我有一些代码，我使用字符串数组并将特定的索引转换为目标类型。我可以通过调用ParameterExpression（如果类型为基本类型）或尝试进行原始转换（希望转换为字符串或隐式字符串）来实现此目的。

Parse

这行得通，但是我正试图重写条件代码。

static Expression ParseOrConvert(ParameterExpression strArray, ConstantExpression index, ParameterInfo paramInfo)
{
    Type paramType = paramInfo.ParameterType;

    Expression paramValue = Expression.ArrayIndex(strArray, index);

    if (paramType.IsPrimitive) {
        MethodInfo parseMethod = paramType.GetMethod("Parse", new[] { typeof(string) });
        // Fetch Int32.Parse(), etc.

        // Parse paramValue (a string) to target type
        paramValue = Expression.Call(parseMethod, paramValue);
    }
    else {
        // Else attempt a raw conversion
        paramValue = Expression.Convert(paramValue, paramType);
    }

    return paramValue;
}

这总是产生paramValue = Expression.Condition( Expression.Constant(paramType.IsPrimitive), Expression.Call(parseMethod, paramValue), Expression.Convert(paramValue, paramType) );，大概是因为它尝试了两次转换。我发现第二种书写方式更直观，所以很不幸。

我可以用这种方式将评估推迟到实际需要这些值的时间吗？

Answer 1

通常调试就像新闻业...在新闻业中，有five Ws：谁，什么，其中，< em> when ， why （加上 how ）..和在编程中类似。谁引发异常（即什么）？让我们使代码更易于调试：

static Expression ParseOrConvert(ParameterExpression strArray, ConstantExpression index, ParameterInfo paramInfo)
{
    Type paramType = paramInfo.ParameterType;

    Expression paramValue = Expression.ArrayIndex(strArray, index);
    MethodInfo parseMethod = paramType.GetMethod("Parse", new[] { typeof(string) });

    var isPrimitive = Expression.Constant(paramType.IsPrimitive);
    var call = Expression.Call(parseMethod, paramValue);
    var convert = Expression.Convert(paramValue, paramType);

    var paramValue2 = Expression.Condition(
        isPrimitive,
        call,
        convert
    );

    return paramValue2;
}

然后像这样调用它：

public static void MyMethod(int par1)
{
}

然后

ParameterExpression strArray = Expression.Parameter(typeof(string[]));

// paramType int
var paramInfo = typeof(Program).GetMethod("MyMethod").GetParameters()[0];

var result = ParseOrConvert(strArray, Expression.Constant(0), paramInfo);

现在... 谁引发异常？ Expression.Convert(paramValue, paramType)引发异常... 为什么？因为您正在尝试执行以下操作：

string paramValue = ...;
convert = (int)paramValue;

那肯定是非法的！甚至“死”代码（无法访问的代码）也必须在.NET中（其IL语言）“可编译”。因此，您的错误是试图在表达式中引入一些非法的无效代码，即：

string paramValue = ...;
isPrimitive = true ? int.Parse(paramValue) : (int)paramValue;

这不会在C＃中编译，甚至可能无法用IL代码编写。然后，Expression类就扔了。

Answer 2

表达式将代码表示为数据，此处不评估true和false分支；它不是“尝试两次转换”。相反，它正在尝试构建一个表示每次转换的表达式树。但是，作为条件Constant的条件会根据类型急切地放入条件中。

您正在构建具有以下结构的表达式：

var result = true // <`true` or `false` based on the type T> 
    ? T.Parse(val)
    : (T) val;

当T为int（因此“测试”为常数true）时，由于没有从string到{{ 1}}，即使在运行时它始终会评估/执行int。

当int.Parse(val)为T时，如果Foo同时具有静态Foo方法和显式强制转换运算符，则会进行编译

Parse(string val)

即使它只执行显式强制转换运算符，因为public class Foo { public static Foo Parse(string fooStr) { return default(Foo); } public static explicit operator Foo(string fooStr) { return default(Foo); } }不是原始的。

您的原始代码实际上已经构建了一个表达式，该表达式将使用基于Foo的“正确”转换策略，而无需尝试编译/评估另一个。如果这不适用于您，我怀疑是因为所涉及的类型没有从T定义的显式强制转换。

顺便说一句，我不鼓励将string既用作原始值（未转换）又转换为转换后的值，除其他事项外，它使调试变得比原本需要的困难得多。

C＃中的表达式树和惰性评估

2 个答案: