Выборка всех подматриц матрицы

    public class Programm
    {
        static void Main(string[] args)
        {
            var matrix = Ext.Create(4, 5, 0, 10);
 
            matrix.Print();
 
            var list = new List<int[,]>();
 
            for(int i = 0; i < matrix.GetLength(0) - 1; i++)
            {
                for(int j = 0; j < matrix.GetLength(1) - 1; j++)
                {
                    var min = matrix.GetLength(0) - i;
                    if (matrix.GetLength(1) - j < min) min = matrix.GetLength(1) - j;
 
                    int[,] arr = new int[min, min];
 
                    for(int k = 0; k < min; k++)
                    {
                        for(int z = 0; z < min; z++)
                        {
                            arr[k, z] = matrix[i + k, j + z];
                        }
                    }
                    list.Add(arr);
                }
            }
 
            foreach (var arrs in list) arrs.Print();
 
            Console.ReadLine();
        }
    }
 
    public static class Ext
    {
        public static ConsoleColor Farbe = ConsoleColor.Red;
 
        /// <summary>
        /// Создает матрицу заданного размера и заполняет ее случайными значениями в заданном диапазоне
        /// </summary>
        /// <param name="rows">Количество строк матрицы</param>
        /// <param name="columns">Количество столбцов матрицы</param>
        /// <param name="minValue">Нижняя граница диапазона</param>
        /// <param name="maxValue">Верхняя граница диапазона</param>
        /// <returns></returns>
        public static int[,] Create(int rows, int columns, int minValue, int maxValue)
        {
            var random = new Random();
            var matrix = new int[rows, columns];
 
            for (int i = 0; i < rows; i++)
            {
                for (int j = 0; j < columns; j++)
                {
                    matrix[i, j] = random.Next(minValue, maxValue);
                }
            }
 
            return matrix;
        }
 
        /// <summary>
        /// Выводит массив на экран
        /// </summary>
        /// <typeparam name="T">Тип элементов матрицы</typeparam>
        /// <param name="matrix">Исходная матрица</param>
        /// <param name="coloredRow">Индекс строки, для выделения другим цветом</param>
        /// <param name="coloredColumn">Индекс столбца, для выделения другим цветом</param>
        public static void Print<T>(this T[,] matrix, int[] coloredRow = null, int[] coloredColumn = null)
        {
            var maxLength = matrix.MaxLength();
 
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                Console.Write("|");
 
                if (coloredRow != null && coloredRow.Contains(i)) Console.ForegroundColor = Farbe;
 
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    if (coloredColumn != null && coloredColumn.Contains(j)) Console.ForegroundColor = Farbe;
 
                    var anz = maxLength - matrix[i, j].ToString().Length;
                    var l = "".PadRight(anz, ' ');
 
                    if (coloredRow != null && coloredColumn != null && !coloredRow.Contains(i) && coloredColumn.Contains(j)) Console.ResetColor();
 
                    Console.Write(" " + matrix[i, j] + l + " ");
                }
 
                Console.ResetColor();
                Console.Write("|\n");
            }
            Console.WriteLine();
        }
 
        /// <summary>
        /// Преобразует элементы массива в строки и определяет максимальную длину этих строк
        /// </summary>
        /// <typeparam name="T">Тип элементов матрицы</typeparam>
        /// <param name="matrix">Исходная матрица</param>
        /// <returns></returns>
        public static int MaxLength<T>(this T[,] matrix)
        {
            int max = int.MinValue;
 
            for (int i = 0; i < matrix.GetLength(0); i++)
            {
                for (int j = 0; j < matrix.GetLength(1); j++)
                {
                    if (matrix[i, j].ToString().Length > max) max = matrix[i, j].ToString().Length;
                }
            }
 
            return max;
        }
    }

static void Print(int[,] a)
    {
        for (int i = 0; i < a.GetLength(0); i++)
        {
            for (int j = 0; j < a.GetLength(1); j++)
                Console.Write("{0,3}", a[i, j]);
            Console.WriteLine();
        }
        Console.WriteLine();
    }
    static List<int[,]> GetList(int[,] a)
    {
        int m = a.GetLength(0);
        int n = a.GetLength(1);
        int s = 2;//2*2
        List<int[,]> lA = new List<int[,]>();
        for (int i = 0; m - i >= s; i++)
            for (int j = 0; n - j >= s; j++)
                for (int h = s; i + h <= m && j + h <= n; h++)
                {
                    int[,] b = new int[h, h];
                    for (int k = i; k - i < h; k++)
                        for (int l = j; l - j < h; l++)
                            b[k - i, l - j] = a[k, l];
                    lA.Add(b);
                }
        return lA;
    }
    public static void Main()
    {
        int m = 3, n = 4;
        int[,] a = new int[m, n];
        for (int i = 0; i < m * n; i++)
            a[i / n, i % n] = i;
        Print(a);
        Console.WriteLine();
        List<int[,]> lA = GetList(a);
        foreach (int[,] b in lA)
        {
            Print(b);
            Console.WriteLine();
        }

static void Main(string[] args)
        {
            var matrix = Ext.Create(4, 5, 0, 10);
 
            matrix.Print();
 
            var list = new List<int[,]>();
 
            for(int i = 0; i < matrix.GetLength(0) - 1; i++)
            {
                for(int j = 0; j < matrix.GetLength(1) - 1; j++)
                {
                    var min = matrix.GetLength(0) - i;
                    if (matrix.GetLength(1) - j < min) min = matrix.GetLength(1) - j;
 
                    for(int m = 2; m <= min; m++)
                    {
                        var arr = matrix.GetSubMatrix(i, j, m);
                        list.Add(arr);
                    }
                }
            }
 
            foreach (var arrs in list) arrs.Print();
 
            Console.ReadLine();
        }
 
//ну и функция: GetSubMatrix:
 
public static int[,] GetSumMatrix(this int[,] matrix, int row, int col, int length)
        {
            var result = new int[length, length];
 
            for(int i = 0;i < length; i++)
            {
                for(int j = 0; j < length; j++)
                {
                    result[i, j] = matrix[row + i, col + j];
                }
            }
 
            return result;
        }

static class MatrixExtensions
{
    public static IEnumerable<T[,]> EnumerateSquares<T>(this T[,] m)
    {
        int min = Math.Min(m.GetLength(0), m.GetLength(1));
        for (int w = 1; w < min; w++)
            for (int i = 0; i < m.GetLength(0) - w + 1; i++)
                for (int j = 0; j < m.GetLength(1) - w + 1; j++)
                {
                    T[,] z = new T[w, w];
                    for (int k = 0; k < w; k++)
                        for (int t = 0; t < w; t++)
                            z[k, t] = m[k + i, t + j];
                    yield return z;
                }
    }
 
    public static void Print(this int[,] m)
    {
        int max = m.Cast<int>().Max();
        int len = max == 0 ? 1 : (int)Math.Log10(max) + 1;
 
        var fmt = "{0," + len + "} ";
        for (int i = 0; i < m.GetLength(0); i++)
        {
            for (int j = 0; j < m.GetLength(1); j++)
                Console.Write(fmt, m[i, j]);
            Console.WriteLine();
        }
        Console.WriteLine();
    }
}

int[,] m = ...
foreach (var m1 in m.EnumerateSquares())
   m1.Print();

static void Main(string[] args)
        {
            int[,] arr = new int[5, 5]
                {
                    { 1,2,3,4,5 },
                    { 6,7,8,9,10 },
                    { 11,12,13,14,15 },
                    { 16,17,18,19,20 },
                    { 21,22,23,24,25 }
                };
 
            List<int[,]> res = GetSubSquareMatrix(arr).ToList();
 
        }
 
        static IEnumerable<T[,]> GetSubSquareMatrix<T>(T[,] arr)
        {
            int n = arr.GetLength(0);
            int m = arr.GetLength(1);
 
            int[] nIndxs = Enumerable.Range(0, n).ToArray();
            int[] mIndxs = Enumerable.Range(0, m).ToArray();
 
            for (int i = 2; i < Math.Min(n, m); i++)
            {
                foreach (var sub_N_Indxs in GetCombinations(nIndxs, i))
                {
                    foreach (var sub_M_Indxs in GetCombinations(mIndxs, i))
                    {
                        T[,] res = new T[i, i];
                        for (int k = 0; k < i; k++)
                        {
                            for (int j = 0; j < i; j++)
                            {
                                res[k,j] = arr[sub_N_Indxs[k], sub_N_Indxs[j]];  
                            }
                        }
                        yield return res;
                    }
                }
            }
        }
 
        /// <summary>
        /// Получение всех сочетаний из n (количество элементов массива arr) по k (combinationSize)
        /// </summary>
        static IEnumerable<T[]> GetCombinations<T>(T[] arr, int combinationSize)
        {
            if (arr == null || arr.Length == 0) yield break;
            if (combinationSize > arr.Length || combinationSize <= 0) throw new ArgumentException();
 
            T[] res = new T[combinationSize];
            int[] indxs = new int[combinationSize];
            for (int i = 0; i < combinationSize; i++)
                indxs[i] = i;
            res = indxs.Select(x => arr[x]).ToArray();
            yield return res;
            while (indxs[0] < arr.Length - combinationSize)
            {
                NextIndexes(indxs, arr.Length - 1);
                res = indxs.Select(x => arr[x]).ToArray();
                yield return res;
            }
        }
 
        /// <summary>
        /// Вычисляет индексы элементов, составляющих еще пока непройденную комбинацию
        /// </summary>
        /// <param name="arr">Массив с индексами</param>
        /// <param name="maxIndx">Максимальный возможный индекс</param>
        static void NextIndexes(int[] arr, int maxIndx)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                int temp = arr.Length - 1 - i;
                if (arr[temp] < maxIndx - i)
                {
                    arr[temp]++;
                    for (int j = temp + 1; j < arr.Length; j++)
                    {
                        arr[j] = arr[j - 1] + 1;
                    }
                    break;
                }
            }
        }