C# 克隆通用

我有一个类，

Matrix

，并尝试重载该类中的+运算符。 问题在于

matrix1

和

matrix2

中，我无法创建此对象的克隆。我甚至已经尝试过使用一些

for

循环，但是它抛出了一个

OutOfMemoryException

    public static Matrix<T> operator +(Matrix<T> matrix1, Matrix<T> matrix2)
    {
        Matrix<T> m1 = matrix1;
        Matrix<T> m2 = matrix2;
        Matrix<T> result = new Matrix<T>();

        if (m1.Cols != m2.Cols || m1.Rows != m2.Rows)
        {
            if (m1.Rows > m2.Rows)
                m2.Rows = m1.Rows;
            else if (m1.Rows < m2.Rows)
                m1.Rows = m2.Rows;
            if (m1.Cols > m2.Cols)
                m2.Cols = m1.Cols;
            else if (m1.Cols < m2.Cols)
                m1.Cols = m2.Cols;
        }

        for (int i = 0; i < m1.Rows; i++)
        {
            result.Add(new List<T>());

            for (int j = 0; j < m1.Cols; j++)
            {
                result[i].Add(new T());
                result[i][j] = Sum<T>(m1[i, j], m2[i, j]);
            }
        }

        result.Cols = m1.Cols;
        return result;
    }

公共静态矩阵运算符+（矩阵matrix1，矩阵matrix2）
{
矩阵m1=矩阵X1；
矩阵m2=矩阵X2；
矩阵结果=新矩阵（）；
if（m1.Cols！=m2.Cols | | m1.Rows！=m2.Rows）
{
如果（m1.行>m2.行）
m2.行=m1.行；
否则如果（m1.行m2.Cols）
m2.Cols=m1.Cols；
否则如果（m1.Cols

我是这样做的

    public static List<List<T>> ListClone(List<List<T>> data)
    {  
        var new_data= new List<List<T>>();

        foreach (var list in data)
        {
            new_data.Add(ListClone(list)); 
        }

        return new_data;
    }

    public static List<T> ListClone(List<T> list)
    {
        var new_list = new List<T>();

        foreach(var i in list)
        {
            new_list.Add((T)i);
        }

        return new_list;
    }

    public static Matrix<T> operator +(Matrix<T> matrix1, Matrix<T> matrix2)
    {
        var m1 = new Matrix<T>();
        m1.Cols = matrix1.Cols;
        m1.Rows = matrix1.Rows;
        m1.Data = ListClone(matrix1.data);

        var m2 = new Matrix<T>();
        m2.Cols = matrix2.Cols;
        m2.Rows = matrix2.Rows;
        m2.Data = ListClone(matrix2.data);

        Matrix<T> result = new Matrix<T>();

        if (m1.Cols!=m2.Cols || m1.Rows!=m2.Rows)
        {
            if (m1.Rows > m2.Rows)
                m2.Rows = m1.Rows;
            else if (m1.Rows < m2.Rows)
                m1.Rows = m2.Rows;
            if (m1.Cols > m2.Cols)
                m2.Cols = m1.Cols;
            else if (m1.Cols < m2.Cols)
                m1.Cols = m2.Cols;

        }

        for (int i = 0; i < m1.Rows; i++)
        {
            result.Add(new List<T>());

            for (int j = 0; j < m1.Cols; j++)
            {
                result[i].Add(new T());
                result[i][j] = Sum<T>(m1[i, j], m2[i, j]);
            }
        }

        result.Cols = m1.Cols;
        return result;           
    }

公共静态列表列表克隆（列表数据）
{  
var new_data=新列表（）；
foreach（数据中的var列表）
{
新增_data.Add（ListClone（list））；
}
返回新的_数据；
}
公共静态列表列表克隆（列表列表）
{
var new_list=新列表（）；
foreach（列表中的变量i）
{
新增(T)i ;；
}
返回新的_列表；
}
公共静态矩阵运算符+（矩阵matrix1，矩阵matrix2）
{
var m1=新矩阵（）；
m1.Cols=matrix1.Cols；
m1.行=矩阵1.行；
m1.Data=ListClone（matrix1.Data）；
var m2=新矩阵（）；
m2.Cols=matrix2.Cols；
m2.行=矩阵2.行；
m2.Data=ListClone（matrix2.Data）；
矩阵结果=新矩阵（）；
if（m1.Cols！=m2.Cols | | m1.Rows！=m2.Rows）
{
如果（m1.行>m2.行）
m2.行=m1.行；
否则如果（m1.行m2.Cols）
m2.Cols=m1.Cols；
否则如果（m1.Cols

---

但是也许有人有更好的idiea怎么做更简单？

首先，不要使用

列表制作矩阵。只需使用
列表
，自己找出访问操作员即可

第二，为什么允许用户设置行数或列数？使矩阵不可变，并在构造时固定大小

public class Matrix<T> : ICloneable
    where T : struct, IComparable, IFormattable, IConvertible, IComparable<T>, IEquatable<T>
{
    private readonly int _rows;
    private readonly int _columns;
    private readonly IList<T> _data;

    public Matrix(int rows, int columns)
    {
        _rows = rows;
        _columns = columns;
        _data = new List<T>(Rows * Columns);
    }

    private Matrix(int rows, int columns, IList<T> data)
    {
        _rows = rows;
        _columns = columns;
        _data = new List<T>(data);
    }

    public int Rows
    {
        get { return _rows; }
    }

    public int Columns
    {
        get { return _columns; }
    }

    public T Element(int row, int column)
    {
        return _data[row * column];
    }

    public object Clone()
    {
        return new Matrix<T>(Rows, Columns, _data);
    }
}

公共类矩阵：可克隆
其中T:struct，i可比较，i可附加，i可转换，i可比较，i可计算
{
私有只读int_行；
私有只读int_列；
私有只读IList_数据；
公共矩阵（整数行、整数列）
{
_行=行；
_列=列；
_数据=新列表（行*列）；
}
专用矩阵（int行、int列、IList数据）
{
_行=行；
_列=列；
_数据=新列表（数据）；
}
公共整数行
{
获取{返回_行；}
}
公共int列
{
获取{return\u columns；}
}
公共T元素（int行，int列）
{
返回_数据[行*列]；
}
公共对象克隆（）
{
返回新矩阵（行、列、数据）；
}
}

作为练习，我留下的其他操作符第一个和第二个必须是这样的，包括我的单元测试…不是我的选择好的，你的
ListClone
方法可以很容易地简化为一行
var newData=data.Select（x=>newlist（x））.ToList（）