为什么这种泛型方案会导致类型加载异常

这有点啰嗦，所以这里是快速版本：

为什么这会导致运行时 TypeLoadException？（编译器应该阻止我这样做吗？）

interface I
{
    void Foo<T>();
}
class C<T1>
{
    public void Foo<T2>() where T2 : T1 { }
}
class D : C<System.Object>, I { } 

如果尝试实例化 D，则会发生异常。

---

更长、更具探索性的版本：

考虑：

interface I
{
    void Foo<T>();
}
class C<T1>
{
    public void Foo<T2>() where T2 : T1 { }
}
class some_other_class { }
class D : C<some_other_class>, I { } // compiler error CS0425

这是非法的，因为C.Foo()的类型约束与 I.Foo() 上的类型约束不匹配。它生成编译器错误 CS0425。

但我想我也许可以打破规则：

class D : C<System.Object>, I { } // yep, it compiles

通过使用 Object 作为 T2 上的约束，我否定了该约束。我可以安全地将任何类型的传递给D.Foo<T>()，因为一切都源于Object。

即便如此，我仍然希望得到编译器错误。在 C# 语言意义上，它违反了"C.Foo（） 上的约束必须与 I.Foo（） 上的约束匹配"的规则，我认为编译器会坚持这些规则。但它确实可以编译。编译器似乎看到了我在做什么，理解它是安全的，并且视而不见。

我以为我已经侥幸逃脱了，但运行时说没有那么快。如果我尝试创建D的实例，我会得到一个TypeLoadException："类型'D'上的方法'C'1.Foo'试图隐式实现具有较弱类型参数约束的接口方法。

但这个错误在技术上不是错误的吗？使用 Object 表示C<T1>是否否定了对C.Foo()的约束，从而使它等同于 - 不强于 - I.Foo()？编译器似乎同意，但运行时不同意。

为了证明我的观点，我通过从等式中剔除D来简化它：

interface I<T1>
{
    void Foo<T2>() where T2 : T1;
}
class some_other_class { }
class C : I<some_other_class> // compiler error CS0425
{
    public void Foo<T>() { }
}

但：

class C : I<Object> // compiles
{
    public void Foo<T>() { }
}

这对于传递给Foo<T>()的任何类型都可以完美编译和运行。

为什么？运行时中是否存在错误，或者（更有可能）是否有我没有看到此异常的原因 - 在这种情况下，编译器不应该阻止我？

有趣的是，如果通过将约束从类移动到接口来反转场景......

interface I<T1>
{
    void Foo<T2>() where T2 : T1;
}
class C
{
    public void Foo<T>() { }
}
class some_other_class { }
class D : C, I<some_other_class> { } // compiler error CS0425, as expected

我再次否定约束：

class D : C, I<System.Object> { } // compiles

这次运行良好！

D d := new D();
d.Foo<Int32>();
d.Foo<String>();
d.Foo<Enum>();
d.Foo<IAppDomainSetup>();
d.Foo<InvalidCastException>();

任何事情都会发生，这对我来说非常有意义。（在等式中带或不带D相同）

那么为什么第一种方式会破裂呢？

补遗：

我忘了补充一点，TypeLoadException有一个简单的解决方法：

interface I
{
    void Foo<T>();
}
class C<T1>
{
    public void Foo<T2>() where T2 : T1 { }
}
class D : C<Object>, I 
{
    void I.Foo<T>() 
    {
        Foo<T>();
    }
}

显式实现I.Foo()就可以了。只有隐式实现会导致 TypeLoadException。现在我可以这样做：

        I d = new D();
        d.Foo<any_type_i_like>();

但这仍然是一个特例。尝试使用除 System.Object 以外的任何其他内容，这不会编译。我觉得这样做有点肮脏，因为我不确定它是否故意这样工作。

interface I
{
    object M();
}
class C
{
    public some_type M() { return null; }
}
class D : C, I
{
}

interface I<T1>
{
    void Foo<T2>() where T2 : T1;
}
class C : I<string> // compiler error CS0425
{
    public void Foo<T>() { }
}

interface I<T1>
{
    void Foo<T2>() where T2 : T1;
}
class C : I<MyClass>
{
    public void Foo<T>() where T : MyClass { }
}
public class MyClass
{
}

public sealed class MyClass
{
}