Question

这是MiscUtils中的错误还是我错过了什么？

decimal a = (1M/30);
int b = 59;
Assert.AreEqual(a*b, Operator.MultiplyAlternative(a, b));
Assert.AreEqual(b*a, Operator.MultiplyAlternative(b, a));

最后一行失败：

expected: <1.9666666666666666666666666647>
 but was: <0>

更新

正如Petr指出的那样，CreateExpression方法中存在一些强制导致问题的原因。使用编译器时，我们没有看到这样的问题，因为参数被提升到具有最高精度的类型，这也成为返回类型。

第二个'Assert'无论如何都应该失败，因为如果与正常的C＃行为一致，我希望它将第一个参数（b）提升到decimal并执行操作。通常，如果我们想将结果存储到精度较低的类型的变量中，我们需要进行显式转换。但是，由于我们调用的方法具有可能具有较低精度的返回类型，并且调用者已显式调用返回较低精度结果的方法 - 在操作的一部分中自动执行可能截断的强制转换似乎是合理的。换句话说，第二个表达式的预期结果将是1。

因此，我们可以更改CreateExpression以反映该行为，如下所示：

if (castArgsToResultOnFailure && !(         // if we show retry                                                        
        typeof(TArg1) == typeof(TResult) &&  // and the args aren't
        typeof(TArg2) == typeof(TResult)))
{ // already "TValue, TValue, TValue"...
    var ltc = Type.GetTypeCode(lhs.Type);
    var rtc = Type.GetTypeCode(rhs.Type);
    // Use the higher precision element
    if (ltc > rtc)
    {
        // TArg1/TResult is higher precision than TArg2. Simply lift rhs
        var castRhs = Expression.Convert(rhs, lhs.Type);
        return
            Expression.Lambda<Func<TArg1, TArg2, TResult>>(body(lhs, castRhs), lhs, rhs).Compile();
    }
    // TArg2 is higher precision than TArg1/TResult. Lift lhs and Cast result
    var castLhs = Expression.Convert(lhs, rhs.Type);
    var castResult = Expression.Convert(body(castLhs, rhs), lhs.Type);
    return Expression.Lambda<Func<TArg1, TArg2, TResult>>(castResult, lhs, rhs).Compile();
}

因此需要重写第二个断言：

Assert.AreEqual((int)(b*a), Operator.MultiplyAlternative(b, a));

现在两个断言都成功了。和以前一样，根据参数的顺序，将返回不同的结果，但现在第二次调用会产生逻辑上正确的结果。

Answer 1

根据source code，方法签名如下：

public static TArg1 MultiplyAlternative<TArg1, TArg2>(TArg1 value1, TArg2 value2)

和返回类型与第一个参数相同。因此，在第二种情况下，它使用int作为返回类型，并且很可能也将第二个参数转换为该类型，因此59*0为零。

关于您的评论，this part源代码提供了详细信息：

/// <summary>
/// Create a function delegate representing a binary operation
/// </summary>
/// <param name="castArgsToResultOnFailure">
/// If no matching operation is possible, attempt to convert
/// TArg1 and TArg2 to TResult for a match? For example, there is no
/// "decimal operator /(decimal, int)", but by converting TArg2 (int) to
/// TResult (decimal) a match is found.
/// </param>
/// <typeparam name="TArg1">The first parameter type</typeparam>
/// <typeparam name="TArg2">The second parameter type</typeparam>
/// <typeparam name="TResult">The return type</typeparam>
/// <param name="body">Body factory</param>
/// <returns>Compiled function delegate</returns>
public static Func<TArg1, TArg2, TResult> CreateExpression<TArg1, TArg2, TResult>(
        Func<Expression, Expression, BinaryExpression> body, bool castArgsToResultOnFailure)
{
    ParameterExpression lhs = Expression.Parameter(typeof(TArg1), "lhs");
    ParameterExpression rhs = Expression.Parameter(typeof(TArg2), "rhs");
    try
    {
        try
        {
            return Expression.Lambda<Func<TArg1, TArg2, TResult>>(body(lhs, rhs), lhs, rhs).Compile();
        }
        catch (InvalidOperationException)
        {
            if (castArgsToResultOnFailure && !(         // if we show retry
                            typeof(TArg1) == typeof(TResult) &&  // and the args aren't
                            typeof(TArg2) == typeof(TResult)))
            { // already "TValue, TValue, TValue"...
                // convert both lhs and rhs to TResult (as appropriate)
                Expression castLhs = typeof(TArg1) == typeof(TResult) ?
                                (Expression)lhs :
                                (Expression)Expression.Convert(lhs, typeof(TResult));
                Expression castRhs = typeof(TArg2) == typeof(TResult) ?
                                (Expression)rhs :
                                (Expression)Expression.Convert(rhs, typeof(TResult));

                return Expression.Lambda<Func<TArg1, TArg2, TResult>>(
                        body(castLhs, castRhs), lhs, rhs).Compile();
            }
            else throw;
        }
    }
    catch (Exception ex)
    {
        string msg = ex.Message; // avoid capture of ex itself
        return delegate { throw new InvalidOperationException(msg); };
    }
}

您看，Expression.Lambda<Func<TArg1, TArg2, TResult>>(body(lhs, rhs), lhs, rhs).Compile();对TArg1和TArg2 int和decimal的任意组合都失败了（如果您更改{{它实际上有相同的行为}例如{1}}到decimal，因此不仅double受影响了“，然后decimal阻止尝试将两个参数都转换为catch类型，，取决于参数顺序。因此，您在第一种情况下获得所有TResult投射，在第二种情况下获得所有decimal投射。

我不知道如何回答为什么这个lambda编译失败了，这是一个错误或语言限制。

这是MiscUtils中的错误吗？

更新

1 个答案: