class Program

{

    private static async Task Main(string[] args)

    {

        var arr = new int[10, 1_000];

        ParallelInitRandomIntMatrix(0, 1_000_000 ,12, arr);

        // {

        //     { 1, 2, 3, 4, 5 },

        //     { 2, 3, 6, 7, 8 },

        //     { 10, 20, 3, 4, 5 },

        //     { 1, 2, 3, 4, 5 },

        //     { 2, 3, 6, 7, 8 },

        //     { 10, 20, 3, 4, 5 },

        // };

        async Task<IEnumerable<IEnumerable<int>>> ToTaskEnum(int[,] array) => await Task.Run(() => arr.ToEnumerable());

​

        async Task<IEnumerable<int>> GetMax(Task<IEnumerable<IEnumerable<int>>> toTaskEnum) =>

            await Task.Run(async () =>

            {

                var result = await toTaskEnum;

                return result.Select(col => col.Max());

            });

​

        async Task WriteResult(Task<IEnumerable<int>> task) =>

            await Task.Run(async () =>

            {

                var result = await task;

                Console.WriteLine(string.Join(Environment.NewLine, result));

            });

​

         await WriteResult(GetMax(ToTaskEnum(arr)));

    }

    private static void ParallelInitRandomIntMatrix(int min, int max, int numOfThreads, int[,] matrix)

    {

        var rnd = Random.Shared;

        var rowsCount = matrix.GetLength(0);

        var columnsCount = matrix.GetLength(1);

​

        var portion = rowsCount / numOfThreads; // calculate portion for each thread

        var remainder = rowsCount % numOfThreads; // calculate remainder for last thread

​

        // create array of tasks

        var tasks = new Task[numOfThreads];

​

        for (var i = 0; i < numOfThreads; i++)

        {

            var start = i * portion; // calculate start index for current thread

            var end = (i + 1) * portion; // calculate end index for current thread

​

            // if last thread, add remainder to end index

            if (i == numOfThreads - 1)

            {

                end += remainder;

            }

​

            // create task for current thread

            tasks[i] = Task.Run(() => {

                for (var j = start; j < end; j++)

                {

                    for (var k= 0; k < columnsCount; k++)

                    {

                        matrix[j, k] = rnd.Next(min, max+1);

                    }

                }

            });

        }

​

        // wait for all tasks to complete

        Task.WaitAll(tasks);

    }

}

​

public static class ToEnum

{

    public static IEnumerable<IEnumerable<int>> ToEnumerable(this int[,] arr)

    {

        for (var i = 0; i < arr.GetLength(0); i++)

        {

            var list = new List<int>();

            for (var j = 0; j < arr.GetLength(1); j++)

                list.Add(arr[i, j]);

            yield return list;

        }

    }

}