C#泛型结构体隐式转换问题：如何通过中间包装类转换BCL类型

原始问题 #

我有一个泛型类作为其他包装类的外层包装，这些包装类用于包装特定BCL类。希望实现从原始BCL类通过中间包装类隐式转换到外层泛型类，示例代码如下：

public interface IWrapper<T> { }

public struct IntWrapper : IWrapper<int>
{
    public IntWrapper(int i) { }
}

public struct MainWrapper<T, TW> where TW : IWrapper<T>
{
    public TW field;

    public static implicit operator MainWrapper<T, TW>(int val) 
        => new MainWrapper<T, TW>{field = new IntWrapper(val)}; // 此处报错：IntWrapper无法转换为TW
}

报错原因是编译器无法确定TW就是IntWrapper——泛型约束仅要求TW实现IWrapper<T>，但TW可以是任何满足该约束的类型，因此直接将IntWrapper实例赋值给TW类型的field不合法。

我尝试了以下方法，但均失败：

• 显式转换：(TW)new IntWrapper(val)
• 显式指定返回值类型：new MainWrapper<int, IntWrapper>
• 显式指定转换方法的返回类型：MainWrapper<int, IntWrapper>(int val)

请问是否有可行的实现方式？

更新尝试 #

将隐式转换拆分到中间类型后，代码可以运行，但使用时必须显式转换到中间类，编译器才能识别转换链：

public interface IWrapper<T> { }

public struct IntWrapper : IWrapper<int>
{
    public IntWrapper(int i) { }

    public static implicit operator IntWrapper(int val)
        => new IntWrapper(val);

    public static implicit operator MainWrapper<int, IntWrapper>(IntWrapper val)
        => new MainWrapper<int, IntWrapper> { field = val };
}

public struct MainWrapper<T, TW> where TW : IWrapper<T>
{
    public TW field;
}

public class UseExample
{
    public void Do(MainWrapper<int, IntWrapper> data) { }

    public void Test()
    {
        Do((IntWrapper)1); // 必须显式转换到IntWrapper
    }
}

请问是否可以无需显式转换，让编译器自动识别这条转换链？

核心问题解析 #

C# 编译器不支持串联两个自定义隐式转换（即int → IntWrapper（自定义） + IntWrapper → MainWrapper（自定义）这种两步自定义转换），因此必须通过调整转换逻辑，将两步转换合并为一步可被编译器识别的自定义转换。

可行实现方式 #

通过在外层泛型类MainWrapper<T, TW>中定义从T到MainWrapper<T, TW>的隐式转换，并利用中间包装类TW的隐式转换能力完成内部赋值：

public interface IWrapper<T> { }

public struct IntWrapper : IWrapper<int>
{
    public IntWrapper(int i) { }

    // 保留从BCL类型到中间包装类的隐式转换
    public static implicit operator IntWrapper(int val)
        => new IntWrapper(val);
}

public struct MainWrapper<T, TW> where TW : IWrapper<T>
{
    public TW field;

    // 定义从T到外层包装类的隐式转换
    public static implicit operator MainWrapper<T, TW>(T val)
        => new MainWrapper<T, TW> { field = val };
}

public class UseExample
{
    public void Do(MainWrapper<int, IntWrapper> data) { }

    public void Test()
    {
        Do(1); // 无需显式转换，编译器自动完成int → IntWrapper → MainWrapper的逻辑
    }
}

原理说明 #

1. 当调用Do(1)时，编译器需要将int转换为MainWrapper<int, IntWrapper>，会匹配到MainWrapper<T, TW>中定义的T → MainWrapper<T, TW>隐式转换。
2. 在转换运算符内部，field = val会自动触发IntWrapper中定义的int → IntWrapper隐式转换——这一步是在转换运算符内部完成的，不属于外部的转换链，因此编译器可以正常识别。
3. 最终整个过程对调用者来说是一步隐式转换，无需显式指定中间类型。

替代方案（若无法依赖隐式转换） #

如果中间包装类不适合定义隐式转换，可以通过泛型约束要求TW提供从T构建实例的方式，例如要求TW具有接受T的构造函数（需借助反射实现，因为C#的new()约束仅支持无参构造）：

public struct MainWrapper<T, TW> where TW : IWrapper<T>
{
    public TW field;

    public static implicit operator MainWrapper<T, TW>(T val)
    {
        // 通过反射创建TW实例
        var constructor = typeof(TW).GetConstructor(new[] { typeof(T) });
        if (constructor == null)
            throw new InvalidOperationException($"{typeof(TW)} 缺少接受{typeof(T)}的构造函数");
        
        return new MainWrapper<T, TW> 
        { 
            field = (TW)constructor.Invoke(new object[] { val }) 
        };
    }
}

此方案无需中间包装类定义隐式转换，但依赖反射，性能略低，适合无法修改中间包装类的场景。

内容的提问来源于stack exchange，提问作者ApmeM