C# 如何在c中声明自由长度2d数组#

你好

通常，我创建二维阵列如下所示：

string [,] arr = new string [9,4];

这是一个包含9行4列的二维数组

我想问一下，如何创建任意长度的二维阵列。

---

例如，不必将行设置为9，它可以是任何数字，具体取决于情况。

简单

列表如何

这就像一个概念，您自然可以将其封装在自定义类中，这样API的使用者就不会看到这些wiered嵌套声明

public class Matrix {

   private mtx = new List<List<T>>(); 


   public void Append(T value) {
      .....
   }  

   public void InsertAt(T value, int row, int column) {
      ....
   }

}

公共类矩阵{
私有mtx=新列表（）；
公共无效附加（T值）{
.....
}  
public void InsertAt（T值、int行、int列）{
....
}
}
简单的
列表如何

这就像一个概念，您自然可以将其封装在自定义类中，这样API的使用者就不会看到这些wiered嵌套声明

public class Matrix {

   private mtx = new List<List<T>>(); 


   public void Append(T value) {
      .....
   }  

   public void InsertAt(T value, int row, int column) {
      ....
   }

}

公共类矩阵{
私有mtx=新列表（）；
公共无效附加（T值）{
.....
}  
public void InsertAt（T值、int行、int列）{
....
}
}
为此，您必须使用
列表
实例。现在，您可以动态添加所需的任何内容，但与数组格式相比，这也有缺点，如果您已达到最大行数或列数，则需要自己检查数组格式。
为此，您必须使用
列表
实例。现在，您可以动态添加所需的任何内容，但与数组格式相比，这也有一个缺点，即如果您已达到最大行数或列数，则需要自己检查数组格式。
此
矩阵
类是空间（基于访问模式）和性能效率：

class Matrix<T>
{
    readonly Dictionary<int, Dictionary<int, T>> _rows = new Dictionary<int, Dictionary<int, T>>();

    public T this[int i, int j]
    {
        get
        {
            var row = ExpandOrGet(j);
            if (!row.ContainsKey(i)) row[i] = default(T);

            UpdateSize(i, j);

            return row[i];
        }
        set
        {
            ExpandOrGet(j);
            _rows[j][i] = value;

            UpdateSize(i, j);
        }
    }

    void UpdateSize(int i, int j)
    {
        if (j > SizeRows) SizeRows = j;
        if (i > SizeColums) SizeColums = i;
    }

    public int SizeRows { get; private set; }
    public int SizeColums { get; private set; }

    Dictionary<int, T> ExpandOrGet(int j)
    {
        Dictionary<int, T> result = null;

        if (!_rows.ContainsKey(j))
        {
            result = new Dictionary<int, T>();
            _rows[j] = result;
        }
        else result = _rows[j];

        return result;
    }
}

类矩阵
{
只读字典_rows=新字典（）；
公共T这[int i，int j]
{
得到
{
var row=ExpandOrGet（j）；
如果（！row.ContainsKey（i））row[i]=默认值（T）；
更新（i，j）；
返回行[i]；
}
设置
{
ExpandOrGet（j）；
_行[j][i]=值；
更新（i，j）；
}
}
void UpdateSize（inti，intj）
{
如果（j>SizeRows）SizeRows=j；
如果（i>SizeColums）SizeColums=i；
}
公共int SizeRows{get；私有集；}
public int SizeColums{get；private set；}
字典扩充器（int j）
{
字典结果=null；
如果（！_行。容器（j））
{
结果=新字典（）；
_行[j]=结果；
}
else结果=_行[j]；
返回结果；
}
}

尽管您可以添加更多的实用程序来简化您的工作流程。
此
矩阵
类具有空间（基于访问模式）和高效性能：

class Matrix<T>
{
    readonly Dictionary<int, Dictionary<int, T>> _rows = new Dictionary<int, Dictionary<int, T>>();

    public T this[int i, int j]
    {
        get
        {
            var row = ExpandOrGet(j);
            if (!row.ContainsKey(i)) row[i] = default(T);

            UpdateSize(i, j);

            return row[i];
        }
        set
        {
            ExpandOrGet(j);
            _rows[j][i] = value;

            UpdateSize(i, j);
        }
    }

    void UpdateSize(int i, int j)
    {
        if (j > SizeRows) SizeRows = j;
        if (i > SizeColums) SizeColums = i;
    }

    public int SizeRows { get; private set; }
    public int SizeColums { get; private set; }

    Dictionary<int, T> ExpandOrGet(int j)
    {
        Dictionary<int, T> result = null;

        if (!_rows.ContainsKey(j))
        {
            result = new Dictionary<int, T>();
            _rows[j] = result;
        }
        else result = _rows[j];

        return result;
    }
}

类矩阵
{
只读字典_rows=新字典（）；
公共T这[int i，int j]
{
得到
{
var row=ExpandOrGet（j）；
如果（！row.ContainsKey（i））row[i]=默认值（T）；
更新（i，j）；
返回行[i]；
}
设置
{
ExpandOrGet（j）；
_行[j][i]=值；
更新（i，j）；
}
}
void UpdateSize（inti，intj）
{
如果（j>SizeRows）SizeRows=j；
如果（i>SizeColums）SizeColums=i；
}
公共int SizeRows{get；私有集；}
public int SizeColums{get；private set；}
字典扩充器（int j）
{
字典结果=null；
如果（！_行。容器（j））
{
结果=新字典（）；
_行[j]=结果；
}
else结果=_行[j]；
返回结果；
}
}

尽管您可以添加更多的实用程序来简化您的工作流程。
既然您正在包装这个东西，那么只有一个大小为x*y的列表，并在访问元素时计算适当的偏移量，不是会更节省内存吗？可能是的，但您在遍历该列表时会花费更多的时间来选择所需的内容（如果需要的话）来自给定行和列的值。而且它变得很难管理，特别是在矩阵应该变得非对称的情况下。既然你正在包装这个东西，那么只有一个大小为x*y的列表，并在访问元素时计算适当的偏移量不是会更节省内存吗？可能是的，但您要花更多的时间遍历该列表，以便从给定的行和列中选择所需（如果需要）的值。而且这变得很难管理，尤其是在矩阵变得非对称的情况下。对于MATLAB稀疏矩阵来说，这是一个相当不错的c#转换。@AdrienPlisson这是好事还是坏事？（我从90年代就没有使用过MATLAB）这是一件特殊的事情：稀疏矩阵有它的用途，但用户必须知道稀疏矩阵的利与弊。优点：内存占用小，内部数据很少，非常大的边界，缺点：如果矩阵不是稀疏的，那将是一个可怕的膨胀！对于MATLAB稀疏矩阵来说，这是一个相当不错的c#转换。@AdrienPlisson这是好事还是坏事？（我从90年代就没有使用过MATLAB）这是一件特殊的事情：稀疏矩阵有它的用途，但用户必须知道稀疏矩阵的利与弊。优点：内存占用小，内部数据很少，非常大的边界，缺点：如果矩阵不是稀疏的，那将是一个可怕的膨胀！