c# - 为什么 C# 编译器使用隐式运算符返回的值的父类型来调用重载运算符

Question

我有以下两个类(class):

public class Parent
{
    public static Parent operator +(Parent l, Parent r)
    {
        return new Parent(); //do something meaningful
    }
}

public class Child: Parent
{
    public static Child operator +(Child l, Parent r)
    {
        return new Child(); //do something meaningful, child related
    }
}

然后我有一个使用 implicit 的包装类转换以返回包装的值:

public class Wrapper<T>
{
    private T value;

    public T Value => value;

    public static implicit operator T(Wrapper<T> wrapper)
    {
        return wrapper.value;
    }
}

然后我将 2 组合如下:

public class Usage
{
    private Parent someField;
    private Wrapper<Child> wrappedValue;

    public void UseOperatorWithImplicitConversion()
    {
        //Child sum1 = wrappedValue + someField; //<-- compilation error
        Parent sum2 = wrappedValue + someField;

        Child temp = wrappedValue; //works but defeats the purpose of reduced verbosity
        Child sum3 = temp + someField;
    }
}

我期待 sum1线上类。我查看了生成的 IL，似乎类型在那里:

IL_0001: ldarg.0      // this
IL_0002: ldfld        class Example.Wrapper`1<class Example.Child> Example.Usage::wrappedValue
IL_0007: call         !0/*class Example.Child*/ class Example.Wrapper`1<class Example.Child>::op_Implicit(class Example.Wrapper`1<!0/*class Example.Child*/>)
IL_000c: ldarg.0      // this
IL_000d: ldfld        class Example.Parent Example.Usage::someField
IL_0012: call         class Example.Parent Example.Parent::op_Addition(class Example.Parent, class Example.Parent)
IL_0017: stloc.0      // sum2

虽然 IL_0012调用 op_Addition的 Parent而不是 Child .

有什么我在这里想念的吗？

我正在使用 .NET Framework 4.6.1 C# 7.2

Answer 1

在尝试确定在特定情况下调用哪个运算符重载时，C# 不会考虑每个类中每个可能的用户定义运算符重载。它只考虑在操作数之一的(编译时)类型中定义的运算符重载。它不考虑在任何操作数具有隐式转换的每种类型中定义的运算符。