How true is this implementation of multithreading?

one.

Too many class level variables. Each of them needs to be rechecked separately - and I'm lazy. Much safer local variables and function parameters.

2

The variable fifi used in a dangerous way. It is better to abandon it altogether, and do parallelization with other methods.

For parallelization through tasks, I use it myself and recommend this structure to everyone:

 await TaskEx.WhenAll( from file in findFiles select Task.Run(() => ConvertDoWork(file)) ); 

I understand that you still need to limit the number of the number of simultaneously performed tasks to the number of cores. You can do it manually like this:

 class LimitedConcurrencyGuard { private readonly object _lock = new object(); private readonly Queue<TaskCompletionSource<object>> queue = new Queue<TaskCompletionSource<object>>(); private int slots; public LimitedConcurrencyGuard (int slots) { this.slots = slots; } public async Task<IDisposable> AcquireSlot() { TaskCompletionSource<object> tcs; lock(_lock) { if (slots > 0) { slots--; return new Slot(this); } tcs = new TaskCompletionSource<object>(); queue.Enqueue(tcs); } await tcs.Task; return new Slot(this); } private class Slot : IDisposable { private readonly LimitedConcurrencyGuard owner; public void Slot(LimitedConcurrencyGuard owner) { this.owner = owner; } public void Dispose() { TaskCompletionSource<object> tcs; lock(owner._lock) { if (owner.queue.Count > 0) tcs = owner.queue.Dequeue(); else { owner.slots++; return; } } tcs.SetResult(null); } } } // ... var guard = new LimitedConcurrencyGuard(Environment.ProcessorCount); await TaskEx.WhenAll( from file in findFiles select Task.Run(async () => { using (await guard.AcquireSlot()) ConvertDoWork(file); }) ); 

If you search Google for the query "limiting the number of simultaneously executed tasks", there will most certainly be other implementations. For example, implement the restriction on the side of the task scheduler.

Or you can first beat the original sequence of files into pieces, and then run them in parallel:

 static IEnumerable<IEnumerable<T>> SplitAndBatch<T> (ICollection<T> items, int batches) { var count = items.Count; var it = items.GetEnumerator(); while (count > 0) { var current = (count + batches - 1) / batches; // Это на самом деле частное, округленное вверх count -= current; var batch = new T[current]; for (var i=0; i<current; i++) { it.MoveNext(); batch[i] = it.Current; } yield return batch; } } // ... await TaskEx.WhenAll( from batch in SplitAndBatch(findFiles, Environment.ProcessorCount) select Task.Run(() => { foreach (var file in batch) ConvertDoWork(file); }) ); 

In any case, it is better to take the logic of dividing files across processor cores beyond the limits of the ConvertDoWork method - this is called “responsibility sharing”.

Or maybe you need to completely abandon the use of tasks and use the Parallel API - where the limit on the number of cores has already been implemented.

3

Notifying the user of the current progress is a good thing, but it is done on outdated technology. Elementary: if the user closes the window, then the Invoke method will crash with an error.

For progress notifications, there are classes such as IProgress<T> / Progress<T> :

 public void ConvertDoWork(string file, IProgress<object> progress) { // ... progress.Report(null); // ... } // ... progressBar1.Maximum = findFiles.Length; var progress = new Progress<object>(_ => { progressBar1.Value = ++done; }); await TaskEx.WhenAll( from file in findFiles select Task.Run(() => ConvertDoWork(file, progress)) ); 

The advantage of this method is that

• extra responsibility is taken from the ConvertDoWork method (progress indication);
• the Progress class takes the task of transitioning back to the UI flow to itself.

By the way, how do you like this idea - to count files not 1 each, but proportionally to their size? ..

four.

Formation of Arguments best done through string.Format - this is much simpler in perception.

five.

It is better not to use Application.Exit just like this: if you later need to use the old code as part of a larger project, you will have to painfully and painfully search for all the places where it can close the entire program.

In this case, simply close the form.

PS about net 4.0

Many great classes are implemented in Mono and .NET Core. projects .NET Core.

Their licenses are free, the code is open - so 1-2 classes (the same Progress ) can often be copied directly from there to your project. Only if the project will be distributed - then the licenses will have to figure it out.