有没有办法声明派生类的类型的抽象基类的成员？

Question

假设我有一个抽象基类，我想在其中声明与派生自该基类的类的类型匹配的成员。

public abstract class BaseClass
{
    protected BaseClass parent;
}

public class DerivedClass1 : BaseClass
{
    // parent could be of type DerivedClass2
}

public class DerivedClass2 : BaseClass
{
    // parent could be of type DerivedClass1
}

这不起作用，因为每个派生类中的parent 字段可以是从BaseClass 派生的任何内容。我想确保DerivedClass1 中的parent 字段只能是DerivedClass1 类型。所以我在想也许我应该使用泛型。

public abstract class BaseClass<T> where T : BaseClass<T>
{
    protected T parent;
}

这可能看起来令人困惑和循环，但它确实可以编译。它基本上是说parent 是T 类型，它必须派生自通用BaseClass。所以现在派生类可以如下所示：

public class DerivedClass : BaseClass<DerivedClass>
{
    // parent is of type DerivedClass
}

问题是当我声明DerivedClass 时，我必须自己强制执行类型匹配。没有什么能阻止某人做这样的事情：

public class DerivedClass1 : BaseClass<DerivedClass2>
{
    // parent is of type DerivedClass2
}

C# 是否有办法做到这一点，以便在基中声明的成员的类型肯定与派生类型匹配？

我认为这类似于这个 C++ 问题试图提出的问题：Abstract base class for derived classes with functions that have a return type of the derived class

Answer 1

如果我正确理解您的要求，您有一系列具有继承关系的类，并且您希望将它们排列在一个树形结构中，其中每个实例都有一个相同类型且仅属于相同类型的父级。这是一个有趣的问题。

稍微琢磨了一下，我建议你把需求分成两个平行但相关的对象图，这样你就有了

1. 一组具有继承关系的类
2. 一组类，可以包含第一组中的任何类，并且具有类型严格的父项和子项。

首先，让我们声明第一组相互继承的类。暂时忽略Node 位。

public class BaseClass 
{
    public Node ContainerNode { get; set; }
}

public class DerivedClass1 : BaseClass
{
}

public class DerivedClass2 : BaseClass
{
}

这些类不能做太多，但这只是一个例子。

现在让我们设置另一组可以参与树的类。树中的每个元素都称为Node。

//Basic node
public class Node
{
}

//A node that can contain a T (which must be a BaseClass or derived from one)
public class Node<T> : Node where T : BaseClass
{
    public T Parent { get; set; }
    public T This { get; set; }

    public Node(T innerClass) 
    {
        this.This = innerClass;
        innerClass.ContainerNode = this;
    }
}

现在我们拥有了执行您所寻求的类型安全所需的一切。我们可以像这样在继承层次结构中创建类：

    var child1 = new Node<DerivedClass1>(new DerivedClass1());
    var parent1 = new Node<DerivedClass1>(new DerivedClass1());
    child1.Parent = parent1.This;

让我们看看如果我们错误地混淆了 DerivedClass1 和 DerivedClass2 会发生什么：

    var child2 = new Node<DerivedClass2>(new DerivedClass2());
    var parent2 = new Node<DerivedClass1>(new DerivedClass1()); //Oops
    child2.Parent = parent2.This;  //Does not compile

如您所见，Parent 属性现在是类型安全的。

现在所有的东西 ^^^^ 看起来有点乱，所以让我们通过添加一些辅助方法来清理它。

public class Node
{
    public T GetParent<T>() where T : BaseClass
    {
        return ((Node<T>)this).Parent;
    }

    static public Node<T> Create<T>(T innerClass) where T : BaseClass
    {
        return new Node<T>(innerClass);
    }

    static public T GetParent<T>(T child) where T: BaseClass
    {
        return child.ContainerNode.GetParent<T>();
    }

    static public implicit operator T (Node<T> input)
    {
        return input.This;
    }
}

现在，由于编译器可以推断 <T> 参数，我们的声明更加简洁：

    var child1 = Node.Create(new DerivedClass1());
    var parent1 = Node.Create(new DerivedClass1());
    child1.Parent = parent1;

任何派生类都很容易找到自己的父类：

public class DerivedClass1 : BaseClass
{
    protected DerivedClass1 Parent
    {
        get
        {
            return Node.GetParent(this);  //This is type safe!
        }
    }
}

对这一切的一个反对意见是，您不希望编码人员处理这个 Node 层。好吧，他们没有，因为我们设置了一个隐式转换：

    Node<DerivedClass1> a = Node.Create(new DerivedClass1());
    DerivedClass1 b = a;  //Works!!! And is type-safe.

Full working code on DotNetFiddle.