Матрица переменной размерности, представленная динамическим массивом - C#

namespace Matrix_test
{
    /*Разработать класс для требуемого типа данных: 
     * внутреннее представление данных, 
     * конструкторы, 
     * деструктор,
     * методы ввода/вывода, 
     * изменения содержимого отдельных элементов. 
     * Матрица переменной размерности, представленная динамическим массивом, в котором строки матрицы расположены последовательно друг за другом.*/
    class Matrix
    {
        // * * * * * Переменные * * * * * * *
        /// <summary>
        /// Скрытые перменные класса.
        /// </summary>
        private int _row, _col;
        private int[,] _matrix = new int[0,0];
        Random rnd = new Random();
 
 
        // * * * * * Конструкторы * * * * * * *
        /// <summary>
        /// Конструктор возвращает размер Строк и Столбцов.
        /// </summary>
        /// <param name="Row"></param>
        /// <param name="Col"></param>
        public Matrix(int Row,int Col)
        {
            _row = Row;
            _col = Col;
        }
        /// <summary>
        /// Конструктор по умолчанию принимает нулевое значение.
        /// </summary>
        public Matrix()
        {
            _row = 0;
            _col = 0;
        }
        /// <summary>
        /// Деструктор Матрицы
        /// </summary>
        ~Matrix()
        { }
        // * * * * * Свойства * * * * * *
        /// <summary>
        /// (свойство)Строка принимающий параметр из вне класса, с проверкой на отрицательное число.
        /// </summary>
        internal int Row
        {
            get { return +_row; }
            set {
                if ( value > 0 )
                    _row = value;
                else
                    _row = 0;
            }
        }
        /// <summary>
        /// (свойство)Колонка принимающий параметр из вне класса, с проверкой на отрицательное число
        /// </summary>
        internal int Col
        {
            get { return _col; }
            set { if ( value > 0 )
                    _col = value;
                else
                    _col = 0;
            }
        }
        /// <summary>
        /// (свойство) возвращает количество строк в массиве
        /// </summary>
        internal int length_r
        {
            get { return _matrix.GetLength(0); }
        }
        /// <summary>
        /// (свойство) возвращает количество столбцов в массиве
        /// </summary>
        internal int length_c
        {
            get { return _matrix.GetLength(1); }
        }
        // * * * * * Методы * * * * * * *
        /// <summary>
        /// Возвращает матрицу с N количество "Строк" и "Столбцов", иначе возвращает нулевую матрицу.
        /// </summary>
        /// <param name="Row">Кол-во Строк</param>
        /// <param name="Col">Кол-во Столбцов</param>
        /// <returns></returns>
        internal int[,] Add(int Row,int Col)
        {
            this.Row = Row;
            this.Col = Col;
            
            if ( this.Col >= 0 || this.Row >= 0 )
                return _matrix = new int[Row , Col];
 
            return _matrix = new int[0 , 0];
        }
        /// <summary>
        /// Возвращает матрицу с N "Строк" или N "Столбцов", иначе возвращает нулевую матрицу.
        /// </summary>
        /// <param name="size">Размерность</param>
        /// <param name="N">"Строка" или "Столбец"</param>
        /// <returns></returns>
        internal int[,] Add(int size, string N)
        {
            if ( N.ToLower() == "row" || N.ToLower() == "строка" )
                return _matrix = new int[size , 0];
            else if ( N.ToLower() == "col" || N.ToLower() == "столбец")
                return _matrix = new int[0 , size];
            return _matrix = new int[0 , 0];
        }
        /// <summary>
        /// Устанавливает значение ячейки i-строки j-столбца
        /// </summary>
        /// <param name="i">Строка</param>
        /// <param name="j">Столбец</param>
        /// <param name="val">Значение</param>
        internal void Set_m( int i , int j , int val )
        {
            if ( i >= 0 && j >= 0 )
                _matrix[i , j] = val;
        }
        /// <summary>
        /// Заполняет матрицу случайными числами от min к max.
        /// </summary>
        /// <param name="min">Минимальное число</param>
        /// <param name="max">Максимальное число</param>
        /// <returns></returns>
        internal int[,] Fill( int min , int max )
        {
            for ( int i = 0 ; i < _matrix.GetLength(0) ; i++ )
                for ( int j = 0 ; j < _matrix.GetLength(1) ; j++ )
                    _matrix[i , j] = rnd.Next(min , max);
            return _matrix;
        }
        /// <summary>
        /// Заполняет матрицу случаными числами до max числа
        /// </summary>
        /// <param name="max">Максимальное число</param>
        /// <returns></returns>
        internal int[,] Fill( int max )
        {
            for ( int i = 0 ; i < length_r ; i++ )
                for ( int j = 0 ; j < length_c ; j++ )
                    _matrix[i , j] = rnd.Next(max+1);
            return _matrix;
        }
        /// <summary>
        /// Возвращает "string" строку всей матрицы на экран.
        /// </summary>
        /// <returns></returns>
        public override string ToString()
        {
            string View = $"{null,-3}";
            for ( int i = 0 ; i < length_r ; i++ )
            {
                if ( i == 0 )
                {
                    for ( int v = 0 ; v < length_r ; v++ )
                        View += string.Format($"{v,3}");
                    View += "\n";
                }
 
                View += string.Format($"{i,-2}:");
                for ( int j = 0 ; j < length_c ; j++ )
                    View += string.Format($"{_matrix[i , j],3}");
                View += string.Format("\n");
            }
            return View;
        }
        /// <summary>
        /// Возвращает новую матрицу, пустые поля заполняет нулями.
        /// </summary>
        /// <param name="Row">Новый размер Строк</param>
        /// <param name="Col">Новый размер Колонок</param>
        /// <returns></returns>
        internal int[,] Change_Size(int Row,int Col)
        {
            int[,] new_matrix = new int[Row , Col];
 
            for ( int i = 0 ; i < new_matrix.GetLength(0) ; i++ )
                for ( int j = 0 ; j < new_matrix.GetLength(1) ; j++ )
                    if ( i < _matrix.GetLength(0) )
                        new_matrix[i , j] = j < _matrix.GetLength(1) ? new_matrix[i , j] = _matrix[i , j] : new_matrix[i , j] = 0;
                    else
                        new_matrix[i , j] = 0;
                
            return _matrix = new_matrix;
        }
 
        /// <summary>
        /// Совершает операцию N строкой массива с K строкой масиива, возвращает результат, иначе возвращает 0
        /// </summary>
        /// <param name="N">Первая строка</param>
        /// <param name="K">Вторая строка</param>
        /// <param name="Op">Операция ( +, -, *, / )</param>
        /// <returns></returns>
        internal float Operation(int N,int K,string Op)
        {
            float Res = 0, Tmp = 0;
            switch (Op)
            {
                case "+":
                    for ( int i = 0 ; i < length_c; i++ )
                        Res += _matrix[N , i] + _matrix[K,i];
                    return Res;
                case "-":
                    for ( int i = 0 ; i < length_c ; i++ )
                    {
                        Res += _matrix[N , i];
                        Res -= _matrix[K, i];
                    }
                    return Res;
                case "/":
                    for ( int i = 0 ; i < length_c ; i++ )
                    {
                        Res += _matrix[N , i];
                        Tmp += _matrix[K , i];
                    }
                    if ( Tmp != 0 )
                    {
                        Res /= Tmp;
                        return Res;
                    }
                    else return 0;
                case "*":
                    for ( int i = 0 ; i < length_c ; i++ )
                        Res += _matrix[N , i] * _matrix[K,i];
                    return Res;
                default:
                    break;
            }
            return 0;
        }
        /// <summary>
        /// Возвращает значение массива по индексу, иначе 0
        /// </summary>
        /// <param name="i">i-строка</param>
        /// <param name="j">j-столбец</param>
        /// <returns></returns>
        internal int Index_m(int i,int j)
        {
            if ( i >= 0 && j >= 0 )
                return _matrix[i , j];
            else
                return 0;
        }
        
    }
}