c# - 告诉编译器通用类型存在隐式转换

Question

考虑下面的代码；

class SomeType1
{
}

class SomeType2
{
}

class CombinedType
{
    public static implicit operator CombinedType(SomeType1 source)
    {
        return new CombinedType
        {
            ...
        };
    }

    public static implicit operator CombinedType(SomeType2 source)
    {
        return new CombinedType
        {
            ...
        };
    }
}

void SomeMethod()
{
    var listOfType1 = new List<SomeType1>();
    DoSomethingWith(listOfType1);

    var listOfType2 = new List<SomeType2>();
    DoSomethingWith(listOfType2);
}

void DoSomethingWith<T>(IEnumerable<T> stuff)
{
    IEnumerable<CombinedType> converted = stuff.Select(i => (CombinedType) i);
    ...
}

这失败了

Error CS0030 Cannot convert type 'T' to 'CombinedType'

但是，我知道当 T是 CombinedType或 T时， SomeType1和 SomeType2之间存在隐式转换。我如何告诉编译器应该可行？我不能在通用方法上添加 where T : CombinedType，因为那是不正确的。

Answer 1

隐式转换只是由编译器在编译时插入的方法调用。

例如:

CombinedType c = new SomeType1();

变成:

CombinedType c = CombinedType.op_Implicit(new SomeType1());

JIT不具备插入这些方法调用的知识。但是，泛型在JIT时(即您希望这种情况发生时)进行扩展。

别忘了您的代码还允许某人传递不可转换为 T的 CombinedType。

但是，您有一些选择。

一种是:

void DoSomethingWith<T>(IEnumerable<T> stuff)
{
    IEnumerable<CombinedType> converted = stuff.Select(i => i switch
    {
        SomeType1 s1 => (CombinedType)s1,
        SomeType2 s2 => (CombinedType)s2,
        _ => throw ...
    });
}

另一个类似于:

public interface IConvertibleToCombinedType
{
    CombinedType ConvertToCombinedType();
}

public class SomeType1 : IConvertibleToCombinedType
{
    // ... or get rid of the implicit conversion, and put the logic here
    public CombinedType ConvertToCombinedType() => this;
}

public class SomeType2 : IConvertibleToCombinedType
{
   ...
}

void DoSomethingWith<T>(IEnumerable<T> stuff) where T : IConvertibleToCombinedType
{
    IEnumerable<CombinedType> converted = stuff.Select(i => ConvertToCombinedType());
    ...
}