Parallel.ForEach эффективное использование

Parallel.ForEach(current, (r) =>
                    {
                        currentData = Path.Combine(baseFolder, Path.GetFileNameWithoutExtension(r));
                        Directory.CreateDirectory(currentData);
                        using (ArchiveFile rar = new ArchiveFile(r))
                        {
                            rar.Extract(currentData);
                        }
 
                        foreach (var s in Directory.EnumerateFiles(currentData, "*.*", SearchOption.AllDirectories))
                        {
                            if (Path.GetExtension(s) == ".pdf")
                            {
                                iTextPdf.ExtractTextPdf(s);
                                File.Delete(s);
                            }
                            else
                                File.Delete(s);
                        }
 
                        Utils.CopyFolderContents(currentData, outData);
                        Directory.Delete(currentData, true);
                    });

Task<byte[]> loaded_file = null;
List<Task> write_tasks = new List<Task>();
foreach(string filename in files)
{
   byte[] archived = loaded_file?.Result;
   loaded_file = ReadFileAsync(filename);
   if(archived==null)
       continue;
   List<Pair<string, byte[]>> unpacked = ParallelUnZip(archived, GetComputerCoreCount());
   Task wr = WriteMyFilesAsync(updacked);
   write_tasks.Add(wr);
}

    class FileLoader
    {
        private Thread worker;
        private readonly string[] filenames;
        readonly ConcurrentQueue<Tuple<string, Stream>> queue;
        private long finished;
        public bool Finished => Interlocked.Read(ref finished) != 0 && queue.IsEmpty;
        public FileLoader(IEnumerable<string> files)
        {
            filenames = files.ToArray();
            queue = new ConcurrentQueue<Tuple<string, Stream>>();
            worker = new Thread(LoadFiles);
            worker.Start();
        }
 
        private void LoadFiles()
        {
            foreach (string n in filenames)
                using (Stream fs = File.OpenRead(n))
                {
                    MemoryStream ms = new MemoryStream();
                    fs.CopyTo(ms);
                    ms.Seek(0, SeekOrigin.Begin);
                    queue.Enqueue(new Tuple<string, Stream>(n, ms));
                }
            Interlocked.Exchange(ref finished, 1);
        }
 
        public Tuple<string, Stream> GetNext()
        {
            Tuple<string, Stream> result = null;
            if (queue.TryDequeue(out result))
                return result;
            return null;
        }
    }
 
    class Unzipper
    {
        FileLoader loader;
        public Unzipper(FileLoader fl)
        {
            loader = fl;
            Parallel.For(0, 10, _=>Handler());
        }
 
        private Dictionary<string, Stream> results = new Dictionary<string, Stream>();
        public IReadOnlyDictionary<string, Stream> Results
        {
            get
            {
                lock (results)
                    return new Dictionary<string, Stream>(results);
            }
        }
        private void Handler()
        {
            while (!loader.Finished)
            {
                Tuple<string, Stream> rar = loader.GetNext();
                if (rar != null)
                    UnZip(rar.Item1, rar.Item2);
                else
                {
                    if (!loader.Finished)
                        Thread.Sleep(5);
                }
            }
        }
        private void UnZip(string archiveName, Stream stream)
        {
            List<string> paths = new List<string>();
            List<Stream> data = new List<Stream>();
            using (ArchiveFile af = new ArchiveFile(stream))
                foreach (Entry entry in af.Entries)
                {
                    string f = entry.FileName;
                    if (f.Substring(f.Length - 4) != ".pdf")
                        continue;
                    MemoryStream ms = new MemoryStream();
                    entry.Extract(ms);
                    ms.Seek(0, SeekOrigin.Begin);
 
                    // Я не стал за тебя читать документацию к IText, так что сам узнай, как там сделать вывод в Stream
                    IText itext = = new IText(ms);
                    MemoryStream text = new MemoryStream();
                    itext.ExtractTextPdfToStream(text);
                    text.Seek(0, SeekOrigin.Begin);
                    
                    paths.Add(Path.Combine(archiveName, f));
                    data.Add(text);
                }
            lock (results)
            {
                for (int i = 0; i < paths.Count; ++i)
                    results[paths[i]] = data[i];
            }
        }
 
    }
 
    class Program
    {
        public static void Main(string [] args)
        {
            FileLoader loader = new FileLoader(args);
            Unzipper unzipper = new Unzipper(loader);
            foreach(KeyValuePair<string, Stream> res in unzipper.Results)
            {
                string path = Path.Combine("Output", res.Key);
                using (Stream f = File.Create(path))
                {
                    res.Value.CopyTo(f);
                }
            }
        }
    }

using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
 
namespace ConAppPdf
{
    class Program
    {
        const string folder = @"E:\Downloads\ЭР-Телеком";
 
        static void Main(string[] args)
        {
            TestReadFilesСonsistently(folder);
            TestReadFilesParallel(folder);
            Console.Read();
        }
        public static void TestReadFilesСonsistently(string dirName)
        {
            Stopwatch w = new Stopwatch();
            w.Start();            
 
            foreach (var s in System.IO.Directory.EnumerateFiles(dirName, "*.pdf", System.IO.SearchOption.AllDirectories))
            {
                using (FileStream f = new FileStream(s, FileMode.Open, FileAccess.Read))
                {
                    MemoryStream m = new MemoryStream();
                    f.CopyTo(m);
                }
            }           
 
            w.Stop();
            Console.WriteLine("TestReadFilesСonsistently successful complete. Time {0}", w.Elapsed);
        }
        public static void TestReadFilesParallel(string dirName)
        {
            Stopwatch w = new Stopwatch();
            w.Start();
 
            List<string> files = System.IO.Directory.EnumerateFiles(dirName, "*.pdf", System.IO.SearchOption.AllDirectories).ToList();
            List<string> current = new List<string>();
 
            int i = 0;
            int count = 0;
            int step = Environment.ProcessorCount;//amount cores            
            int iter = files.Count / step;
 
            if (iter != 0)
            {
                for (i = 0; count < iter; i += step)
                {
                    current = files.GetRange(i, step);
 
                    Parallel.ForEach(current, (p) =>
                    {
                        using (FileStream f = new FileStream(p, FileMode.Open, FileAccess.Read))
                        {
                            MemoryStream m = new MemoryStream();
                            f.CopyTo(m);
                        }
                    });
 
                    count++;
                }
            }
 
            int remainder = files.Count % step;
 
            if (remainder != 0)
            {
                current = files.GetRange(i, remainder);
 
                Parallel.ForEach(current, (p) =>
                {
                    using (FileStream f = new FileStream(p, FileMode.Open, FileAccess.Read))
                    {
                        MemoryStream m = new MemoryStream();
                        f.CopyTo(m);
                    }
                });
            }
 
            w.Stop();
            Console.WriteLine("TestReadFilesParallel successful complete. Time {0}", w.Elapsed);           
        }
    }
}

readonly BlockingCollection<Tuple<string, Stream>> queue;
//....
Interlocked.Exchange(ref finished, 1);
queue.CompleteAdding();
 
 
private void Handler()
{
    while (!loader.Finished)
    {
          Tuple<string, Stream> rar = null;
          try{
               rar = loader.Take();
          }
          catch(InvalidOperationException){}
          if (rar != null)
                UnZip(rar.Item1, rar.Item2);
        }
}

Parallel.For(0, Basises.Count, j =>
{
     res[j] = Analyze(TruthTable, Basises[j]);
});

 using (Stream fs = File.OpenRead(n))
                {
                    MemoryStream ms = new MemoryStream();
                    fs.CopyTo(ms);
                    ms.Seek(0, SeekOrigin.Begin);
                    queue.Enqueue(new Tuple<string, Stream>(n, ms));
                }

 using (ArchiveFile af = new ArchiveFile(stream))
                foreach (Entry entry in af.Entries)
                {

WebRequest request = WebRequest.Create ("http://www.contoso.com/file.aspx?id=12345");
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
 
using (ArchiveFile archiveFile = new ArchiveFile(response.GetResponseStream())
{
    archiveFile.Extract("Output"); 
}