Question

我试图变得懒惰并在抽象基类中而不是在每个派生的具体类中实现强制转换运算符。我已经成功地投了一条路，但是我无法施展另一条路。我认为这可能是不可能的，但是在放弃之前想要选择集体的思想：

public interface IValueType<T>
{
    T Value{ get; set; }
}

public abstract class ValueType<T> : IValueType<T> {
    public abstract T Value { get; set; }
    public static explicit operator T(ValueType<T> vt) {
        if(vt == null)
            return default(T);
        return vt.Value;
    }

    public static implicit operator ValueType<T>(T val) {
        ValueType<T> vt = new ValueType<T>(); //<--- obviously this won't work as its abstract
        vt.Value = val;
        return vt;
    }
}

Answer 1

您需要引入另一个通用参数来标识具体类型。

类似......

public interface IValueType<T> 
{    
    T Value{ get; set; } 
} 

public abstract class ValueType<T,K> : 
    IValueType<T> where K : ValueType<T,K>,new()
{     
    public abstract T Value { get; set; }     
    public static explicit operator T(ValueType<T,K> vt) 
    {         
        if(vt == null)            
            return default(T);         
        return vt.Value;     
    }      

    public static implicit operator ValueType<T,K>(T val) 
    {         
        K k = new K();
        k.Value = val;
        return k;    
    } 
}

创建具体类

public class Test : ValueType<int,Test>
{
    public override int Value {get;set;}
}

然后

var t = new Test();
t.Value = 99;
int i = (int)t;
Test t2 = (Test)6;

Console.WriteLine(i);
Console.WriteLine(t2);

在通用抽象类中实现强制转换操作符

1 个答案: