c# - 32 位隐式转换无法通过通用重载解析

Question

我正在试验自定义整数类型，遇到了一个涉及泛型、隐式转换和 32 位整数的有趣问题。

以下是如何重现问题的精简示例。如果我有两个隐式方法将int转换为MyInt，反之亦然，我会得到一个编译错误，看起来像C#无法解决要使用的通用类型。而且它只发生 int 或 uint。所有其他整数类型都可以正常工作:sbyte、byte、short、ushort、long,乌龙。

如果我删除其中一种隐式转换方法，它也可以正常工作。与循环隐式转换有关？

using Xunit;

public class MyInt
{
    public int Value;

    //If I remove either one of the implicit methods below, it all works fine.
    public static implicit operator int(MyInt myInt)
    {
        return myInt.Value;
    }
    public static implicit operator MyInt(int i)
    {
        return new MyInt() { Value = i };
    }

    public override bool Equals(object obj)
    {
        if (obj is MyInt myInt)
        {
            return this.Value == myInt.Value;
        }
        else
        {
            int other_int = (int)obj;
            return Value == other_int;
        }
    }
}

下面是测试代码，显示了定义两个隐式方法时出现的编译错误。

public class Test
{
    [Fact]
    public void EqualityTest()
    {
        MyInt myInt = new MyInt();
        myInt.Value = 4 ;

        Assert.Equal(4, myInt.Value);   //Always OK which makes sense

        //Compile errors when both implicit methods defined:
        //  Error CS1503  Argument 1: cannot convert from 'int' to 'string', 
        //  Error CS1503  Argument 2: cannot convert from 'ImplicitConversion.MyInt' to 'string'
        Assert.Equal(4, myInt);
    }
}

我相信 C# 提示无法将两种类型都转换为字符串，因为这是最后一个 Xunit.Assert.Equal() 重载的类型，而所有其他类型都无法匹配:

    //Xunit.Assert.Equal methods:
    public static void Equal<T>(T expected, T actual);
    public static void Equal(double expected, double actual, int precision);
    public static void Equal<T>(T expected, T actual, IEqualityComparer<T> comparer);
    public static void Equal(decimal expected, decimal actual, int precision);
    public static void Equal(DateTime expected, DateTime actual, TimeSpan precision);
    public static void Equal<T>(IEnumerable<T> expected, IEnumerable<T> actual, IEqualityComparer<T> comparer);
    public static void Equal<T>(IEnumerable<T> expected, IEnumerable<T> actual);
    public static void Equal(string expected, string actual, bool ignoreCase = false, bool ignoreLineEndingDifferences = false, bool ignoreWhiteSpaceDifferences = false);
    public static void Equal(string expected, string actual);

我不认为我在隐式转换上犯了错误，因为我可以进行其他 similar examples与 32 位整数一起使用时会产生相同的问题。

我正在 .NET Core 3.0 项目中进行测试。

如有任何帮助，我们将不胜感激。谢谢!

澄清:我想知道的是为什么这只对 32 位整数失败。当类型与下面使用 long 的示例类似时，隐式转换有效(通过调试确认)。

using Xunit;

public class MyLong
{
    public long Value;

    public static implicit operator long(MyLong myInt)
    {
        return myInt.Value;
    }
    public static implicit operator MyLong(long i)
    {
        return new MyLong() { Value = i };
    }

    public override bool Equals(object obj)
    {
        if (obj is MyLong myInt)
        {
            return this.Value == myInt.Value;
        }
        else
        {
            long other_int = (long)obj;
            return Value == other_int;
        }
    }
}

public class Test2
{
    [Fact]
    public void EqualityTest()
    {
        MyLong myLong = new MyLong();
        myLong.Value = 4 ;
        Assert.Equal(4, myLong); //NOTE! `4` is implicitly converted to a MyLong 
                                 //object for comparison. Confirmed with debugging.
    }
}

Answer 1

Something to do with circular implicit conversions?

是的(不过，您已经通过证明在消除其中一个转化时它工作正常来证明了这一点)。

int 发生这种情况的原因，而不是其他类型，是你的文字类型是 int .这意味着在重载解析期间，编译器可以选择任何一种方式:convert int至 MyInt , 或转换 MyInt至 int .这两种选择都不明显比另一种“更好”，因此这些转换都没有考虑在内。

然后，在排除了该方法的最接近可能的通用版本之后，在剩余的可用重载中，唯一剩下的是 Equal(string, string)。重载(唯一剩下两个参数的是 Equal<T>(IEnumerable<T>, IEnumerable<T>) ，根据重载解析规则，它比 Equal(string, string) 重载“更差”)。找到一个明显比其他方法“更好”的方法后，编译器会尝试将该方法与您的参数一起使用，当然这些参数不适合，从而导致发出错误。

另一方面……

当您尝试调用 Equal(4, myLong) 时，你有两个不兼容的类型。类型为 int 的文字, 和 MyLong值(value)。在这种情况下，编译器一个一个地尝试每个参数，并发现当它使用 MyLong 时type 作为类型参数，可以提升 int文字到 long然后将其隐式转换为 MyLong .但它不能走另一条路。无法选择 int作为通用类型参数，因为 MyLong无法隐式转换为 int .所以在这种情况下， 有一个“更好”的重载可供选择，所以它被选中了。

通过显式指定文字的类型，您可以尝试不同的组合，并在工作中看到这种模式。首先，我更喜欢使用更简单的包装类进行测试:

public class Wrapper<T>
{
    public T Value;

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

然后试试这些:

Wrapper<int> w1 = new Wrapper<int> { Value = 4 };
Wrapper<long> w2 = new Wrapper<long> { Value = 4 };

Assert.Equal(4, w1);        // error
Assert.Equal((short)4, w1); // no error
Assert.Equal(4, w2);        // no error
Assert.Equal(4L, w2);       // error

唯一使 int 成为可能的东西特别之处在于这是数字文字的默认类型。否则，包装 int 的类型与包装其他任何内容的类型的工作方式完全相同。只要两个参数之间只能在一个方向上进行转换，一切都很好。但是当双向都可以转换时，编译器只好举手放弃。