为什么可以'；t基类规范的含义递归地依赖于C#中的基类规范本身

以下C#代码不编译：

public class A
{
    public interface B { }
}              
public class C
    : A,
      C.B // Error given here: The type name 'B' does not exist in the type 'C'.
{ }
public class D : C.B // Compiles without problems if we comment out 'C.B' above.
{ }

根据C#4.0规范（第10.1.4.1段），这种行为是正确的：

在确定类B的直接基类规范A的含义时，暂时假定B的直接类为对象。直观地说，这确保了基类规范的含义不能递归地依赖于它自己。

我的问题是：为什么这种行为不被允许？

Intellisense对此没有问题——尽管我知道这并不能说明什么，但在目睹了Visual Studio崩溃之后，Intellisense试图理解一些带有变体泛型的邪恶类组合。

在互联网上搜索规范中的上述引用没有任何结果，所以我猜这还没有在任何地方被提及。

我为什么在乎？我设计了以下代码：

// The next three classes should really be interfaces,
// but I'm going to override a method later on to prove my point.
// This is a container class, that does nothing except contain two classes.
public class IBagContainer<Bag, Pointer>
    where Bag : IBagContainer<Bag, Pointer>.IBag
    where Pointer : IBagContainer<Bag, Pointer>.IPointer
{
    // This could be an interface for any type of collection.
    public class IBag
    {
        // Insert some object, and return a pointer object to it.
        // The pointer object could be used to speed up certain operations,
        // so you don't have to search for the object again.
        public virtual Pointer Insert(object o) { return null; }
    }
    // This is a pointer type that points somewhere insice an IBag.
    public class IPointer
    {
        // Returns the Bag it belongs to.
        public Bag GetSet() { return null; }
    }
}
// This is another container class, that implements a specific type of IBag.
public class BinarySearchTreeContainer<Tree, Node> : IBagContainer<Tree, Node>
    where Tree : BinarySearchTreeContainer<Tree, Node>.BinarySearchTree
    where Node : BinarySearchTreeContainer<Tree, Node>.BinarySearchTreeNode
{
    // This is your basic binary search tree.
    public class BinarySearchTree : IBagContainer<Tree, Node>.IBag
    {
        // We can search for objects we've put in the tree.
        public Node Search(object o) { return null; }
        // See what I did here? Insert doesn't return a Pointer or IPointer,
        // it returns a Node! Covariant return types!
        public override Node Insert(object o) { return null; }
    }
    // A node in the binary tree. This is a basic example of an IPointer.
    public class BinarySearchTreeNode : IBagContainer<Tree, Node>.IPointer
    {
        // Moar covariant return types!
        public override Tree GetSet() { return null; }
        // If we maintain next and prev pointers in every node,
        // these operations are O(1). You can't expect every IBag
        // to support these operations.
        public Node GetNext() { return null; }
        public Node GetPrev() { return null; }
    }
}

瞧，我们已经实现了协变返回类型！然而，有一个小细节。

尝试实例化BinarySearchTree。为此，我们需要为一些合适的Tree和Node类指定BinarySearchTreeContainer.BinarySearchTree。对于Tree，我们希望使用BinarySearchTree，为此我们需要指定BinarySearchTreeContainer。

这本质上是一种奇怪的重复模板模式（CRTP）。不幸的是，我们无法像在CRTP:中那样修复它

public class BinarySearchTreeContainer
    : BinarySearchTreeContainer
        <BinarySearchTreeContainer.BinarySearchTree,
         BinarySearchTreeContainer.BinarySearchTreeNode> { }
public class IBagContainer
    : IBagContainer
        <IBagContainer.IBag,
         IBagContainer.IPointer> { }
(...)
BinarySearchTreeContainer.BinarySearchTree tree
    = new BinarySearchTreeContainer.BinarySearchTree();
tree.Search(null);
IBagContainer.IBag bag = tree; // No cast!
//bag.Search(null); // Invalid!
//BinarySearchTreeContainer.BinarySearchTreeNode node
//    = bag.Insert(null); // Invalid!

我们回到我最初的问题：前两个类定义是C#规范不允许的。如果允许这个类定义，我的二进制搜索树将是可用的。现在，它们只是编译：不能使用。