C# 如何扩展多维数组？

它有一个数组

CriticalArray

，可能由多个线程在整个应用程序中使用。 此数组的大小有时需要根据用户操作进行扩展。当需要大幅增加大小时，下面的代码需要几分钟才能执行。 有没有办法以更有效的方式扩展阵列的大小

Data[,] CriticalArray = new Data[COLS,ROWS];

通常的值是

COLS

=50和

ROWS

=3000。扩展时，尺寸可以变成5090000

这是导致延迟的扩展代码：

Data[,] TempCriticalArray = new Data[COLS, DELTA + ROWS];

for (int i = 0; i < COLS; i++)
  for (int j = 0; j < ROWS; j++)
    TempCriticalArray[i, j] = CriticalArray[i, j];

CriticalArray = TempQuoteStore;

Data[，]TempCriticalArray=新数据[COLS，DELTA+行]；
for（int i=0；i

您可能已经注意到，通常的

数组.Resize

不适用于多维数组

由于不更改列数，因此可以使用

Array.Copy

（请注意，实例方法

Array.CopyTo

不支持多维数组）

注：

在多维数组之间复制时，数组的行为类似于 长一维数组，其中行（或列）为 从概念上讲是端到端的。例如，如果一个数组有三行 （或列）每个包含四个元素，从 数组的开头将复制第一行的所有四个元素 （或列）和第二行（或列）的前两个元素

这可能与C#中复制数组的速度一样快，但如果必须移动10GB的数据，则可能会出现一些延迟

---

您还可以考虑使用另一个数据结构或更改设计，如果可能的话，不需要同时加载多个项目。

您也可以更改数据结构，这样您就不需要复制数据，而只需将数据附加到它。这意味着您需要自己实现索引器，这可能会降低索引访问的速度，但在将行添加到矩阵中的同时保持列计数固定，则速度会快得多。 以下是LinkedList的草稿，其中显示了该想法，尽管其中可能仍存在一些边界错误：

class LinkedMatrix<T>
{
    int LowerY;
    int UpperY;

    public int TotalColums
    {
        get;
        private set;
    }

    LinkedMatrix<T> Next;

    T[,] InternalArray;

    public LinkedMatrix(int rows, int cols)
    {
        InternalArray = new T[rows, cols];
        UpperY = rows;
        TotalColums = cols;
    }

    private LinkedMatrix(int lowerY, int addedRows, int colums)
    {
        InternalArray = new T[addedRows, colums];
        LowerY = lowerY;
        UpperY = LowerY + addedRows;
    }

    public void AppendRows(int addedRows)
    {
        LinkedMatrix<T> LastNotNull = this;
        while( LastNotNull.Next != null )
        {
            LastNotNull = LastNotNull.Next;
        }

        LastNotNull.Next = new LinkedMatrix<T>(LastNotNull.UpperY, addedRows, this.TotalColums);
    }

    public T this[int y, int x]
    {
        get
        {
            if( y >= UpperY  )
            {
                if( Next != null)
                {
                    return Next[y, x];
                }
                else
                {
                    throw new IndexOutOfRangeException();
                }
            }
            else if( y >= LowerY )
            {
                return InternalArray[y - LowerY, x];
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }

        set
        {
            if (y >= UpperY)
            {
                if (Next != null)
                {
                    Next[y,x] = value;
                }
                else
                {
                    throw new IndexOutOfRangeException();
                }
            }
            else if (y >= LowerY)
            {
                InternalArray[y - LowerY, x] = value;
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
    }
}


class Program
{
    static void Main(string[] args)
    {
        LinkedMatrix<string> matrix = new LinkedMatrix<string>(1, 1);
        matrix[0, 0] = "0,0";
        matrix.AppendRows(1);
        matrix[1, 0] = "1,0";
    }
}

类链接矩阵
{
内特洛厄里；
int UpperY；
公共图书馆
{
得到；
私人设置；
}
LinkedMatrix下一步；
T[，]内部数组；
公共链接矩阵（int行，int列）
{
InternalArray=新的T[行，列]；
UpperY=行；
总柱=柱；
}
专用链接矩阵（int lowerY、int addedRows、int colums）
{
InternalArray=新的T[addedRows，colums]；
LowerY=LowerY；
UpperY=LowerY+addedRows；
}
公共无效追加行（整数追加行）
{
LinkedMatrix LastNotNull=此；
while（LastNotNull.Next！=null）
{
LastNotNull=LastNotNull.Next；
}
LastNotNull.Next=新链接的矩阵（LastNotNull.UpperY、addedRows、this.TotalColumns）；
}
公共T这个[int y，int x]
{
得到
{
如果（y>=y）
{
如果（下一步！=null）
{
返回下一个[y，x]；
}
其他的
{
抛出新的IndexOutOfRangeException（）；
}
}
如果（y>=LowerY），则为else
{
返回内部数组[y-LowerY，x]；
}
其他的
{
抛出新的IndexOutOfRangeException（）；
}
}
设置
{
如果（y>=y）
{
如果（下一步！=null）
{
Next[y，x]=值；
}
其他的
{
抛出新的IndexOutOfRangeException（）；
}
}
如果（y>=LowerY），则为else
{
InternalArray[y-LowerY，x]=值；
}
其他的
{
抛出新的IndexOutOfRangeException（）；
}
}
}
}
班级计划
{
静态void Main（字符串[]参数）
{
LinkedMatrix矩阵=新的LinkedMatrix（1，1）；
矩阵[0,0]=“0,0”；
矩阵。追加行（1）；
矩阵[1,0]=“1,0”；
}
}

尝试使用列表而不是数组。它会自动扩展，效率更高。在我看来，似乎只有行数发生了变化（因为存在

DELTA

）。如果是这种情况，一个

列表可能适合，其中每个列表元素都是一行。@BradleyDotNET True，但这或多或少会产生一个锯齿状数组。不是多维数组<代码>列表

带有自定义类型会更好。对象数据的结构是什么？50x90000=分配了4500000个插槽。它似乎占用了大量内存。当您分配一个50*9000的矩阵并在其中存储对象（我假设为x64）时，仅emtpy对象就必须消耗10,8GB的内存。难怪如果你需要从某处加载4.5亿个对象的数据，那么这个操作需要几分钟的时间。然后在最后添加这一行？？CriticalArray=TempQuoteStore；？TempQuoteStore来自哪里？你在你的问题中使用了TempCriticalArray。。。编辑：啊，我在最后一行看到了。但是，这是从哪里来的呢？它与TempCriticalArray有何不同？@bsobaid

Array.Copy

将数组的内容复制到目标中，您不需要重新分配任何内容。typo，是的，它是CriticalArray=TempQuoteStore。在您的示例中，CriticalArray数组的大小没有改变。如果我加上最后一行，那么它将是.grrrr。。。它是CriticalArray=临时CriticalArray

class LinkedMatrix<T>
{
    int LowerY;
    int UpperY;

    public int TotalColums
    {
        get;
        private set;
    }

    LinkedMatrix<T> Next;

    T[,] InternalArray;

    public LinkedMatrix(int rows, int cols)
    {
        InternalArray = new T[rows, cols];
        UpperY = rows;
        TotalColums = cols;
    }

    private LinkedMatrix(int lowerY, int addedRows, int colums)
    {
        InternalArray = new T[addedRows, colums];
        LowerY = lowerY;
        UpperY = LowerY + addedRows;
    }

    public void AppendRows(int addedRows)
    {
        LinkedMatrix<T> LastNotNull = this;
        while( LastNotNull.Next != null )
        {
            LastNotNull = LastNotNull.Next;
        }

        LastNotNull.Next = new LinkedMatrix<T>(LastNotNull.UpperY, addedRows, this.TotalColums);
    }

    public T this[int y, int x]
    {
        get
        {
            if( y >= UpperY  )
            {
                if( Next != null)
                {
                    return Next[y, x];
                }
                else
                {
                    throw new IndexOutOfRangeException();
                }
            }
            else if( y >= LowerY )
            {
                return InternalArray[y - LowerY, x];
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }

        set
        {
            if (y >= UpperY)
            {
                if (Next != null)
                {
                    Next[y,x] = value;
                }
                else
                {
                    throw new IndexOutOfRangeException();
                }
            }
            else if (y >= LowerY)
            {
                InternalArray[y - LowerY, x] = value;
            }
            else
            {
                throw new IndexOutOfRangeException();
            }
        }
    }
}


class Program
{
    static void Main(string[] args)
    {
        LinkedMatrix<string> matrix = new LinkedMatrix<string>(1, 1);
        matrix[0, 0] = "0,0";
        matrix.AppendRows(1);
        matrix[1, 0] = "1,0";
    }
}