为什么 C# 编译器不调用隐式强制转换运算符？

Question

假设我们有以下类型：

struct MyNullable<T> where T : struct
{
    T Value;

    public bool HasValue;

    public MyNullable(T value)
    {
        this.Value = value;
        this.HasValue = true;
    }

    public static implicit operator T(MyNullable<T> value)
    {
        return value.HasValue ? value.Value : default(T);
    }
}

并尝试编译以下代码片段：

MyNullable<int> i1 = new MyNullable<int>(1);
MyNullable<int> i2 = new MyNullable<int>(2);

int i = i1 + i2;

这个片段编译得很好并且没有错误。 i1 和 i2 转换为整数并计算加法。

但是，如果我们有以下类型：

struct Money
{
    double Amount;
    CurrencyCodes Currency; /*enum CurrencyCode { ... } */

    public Money(double amount, CurrencyCodes currency)
    {
        Amount = amount;
        Currency = currency;
    }

    public static Money operator + (Money x, Money y)
    {
        if (x.Currency != y.Currency)
            // Suppose we implemented method ConvertTo
            y = y.ConvertTo(x.Currency); 

        return new Money(x.Amount + y.Amount, x.Currency);
    }
}

尝试编译另一个代码片段：

MyNullable<Money> m1 = 
   new MyNullable<Money>(new Money(10, CurrenciesCode.USD));
MyNullable<Money> m2 = 
   new MyNullable<Money>(new Money(20, CurrenciesCode.USD));

Money m3 = m1 + m2;

现在的问题是，为什么编译器会生成“错误 CS0019：运算符 '+' 无法应用于类型 'MyNullable' 的操作数” 和“MyNullable””？

Answer 1

这是一个有趣的问题......例如，它适用于 Decimal，但不适用于 TimeSpan，它们都是正确的 .NET 类型（与 float 不同） > 等是原语）并且都有一个 + 运算符。 好奇的！

当然，您可以使用以下方法扭转手臂：

Money m3 = (Money)m1 + (Money)m2;

如果您只使用 Nullable ，它当然可以免费工作 - 而且您还可以获得编译器 + 运行时（装箱）支持。 是否有理由不在这里使用 Nullable ？

我会看一下规格； 在此期间，您可能会考虑将运算符提升为 MyNullable； 对于常规 Nullable，C# 编译器为类型支持的运算符提供“提升”运算符，但您自己无法执行此操作。 您能做的最好的事情就是提供所有明显的操作符，并希望类型支持它；-p 要使用泛型访问运算符，请参阅 此处，可免费下载

请注意，您可能希望应用适当的“提升”检查 - 即

x + y => (x.HasValue && y.HasValue)
          ? new MyNullable<T>(x.Value + y.Value)
          : new MyNullable<T>();

更新

不同的处理看起来与 14.7.4 (ECMA 334 v4)“加法运算符”相关，其中它是预定义的对于一系列类型包括十进制（所以这是我的一个糟糕的测试），因为到14.2.4（相同）“二元运算符重载解析”，预定义运算符确实得到了特别提及。 不过，我并不声称完全理解它。

Answer 2

Marc 的观点是正确的 - 这是 C# 3.0 规范中的第 7.2.4 节 - 二元运算符重载解析。

基本上步骤是：

• 我们需要解决“X + Y”的实现，其中 X 和 Y 都是 MyNullable。
• 查看第 7.2.5 节（候选用户定义运算符），我们最终得到一个空集，因为 MyNullable 不会重载 +。
• 回到 7.2.4，候选运算符集是 + 的内置二元运算符集，即 int+int、decimal+decimal 等。
• 然后应用 7.4.3 中的重载解析规则。 当我们执行 MyNullable时 + MyNullable 之所以有效，是因为每个参数都隐式转换为 int - 但是当我们执行 MyNullable时， + MyNullable 它不起作用，因为 Money + Money 不在候选运算符集中。