c# - 为什么在泛型类中使用重复嵌套类型的字段声明会导致大量源代码增加？

Question

这种情况很少见，但非常简单:您定义一个泛型类，然后创建一个从外部类继承的嵌套类，并在嵌套内定义一个关联字段(自身类型)。代码片段比描述更简单:

class Outer<T>
{
    class Inner : Outer<Inner>
    {
        Inner field;
    }
}

IL反编译后的C#代码如下:

internal class Outer<T>
{
    private class Inner : Outer<Outer<T>.Inner>
    {
        private Outer<Outer<T>.Inner>.Inner field;
    }
}

这似乎很公平，但是当您更改字段的类型声明时，事情就变得棘手了。所以当我将字段声明更改为

Inner.Inner field;

反编译后这个字段看起来像这样:

private Outer<Outer<Outer<T>.Inner>.Inner>.Inner field;

我明白，类的“嵌套”和继承不太相配，但是为什么我们会观察到这种行为？ Inner.Inner 类型声明是否完全改变了类型？ Inner.Inner 和 Inner 类型在这种情况下有什么不同吗？

当事情变得非常棘手时

你可以看到 decompiled source code对于下面的类(class)。它真的很大，总长度为 12159 个符号。

class X<A, B, C>
{
    class Y : X<Y, Y, Y>
    {
        Y.Y.Y.Y.Y.Y y;
    }
} 

最后，这个类:

class X<A, B, C, D, E>
{
    class Y : X<Y, Y, Y, Y, Y>
    {
        Y.Y.Y.Y.Y.Y.Y.Y.Y y;
    }
}

27.9 MB(29,302,272 字节) 程序集和总构建时间:00:43.619

使用的工具

编译是在 C# 5 和 C# 4 编译器下完成的。反编译由 dotPeek 完成。构建配置:Release 和 Debug

Answer 1

你问题的核心是为什么Inner.Inner是不同于 Inner 的类型.一旦您理解了这一点，您对编译时间和生成的 IL 代码大小的观察就很容易了。

首先要注意的是，当你有这个声明的时候

public class X<T>
{
  public class Y { }
}

有无限多种类型与名称 Y 相关联.每个泛型类型参数都有一个 T , 所以 X<int>.Y不同于 X<object>.Y ，而且，对以后很重要，X<X<T>>.Y是不同于 X<T>.Y 的类型对于所有 T的。您可以针对各种类型进行测试 T .

接下来要注意的是在

public class A
{
  public class B : A { }
}

引用嵌套类型的方式有无数种B .一个是 A.B , 另一个是 A.B.B ， 等等。声明typeof(A.B) == typeof(A.B.B)返回 true .

当您按照您的方式将这两者结合起来时，会发生一些有趣的事情。类型Outer<T>.Inner与 Outer<T>.Inner.Inner 的类型不同. Outer<T>.Inner是 Outer<Outer<T>.Inner> 的子类同时Outer<T>.Inner.Inner是 Outer<Outer<Outer<T>.Inner>.Inner> 的子类，我们之前建立的不同于Outer<T>.Inner .所以Outer<T>.Inner.Inner和 Outer<T>.Inner指的是不同的类型。

生成 IL 时，编译器始终使用类型的完全限定名称。您已经巧妙地找到了一种方法来引用名称长度以指数速率增长的类型。这就是为什么当你增加 Outer 的通用性时或添加其他级别 .Y到现场field在 Inner输出 IL 大小和编译时间增长得如此之快。