Min Max wielowątkowy - Code Review

Witam,

mam takie zadanie z wielowątkowości:
Napisz program przeszukujący xxx elementową tablice w poszukiwaniu Min i Max. Przyspiesz działanie owego programu korzystając z wielu wątków w najprostszy sposób, tj. dzieląc zakres przeszukiwanych komórek równo pomiędzy wątki. Wykorzystaj tyle wątków, ile jest dostępnych rdzeni.

 
class Program
    {
        private static int[] table;
        
        static void Main(string[] args)
        {
            Random r = new Random();
            
            int numberOfAvailableThreads = Environment.ProcessorCount;
            int tableSize = numberOfAvailableThreads * 10;

            table = new int[tableSize];
            for (int i = 0; i < tableSize; i++)
            {
                table[i] = r.Next(100);
                Console.Write(table[i] + " ");
            }

            int globalMax = table[0], globalMin = table[0];
            
            Thread[] threads = new Thread[numberOfAvailableThreads];

            var step = tableSize / numberOfAvailableThreads;

            for (int i = 0; i < tableSize; i++)
            {
                if (i % step == 0)Console.WriteLine();
                Console.Write(table[i] + " ");                
            }
            Console.WriteLine();

            List<ThreadParam> allParams = new List<ThreadParam>();
            for (int i = 0; i < numberOfAvailableThreads; i++) 
            {
                var param = new ThreadParam() { Id = i, FirstElement = i * step, Size = step };
                allParams.Add(param);
                threads[i] = new Thread(DoWork);
                threads[i].Start(param);
            }

            for (int i = 0; i < numberOfAvailableThreads; i++)
            {
                threads[i].Join();
            }

            allParams.ForEach(p =>
            {
                globalMin = Math.Min(globalMin, p.LocalMin);
                globalMax = Math.Max(globalMax, p.LocalMax);
            });

            Console.WriteLine("GlobalMin {0}, GlobalMax {1}", globalMin, globalMax);
            Console.ReadLine();
        }

        private static void DoWork(object arg)
        {
            ThreadParam param = arg as ThreadParam;
            
            var end = param.FirstElement + param.Size;

            Console.WriteLine("Id {0}, FirstElement {1}, Size {2}, LastElement :{3}", param.Id, param.FirstElement, param.Size, end);
            
            int localMin = table[param.FirstElement];
            int localMax = table[param.FirstElement];

            for(int i = param.FirstElement; i < end; i++ ) 
            {
                localMax = Math.Max(localMax, table[i]);
                localMin = Math.Min(localMin, table[i]);
            }

            Console.WriteLine("Id {0}, LocalMin {1}, LocalMax {2}", param.Id, localMin, localMax);

            param.LocalMax = localMax;
            param.LocalMin = localMin;
        }

        public class ThreadParam
        {
            public int Id { get; set; }
            public int FirstElement { get; set; }
            public int Size { get; set; }
            public int LocalMin { get; set; }
            public int LocalMax { get; set; }
        }
            
    }

Jakieś uwagi? Potencjalne zagrożenia ?

ThreadParam param = arg as ThreadParam; - po tej linijce param może mieć wartość null. Powinieneś użyć zwykłego rzutowania, aby w razie czego dostać InvalidCastException, gdy przypadkiem przekażesz tam inną wartość.

ThreadParam jest mutowalna (właściwości mają publiczne settery), co jest brzydkie, a co gorsza łamie zasadę SRP, bo służy do dwóch celów - przekazania danych do metody i zwrócenia z niej wartości.