摘要通用隐式转换为派生类型，错误？

Question

假设以下定义抽象类型A：

public abstract class A<T, J> : where J : A<T, J>, new()
{
    public virtual T Value { get; set; }

    //Error: User-defined conversion must convert to or from the enclosing type
    public static implicit operator J(T value)
    {
        return new J
        {
            Value = value
        };
    }
}

隐式运算符导致编译器发出错误“用户定义的转换必须转换为封闭类型或从封闭类型转换”。

隐式运算符转换为封闭类型的派生类型。 这是C＃的错误还是限制？

我试图将T型拳击概括为J.

更新：

继续该错误，我尝试了以下内容：

public abstract class A<T, J> : where J : Primary<T, J>, new()
{
    public virtual T Value { get; set; }

    public static implicit operator A<T, J>(T value)
    {
        return new J
        {
            Value = value
        };
    }

    public static implicit operator J(A<T, J> value)
    {
        return value as J;
    }
}

这确实可以防止编译器错误（如预期的那样），尽管它会强制显式转换。 这是不可取的。

基本上，我希望能够做到以下几点：

public class B { }

public class C : A<B, C> 
{ 
    public C Foo(B b)
    {
        return b;
    }
}

上面的任何其他替代方案都提供了一般类型的隐式装箱？

Answer 1

使你的班级A<T, J>工作的最接近的是：

public class A<T, J> where J : A<T, J>, new()
{
    public virtual T Value { get; set; }

    public static implicit operator A<T, J>(T value)
    {
        return new A<T, J>
        {
            Value = value
        };
    }
}

但是只要你标记这个abstract它就会因为new A<T, J>而无效。 所以这就是能够依赖于where J : A<T, J>, new()来表示你正在创建派生类型的地方。 但那不再是有效的c＃语法。

最重要的是，你不能做你希望做的隐式转换。

您可以进行显式转换：

public abstract class A<T, J> where J : A<T, J>, new()
{
    public virtual T Value { get; set; }

    public static J Convert(T value)
    {
        return new J
        {
            Value = value
        };
    }
}

现在这可行：

public class B { }

public class C : A<B, C> 
{ 
    public C Foo(B b)
    {
        return C.Convert(b);
    }
}

结果代码中的净差异非常小，但您必须进行显式转换（这对于代码可读性和维护来说并不是一件坏事。）