Execute all .bat files in the current folder and delete them after execution

I am a newbie programmer wanting to make averaging videos. I have made a program to create n .bat files doing the average of n images, now I would like to execute them as fast as possible.

The .bat files are independent. I am in a Windows environment.

I have looked at C# multi threading (threadpool, parrallel.for, parralel.foreach etc), but none of the functions there seems to work. I have no illusion that it's me who's doing something wrong though.

Powershell has a function doing what I want, but only for other powershell commands.

The code I have now that mostly works is: (complete solution at https://github.com/Madsfoto/ParallelExecutionForEach )

var paths = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.bat"); // have a list of all .bat files in the current directory
System.Diagnostics.Process proc = new System.Diagnostics.Process();
            proc.StartInfo.CreateNoWindow = true;
            proc.StartInfo.UseShellExecute = false; // above is to not see the cmd window

            proc.StartInfo.WorkingDirectory = Directory.GetCurrentDirectory(); // It's easier than having to specify where this program will be run.



Parallel.ForEach(paths, new ParallelOptions { MaxDegreeOfParallelism = 4 }, currentFile => // 4 is set because I have 4 cores to use
                {
                    proc.StartInfo.FileName = currentFile; // Set the currentfile as the one being executed. currentFile is the name of the .bat file to execute
    proc.Start(); // execute the .bat file
                        proc.WaitForExit();
                    File.Delete(currentFile);
                });

I get System.InvalidOperationException: No process is associated with this object and System.UnauthorizedAccessException’s when I run more than 3-4 processes at the same time.

I suspect that it is the WaitForExit() that is giving me problems, but do not have the skills to debug it.

I have looked at Threading.Task as well, but my skill is not good enough to use it.

So the solution I am after is as follows:

Execute either 1 input file with x lines of independent action or x files with 1 action, with a limit of y processes at the same time either set at compile or runtime.
Programming language is not important to me, although my preference is understandable C#.

(The result is something like https://www.youtube.com/watch?v=ph6-6bYTgs0, with n frames averaged together)