C# 中的表达式树和惰性求值

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)
);

这总是导致 System.InvalidOperationException，大概是因为它尝试了两种转换。我发现第二种风格写起来更直观，所以这很不幸。

我可以用一种将评估推迟到实际需要值时的方式来编写吗？

Answer 1

表达式将代码表示为数据，这里不计算真假分支；它不是 "attempting both conversions"。相反，它试图构建一个表示每个转换的表达式树。但是，作为 Constant 的条件正在根据类型急切地融入条件。

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

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

当 T 是 int 时（因此 "Test" 是常量 true）这不会编译，因为 [=16= 没有有效的转换] 到 int，即使在运行时它总是 evaluate/execute 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 的 "correct" 转换策略，而无需尝试 compile/evaluate 另一个。如果这对您不起作用，我怀疑这是因为所涉及的类型没有从 string.

定义的显式转换

顺便说一句，我不鼓励重复使用 paramValue 作为原始（未转换的）值和转换后的值，除其他外，它使调试变得比需要的困难得多。

Answer 2

通常调试就像新闻...在新闻中有 five Ws: who, what, where, when, why (plus 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;

那肯定是违法的！即使是 "dead" 代码（无法到达的代码）在 .NET 中（在其 IL 语言中）也必须是 "compilable"。所以你的错误是试图在你的表达式中引入一些非法的死代码，那就是：

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

这不会在 C# 中编译，甚至可能无法用 IL 代码编写。然后表达式类抛出它。

C# 中的表达式树和惰性求值

Expression trees and lazy evaluation in C#

c#

expression-trees

lazy-evaluation