处理“非常非常”的大型阵列

如果确实必须打破数组长度限制，则必须将数组拆分为适当大小的块。您可以将这些块包装在具有适当语义的容器中，例如James McCaffrey不久前在博客中写道的BigArrayOfLong对象。有很多其他喜欢它的人。

基本思想是使用锯齿状数组分配要使用的空间。请注意，多维数组不会给您任何好处，因为它仍然是单个对象，而锯齿状数组是较小的数组数组，每个数组都是（可能不是连续的）内存中的自己的对象。

这是一个非常简单的（不是最佳的）实现：

public class HugeArray<T> : IEnumerable<T>
    where T : struct
{
    public static int arysize = (Int32.MaxValue >> 4) / Marshal.SizeOf<T>();

    public readonly long Capacity;
    private readonly T[][] content;

    public T this[long index]
    {
        get
        {
            if (index < 0 || index >= Capacity)
                throw new IndexOutOfRangeException();
            int chunk = (int)(index / arysize);
            int offset = (int)(index % arysize);
            return content[chunk][offset];
        }
        set
        {
            if (index < 0 || index >= Capacity)
                throw new IndexOutOfRangeException();
            int chunk = (int)(index / arysize);
            int offset = (int)(index % arysize);
            content[chunk][offset] = value;
        }
    }

    public HugeArray(long capacity)
    {
        Capacity = capacity;
        int nChunks = (int)(capacity / arysize);
        int nRemainder = (int)(capacity % arysize);

        if (nRemainder == 0)
            content = new T[nChunks][];
        else
            content = new T[nChunks + 1][];

        for (int i = 0; i < nChunks; i++)
            content[i] = new T[arysize];
        if (nRemainder > 0)
            content[content.Length - 1] = new T[nRemainder];
    }

    public IEnumerator<T> GetEnumerator()
    {
        return content.SelectMany(c => c).GetEnumerator();
    }

    IEnumerator System.Collections.IEnumerable.GetEnumerator() { return GetEnumerator(); }
}

这是静态分配的，但要使其增长以适应需求并不难。只要确保您指定的块大小不完全超出范围即可。为了防万一，我已经根据商品尺寸进行了计算。