🔀 merge from fature/gold-plating

Author: nop77svk

jwl.core/JwlCoreProcess.cs

@@ -164,7 +164,7 @@ private async Task FillJiraWithWorklogs(InputWorkLog[] inputWorklogs, WorkLog[]
         MultiTaskStats progress = new MultiTaskStats(fillJiraWithWorklogsTasks.Length);
         MultiTask multiTask = new MultiTask()
         {
-            TaskFeedback = t => Feedback?.FillJiraWithWorklogsProcess(progress.ApplyTaskStatus(t.Status))
+            OnTaskAwaited = t => Feedback?.FillJiraWithWorklogsProcess(progress.ApplyTaskStatus(t.Status))
         };
 
         await multiTask.WhenAll(fillJiraWithWorklogsTasks);
@@ -181,7 +181,7 @@ private async Task<InputWorkLog[]> ReadInputFiles(IEnumerable<string> fileNames)
         MultiTaskStats progressStats = new MultiTaskStats(readerTasks.Length);
         MultiTask multiTask = new MultiTask()
         {
-            TaskFeedback = t => Feedback?.ReadCsvInputProcess(progressStats.ApplyTaskStatus(t.Status))
+            OnTaskAwaited = t => Feedback?.ReadCsvInputProcess(progressStats.ApplyTaskStatus(t.Status))
         };
 
         if (readerTasks.Any())

jwl.infra/MultiTask.cs

@@ -6,17 +6,17 @@ public enum ProgressState
     {
         Unknown,
         Starting,
-        BeforeTaskWait,
-        AfterTaskWait,
+        BeforeTaskAwait,
+        AfterTaskAwait,
         Finished,
         Error,
         Cancelled
     }
 
     public ProgressState State { get; private set; } = ProgressState.Unknown;
 
-    public Action<MultiTask>? ProcessFeedback { get; init; }
-    public Action<Task>? TaskFeedback { get; init; }
+    public Action<MultiTask>? OnStateChange { get; init; }
+    public Action<Task>? OnTaskAwaited { get; init; }
 
     public MultiTask()
     {
@@ -25,35 +25,34 @@ public MultiTask()
     public async Task WhenAll(IEnumerable<Task> tasks, CancellationToken? cancellationToken = null)
     {
         State = ProgressState.Starting;
-        ProcessFeedback?.Invoke(this);
+        OnStateChange?.Invoke(this);
 
         HashSet<Task> tasksToExecute = tasks.ToHashSet();
         List<Exception> errors = new List<Exception>();
 
         while (tasksToExecute.Any())
         {
-            State = ProgressState.BeforeTaskWait;
-            ProcessFeedback?.Invoke(this);
+            State = ProgressState.BeforeTaskAwait;
+            OnStateChange?.Invoke(this);
 
-            Task? taskFinished = null;
             try
             {
                 cancellationToken?.ThrowIfCancellationRequested();
 
-                taskFinished = await Task.WhenAny(tasksToExecute);
+                Task finishedTask = await Task.WhenAny(tasksToExecute);
 
-                State = ProgressState.AfterTaskWait;
-                ProcessFeedback?.Invoke(this);
-                TaskFeedback?.Invoke(taskFinished);
+                State = ProgressState.AfterTaskAwait;
+                OnStateChange?.Invoke(this);
+                OnTaskAwaited?.Invoke(finishedTask);
 
-                if (taskFinished.Status is TaskStatus.Faulted or TaskStatus.Canceled)
+                if (finishedTask.Status is TaskStatus.Faulted or TaskStatus.Canceled)
                 {
-                    tasksToExecute.Remove(taskFinished);
-                    throw taskFinished.Exception ?? new Exception($"Task ended in {taskFinished.Status} status without exception details");
+                    tasksToExecute.Remove(finishedTask);
+                    throw finishedTask.Exception ?? new Exception($"Task ended in {finishedTask.Status} status without exception details");
                 }
-                else if (taskFinished.Status == TaskStatus.RanToCompletion)
+                else if (finishedTask.Status == TaskStatus.RanToCompletion)
                 {
-                    if (!tasksToExecute.Remove(taskFinished))
+                    if (!tasksToExecute.Remove(finishedTask))
                         throw new InvalidOperationException("Task reported as finished... again!");
                 }
             }
@@ -72,22 +71,22 @@ public async Task WhenAll(IEnumerable<Task> tasks, CancellationToken? cancellati
             if (errors.All(ex => ex is TaskCanceledException))
             {
                 State = ProgressState.Cancelled;
-                ProcessFeedback?.Invoke(this);
+                OnStateChange?.Invoke(this);
 
                 throw new TaskCanceledException($"All {errors.Count} tasks have been cancelled", new AggregateException(errors));
             }
             else
             {
                 State = ProgressState.Error;
-                ProcessFeedback?.Invoke(this);
+                OnStateChange?.Invoke(this);
 
                 throw new AggregateException(errors);
             }
         }
         else
         {
             State = ProgressState.Finished;
-            ProcessFeedback?.Invoke(this);
+            OnStateChange?.Invoke(this);
         }
     }
 }