C# Maximal 20 Threads zum Verarbeiten verwenden

        public void fetchFile()
        {
            //assign file content to string array
            string appPath = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location);
            string[] rawdata = File.ReadLines(appPath + @"\" + "rawdata.txt").ToArray(); //"

            //loop through array
            for (int i = 0; i < rawdata.Length; i++)
            {
                //simple parameters, e.g. taken from rawdata array
                string a = "aaa", b = "bbb";

                Thread nthread = new Thread(() => WorkerMethod(a, b));
                myNewThread.Start();
            }

        }
        public void WorkerMethod(string a, string b)
        {
            //new objects does get created and method "WorkData" does get called
            Workerclass a = new Workerclass();
            string result = a.WorkData(a, b); //WorkData returns string
            Console.WriteLine(result);
        }

  public delegate void TaskCallback(object state);

   public class ThreadQueue<T> {

        private object locker = new object();
        private List<Thread> threadList;
        private Queue<T> taskQueue;
        private TaskCallback callback;

        public ThreadQueue(int threadCount, TaskCallback callback) {
            this.callback = callback; //methoenzeiger auf die methode, die ausgeführt werden soll, wenn ein neues 
                                                 // taskObject zur queue hinzugefügt wird
            threadList = new List<Thread>(threadCount);
            taskQueue = new Queue<T>();

            for (int i = 0; i < threadCount; i++) {
                Thread thread = new Thread(Run);
   
                threadList.Add(thread);
                t.Start();
            }

        }

        public void AddTask(T taskObject) {
            lock (locker) {
                
                taskQueue.Enqueue(taskObject);
                Monitor.PulseAll(locker);
            }
        }


        private void Run() {
            while (true) {
             
                lock (locker) {
                    while (taskQueue.Count == 0) {
                        Monitor.Wait(locker);
                    }
                   T taskObject = taskQueue.Dequeue();

                    if (taskObject == null) {
       
                         return;
                    }

                   callback(taskObject);
                }

            }
        }

    }

     public void ThreadQueueTest() {
           
            ThreadQueue<int> tQueue = new ThreadQueue<int>(20, ThreadMethod);
            for (int i = 0; i < 100; i++) {
                tQueue.AddTask(i);
            }
            
        }

        public void ThreadMethod(object taskObject) {
            int? i = taskObject as int?;
            Console.WriteLine("ThreadMethod "+i);
        }

static void FetchFile(string path)
{
    Parallel.ForEach(File.ReadLines(path), DoWork);
}

static void DoWork(string s)
{
    //TODO: whatever
}