为什么使用隐式转换运算符的自定义结构上的 Assert.AreEqual 会失败?

Why does Assert.AreEqual on custom struct with implicit conversion operator fail?

我创建了一个自定义结构来表示金额。它基本上是 decimal 的包装器。它有一个隐式转换运算符将其转换回 decimal.

在我的单元测试中,我断言金额等于原始十进制值,但测试失败。

[TestMethod]
public void AmountAndDecimal_AreEqual()
{
    Amount amount = 1.5M;

    Assert.AreEqual(1.5M, amount);
}

当我使用 int 时(我没有为其创建转换运算符),测试 成功。

[TestMethod]
public void AmountAndInt_AreEqual()
{
    Amount amount = 1;

    Assert.AreEqual(1, amount);
}

当我悬停 AreEqual 时,它显示第一个解析为

public static void AreEqual(object expected, object actual);

第二个导致

public static void AreEqual<T>(T expected, T actual);

看起来 int1 隐式转换为 Amount,而 decimal1.5M 不是。

我不明白为什么会这样。我本以为恰恰相反。第一个单元测试应该能够将 decimal 转换为 Amount.

当我向 int 添加隐式转换时(这没有意义),第二个单元测试也失败了。所以添加隐式转换运算符会破坏单元测试。

我有两个问题:

  1. 对此行为的解释是什么?
  2. 如何修复 Amount 结构,以便两个测试都能成功?

(我知道我可以更改测试以进行显式转换,但如果我不是绝对必须这样做,我不会)

我的金额结构(只是显示问题的最小实现)

public struct Amount
{
    private readonly decimal _value;

    private Amount(decimal value)
    {
        _value = value;
    }

    public static implicit operator Amount(decimal value)
    {
        return new Amount(value);
    }

    public static implicit operator decimal(Amount amount)
    {
        return amount._value;
    }
}

当您可以双向转换 implicit 时,就会发生不好的事情,这就是一个例子。

由于隐式转换,编译器能够选择具有相等值的 Assert.AreEqual<decimal>(1.5M, amount);Assert.AreEqual<Amount>(1.5M, amount);。*

因为它们相等,所以不会通过推理选择任何重载。

由于没有可通过推理选择的过载,因此也没有进入选择最佳匹配的列表,只有 (object, object) 形式可用。所以就选了这个。

使用 Assert.AreEqual(1, amount) 那么因为存在从 intAmount 的隐式转换(通过隐式 int->decimal)但没有从 Amountint 编译器认为 "obviously they mean the Assert.AreEqual<Amount>() here"†,所以它被选中。

您可以使用 Assert.AreEqual<Amount>()Assert.AreEqual<decimal>() 明确选择重载,但您最好将其中一个转换 "narrowing" 设为 explicit 如果可能的话,因为你的结构的这个特性会再次伤害你。 (单元测试发现缺陷万岁)。


*另一个有效的重载选择是选择 Assert.AreEqual<object>,但它从未被推理选择,因为:

  1. 两个被拒绝的重载都被认为更好。
  2. 它总是被采用 object 的非泛型形式打败。

因此,它只能通过在代码中包含 <object> 来调用。

†编译器将对它所说的一切都视为意义明显或完全无法理解。也有这样的人。