抽象泛型类采用本身派生自该类的类型参数

Question

你认为创建一个抽象的泛型类是可以接受的还是不好的做法？

这允许抽象泛型类操作派生类的实例，特别是能够根据需要创建派生类的 new() 实例，并有助于避免在派生自它的具体类中重复代码.

如果“不好”，你更喜欢用什么替代方法来处理这种情况，你会如何构造下面的代码？

例如：-

    // We pass both the wrapped class and the wrapping class as type parameters 
    // to the generic class allowing it to create instances of either as necessary.

    public abstract class CoolClass<T, U>
        where U : CoolClass<T, U>, new()
    {
        public T Value { get; private set; }
        protected CoolClass() { }
        public CoolClass(T value) { Value = value; }
        public static implicit operator CoolClass<T, U>(T val)
        {
            // since we know the derived type and that its new(), we can
            // new up an instance of it (which we couldn't do as an abstract class)
            return new U() { Value = val};
        }
        public static implicit operator T(CoolClass<T, U> obj)
        {
            return obj.Value;
        }
    }

还有一个额外的问题：为什么这些隐式运算符中的一个有效而另一个无效？

例如

    public class CoolInt : CoolClass<int, CoolInt>
    {
        public CoolInt() {  }
        public CoolInt(int val) (val) { }
    }

                                    // Why does this not work
        CoolInt x = 5;
                                    // when this works
        CoolInt x2 = (CoolInt)5;    
                                    // and this works
        int j = x;

Answer 1

这有点主观，但我不是隐式演员表的忠实粉丝。当您使用它们时，代码经常会产生误导，有时如果它是由隐式强制转换引起的，则很难找到错误。如果您的课程仅设计用于使用它们，那么我不会以这种方式使用它。

为什么这些隐式运算符中的一个有效而另一个无效？

因为您定义了来自CoolClass<T, U> 的转换，而不是来自CoolInt。它们是不同的类型。如果您在 CoolInt 实现中使用此方法，它将起作用：

public static implicit operator CoolInt(int val)

关于泛型的使用：

如果您需要创建具有许多类的复杂继承层次结构（例如，引入新的抽象级别可能会很棘手），泛型的这种使用会对您的架构造成限制。但这真的取决于你需要什么。我实际上在其中一个项目中使用了这种技术来避免代码重复。如果您的 CoolClass 克服 new() 限制，您也可以将委托 Func<U> 传递给构造函数:)

Answer 2

这是 C++ 中的一种常见（而且很好！）模式，看起来有点像这样：

template<typename T> class Base {
    void foo() { T::foo(); /* Call the derived implementation*/ }
};
class Derived : public Base<Derived> {
    void foo() { /* do something*/ }
};

我们将它用于静态多态/继承，以及其他。

但是，在 .NET 中，泛型参数在运行时并且还有反射，我不完全确定好处在哪里。我的意思是，派生类型很有用，但你必须问自己——有什么用，它与直接继承有何不同？