.net core — передача неизвестного числа IProgress<T> в библиотеку классов

Меня немного смущает ваше описание, но давайте посмотрим, понимаю ли я, что вы задумали. Итак, если вы обернете все это в класс, тогда taskList1 и taskList2 могут быть переменными класса. (Кстати, taskList1/2 должен называться лучше: скажем, parallelTaskList и что угодно... в любом случае.) Затем вы можете написать новый метод для класса CheckTaskStatus() и просто перебирать две переменные класса. Это помогает или я полностью пропустил ваш вопрос?

Можете ли вы изменить его так?

public Task<ICollection<IProgress<int>>> StartAsync(CancellationToken cancellationToken)
{
    var progressList = _myServiceFromLibrary.RunTasks();

    return Task.FromResult(progressList);
}

public ICollection<IProgress<int>> RunTasks()
{
    var taskList1 = new List<ITask> { Task1, Task2 };
    var plist1 = taskList1.Select(t => t.Progress).ToList();
    var taskList2 = new List<ITask> { Task3, Task4, Task5 }:
    var plist2 = taskList2.Select(t => t.Progress).ToList();

    taskList1.foreach( task => task.Run() );

    Parallel.Foreach(taskList2, task => { task.Run() });

    return plist1.Concat(plist2).ToList();
}

Task.Progress наверное есть геттер прогресса. на самом деле IProgress, вероятно, следует внедрять через конструкторы задач. Но дело в том, что ваш публичный интерфейс не принимает список задач, поэтому он должен просто возвращать набор отчетов о ходе выполнения.

Как внедрить отчеты о прогрессе в ваши задачи — это отдельная история, которая зависит от реализации задач, и она может поддерживаться или не поддерживаться. из коробки.

Однако то, что вы, вероятно, должны сделать, это предоставить обратный вызов прогресса или фабрику прогресса, чтобы создавать отчеты о прогрессе по вашему выбору:

public Task StartAsync(CancellationToken cancellationToken, Action<Task,int> onprogress)
{
    _myServiceFromLibrary.RunTasks(onprogress);

    return Task.CompletedTask;
}

public class SimpleProgress : IProgress<int>
{
    private readonly Task task;
    private readonly Action<Task,int> action;
    public SimpleProgress(Task task, Action<Task,int> action)
    {
        this.task = task;
        this.action = action;
    }

    public void Report(int progress)
    {
        action(task, progress);
    }
}

public ICollection<IProgress<int>> RunTasks(Action<Task,int> onprogress)
{
    var taskList1 = new List<ITask> { Task1, Task2 };
    taskList1.foreach(t => t.Progress = new SimpleProgress(t, onprogress));
    var taskList2 = new List<ITask> { Task3, Task4, Task5 }:
    taskList2.foreach(t => t.Progress = new SimpleProgress(t, onprogress));

    taskList1.foreach( task => task.Run() );

    Parallel.Foreach(taskList2, task => { task.Run() });
}

Вы можете видеть здесь, что на самом деле это в основном вопрос о том, как ваши задачи будут вызывать метод IProgress<T>.Report(T value).

Честно говоря, я бы просто использовал событие в прототипе вашей задачи.

На самом деле не совсем ясно, чего вы хотите, потому что опубликованный вами код не соответствует именам, которые вы затем ссылаетесь в тексте своего вопроса... Было бы полезно иметь весь код (например, функцию RunTasks, ваш прототип IProgress и т. д.). ).

Тем не менее, событие существует специально для сигнализации о вызывающем коде. Вернемся к основам. Допустим, у вас есть библиотека MyLib с методом DoThings().

Создайте новый класс, который наследуется от EventArgs и будет содержать отчеты о ходе выполнения вашей задачи...

public class ProgressEventArgs : EventArgs
{
    private int _taskId;
    private int _percent;
    private string _message;


    public int TaskId => _taskId;
    public int Percent => _percent;
    public string Message => _message;

    public ProgressEventArgs(int taskId, int percent, string message)
    {
        _taskId = taskId;
        _percent = percent;
        _message = message;
    }
}

Затем в определении класса вашей библиотеки добавьте такое событие:

public event EventHandler<ProgressEventArgs> Progress;

И в своем консольном приложении создайте обработчик событий прогресса:

void ProgressHandler(object sender, ProgressEventArgs e)
{
    // Do whatever you want with your progress report here, all your
    // info is in the e variable
}

И подпишитесь на событие вашей библиотеки классов:

var lib = new MyLib();
lib.Progress += ProgressHandler;
lib.DoThings();

Когда вы закончите, отпишитесь от события:

lib.Progress -= ProgressHandler;

В вашей библиотеке классов теперь вы можете отправлять отчеты о ходе выполнения, вызывая событие в своем коде. Сначала создайте метод-заглушку для вызова события:

protected virtual void OnProgress(ProgressEventArgs e)
{
    var handler = Progress;
    if (handler != null)
    {
        handler(this, e);
    }
}

А затем добавьте это в код своей задачи, где вы хотите:

OnProgress(new ProgressEventArgs(2452343, 10, "Reindexing google..."));

Единственное, с чем нужно быть осторожным, — это скупо сообщать о прогрессе, потому что каждый раз, когда ваше событие запускается, оно прерывает ваше консольное приложение, и вы можете сильно затормозить его, если отправите 10 миллионов событий одновременно. Будьте логичны в этом.

Альтернативный способ; Если у вас есть код IProgress<T> и Progress

IProgress<T>
{
   IProgress<T> CreateNew();    
   Report(T progress);
}

Progress<T> : IProgress<T>
{
  Progress(ShellProgressClass)
  {
    // initialize progressBar or span new
  }   
  ....
   IProgress<T> CreateNew()
   {
     return new Progress();
   }
}

позже вы можете импровизировать, чтобы иметь один большой progressBar (набор Sequential или Parallel), а что нет

Ваш MyService может иметь зависимость, подобную:

public interface IJobContainer
{
    void Add(IJob job);

    void RunJobs(IProgress<MyProgress> progress, Action<IJob>? callback = null); // Using an action for extra work you may want to do
}

Таким образом, вам не нужно беспокоиться об отчетах о прогрессе в MyService (что в любом случае не похоже на то, что это должно быть заданием MyService. Реализация для контейнера параллельных заданий может выглядеть примерно так:

public class MyParallelJobContainer
{
    private readonly IList<IJob> parallelJobs = new List<IJob>();

    public MyParallelJobContainer()
    {
        this.progress = progress;
    }

    public void Add(IJob job) { ... }

    void RunJobs(IProgress<MyProgress> progress, Action<IJob>? callback = null)
    {
        using (var progressBar = new ProgressBar(options...))
        {
            Parallel.ForEach(parallelJobs, job =>
            {
                callback?.Invoke(job);
                job.Execute();
                progressBar.Tick();
            })
        }
    }
}

Тогда MyService будет выглядеть так:

public class MyService : IMyService
{
    private readonly IJobContainer sequentialJobs;
    private readonly IJobContainer parallelJobs;

    public MyService(
        IJobContainer sequentialJobs,
        IJobContainer parallelJobs)
    {
        this.sequentialJobs = sequentialJobs;
        this.parallelJobs = parallelJobs;

        this.sequentialJobs.Add(new DoSequentialJob1());
        this.sequentialJobs.Add(new DoSequentialJob2());
        this.sequentialJobs.Add(new DoSequentialJob3));

        this.parallelJobs.Add(new DoParallelJobA());
        this.parallelJobs.Add(new DoParallelJobB());
        this.parallelJobs.Add(new DoParallelJobC());
    }

    public void RunJobs(IProgress<MyCustomProgress> progress)
    {
        sequentialJobs.RunJobs(progress, job => 
        {
             // do something with the job if necessary
        });

        parallelJobs.RunJobs(progress, job => 
        {
             // do something with the job if necessary
        });
    }

Преимущество этого способа заключается в том, что у MyService есть только одно задание, и ему не нужно беспокоиться о том, что вы будете делать после завершения задания.

Насколько я понимаю вашу проблему, вопрос заключается в том, как вы отображаете ход выполнения оба выполнения синхронных и параллельных заданий.

Теоретически параллельные задания могут начинаться и заканчиваться одновременно, поэтому вы можете рассматривать параллельные задания как одно задание. Вместо того, чтобы использовать количество последовательных заданий в качестве общего, увеличьте это число на единицу. Этого может быть достаточно для небольшого количества параллельных заданий.

Если вы хотите добавить прогресс между параллельными заданиями, вам нужно будет обрабатывать многопоточность в своем коде, потому что параллельные задания будут выполняться одновременно.

object pJobLock = new object();
int numProcessed = 0;
foreach(var parallelJob in parallelJobs)
{
    parallelJob.DoWork();
    lock (pJobLock)
    {
        numProcessed++;
        progress.Report(new MyCustomProgress { Current = numProcessed, Total = parallelJobs.Count() });
    }
}