当所使用的值可以隐式地转换为两个结构体时，为什么不能使用'

我注意到在应用operator==时，用户定义的隐式转换到int和用户定义的隐式转换到任意结构体MyStruct的行为之间存在差异。

如果我有:

public struct IntA
{
    public IntA(int value)
    { m_value = value; }
    public static implicit operator int(IntA a)
    { return a.m_value; }
    private int m_value;
}
public struct IntB
{
    public IntB(int value)
    { m_value = value; }
    public static implicit operator int(IntB b)
    { return b.m_value; }
    private int m_value;
}

然后编译以下代码:

{
    var a = new IntA(3);
    var b = new IntB(4);
    bool equal = (a == b); // ok! converted to int and used int operator==
    // ...
}

这将使用我的用户定义的implicit operator int将IntA和IntB转换为int，然后调用operator==(int, int)。

但是，如果我有:

public struct MyStruct
{
    public MyStruct(int value)
    { m_value = value; }
    public static bool operator==(MyStruct lhs, MyStruct rhs)
    { return lhs.m_value == rhs.m_value; }
    public static bool operator!=(MyStruct lhs, MyStruct rhs)
    { return lhs.m_value != rhs.m_value; }
    private int m_value;
}
public struct MyStructA
{
    public MyStructA(int value)
    { m_value = new MyStruct(value); }
    public static implicit operator MyStruct(MyStructA a)
    { return a.m_value; }
    private MyStruct m_value;
}
public struct MyStructB
{
    public MyStructB(int value)
    { m_value = new MyStruct(value); }
    public static implicit operator MyStruct(MyStructB b)
    { return b.m_value; }
    private MyStruct m_value;
}

那么以下代码不能编译:

{
    var a = new MyStructA(3);
    var b = new MyStructB(4);
    bool equal = (a == b); // compile error: Operator `==' cannot be applied to operands of type `MyStructA' and `MyStructB'
                           // why can't it convert to MyStruct and use that operator==?
    // ...
}

我希望它与前面的示例一样，使用用户定义的implicit operator MyStruct转换为MyStruct，然后调用operator==(MyStruct, MyStruct)。

它不会那样做。为什么不呢?从编译器的角度来看，这两种情况有什么不同?