C＃编译器（csc.exe）内存溢出编译嵌套类型和Linq

Question

我发现使用Visual Studio开发了一个不愉快的行为。 在编译C＃时它挂起了我的机器。

我已经减少了对下一个最小源代码的行为

using System.Collections.Generic;
using System.Linq;

namespace memoryOverflowCsharpCompiler {

    class SomeType { public decimal x; }

    class TypeWrapper : Dictionary<int,
                        Dictionary<int,
                        Dictionary<int, SomeType [] []>>> {

        public decimal minimumX() {
            return base.Values.Min(a =>
                      a.Values.Min(b =>
                      b.Values.Min(c =>
                      c       .Sum(d =>
                      d       .Sum(e => e.x)))));
        }
    }
}

用。编译

PROMPT> csc source.cs

    *** BANG! overflow memory usage (up to ~3G)

PROMPT> csc /?
Microsoft (R) Visual C# Compiler version 12.0.30501.0
Copyright (C) Microsoft Corporation. All rights reserved.
...

（使用Windows 8.1 Pro N x64; csc编译器进程运行32位）

明显的修改不会产生这种行为（例如，通过int更改decimal ，减少一个嵌套级别，...），执行大Select然后减少，工作正常

明确的解决方法：

            return base.Values.SelectMany(a =>
                      a.Values.SelectMany(b =>
                      b.Values.Select    (c =>
                      c.       Sum       (d =>
                      d.       Sum       (e => e.x))))).Min();

虽然存在此显式解决方法，但不保证不会再次发生此行为。

怎么了？

谢谢！

Answer 1

在这种情况下，通用类型解析似乎失败了。 从decimal到int是偶然的。 如果你增加嵌套级别，你会发现它也失败了。 在我的x64机器上，这个代码编译int和decimal并使用大约2.5GB的内存，但是当内存使用量增加到4GB时，增加嵌套级别会导致溢出。

明确指定类型参数允许编译代码：

class TypeWrapper : Dictionary<int, Dictionary<int, Dictionary<int, Dictionary<int, SomeType[][]>>>>
{
    public decimal minimumX()
    {
        return base.Values
            .Min<Dictionary<int, Dictionary<int, Dictionary<int, SomeType[][]>>>, decimal>(a => a.Values
                .Min<Dictionary<int, Dictionary<int, SomeType[][]>>, decimal>(b => b.Values
                    .Min<Dictionary<int, SomeType[][]>, decimal>(c => c.Values
                        .Min(d => d
                            .Sum(e => e.Sum(f => f.x))
                        )
                    )
                )
            );
    }
}

当您通过引入局部变量来减少嵌套时，编译器也可以工作：

class TypeWrapper : Dictionary<int, Dictionary<int, Dictionary<int, Dictionary<int, SomeType[][]>>>>
{
    public decimal minimumX()
    {
        Func<Dictionary<int, SomeType[][]>, decimal> inner = (Dictionary<int, SomeType[][]> c) => c.Values
                        .Min(d => d
                            .Sum(e => e.Sum(f => f.x))
                        );

        return base.Values
            .Min(a => a.Values
                .Min(b => b.Values
                    .Min(inner)
                )
            );
    }
}