创建大型锯齿数组触发OutOfMemoryException问题求助

首先咱们先拆解为什么会触发OutOfMemoryException，再一步步给出可行的解决思路：

为什么会出现内存不足？ #

你估算的20GB是理论数据，但实际运行时还有几个容易忽略的关键点：

1. gcAllowVeryLargeObjects配置没用到点子上：这个开关是用来允许单个数组突破2GB限制的（比如元素数超过2^31-1的引用类型数组，或总大小超2GB的值类型数组），但你的锯齿数组每行只有~2.15MB，完全不需要这个配置，等于白开了。
2. 内存碎片化与GC回收时机：循环里连续创建10000个数组，再手动逐个初始化元素，CPU占用高的同时，GC可能没机会及时回收临时对象，导致内存暂时“挤爆”。
3. 系统实际可用内存比你想的少：物理内存16GB+交换13GB看似29GB，但Windows本身、后台进程会占用一部分，交换文件也不会被完全用尽，实际能给你的进程用的可能不到20GB。

可行的解决思路 #

1. 优化现有分配逻辑 #

把手动初始化元素的内层循环换成Array.Fill（.NET Core 3.0+/NET 5+支持），它是底层优化过的方法，比你写的for循环快得多，还能减少内存波动：

public static T[][] Create<T>(int NumOfRows, int NumOfColumns, T Value)
{
    var Result = new T[NumOfRows][];
    for (int i = 0; i < NumOfRows; i++ )
    {
        Result[i] = new T[NumOfColumns];
        Array.Fill(Result[i], Value); // 替换内层循环
        // 可选：每创建一批行就触发一次GC，给系统喘息机会
        if (i % 1000 == 0)
        {
            GC.Collect();
            GC.WaitForPendingFinalizers();
        }
    }
    return Result;
}

手动GC要谨慎，不过在这种极端内存场景下可以尝试。

2. 用虚拟数组彻底省内存 #

既然所有元素都是同一个值，完全没必要真的分配20GB内存！可以写一个虚拟的锯齿数组类，访问元素时直接返回预设值，只有当你需要修改某行时再实际分配内存：

public class VirtualJaggedArray<T> : IList<IList<T>>
{
    private readonly int _rowCount;
    private readonly int _colCount;
    private readonly T _defaultValue;
    private readonly IList<T> _virtualRow;

    public VirtualJaggedArray(int rows, int cols, T defaultValue)
    {
        _rowCount = rows;
        _colCount = cols;
        _defaultValue = defaultValue;
        _virtualRow = new VirtualRow<T>(cols, defaultValue);
    }

    public IList<T> this[int rowIndex] => _virtualRow;

    public int Count => _rowCount;
    public bool IsReadOnly => true;

    // 按需实现其他IList接口方法，不需要的可以抛出NotImplementedException
    public void Add(IList<T> item) => throw new NotImplementedException();
    public void Clear() => throw new NotImplementedException();
    public bool Contains(IList<T> item) => false;
    public void CopyTo(IList<T>[] array, int arrayIndex) => throw new NotImplementedException();
    public IEnumerator<IList<T>> GetEnumerator() => Enumerable.Repeat(_virtualRow, _rowCount).GetEnumerator();
    public int IndexOf(IList<T> item) => -1;
    public void Insert(int index, IList<T> item) => throw new NotImplementedException();
    public bool Remove(IList<T> item) => false;
    public void RemoveAt(int index) => throw new NotImplementedException();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

public class VirtualRow<T> : IList<T>
{
    private readonly int _colCount;
    private readonly T _defaultValue;

    public VirtualRow(int cols, T defaultValue)
    {
        _colCount = cols;
        _defaultValue = defaultValue;
    }

    public T this[int colIndex] => _defaultValue;

    public int Count => _colCount;
    public bool IsReadOnly => true;

    public void Add(T item) => throw new NotImplementedException();
    public void Clear() => throw new NotImplementedException();
    public bool Contains(T item) => EqualityComparer<T>.Default.Equals(item, _defaultValue);
    public void CopyTo(T[] array, int arrayIndex) => Array.Fill(array, _defaultValue, arrayIndex, Math.Min(_colCount, array.Length - arrayIndex));
    public IEnumerator<T> GetEnumerator() => Enumerable.Repeat(_defaultValue, _colCount).GetEnumerator();
    public int IndexOf(T item) => EqualityComparer<T>.Default.Equals(item, _defaultValue) ? 0 : -1;
    public void Insert(int index, T item) => throw new NotImplementedException();
    public bool Remove(T item) => false;
    public void RemoveAt(int index) => throw new NotImplementedException();
    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}

使用时直接var array = new VirtualJaggedArray<Int16>(10000, 1127211, 0);，内存占用几乎可以忽略。

3. 用内存映射文件把数据放磁盘 #

如果必须实际存储所有数据（比如后续要修改大量元素），可以用内存映射文件（MemoryMappedFile），把数据存在磁盘上，只加载部分到内存，完全不用占用大量物理内存：

using (var mmf = MemoryMappedFile.CreateFromFile("jagged_data.bin", FileMode.Create, "MyLargeArray", 10000L * 1127211L * sizeof(Int16)))
using (var accessor = mmf.CreateViewAccessor())
{
    Int16 defaultValue = 0;
    // 初始化所有数据
    for (long i = 0; i < 10000L * 1127211L; i++)
    {
        accessor.Write(i * sizeof(Int16), defaultValue);
    }

    // 访问数据示例：读取第5行第10列
    long position = (5L * 1127211L + 10L) * sizeof(Int16);
    Int16 value = accessor.ReadInt16(position);
}

这种方式适合超大型数据集，内存占用可控。

4. 调整系统配置 #

• 把Windows交换文件设置为固定大小（比如32GB），避免动态调整时的内存缺口；
• 关闭后台不必要的进程，释放更多物理内存和交换空间。

内容的提问来源于stack exchange，提问作者Codor